plan

type ParamBinding struct {
	Number int32
	Field  *ResolvedField
}

type Plan struct {
	Contexts []ResolvedContext
}

type RelationParam struct {
	Number int32
	// Name is the query parameter's own declared name (e.g. "published") —
	// also the key a scope method writes into the builder's scopeValues
	// map, so the two stay in sync regardless of the scope's own name.
	Name        string
	Source      RelationParamSource
	ParentField *ResolvedField  // set when Source == ParamFromParent
	ScopeName   string          // set when Source == ParamFromScope: the scope name whose Default/type this parameter uses
	Default     json.RawMessage // set when Source == ParamFromScope and a default was configured
	GoType      mapping.GoType  // the parameter's resolved Go type
}

type RelationParamSource int

type ResolvedContext struct {
	Name      string
	Package   string
	Directory string
	Models    []ResolvedModel
}

type ResolvedField struct {
	mapping.ResolvedField
	Policy config.FieldPolicy
}

type ResolvedLookup struct {
	Name      string
	QueryName string
	Operation *ResolvedOperation
}

type ResolvedModel struct {
	Name       string
	Row        string
	Operations ResolvedOperations
	Fields     []ResolvedField
	Relations  []ResolvedRelation
	Queries    []ResolvedQuery
	Lookups    []ResolvedLookup
}

type ResolvedOperation struct {
	Kind      contract.OperationKind
	QueryName string
	Query     *pb.Query
	Params    []ParamBinding
	// Scan is the field to hydrate for each returned column, in the
	// query's own column order — this is the exact positional order a
	// generated Scan(...) call must use, which need not match the model's
	// declared field order. Empty for operations that don't return rows
	// (Delete via :execrows/:exec).
	Scan []*ResolvedField
}

type ResolvedOperations struct {
	Find    *ResolvedOperation
	Insert  *ResolvedOperation
	Update  *ResolvedOperation
	Delete  *ResolvedOperation
	Refresh *ResolvedOperation
}

type ResolvedQuery struct {
	Name      string
	Terminal  config.QueryTerminal
	Operation *ResolvedOperation
	Scopes    []ResolvedQueryScope
	Scan      []*ResolvedField
}

type ResolvedQueryScope struct {
	Name      string
	Parameter string
	Value     json.RawMessage
	ValueSet  bool
	Argument  string
	QueryName string
	Relation  string
	GoType    mapping.GoType
	Number    int32
	Variant   *pb.Query
}

type ResolvedRelation struct {
	Name        string
	Kind        config.RelationKind
	Target      *ResolvedModel
	Inverse     *ResolvedRelation
	LocalKey    *ResolvedField
	TargetKey   *ResolvedField
	ForeignKey  string
	Nullable    bool
	LazyQuery   *pb.Query
	EagerQuery  *pb.Query
	AttachQuery *pb.Query
	DetachQuery *pb.Query
	SyncList    *pb.Query
	SyncAttach  *pb.Query
	SyncDetach  *pb.Query
	Parameters  []config.ParameterBinding
	Scopes      []config.ScopeConfiguration
	// LazyParams is LazyQuery's declared parameters, resolved to their
	// binding source, in the query's own positional order.
	LazyParams []RelationParam
	// LazyScan/EagerScan are the target model's fields, in LazyQuery's/
	// EagerQuery's own returned-column order — the exact positional Scan(...)
	// order for hydrating a target instance from that query's result.
	LazyScan  []*ResolvedField
	EagerScan []*ResolvedField
	// ForeignKeyField is the target model's field matching ForeignKey,
	// resolved when EagerQuery is configured (needed to read each returned
	// row's grouping value for batch hydration).
	ForeignKeyField *ResolvedField
	// ScopeVariantQueries maps a query-variant scope's name to its already
	// command/cardinality-validated query (internal/relation's stage 8).
	ScopeVariantQueries map[string]*pb.Query
	// contains filtered or unexported fields
}