pkggraph

type Context interface {
	cfg.Context
	PackageLoader
}

type EditableWorkspaceData interface {
	FormatTo(io.Writer) error

	WithModuleName(string) WorkspaceData
	WithSetDependency(...*schema.Workspace_Dependency) WorkspaceData
	WithReplacedDependencies([]*schema.Workspace_Dependency) WorkspaceData
	WithSetEnvironment(...*schema.Workspace_EnvironmentSpec) WorkspaceData
}

type ExpectedResourceInstance struct {
	Name            *schema.PackageRef
	Class           ResourceClass
	DefaultResource *schema.PackageRef
}

type LoadModuleFunc func(schema.PackageName) (*Module, error)

type Location struct {
	Module      *Module
	PackageName schema.PackageName
	// contains filtered or unexported fields
}

type MinimalPackageLoader interface {
	LoadByName(ctx context.Context, packageName schema.PackageName) (*Package, error)
}

type Module struct {
	Workspace *schema.Workspace
	// contains filtered or unexported fields
}

type ModuleResolver interface {
	ResolveModule(name string) *Module
}

type Modules interface {
	Modules() []*Module
}

type MutableModule interface {
	ModuleName() string // The module that this workspace corresponds to.
	ReadWriteFS() fnfs.ReadWriteFS
}

type Package struct {
	Location Location

	PackageSources fs.FS // Filenames included will be relative to the module root, not the package.
	NewFrontend    bool  // If set to true, the new frontend parser was used to load this package.

	// One of.
	Extension      *schema.Node
	Service        *schema.Node
	Server         *schema.Server
	ServerFragment *schema.ServerFragment

	// Includes auto-generated (e.g. server startup) tests.
	Tests []*schema.Test

	// Inlined or explicitly defined binaries.
	Binaries []*schema.Binary

	// Integration that has been applied to the server in this package. May be nil.
	// Shouldn't be used outside of workspace.FinalizePackage.
	Integration *schema.Integration

	// Parsed secret definitions within the package.
	Secrets []*schema.SecretSpec

	// Parsed volume definitions within the package.
	Volumes []*schema.Volume

	// Resources associated with node types.
	Provides            map[string]*protos.FileDescriptorSetAndDeps // key: `Provides.Name`
	Services            map[string]*protos.FileDescriptorSetAndDeps // key: fully qualified service name
	SkipServiceProtogen []string                                    // Key: fully qualified service name.
	PackageData         []*types.Resource

	// Parsed resources
	Resources         []ResourceInstance
	ResourceClasses   []ResourceClass
	ResourceProviders []ResourceProvider

	// Hooks
	PrepareHooks         []PrepareHook
	LegacyComputeStartup PreStartup
	ComputePlanWith      []*schema.Invocation // Will generate further plan contents.

	// Raw resources definitions within a package.
	ResourceClassSpecs     []*schema.ResourceClass
	ResourceProvidersSpecs []*schema.ResourceProvider
	ResourceInstanceSpecs  []*schema.ResourceInstance

	// Top-level re-usable definitions.
	Vars map[string]string
}

type PackageLoader interface {
	Resolve(ctx context.Context, packageName schema.PackageName) (Location, error)
	LoadByName(ctx context.Context, packageName schema.PackageName) (*Package, error)

	// Ensure that a package is being loaded.
	// Guaranteed to return immediately if the package is already being loaded concurrently.
	// This is important to avoid deadlocks on cyclic dependencies.
	Ensure(ctx context.Context, packageName schema.PackageName) error
}

type PreStartup interface {
	EvalStartup(context.Context, Context, StartupInputs, []ValueWithPath) (*schema.StartupPlan, error)
}

type PrepareHook struct {
	InvokeInternal string
	InvokeBinary   *schema.Invocation
}

type ProvisionInputs struct {
	ServerLocation Location
}

type ResourceClass struct {
	Ref             *schema.PackageRef
	Source          *schema.ResourceClass
	DefaultProvider schema.PackageName // May be empty.
	InstanceType    UserType
}

type ResourceInstance struct {
	ResourceID  string
	ResourceRef *schema.PackageRef
	Spec        ResourceSpec
}

type ResourceProvider struct {
	Spec *schema.ResourceProvider

	ProviderID     string
	IntentType     *UserType
	Resources      []ResourceInstance
	ResourceInputs []ExpectedResourceInstance
}

type ResourceSpec struct {
	Source         *schema.ResourceInstance
	Intent         *anypb.Any // XXX always use serialized JSON.
	IntentType     *UserType
	Class          ResourceClass
	Provider       *ResourceProvider
	ResourceInputs []ResourceInstance // Resources passed to the provider.
}

type SealedContext interface {
	cfg.Context
	SealedPackageLoader
}

type SealedPackageLoader interface {
	PackageLoader
	Modules
	ModuleResolver

	Packages() []*Package
}

type StackEndpoints interface {
	EndpointsBy(schema.PackageName) []*schema.Endpoint
}

type StartupInputs struct {
	ServerImage   string // Result of imageID.ImageRef(), not oci.ImageID to avoid cycles.
	Stack         StackEndpoints
	ServerRootAbs string
}

type UserType struct {
	Descriptor protoreflect.MessageDescriptor
	Sources    *protos.FileDescriptorSetAndDeps
	Registry   *protoregistry.Files
}

type ValueWithPath struct {
	Need  *schema.Need
	Value any
}

type WorkspaceData interface {
	cfg.Workspace

	AbsPath() string
	DefinitionFiles() []string

	EditableWorkspaceData
}