catalog

type Catalog = sources.Catalog

type CatalogChecker interface {
	ExistsCatalog(name string) bool
}

type CatalogManager interface {
	// Load/Unload catalogs (for dynamic schema updates)
	AddCatalog(ctx context.Context, name string, catalog Catalog) error
	RemoveCatalog(ctx context.Context, name string) error
	ExistsCatalog(name string) bool
	// ReloadCatalog re-reads the source and recompiles it in full. The
	// storage's version gate decides whether anything is actually rewritten.
	ReloadCatalog(ctx context.Context, name string) error
	// SuspendCatalog removes a catalog from the active schema without deleting
	// the registration. Used when a hugr-app becomes unreachable.
	SuspendCatalog(ctx context.Context, name string) error
	// ReactivateCatalog re-compiles and re-applies a previously suspended catalog.
	// The catalog source must be updated before calling this.
	ReactivateCatalog(ctx context.Context, name string, catalog Catalog) error
	// IsSuspended returns true if the named catalog exists but is suspended.
	IsSuspended(name string) bool
}

type DataSourceInfo struct {
	Name            string
	Engine          string // the source's engine type string (@catalog engine)
	Description     string
	LongDescription string
	ReadOnly        bool
	AsModule        bool
	IsExtension     bool
	Modules         []string // modules this source contributes members to, sorted; "" = root
}

type ExtensionCatalog = sources.ExtensionCatalog

type FunctionEntry struct {
	Field      *ast.FieldDefinition
	Kind       sdl.ModuleObjectType // ModuleFunction | ModuleMutationFunction | ModuleSubscription
	Module     string
	DataSource string
	IsTable    bool
	// LongDescription is the curated long form; empty without a curation
	// layer. The short description lives on Field, already overlaid.
	LongDescription string
}

type LogicalModel interface {
	// Module resolves a module by full dotted name ("" = root); nil when absent.
	Module(ctx context.Context, name string) *ModuleInfo
	// Modules iterates the DIRECT child modules of parent.
	Modules(ctx context.Context, parent string) iter.Seq[*ModuleInfo]
	// DataObject resolves a data object by GraphQL type name; nil for
	// non-data-object types.
	DataObject(ctx context.Context, name string) *sdl.Object
	// DataObjects iterates the data objects that are members of a module.
	DataObjects(ctx context.Context, module string) iter.Seq[*sdl.Object]
	// Function resolves a callable member of a module by field name, probing
	// the function, mutation-function and subscription roots in that order.
	Function(ctx context.Context, module, name string) *FunctionEntry
	// Functions iterates all callable members of a module (all three kinds).
	Functions(ctx context.Context, module string) iter.Seq[*FunctionEntry]
	// Relations iterates the logical edges of a data object, both directions.
	Relations(ctx context.Context, object string) iter.Seq[*RelationInfo]
	// DataSource resolves an ACTIVE data source by name; nil when absent.
	DataSource(ctx context.Context, name string) *DataSourceInfo
	// DataSources iterates the active data sources, ordered by name.
	DataSources(ctx context.Context) iter.Seq[*DataSourceInfo]
	// Type resolves a GraphQL type definition by name; nil when absent.
	// (Entity storage: the ForName resolution chain.)
	Type(ctx context.Context, name string) *ast.Definition
	// SourceTypes iterates the residual base types DEFINED BY SOURCES —
	// structural objects, inputs (incl. @args), enums, interfaces, unions
	// that are not data objects, module roots, or compiler-generated
	// helpers (filters, mutation inputs, aggregations). This is exactly
	// the content of the future entity-storage types table.
	SourceTypes(ctx context.Context) iter.Seq2[string, *ast.Definition]
	// SystemTypes iterates engine-defined types: scalars, the introspection
	// and hugr system SDL, scalar filter/aggregation inputs — the future
	// binary-owned static prelude. Compiler-DERIVED types (filters,
	// aggregations, mutation inputs, module roots) belong to neither set.
	SystemTypes(ctx context.Context) iter.Seq2[string, *ast.Definition]
}

type Manager interface {
	// Catalog lifecycle
	AddCatalog(ctx context.Context, name string, catalog Catalog) error
	RemoveCatalog(ctx context.Context, name string) error
	ExistsCatalog(name string) bool
	ReloadCatalog(ctx context.Context, name string) error
	Engine(name string) (engines.Engine, error)
	// RegisterEngine adds an engine for planner routing without compilation.
	// Used by cluster workers where schema is already compiled in CoreDB.
	RegisterEngine(name string, engine engines.Engine)
	// SuspendCatalog marks a catalog as suspended (unavailable).
	SuspendCatalog(ctx context.Context, name string) error
	// ReactivateCatalog reactivates a suspended catalog with a new source.
	ReactivateCatalog(ctx context.Context, name string, catalog Catalog) error
	// IsSuspended returns true if the catalog is suspended.
	IsSuspended(name string) bool
}

type ModuleInfo struct {
	Name string // full dotted name; "" for the root module
	// Description is the CURATED text where a curation exists, the stored one
	// otherwise — the same overlay the entity views apply. LongDescription
	// exists only as curation and is empty without one.
	Description     string
	LongDescription string
	// RootTypes maps each PRESENT root kind to its type name
	// (sdl.ModuleTypeName). Key presence carries the information — a module
	// exists when at least one kind is present; the definition is resolved
	// LAZILY via Type(ctx, name) only when a consumer actually needs it (the
	// entity store synthesizes root types on demand — building five of them
	// per module lookup would defeat the on-the-fly model).
	RootTypes   map[sdl.ModuleObjectType]string
	DataSources []string // distinct data sources of direct members, sorted
}

type Operation struct {
	// Enriched AST operation definition
	Definition *ast.OperationDefinition

	// All fragments from the document (needed by the planner for FragmentSpread resolution)
	Fragments ast.FragmentDefinitionList

	// Transformed variables
	Variables map[string]any

	// Classified top-level query requests from the selection set
	Queries []sdl.QueryRequest

	// Combined bitmask of all query types in the operation
	QueryType sdl.QueryType
}

type ParseOption func(*parseConfig)

type Provider base.Provider

type Querier interface {
	Query(ctx context.Context, query string, vars map[string]any) (*types.Response, error)
}

type RelationDirection string

type RelationInfo struct {
	Name            string
	Direction       RelationDirection
	Kind            RelationKind
	FieldName       string // the field ON the viewed object materializing the edge
	Description     string // per-endpoint description (same perspective as FieldName)
	DataObject      string // far data object type name (M2M: the far leg, not the junction)
	Through         string // M2M junction type name; "" otherwise
	SourceKeys      []string
	DestinationKeys []string
	DataSource      string // declaring data source
}

type RelationKind string

type ReloadableCatalog = sources.ReloadableCatalog

type ReplacingCatalogManager interface {
	ReplacesCatalogOnAdd() bool
}

type Service struct {
	// contains filtered or unexported fields
}

type ServiceOption func(*Service)

type VariableTransformer interface {
	TransformVariables(ctx context.Context, vars map[string]any) (map[string]any, error)
}