schemock 0.0.1

package/dist/runtime/index.d.ts

@@ -0,0 +1,814 @@
+import { o as EntitySchema, s as ViewSchema, c as RelationDefinition, C as ComputedFieldDefinition } from '../types-C2bd2vgy.js';
+import { A as Adapter } from '../types-c2AN3vky.js';
+import { HttpHandler } from 'msw';
+
+/**
+ * Schema Registry - Manages schema registration and lookup
+ *
+ * @module runtime/resolver/registry
+ * @category Runtime
+ */
+
+/**
+ * Schema Registry manages all registered entity and view schemas.
+ * Provides fast lookup and traversal of schema metadata.
+ *
+ * @example
+ * ```typescript
+ * import { SchemaRegistry } from 'schemock/runtime';
+ *
+ * const registry = new SchemaRegistry();
+ * registry.register(UserSchema);
+ * registry.register(PostSchema);
+ *
+ * const user = registry.get('user');
+ * ```
+ */
+declare class SchemaRegistry {
+    private entities;
+    private views;
+    /**
+     * Register an entity schema
+     * @param schema - The entity schema to register
+     */
+    register(schema: EntitySchema): void;
+    /**
+     * Register a view schema
+     * @param view - The view schema to register
+     */
+    registerView(view: ViewSchema): void;
+    /**
+     * Get an entity schema by name
+     * @param entityName - The entity name
+     * @returns EntitySchema or undefined if not found
+     */
+    get(entityName: string): EntitySchema | undefined;
+    /**
+     * Get an entity schema by name, throws if not found
+     * @param entityName - The entity name
+     * @returns EntitySchema
+     * @throws Error if entity not found
+     */
+    getOrThrow(entityName: string): EntitySchema;
+    /**
+     * Get a view schema by name
+     * @param viewName - The view name
+     * @returns ViewSchema or undefined if not found
+     */
+    getView(viewName: string): ViewSchema | undefined;
+    /**
+     * Get a view schema by name, throws if not found
+     * @param viewName - The view name
+     * @returns ViewSchema
+     * @throws Error if view not found
+     */
+    getViewOrThrow(viewName: string): ViewSchema;
+    /**
+     * Get all registered entity schemas
+     * @returns Array of all entity schemas
+     */
+    getAll(): EntitySchema[];
+    /**
+     * Get all registered view schemas
+     * @returns Array of all view schemas
+     */
+    getAllViews(): ViewSchema[];
+    /**
+     * Check if an entity schema is registered
+     * @param entityName - The entity name
+     * @returns true if registered
+     */
+    has(entityName: string): boolean;
+    /**
+     * Check if a view schema is registered
+     * @param viewName - The view name
+     * @returns true if registered
+     */
+    hasView(viewName: string): boolean;
+    /**
+     * Get all relations for an entity
+     * @param entityName - The entity name
+     * @returns Array of relation definitions with their names
+     */
+    getRelationsFor(entityName: string): Array<{
+        name: string;
+        relation: RelationDefinition;
+    }>;
+    /**
+     * Get all entities that have a relation to a target entity
+     * @param targetEntityName - The target entity name
+     * @returns Array of entity names that reference the target
+     */
+    getEntitiesReferencingEntity(targetEntityName: string): string[];
+    /**
+     * Get entity names in dependency order (topological sort)
+     * Entities with no dependencies come first
+     * @returns Array of entity names in order
+     */
+    getEntityOrder(): string[];
+    /**
+     * Clear all registered schemas
+     */
+    clear(): void;
+    /**
+     * Get entity count
+     */
+    get entityCount(): number;
+    /**
+     * Get view count
+     */
+    get viewCount(): number;
+}
+/**
+ * Global schema registry instance
+ */
+declare const registry: SchemaRegistry;
+
+/**
+ * Computed Field Resolver - Handles resolution of computed/derived fields
+ *
+ * @module runtime/resolver/computed
+ * @category Runtime
+ */
+
+/**
+ * Context passed to computed field resolvers
+ */
+interface ResolverContext {
+    /** Current user ID for auth-related computations */
+    currentUserId?: string;
+    /** Request parameters */
+    params?: Record<string, unknown>;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Mode: 'seed' uses mock(), 'resolve' uses resolve() */
+    mode: 'seed' | 'resolve';
+}
+/**
+ * Database entity operations interface
+ */
+interface DatabaseEntity {
+    findFirst(query: unknown): unknown;
+    findMany(query: unknown): unknown[];
+    count(query?: unknown): number;
+    create?(data: unknown): unknown;
+    update?(query: unknown): unknown;
+    delete?(query: unknown): unknown;
+}
+/**
+ * Generic database interface for computed field resolvers
+ */
+interface Database {
+    [entityName: string]: DatabaseEntity;
+}
+/**
+ * Sorts computed fields by their dependencies using topological sort.
+ * Fields with no dependencies come first, fields that depend on others come later.
+ *
+ * @param fields - Array of [fieldName, definition] tuples to sort
+ * @param allComputed - Full record of all computed field definitions
+ * @returns Sorted array of [fieldName, definition] tuples
+ * @throws Error if circular dependency is detected
+ *
+ * @example
+ * ```typescript
+ * const fields = [
+ *   ['avgViews', { dependsOn: ['totalViews', 'postCount'] }],
+ *   ['postCount', { dependsOn: [] }],
+ *   ['totalViews', { dependsOn: ['postCount'] }],
+ * ];
+ *
+ * const sorted = topologicalSort(fields, allComputed);
+ * // Returns: [['postCount', ...], ['totalViews', ...], ['avgViews', ...]]
+ * ```
+ */
+declare function topologicalSort<T extends ComputedFieldDefinition>(fields: Array<[string, T]>, allComputed: Record<string, ComputedFieldDefinition>): Array<[string, T]>;
+/**
+ * Clears the compute cache. Should be called at the start of each request.
+ */
+declare function clearComputeCache(): void;
+/**
+ * Resolves a single computed field for an entity.
+ *
+ * @param entity - The entity to compute the field for
+ * @param fieldName - The name of the computed field
+ * @param computed - The computed field definition
+ * @param db - Database interface for queries
+ * @param context - Resolver context
+ * @returns The computed value
+ *
+ * @example
+ * ```typescript
+ * const postCount = resolveComputedField(
+ *   user,
+ *   'postCount',
+ *   { resolve: (user, db) => db.post.count({ where: { authorId: user.id } }) },
+ *   db,
+ *   { mode: 'resolve' }
+ * );
+ * ```
+ */
+declare function resolveComputedField<T>(entity: Record<string, unknown>, fieldName: string, computed: ComputedFieldDefinition<T>, db: Database, context: ResolverContext): T | Promise<T>;
+/**
+ * Resolves all computed fields for an entity.
+ * Fields are resolved in dependency order.
+ *
+ * @param entity - The entity to resolve computed fields for
+ * @param schema - The entity schema
+ * @param db - Database interface for queries
+ * @param context - Resolver context
+ * @returns The entity with computed fields resolved (mutates and returns the same object)
+ *
+ * @example
+ * ```typescript
+ * const user = await resolveComputedFields(rawUser, UserSchema, db, { mode: 'resolve' });
+ * console.log(user.postCount); // Now available
+ * ```
+ */
+declare function resolveComputedFields<T extends Record<string, unknown>>(entity: T, schema: EntitySchema, db: Database, context: ResolverContext): Promise<T>;
+/**
+ * Resolves computed fields synchronously (for mock mode where all mocks are sync)
+ *
+ * @param entity - The entity to resolve computed fields for
+ * @param schema - The entity schema
+ * @param context - Resolver context (should have mode: 'seed')
+ * @returns The entity with computed fields resolved
+ */
+declare function resolveComputedFieldsSync<T extends Record<string, unknown>>(entity: T, schema: EntitySchema, context: ResolverContext): T;
+
+/**
+ * Relation Resolver - Handles lazy and eager loading of entity relations
+ *
+ * @module runtime/resolver/relation
+ * @category Runtime
+ */
+
+/**
+ * Options for resolving relations
+ */
+interface ResolveRelationOptions {
+    /** Specific relations to include (by name or nested path like 'posts.comments') */
+    include?: string[];
+    /** Maximum depth for nested relation resolution */
+    depth?: number;
+    /** Default limit for hasMany relations */
+    limit?: number;
+    /** Default ordering for hasMany relations */
+    orderBy?: Record<string, 'asc' | 'desc'>;
+}
+/**
+ * Resolves a single relation for an entity.
+ *
+ * @param entity - The source entity
+ * @param relationName - Name of the relation field
+ * @param relation - The relation definition
+ * @param db - Database interface
+ * @param registry - Schema registry
+ * @param options - Resolution options
+ * @param currentDepth - Current recursion depth
+ * @returns The related entity/entities or null/empty array
+ *
+ * @example
+ * ```typescript
+ * const posts = await resolveRelation(
+ *   user,
+ *   'posts',
+ *   { type: 'hasMany', target: 'post', foreignKey: 'authorId' },
+ *   db,
+ *   registry,
+ *   { limit: 10 }
+ * );
+ * ```
+ */
+declare function resolveRelation<T>(entity: Record<string, unknown>, relationName: string, relation: RelationDefinition, db: Database, registry: SchemaRegistry, options?: ResolveRelationOptions, currentDepth?: number): Promise<T | T[] | null>;
+/**
+ * Resolves all relations for an entity.
+ *
+ * @param entity - The entity to resolve relations for
+ * @param schema - The entity schema
+ * @param db - Database interface
+ * @param registry - Schema registry
+ * @param options - Resolution options
+ * @returns The entity with relations resolved (mutates and returns same object)
+ *
+ * @example
+ * ```typescript
+ * const user = await resolveRelations(rawUser, UserSchema, db, registry, {
+ *   include: ['profile', 'posts', 'posts.comments'],
+ * });
+ * ```
+ */
+declare function resolveRelations<T extends Record<string, unknown>>(entity: T, schema: EntitySchema, db: Database, registry: SchemaRegistry, options?: ResolveRelationOptions): Promise<T>;
+/**
+ * Eagerly loads relations for multiple entities (batch loading).
+ * More efficient than loading relations one-by-one.
+ *
+ * @param entities - Array of entities to load relations for
+ * @param schema - The entity schema
+ * @param db - Database interface
+ * @param registry - Schema registry
+ * @param options - Resolution options
+ * @returns The entities with relations resolved
+ *
+ * @example
+ * ```typescript
+ * const users = await eagerLoadRelations(rawUsers, UserSchema, db, registry, {
+ *   include: ['profile'],
+ * });
+ * ```
+ */
+declare function eagerLoadRelations<T extends Record<string, unknown>>(entities: T[], schema: EntitySchema, db: Database, registry: SchemaRegistry, options?: ResolveRelationOptions): Promise<T[]>;
+
+/**
+ * View Resolver - Executes view queries by applying filters and transforms
+ *
+ * @module runtime/resolver/view
+ * @category Runtime
+ */
+
+/**
+ * Options for resolving a view
+ */
+interface ViewResolveOptions {
+    /** URL parameters */
+    params: Record<string, string>;
+    /** Resolver context */
+    context: ResolverContext;
+}
+/**
+ * ViewResolver handles resolution of view schemas.
+ * Views are computed projections over entity data.
+ *
+ * @example
+ * ```typescript
+ * const viewResolver = new ViewResolver(registry, db);
+ * const userFull = await viewResolver.resolve(UserFullView, { id: '123' });
+ * ```
+ */
+declare class ViewResolver {
+    private registry;
+    private db;
+    constructor(registry: SchemaRegistry, db: Database);
+    /**
+     * Resolves a view schema with given parameters.
+     *
+     * @param view - The view schema to resolve
+     * @param params - URL parameters for the view
+     * @param context - Optional resolver context
+     * @returns The resolved view data
+     *
+     * @example
+     * ```typescript
+     * const userData = await viewResolver.resolve(UserFullView, { id: 'user-123' });
+     * ```
+     */
+    resolve<T>(view: ViewSchema, params: Record<string, string>, context?: Partial<ResolverContext>): Promise<T>;
+    /**
+     * Builds the view result by resolving all fields
+     */
+    private buildViewResult;
+    /**
+     * Check if a field definition is a nested object
+     */
+    private isNestedObjectField;
+    /**
+     * Resolves an embedded entity field
+     */
+    private resolveEmbed;
+    /**
+     * Guess the parent entity name from the view endpoint
+     */
+    private guessParentEntityName;
+    /**
+     * Resolves a computed field within a view context
+     */
+    private resolveViewComputedField;
+    /**
+     * Resolves a nested object containing fields and computed values
+     */
+    private resolveNestedObject;
+    /**
+     * Resolves a view with mock data (for seeding)
+     */
+    resolveMock<T>(view: ViewSchema, params: Record<string, string>): Promise<T>;
+}
+/**
+ * Creates a new ViewResolver instance
+ *
+ * @param registry - Schema registry
+ * @param db - Database interface
+ * @returns ViewResolver instance
+ */
+declare function createViewResolver(registry: SchemaRegistry, db: Database): ViewResolver;
+
+/**
+ * Main Resolver Engine - Core CRUD operations with relation and computed field resolution
+ *
+ * @module runtime/resolver
+ * @category Runtime
+ */
+
+/**
+ * Options for single entity queries
+ */
+interface EntityQueryOptions extends ResolveRelationOptions {
+    /** Filter conditions */
+    where?: Record<string, unknown>;
+    /** Specific computed fields to resolve */
+    computed?: string[];
+}
+/**
+ * Options for list queries
+ */
+interface ListQueryOptions extends EntityQueryOptions {
+    /** Maximum number of results */
+    limit?: number;
+    /** Number of results to skip (for pagination) */
+    offset?: number;
+    /** Sort order */
+    orderBy?: Record<string, 'asc' | 'desc'>;
+}
+/**
+ * Options for count queries
+ */
+interface CountOptions {
+    /** Filter conditions */
+    where?: Record<string, unknown>;
+}
+/**
+ * Create input type (partial entity without id)
+ */
+type CreateInput<T> = Omit<Partial<T>, 'id'>;
+/**
+ * Update input type (partial entity)
+ */
+type UpdateInput<T> = Partial<T>;
+/**
+ * Main resolver engine for CRUD operations.
+ * Orchestrates relation loading, computed field resolution, and database queries.
+ *
+ * @example
+ * ```typescript
+ * const resolver = new Resolver(registry, db);
+ *
+ * // Find one with relations
+ * const user = await resolver.findOne('user', '123', {
+ *   include: ['profile', 'posts'],
+ * });
+ *
+ * // Find many with pagination
+ * const users = await resolver.findMany('user', {
+ *   limit: 20,
+ *   offset: 0,
+ *   orderBy: { createdAt: 'desc' },
+ * });
+ * ```
+ */
+declare class Resolver {
+    private registry;
+    private db;
+    private context;
+    private viewResolver;
+    constructor(registry: SchemaRegistry, db: Database, context?: Partial<ResolverContext>);
+    /**
+     * Find a single entity by ID
+     *
+     * @param entityName - The entity type to find
+     * @param id - The entity ID
+     * @param options - Query options (relations, computed fields)
+     * @returns The entity or null if not found
+     *
+     * @example
+     * ```typescript
+     * const user = await resolver.findOne('user', '123', {
+     *   include: ['profile'],
+     *   computed: ['postCount'],
+     * });
+     * ```
+     */
+    findOne<T extends Record<string, unknown>>(entityName: string, id: string, options?: EntityQueryOptions): Promise<T | null>;
+    /**
+     * Find multiple entities with filtering and pagination
+     *
+     * @param entityName - The entity type to find
+     * @param options - Query options (filters, pagination, relations)
+     * @returns Array of entities
+     *
+     * @example
+     * ```typescript
+     * const users = await resolver.findMany('user', {
+     *   where: { role: 'admin' },
+     *   limit: 20,
+     *   offset: 0,
+     *   include: ['profile'],
+     * });
+     * ```
+     */
+    findMany<T extends Record<string, unknown>>(entityName: string, options?: ListQueryOptions): Promise<T[]>;
+    /**
+     * Create a new entity
+     *
+     * @param entityName - The entity type to create
+     * @param data - The entity data
+     * @param options - Query options for the returned entity
+     * @returns The created entity with relations and computed fields
+     *
+     * @example
+     * ```typescript
+     * const user = await resolver.create('user', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     * });
+     * ```
+     */
+    create<T extends Record<string, unknown>>(entityName: string, data: CreateInput<T>, options?: EntityQueryOptions): Promise<T>;
+    /**
+     * Update an existing entity
+     *
+     * @param entityName - The entity type to update
+     * @param id - The entity ID
+     * @param data - The update data
+     * @param options - Query options for the returned entity
+     * @returns The updated entity or null if not found
+     *
+     * @example
+     * ```typescript
+     * const user = await resolver.update('user', '123', {
+     *   name: 'Jane Doe',
+     * });
+     * ```
+     */
+    update<T extends Record<string, unknown>>(entityName: string, id: string, data: UpdateInput<T>, options?: EntityQueryOptions): Promise<T | null>;
+    /**
+     * Delete an entity by ID
+     *
+     * @param entityName - The entity type to delete
+     * @param id - The entity ID
+     * @returns true if deleted, false if not found
+     *
+     * @example
+     * ```typescript
+     * const deleted = await resolver.delete('user', '123');
+     * ```
+     */
+    delete(entityName: string, id: string): boolean;
+    /**
+     * Count entities matching a filter
+     *
+     * @param entityName - The entity type to count
+     * @param options - Count options (filters)
+     * @returns The count
+     *
+     * @example
+     * ```typescript
+     * const adminCount = await resolver.count('user', {
+     *   where: { role: 'admin' },
+     * });
+     * ```
+     */
+    count(entityName: string, options?: CountOptions): number;
+    /**
+     * Resolve a view with parameters
+     *
+     * @param viewName - The view name
+     * @param params - View parameters
+     * @returns The resolved view data
+     *
+     * @example
+     * ```typescript
+     * const userFull = await resolver.view('user-full', { id: '123' });
+     * ```
+     */
+    view<T>(viewName: string, params: Record<string, string>): Promise<T | null>;
+    /**
+     * Build a where clause from simple object to database format
+     */
+    private buildWhereClause;
+    /**
+     * Get the current resolver context
+     */
+    getContext(): ResolverContext;
+    /**
+     * Create a new resolver with updated context
+     */
+    withContext(context: Partial<ResolverContext>): Resolver;
+}
+/**
+ * Creates a new Resolver instance
+ *
+ * @param registry - Schema registry
+ * @param db - Database interface
+ * @param context - Optional resolver context
+ * @returns Resolver instance
+ *
+ * @example
+ * ```typescript
+ * const resolver = createResolver(registry, db, {
+ *   currentUserId: 'user-123',
+ * });
+ * ```
+ */
+declare function createResolver(registry: SchemaRegistry, db: Database, context?: Partial<ResolverContext>): Resolver;
+
+/**
+ * Runtime Setup - Initialize mock runtime with MSW worker
+ *
+ * Provides setup functions for initializing the mock server
+ * in both browser and Node.js environments.
+ *
+ * @module runtime/setup
+ * @category Runtime
+ */
+
+/**
+ * Setup options for runtime initialization.
+ */
+interface SetupOptions {
+    /** The adapter to use */
+    adapter: Adapter;
+    /** Entity schemas */
+    schemas: EntitySchema[];
+    /** Whether to start MSW (browser only) */
+    startMsw?: boolean;
+    /** MSW handler options */
+    mswOptions?: {
+        /** Base URL for handlers */
+        baseUrl?: string;
+        /** Whether to log requests */
+        quiet?: boolean;
+    };
+}
+/**
+ * Initialize the mock runtime.
+ *
+ * Sets up the adapter, registers schemas, and optionally starts
+ * the MSW service worker for browser environments.
+ *
+ * @returns Promise that resolves when setup is complete
+ *
+ * @example
+ * ```typescript
+ * import { setup } from 'schemock/runtime';
+ * import { createMockAdapter } from 'schemock/adapters';
+ *
+ * await setup({
+ *   adapter: createMockAdapter([userSchema, postSchema]),
+ *   schemas: [userSchema, postSchema],
+ *   startMsw: true,
+ * });
+ * ```
+ */
+declare function setup(options?: SetupOptions): Promise<void>;
+/**
+ * Teardown the runtime and clean up resources.
+ *
+ * @example
+ * ```typescript
+ * await teardown();
+ * ```
+ */
+declare function teardown(): Promise<void>;
+/**
+ * Check if the runtime is initialized.
+ *
+ * @returns True if initialized
+ */
+declare function isInitialized(): boolean;
+/**
+ * Get the active adapter.
+ *
+ * @returns The adapter or null
+ */
+declare function getAdapter(): Adapter | null;
+/**
+ * Set the active adapter (for testing or manual configuration).
+ *
+ * @param adapter - The adapter to set
+ */
+declare function setAdapter(adapter: Adapter): void;
+
+/**
+ * Seed Function - Populate database with fake data
+ *
+ * Seeds the MockAdapter database with generated fake data
+ * based on entity schemas and specified counts.
+ *
+ * @module runtime/seed
+ * @category Runtime
+ */
+/**
+ * Seed the database with fake data.
+ *
+ * Uses the configured MockAdapter to generate and persist
+ * fake entities based on the provided counts.
+ *
+ * @param counts - Map of entity names to number of items to create
+ *
+ * @example
+ * ```typescript
+ * import { seed } from 'schemock/runtime';
+ *
+ * // Seed with specific counts
+ * seed({
+ *   user: 10,
+ *   post: 50,
+ *   comment: 100,
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Seed in a setup function
+ * async function initMockData() {
+ *   await setup({ adapter, schemas });
+ *   seed({ user: 5, project: 10 });
+ * }
+ * ```
+ */
+declare function seed(counts: Record<string, number>): void;
+/**
+ * Reset the database to empty state.
+ *
+ * Clears all data from the MockAdapter database.
+ *
+ * @example
+ * ```typescript
+ * import { reset } from 'schemock/runtime';
+ *
+ * // Clear all mock data
+ * reset();
+ * ```
+ */
+declare function reset(): void;
+/**
+ * Seed with related data (maintains referential integrity).
+ *
+ * Seeds entities in dependency order, ensuring foreign keys
+ * reference valid parent entities.
+ *
+ * @param counts - Map of entity names to counts
+ * @param relations - Map of entity to foreign key relationships
+ *
+ * @example
+ * ```typescript
+ * import { seedWithRelations } from 'schemock/runtime';
+ *
+ * seedWithRelations(
+ *   { user: 5, post: 20 },
+ *   { post: { authorId: 'user' } }
+ * );
+ * ```
+ */
+declare function seedWithRelations(counts: Record<string, number>, relations: Record<string, Record<string, string>>): void;
+
+/**
+ * MSW Handlers Generator - REST handlers for all CRUD operations
+ *
+ * Generates MSW (Mock Service Worker) HTTP handlers from entity schemas,
+ * enabling automatic request interception for the MockAdapter.
+ *
+ * @module runtime/handlers
+ * @category Runtime
+ */
+
+/**
+ * Handler options for customizing MSW behavior.
+ */
+interface HandlerOptions {
+    /** Base URL for API endpoints */
+    baseUrl?: string;
+    /** Whether to log requests */
+    quiet?: boolean;
+}
+/**
+ * Create MSW REST handlers for all CRUD operations on entity schemas.
+ *
+ * Generates handlers for:
+ * - GET /{entity} - List all entities
+ * - GET /{entity}/:id - Get single entity
+ * - POST /{entity} - Create new entity
+ * - PUT /{entity}/:id - Update entity
+ * - PATCH /{entity}/:id - Partial update entity
+ * - DELETE /{entity}/:id - Delete entity
+ *
+ * @param schemas - Array of entity schemas to create handlers for
+ * @param adapter - The adapter to use for operations
+ * @param options - Handler configuration options
+ * @returns Array of MSW HTTP handlers
+ *
+ * @example
+ * ```typescript
+ * import { createHandlers } from 'schemock/runtime';
+ * import { setupWorker } from 'msw/browser';
+ *
+ * const handlers = createHandlers([userSchema, postSchema], mockAdapter, {
+ *   baseUrl: '/api',
+ * });
+ *
+ * const worker = setupWorker(...handlers);
+ * await worker.start();
+ * ```
+ */
+declare function createHandlers(schemas: EntitySchema[], adapter: Adapter, options?: HandlerOptions): HttpHandler[];
+
+export { type CountOptions, type CreateInput, type Database, type EntityQueryOptions, type HandlerOptions, type ListQueryOptions, type ResolveRelationOptions, Resolver, type ResolverContext, SchemaRegistry, type SetupOptions, type UpdateInput, type ViewResolveOptions, ViewResolver, clearComputeCache, createHandlers, createResolver, createViewResolver, eagerLoadRelations, getAdapter, isInitialized, registry, reset, resolveComputedField, resolveComputedFields, resolveComputedFieldsSync, resolveRelation, resolveRelations, seed, seedWithRelations, setAdapter, setup, teardown, topologicalSort };