resolve

Documentation

Index

• type ContainerField
  • func ConvertContainerFields(c scan.ContainerSpec) ([]ContainerField, error)
• type EmbeddedContainerRef
  • func DetectEmbeddedContainers(fields []scan.ContainerField, registry map[string]scan.ContainerSpec, ...) []EmbeddedContainerRef
• type ExportedField
• type Graph
  • func BuildGraph(fields []ContainerField, providers []*Provider) (*Graph, error)
• type InjectTag
• type Node
• type Provider
  • func ConvertProviders(ps []scan.ProviderSpec) ([]*Provider, error)
  • func CreateSyntheticProviders(refs []EmbeddedContainerRef) []*Provider
  • func MergeProviders(regular, synthetic []*Provider) []*Provider
  • func OrderProviders(g *Graph) ([]*Provider, error)

Types

type ContainerField

type ContainerField struct {
	Name   string
	Type   types.Type
	Inject InjectTag
}

ContainerField represents an injectable field in a Container struct.

Note: - Name can be "_" for override-only fields. - Type is the type to be provided (e.g. service.User, infra.Database).

func ConvertContainerFields

func ConvertContainerFields(c scan.ContainerSpec) ([]ContainerField, error)

ConvertContainerFields converts a scanned ContainerSpec into resolve-ready fields.

Resolution target rules:

• If the Container has at least one `inject`-marked *public field* (non-blank), only those marked fields are included.
• Blank fields ("_") are treated as provider overrides and do NOT switch the container into explicit mode. They are included only when they are `inject`-marked.

type EmbeddedContainerRef

type EmbeddedContainerRef struct {
	ContainerPkgPath string
	ContainerName    string
	Type             types.Type // *Container or Container
	FuncName         string     // "NewInfra"
	ReturnError      bool
	ExportedFields   []ExportedField
}

EmbeddedContainerRef represents a reference to an embedded container.

func DetectEmbeddedContainers

func DetectEmbeddedContainers(
	fields []scan.ContainerField,
	registry map[string]scan.ContainerSpec,
	processedResults map[string]bool,
) []EmbeddedContainerRef

DetectEmbeddedContainers finds embedded container references among the container fields and returns their metadata.

registry maps "pkgPath.Name" to the corresponding ContainerSpec. processedResults maps the same key to whether the container's generated constructor returns an error.

type ExportedField

type ExportedField struct {
	Name string     // "KVS"
	Type types.Type // *kvs.KVS
}

ExportedField represents an exported field of an embedded container.

type Graph

type Graph struct {
	Roots []*Node
}

Graph represents a resolved dependency graph.

func BuildGraph

func BuildGraph(fields []ContainerField, providers []*Provider) (*Graph, error)

BuildGraph resolves dependencies starting from container fields.

type InjectTag

type InjectTag struct {
	// Provider selects a specific provider function by name.
	// Example: `inject:"provider:service.NewUser"`
	Provider string
}

InjectTag is a parsed `inject` struct tag for Container fields.

type Node

type Node struct {
	Provider *Provider
	Deps     []*Node
}

Node represents a node in the resolved dependency graph.

Each node corresponds to exactly one Provider. Nodes may be shared across the graph to represent a DAG (i.e. the same Provider can be depended on by multiple parents).

type Provider

type Provider struct {
	PkgPath     string
	Name        string
	NameWithPkg string
	ResultType  types.Type
	ReturnError bool
	Params      []types.Type
	Position    string

	// FieldAccess, when non-empty, indicates this is a synthetic
	// field-access provider. The value is the field name (e.g. "KVS").
	// Instead of generating a function call, the emitter produces
	// parentVar.FieldName.
	FieldAccess string

	// IsParam indicates this is a synthetic parameter provider.
	// Instead of generating a function call, the emitter adds this
	// type as a function parameter.
	IsParam bool
}

Provider represents a constructor function that can produce a value for dependency injection.

A Provider is identified by its identity (pointer equality), not by value. It is treated as immutable during resolution and is shared across the dependency graph for cycle detection and override resolution.

func ConvertProviders

func ConvertProviders(ps []scan.ProviderSpec) ([]*Provider, error)

ConvertProviders converts scanned ProviderDecl into resolve Provider nodes.

func CreateSyntheticProviders

func CreateSyntheticProviders(refs []EmbeddedContainerRef) []*Provider

CreateSyntheticProviders creates synthetic providers for the given embedded container references:

1. A constructor provider: NewInfra() → *Infra
2. Field-access providers: *Infra → infra.KVS (one per exported field)

func MergeProviders

func MergeProviders(regular, synthetic []*Provider) []*Provider

MergeProviders merges regular and synthetic providers.

• Field-access synthetic providers override regular providers for the same result type.
• Synthetic constructor providers are skipped if a regular provider with the same NameWithPkg already exists (e.g. from a previously generated file).

func OrderProviders

func OrderProviders(g *Graph) ([]*Provider, error)

OrderProviders returns providers in topological order (dependencies first). Providers may appear only once even if referenced multiple times by roots.