Struct Server

dagql/server.go:35–91

Server represents a GraphQL server whose schema is dynamically modified at runtime.

// Server represents a GraphQL server whose schema is dynamically modified at
// runtime.
type Server struct {
	root          AnyObjectResult
	telemetry     AroundFunc
	objects       map[string]ObjectType
	interfaces    map[string]*Interface
	scalars       map[string]ScalarType
	scalarFilters map[string]ViewFilter
	typeDefs      map[string]TypeDef
	directives    map[string]DirectiveSpec

	schemas       map[call.View]*ast.Schema
	schemaDigests map[call.View]digest.Digest
	schemaOnces   map[call.View]*sync.Once
	schemaLock    *sync.Mutex

	installLock  *sync.RWMutex
	installHooks []InstallHook

	// interfacesDirty is set when an install changes the set of objects or
	// interfaces, and cleared when interface implementations are reconciled.
	// Reconciliation is deferred until the type system is next read (see
	// reconcileInterfaceImplsIfDirty) so a burst of installs reconciles once,
	// against the complete schema, rather than once per install.
	interfacesDirty bool

	// View is the default view that is applied to queries on this server.
	//
	// WARNING: this is *not* the view of the current query (for that, inspect
	// the current id)
	View call.View

	// canonical, if set, is the server without entrypoint sugar.
	// Entrypoint proxies flatten a module's methods onto the Query root
	// as syntactic convenience; the canonical server preserves the real
	// namespace where constructors and core fields live unshadowed.
	//
	// Load, LoadType, and callers that need to bypass proxies (proxy
	// resolvers, SDK plumbing) use Canonical() to reach it.
	canonical *Server

	// nodeLoader, if set, is called by the node(id:) resolver to load
	// an object from its ID. This allows the Dagger core layer to
	// resolve IDs through a server that has all necessary module
	// dependencies installed, rather than being limited to the
	// current server's schema.
	nodeLoader func(ctx context.Context, id *call.ID) (AnyObjectResult, error)

	// resultServerForCall, if set, rebuilds a dependency-aware server from a
	// result's call graph so the cache can resolve an object class that is not
	// installed in the current server's schema. Reconstruction normally uses
	// the class captured on the shared result at construction time
	// (sharedResult.objClass); this hook is the fallback when capture missed
	// the path (e.g., persisted-envelope decode, or imports loaded by ID
	// before any class-bearing wrap). Resolved classes are cached back onto
	// the shared so subsequent reconstructions skip the hook.
	resultServerForCall func(ctx context.Context, resultCall *ResultCall) (*Server, error)
}