@loradb/lora-graphql 0.23.0 → 0.24.0

package/dist/model/types.d.ts

@@ -204,16 +204,26 @@ export declare const RULE_REFERENCES: Set<string>;
 export type AuthorizationWhere = Record<string, unknown>;
 export interface AuthorizationFilterRule {
     operations: ReadonlySet<AuthOperation>;
+    /**
+     * Without a token the rule denies: the schema's
+     * `@authorizationDefaults(requireAuthentication:)`, and always true for
+     * a rule no anonymous request could pass.
+     */
     requireAuthentication: boolean;
-    /** `requireAuthentication` was left to its default (true). */
+    /** The schema left `requireAuthentication` to its default (true). */
     requireAuthenticationDefaulted?: boolean;
     where: AuthorizationWhere;
 }
 export interface AuthorizationValidateRule {
     operations: ReadonlySet<AuthOperation>;
     when: ReadonlySet<"BEFORE" | "AFTER">;
+    /**
+     * Without a token the rule denies: the schema's
+     * `@authorizationDefaults(requireAuthentication:)`, and always true for
+     * a rule no anonymous request could pass.
+     */
     requireAuthentication: boolean;
-    /** `requireAuthentication` was left to its default (true). */
+    /** The schema left `requireAuthentication` to its default (true). */
     requireAuthenticationDefaulted?: boolean;
     where: AuthorizationWhere;
 }

package/dist/options.d.ts

@@ -0,0 +1,255 @@
+import { DocumentNode, GraphQLFieldResolver, GraphQLScalarType } from 'graphql';
+import { LoraDriver, Statement } from './driver.js';
+import { PopulatedByCallback } from './execute/mutate/env.js';
+import { LoraTransaction } from './execute/transaction.js';
+import { DocumentGuards } from './guards.js';
+import { ModelOptions } from './model/build/limits.js';
+import { ObservabilityOptions } from './observe.js';
+export interface LoraGraphQLOptions extends ModelOptions, ObservabilityOptions {
+    /** Annotated SDL: the graph model and the API in one document. */
+    typeDefs: string | DocumentNode;
+    driver: LoraDriver;
+    /** Timeout for every statement, in milliseconds. Default 10 000; 0 disables. */
+    timeoutMs?: number;
+    /**
+     * Time budget for all root fields of one query, in milliseconds: past
+     * it, the operation's statements are aborted and its unfinished fields
+     * fail with TIMEOUT. Default twice `timeoutMs` (20 000); 0 disables.
+     * Subscriptions are not bounded by it; mutations keep `timeoutMs` per
+     * statement.
+     */
+    operationTimeoutMs?: number;
+    /**
+     * Statements one operation runs at once: aliased root fields queue for
+     * a slot instead of taking every libuv worker, so one request cannot
+     * starve the others. Default 2.
+     */
+    maxConcurrentStatements?: number;
+    /**
+     * Approximate bytes the compile cache may hold, and again the parsed
+     * document cache: entries are evicted oldest first past it, besides the
+     * entry caps. Requests with more than 16 KiB of variables a field uses
+     * (long `in:` lists, embedding vectors) are compiled but not cached.
+     * Default 64 MiB.
+     */
+    compileCacheBytes?: number;
+    /**
+     * Reject a root field whose estimated rows touched exceed this, before
+     * it runs. The estimate multiplies page sizes through nested lists,
+     * capped by relationship degrees from `analyze()` or `@cardinality`,
+     * and charges each filter the rows it examines: a label scan when no
+     * index answers it, the related nodes of every relationship it follows.
+     * Default 50 000; `Infinity` disables.
+     */
+    maxCost?: number;
+    /**
+     * The cost limit for one request, from its context (for example by
+     * user or plan). Undefined falls back to `maxCost`.
+     */
+    budget?: (context: unknown) => number | undefined;
+    /** Called with every root field's cost estimate, before it runs. */
+    onCost?: (event: CostEvent) => void;
+    /**
+     * The request's verified claims, from the GraphQL context. Default:
+     * `context.jwt`. The library never verifies tokens: do that in the
+     * server and put the claims in the context.
+     */
+    jwt?: (context: unknown) => Record<string, unknown> | undefined;
+    /**
+     * Most nodes one mutation may create, update or delete, nested ones
+     * included (and ten times as many relationships written). Default 1000: larger imports belong in a Cypher load, not a GraphQL
+     * request. Also the default `limit` of bulk updates and deletes.
+     */
+    maxBatch?: number;
+    /**
+     * Most items a list argument of a `@cypher` field takes, unless its
+     * `@size(max:)` says otherwise. More is BAD_USER_INPUT before the
+     * statement runs. Default 1000.
+     */
+    maxListArgument?: number;
+    /**
+     * Relationship levels one `where` may nest: quantifiers (`some`,
+     * `none`, `all`, `single`, `count`, `aggregate`), connection filters,
+     * `<field>Exists` and filters through a single relationship each count
+     * one. Deeper is BAD_USER_INPUT before anything runs: each level
+     * multiplies the work by the relationship's degree. Default 2.
+     */
+    maxFilterDepth?: number;
+    /**
+     * Items an `in` filter operand may hold. More is BAD_USER_INPUT before
+     * anything runs. Default 1000.
+     */
+    maxListFilter?: number;
+    /**
+     * Characters a string filter operand (`eq`, `contains`, an `in` item, …)
+     * may hold. More is BAD_USER_INPUT before anything runs. Default 10 000.
+     */
+    maxStringFilter?: number;
+    /**
+     * Changes a `changes()` consumer or subscriber may fall behind before it
+     * is ended with an error. Default 1000.
+     */
+    maxQueuedChanges?: number;
+    /**
+     * Live subscriptions one scope (see `subscriptionScope`) may hold; one
+     * more is LIMIT_EXCEEDED. Default 100.
+     */
+    maxSubscriptions?: number;
+    /**
+     * What `maxSubscriptions` counts per: by default the context object, so
+     * a server that reuses one context per connection (graphql-ws) limits
+     * each connection. Return the connection (or user) otherwise.
+     */
+    subscriptionScope?: (context: unknown) => object | undefined;
+    /**
+     * How deep relationship filters may nest in a subscription's `where`,
+     * which runs on every change. Deeper is LIMIT_EXCEEDED. Default 1.
+     */
+    maxSubscriptionFilterDepth?: number;
+    /**
+     * Per statement a subscription runs to check a change (visibility,
+     * `where`, related nodes). Default 2000, or `timeoutMs` when lower.
+     */
+    subscriptionTimeoutMs?: number;
+    /** Named callbacks for `@populatedBy(callback:)`. */
+    callbacks?: Record<string, PopulatedByCallback>;
+    /**
+     * Implementations of custom scalars declared with `@storedAs`, e.g. one
+     * that validates e-mail addresses. Without one a scalar passes through.
+     */
+    scalars?: Record<string, GraphQLScalarType>;
+    /**
+     * Feed subscriptions and `changes()` from the engine's committed change
+     * feed (lora-node `db.changes()`): every write to the database, from
+     * any path in the process that owns it, in commit order. `onWrite`
+     * still reports this instance's mutations, and `previousState` needs
+     * them. Default false.
+     */
+    changeFeed?: boolean;
+    /**
+     * Resolvers of `@customResolver` fields, by type and field name. The
+     * source holds the node's selected fields plus the field's `requires`.
+     */
+    resolvers?: Record<string, Record<string, GraphQLFieldResolver<Record<string, unknown>, unknown>>>;
+    /** Called with every statement before it runs; for logging and tests. */
+    onStatement?: (event: StatementEvent) => void;
+    /**
+     * Hide database error details from clients: they get
+     * `extensions.code` `DATABASE_ERROR` and an `id`, and `onError` gets the
+     * engine's message. Default: on when `NODE_ENV` is `production`.
+     */
+    maskErrors?: boolean;
+    /** Called with every database error, masked or not. */
+    onError?: (event: DatabaseErrorEvent) => void;
+    /**
+     * Limits on the documents `execute()`, `subscribe()` and `persist()`
+     * accept: depth,
+     * aliases, root fields, tokens, introspection. `false` turns them off.
+     * For other servers use `validationRules()` or `envelopPlugin()`.
+     */
+    guards?: DocumentGuards | false;
+    /**
+     * Make `execute()` and `subscribe()` refuse `source` and run only
+     * persisted operations by `id`. Default false.
+     */
+    persistedOnly?: boolean;
+    /**
+     * How `execute()` commits a mutation with several root fields.
+     * `"field"` (the default): each root field in its own transaction, so a
+     * later failure leaves the earlier ones committed. `"operation"`: every
+     * root field in one transaction, committed only when the operation
+     * reports no error, rolled back (with `data: null`) otherwise. A
+     * `transaction` in the context takes precedence. Envelop / Yoga servers
+     * on `getSchema()` get the same with `lora.envelopPlugin()`; other
+     * servers calling graphql-js directly put a `lora.begin()` transaction
+     * in the context (without one, a one-time warning says each root field
+     * committed on its own).
+     */
+    mutationTransaction?: "field" | "operation";
+    /**
+     * Add `extensions.timing` to `execute()` results: the request's total
+     * time, the time spent in LoraDB, and both per root field, in
+     * milliseconds. `true` for every request, or a function deciding per
+     * request from the GraphQL context (for example only for admins or in
+     * development). Default off: timings sent to clients can act as a
+     * timing side channel.
+     */
+    timing?: boolean | ((context: unknown) => boolean);
+}
+export interface CostEvent {
+    field: string;
+    /** Estimated rows this root field touches. */
+    cost: number;
+    /** Estimated rows of the operation so far, this field included. */
+    total: number;
+    /** The limit that applies: `budget(context)` or `maxCost`. */
+    limit: number;
+    context: unknown;
+}
+export interface DatabaseErrorEvent {
+    /** Correlation id, also in the client error's `extensions.id`. */
+    id: string;
+    /**
+     * The root field that failed, or `changeFeed` for a failure of the
+     * change feed (it reopens from where it stopped after a backoff).
+     */
+    field: string;
+    /** The engine's message, which may name labels, properties and Cypher. */
+    message: string;
+    /** The error as thrown by the driver. */
+    error: unknown;
+}
+export interface StatementEvent {
+    field: string;
+    statement: Statement;
+}
+/** Per-request options read from the GraphQL context, when present. */
+export interface LoraGraphQLContext {
+    /** Verified claims; enables @authentication and @authorization. */
+    jwt?: Record<string, unknown>;
+    /** Cancels the request's statements when aborted. */
+    signal?: AbortSignal;
+    /**
+     * Run in this transaction (from `lora.begin()`) instead of one per
+     * field: the caller commits, together with its own Cypher.
+     */
+    transaction?: LoraTransaction;
+}
+export interface AssertSchemaOptions {
+    /** Create what is missing instead of only reporting it. */
+    create?: boolean;
+}
+export interface CheckOptions {
+    /**
+     * Flag statements whose largest engine row estimate (from graph
+     * statistics) exceeds this. Off by default: estimates ignore a LIMIT
+     * that stops an index-ordered scan early.
+     */
+    rowBudget?: number;
+    /**
+     * Operations to compile and plan-check (S2), with example variables and
+     * the GraphQL context to compile them under (e.g. `{ jwt }`, so rules
+     * compile as they do for a signed-in caller). Without one, an operation
+     * compiles as an anonymous request would.
+     */
+    operations?: Array<{
+        name?: string;
+        document: string | DocumentNode;
+        variables?: Record<string, unknown>;
+        context?: unknown;
+    }>;
+}
+export interface ExecuteArgs {
+    /** The document, or `id` of a persisted operation. */
+    source?: string;
+    id?: string;
+    variables?: Record<string, unknown>;
+    operationName?: string;
+    context?: unknown;
+    /**
+     * Attach the operation's read-set to the result as a non-enumerable
+     * `readSet` property (never serialized to the client), for a response
+     * cache to invalidate with `lora.affects(result.readSet, change)`.
+     */
+    readSet?: boolean;
+}

package/dist/results.d.ts

@@ -0,0 +1,70 @@
+import { ExecutionResult } from 'graphql';
+import { CypherFinding } from './analyze/cypher-check.js';
+import { SchemaRequirement } from './analyze/indexes.js';
+import { PlanReport } from './analyze/plans.js';
+import { ReadSet } from './compile/read/types.js';
+import { ModelWarning } from './model/types.js';
+/** `extensions.timing` of an `execute()` result (see the `timing` option). */
+export interface ExecutionTiming {
+    /** The whole `execute()` call: parse, validation, execution. */
+    totalMs: number;
+    /** Time spent running statements in LoraDB. */
+    databaseMs: number;
+    /** Per root field, by response key (alias or name). */
+    fields: Record<string, {
+        totalMs: number;
+        databaseMs: number;
+    }>;
+}
+/** `execute()`'s result; `readSet` is there when `ExecuteArgs.readSet` asked. */
+export type LoraExecutionResult = ExecutionResult & {
+    readonly readSet?: ReadSet;
+};
+export interface SchemaAssertion {
+    required: SchemaRequirement[];
+    missing: SchemaRequirement[];
+    created: SchemaRequirement[];
+    /**
+     * Full-text and vector indexes present under their name but defined
+     * differently (labels, properties, kind): search would keep using the
+     * old definition. Without `create`; with it they are re-created.
+     */
+    mismatched: SchemaRequirement[];
+    /** Indexes `create` dropped and created again with the model's definition. */
+    recreated: SchemaRequirement[];
+}
+export interface CheckReport {
+    /** True when nothing below is a failure. */
+    ok: boolean;
+    /** Model warnings, e.g. an unused @cypher argument. */
+    warnings: readonly ModelWarning[];
+    /** @cypher statements the engine rejects or that write from a query. */
+    cypher: CypherFinding[];
+    /** Constraints and indexes the database lacks. */
+    missing: SchemaRequirement[];
+    /** Indexes the database has that no part of the API needs. */
+    unused: Array<{
+        name: string;
+        type: string;
+        labels: string[];
+        properties: string[];
+    }>;
+    /** Schema lint: valid but costly or risky choices (not failures). */
+    lint: readonly ModelWarning[];
+    /**
+     * `@mutation` types with writes no rule guards (failures): declare them
+     * with `@authorization(public: [...])` when that is intended.
+     */
+    security: readonly ModelWarning[];
+    /** Plan findings per operation and root field. */
+    plans: Array<{
+        operation: string;
+        field: string;
+        reports: PlanReport[];
+    }>;
+    /** Operations that failed to compile. */
+    errors: Array<{
+        operation: string;
+        message: string;
+    }>;
+}

package/dist/runtime/custom-requires.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLSchema } from 'graphql';
+import { GraphModel } from '../model/types.js';
+/**
+ * Every `@customResolver(requires:)` is a valid selection on its type and
+ * does not require custom fields (they are computed after the read).
+ */
+export declare function checkCustomRequires(model: GraphModel, schema: GraphQLSchema): void;

package/dist/runtime/database-error.d.ts

@@ -0,0 +1,10 @@
+import { GraphModel } from '../model/types.js';
+import { DatabaseErrorEvent } from '../options.js';
+export interface DatabaseErrorEnv {
+    model: GraphModel;
+    /** Hide database error details from clients (the `maskErrors` option). */
+    maskErrors: boolean;
+    onError: ((event: DatabaseErrorEvent) => void) | undefined;
+}
+/** The error to throw for `err`, raised while `field` ran. */
+export declare function databaseError(env: DatabaseErrorEnv, field: string, err: unknown): unknown;

package/dist/runtime/documents.d.ts

@@ -0,0 +1,35 @@
+import { DocumentNode, ExecutionResult, GraphQLSchema, OperationDefinitionNode, ValidationRule } from 'graphql';
+import { OperationManifest } from '../codegen.js';
+import { DocumentGuards } from '../guards.js';
+import { ExecuteArgs } from '../options.js';
+export interface DocumentsOptions {
+    guards: DocumentGuards | false;
+    persistedOnly: boolean;
+    /** Approximate bytes the parsed document cache may hold. */
+    bytesMax: number;
+    /** The executable schema, built on first use. */
+    schema: () => GraphQLSchema;
+    /** The configured document guards as validation rules. */
+    rules: () => ValidationRule[];
+}
+export declare class Documents {
+    #private;
+    constructor(options: DocumentsOptions);
+    /**
+     * Register persisted operations by id. Every document is parsed and
+     * validated now, so a broken one fails at startup; at request time an
+     * id is looked up and executed without parsing or validating.
+     */
+    persist(operations: Record<string, string>): void;
+    /** Register a manifest's operations, without parsing or validating. */
+    load(manifest: OperationManifest): void;
+    /** A persisted operation's document, by id. */
+    persisted(id: string): DocumentNode | undefined;
+    /** The persisted id an operation node was registered under. */
+    persistedId(operation: OperationDefinitionNode): string | undefined;
+    /**
+     * The document `args` names: a persisted one by id, or `source` parsed
+     * and validated through the cache. An error result when there is none.
+     */
+    document(args: ExecuteArgs): DocumentNode | ExecutionResult;
+}

package/dist/runtime/limits.d.ts

@@ -0,0 +1,37 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { OperationBudget } from '../execute/budget.js';
+import { LoraGraphQLOptions } from '../options.js';
+export interface OperationLimitsOptions {
+    operationTimeoutMs: number;
+    maxConcurrentStatements: number;
+    maxCost: number;
+    budget: LoraGraphQLOptions["budget"];
+    onCost: LoraGraphQLOptions["onCost"];
+}
+export declare class OperationLimits {
+    #private;
+    constructor(options: OperationLimitsOptions);
+    /** Mark `execution` as a root value `execute()` made. */
+    track(execution: object): void;
+    /** The estimated cost charged to an execution so far. */
+    spent(execution: object): number | undefined;
+    /**
+     * Charge `cost` to the operation: the limit holds per operation, so
+     * aliasing a root field many times does not multiply it. A
+     * subscription is charged per event.
+     */
+    charge(field: string, cost: number, context: unknown, info?: GraphQLResolveInfo): void;
+    /**
+     * The deadline and statement slots of the query `info` belongs to,
+     * started by its first root field. Subscriptions run indefinitely and
+     * are bounded per statement only.
+     */
+    operationBudget(context: unknown, info: GraphQLResolveInfo | undefined): OperationBudget | undefined;
+    /**
+     * A root field is done. When none is left in flight after the current
+     * turn (graphql-js starts a query's root fields together, and the next
+     * root field of a mutation in a microtask), the operation is over: a
+     * context reused for another request starts a fresh budget.
+     */
+    leaveOperation(context: object, info: GraphQLResolveInfo, budget: OperationBudget): void;
+}

package/dist/runtime/request.d.ts

@@ -0,0 +1,33 @@
+import { GraphQLError, DocumentNode, ExecutionResult, GraphQLResolveInfo, OperationDefinitionNode } from 'graphql';
+import { RootKind } from '../compile/read/types.js';
+import { SelectionContext } from '../compile/selection.js';
+import { QueryResult, Statement } from '../driver.js';
+import { LoraTransaction } from '../execute/transaction.js';
+import { GraphModel, NodeType, SearchIndex } from '../model/types.js';
+/** The read root field of a node type that `fieldName` names, if any. */
+export declare function rootOf(model: GraphModel, fieldName: string): {
+    kind: RootKind;
+    node: NodeType;
+} | undefined;
+export declare function searchOf(model: GraphModel, fieldName: string): {
+    node: NodeType;
+    index: SearchIndex;
+    connection: boolean;
+} | undefined;
+/**
+ * A mutation with several root fields; a fragment at the root counts as
+ * several, since it may hold more than one.
+ */
+export declare function multiRoot(operation: OperationDefinitionNode): boolean;
+export declare function isDocument(value: DocumentNode | ExecutionResult): value is DocumentNode;
+/**
+ * The type of the operation `operationName` selects; undefined when it
+ * selects none, which graphql then reports.
+ */
+export declare function operationType(document: DocumentNode, operationName: string | null | undefined): "query" | "mutation" | "subscription" | undefined;
+/** A variable graphql-js could not coerce: a request error with no code. */
+export declare function isVariableError(e: GraphQLError): boolean;
+export declare function findOperation(doc: DocumentNode, operationName: string | undefined): OperationDefinitionNode;
+export declare function infoContext(info: GraphQLResolveInfo): SelectionContext;
+/** Run statements one after the other in a caller-owned transaction. */
+export declare function runInOrder(tx: LoraTransaction, statements: Statement[]): Promise<QueryResult[]>;

package/dist/runtime/timing.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLResolveInfo } from 'graphql';
+/** A request's timing entry for a root field, created on first use. */
+export declare function timingEntry(timing: Map<string, {
+    totalMs: number;
+    databaseMs: number;
+}>, key: string): {
+    totalMs: number;
+    databaseMs: number;
+};
+/** The response key of the root field `info` belongs to. */
+export declare function rootKey(info: GraphQLResolveInfo | undefined): string | undefined;
+/** Milliseconds, to a hundredth. */
+export declare const ms: (value: number) => number;

package/dist/schema/aggregates.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLEnumType, GraphQLObjectType } from 'graphql';
+import { GraphModel, ScalarField } from '../model/types.js';
+import { BaseTypes } from './base.js';
+/** Fields whose values can be aggregated: ordered scalars, not lists. */
+export declare const aggregatable: (f: ScalarField) => boolean;
+export declare const isNumeric: (f: ScalarField) => boolean;
+/** The memoized `<Scalar>Aggregate` type of a field, shared by every aggregate. */
+export declare function buildAggregateFieldType(base: BaseTypes): (f: ScalarField) => GraphQLObjectType<any, any>;
+export type AggregateFieldType = ReturnType<typeof buildAggregateFieldType>;
+export declare function buildAggregates(model: GraphModel, base: BaseTypes, aggregateFieldType: AggregateFieldType): {
+    aggregates: Map<string, GraphQLObjectType<any, any>>;
+    groups: Map<string, {
+        field: GraphQLEnumType;
+        group: GraphQLObjectType;
+    }>;
+};
+export type AggregateTypes = ReturnType<typeof buildAggregates>;

package/dist/schema/base.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLInputType, GraphQLOutputType, GraphQLScalarType } from 'graphql';
+import { GraphModel, ScalarField, ScalarType } from '../model/types.js';
+import { SchemaHooks } from './hooks.js';
+export declare const nonNull: <T extends GraphQLOutputType | GraphQLInputType>(t: T) => GraphQLNonNull<T>;
+export declare const listOf: <T extends GraphQLOutputType | GraphQLInputType>(t: T) => GraphQLList<T>;
+export declare function buildBaseTypes(model: GraphModel, hooks: SchemaHooks): {
+    sortDirection: GraphQLEnumType;
+    pageInfo: GraphQLObjectType<any, any>;
+    countFilter: GraphQLInputObjectType;
+    enums: Map<string, GraphQLEnumType>;
+    nodeInterface: GraphQLInterfaceType | undefined;
+    customScalar: (name: string) => GraphQLScalarType | undefined;
+    scalarType: (f: ScalarField) => GraphQLScalarType | GraphQLEnumType | GraphQLObjectType;
+    baseType: (type: ScalarType, enumName: string | undefined) => GraphQLScalarType | GraphQLEnumType | GraphQLObjectType;
+    scalarOutput: (f: ScalarField) => GraphQLOutputType;
+};
+export type BaseTypes = ReturnType<typeof buildBaseTypes>;

package/dist/schema/build.d.ts

@@ -1,43 +1,4 @@
-import { GraphQLSchema, GraphQLFieldResolver, GraphQLResolveInfo, GraphQLScalarType } from 'graphql';
-import { RootKind } from '../compile/read.js';
-import { AbstractType, CustomField, CypherField, GraphModel, NodeType, ScalarField, SearchIndex } from '../model/types.js';
-import { MutationResolver } from './mutations.js';
-/** One event of a generated subscription. */
-export interface ChangeEvent {
-    operation: "CREATE" | "UPDATE" | "DELETE" | "CONNECT" | "DISCONNECT";
-    key: unknown;
-    /** When the write was committed, ISO-8601. */
-    timestamp?: string | undefined;
-    /** For CONNECT / DISCONNECT: the relationship and its other end. */
-    relationship?: {
-        field: string;
-        type: string;
-        relatedType: string;
-        relatedKey: unknown;
-    } | undefined;
-    /** Stored properties before the write (`previousState: true`). */
-    previous?: Record<string, unknown> | undefined;
-}
-export interface SchemaHooks {
-    resolveAbstract: (abstract: AbstractType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
-    subscribe: (node: NodeType, args: Record<string, unknown>, context: unknown) => AsyncIterable<ChangeEvent>;
-    resolveChangedNode: (node: NodeType, event: ChangeEvent, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
-    /**
-     * A `previousState` value as the subscriber may see it: throws when
-     * field-level @authentication refuses it, applies masks by the claims.
-     */
-    previousValue: (node: NodeType, field: ScalarField, value: unknown, context: unknown) => unknown;
-    /** Implementations of custom scalars, by name (the scalars option). */
-    scalars?: Readonly<Record<string, GraphQLScalarType>> | undefined;
-    /** The resolver of a `@customResolver` field (from the resolvers option). */
-    customResolver: (node: NodeType, field: CustomField) => GraphQLFieldResolver<Record<string, unknown>, unknown>;
-    resolveSearch: (node: NodeType, index: SearchIndex, info: GraphQLResolveInfo, context: unknown, connection: boolean) => Promise<unknown>;
-    resolveRoot: RootResolver;
-    resolveNode: NodeResolver;
-    resolveCypher: CypherRootResolver;
-    resolveMutation: MutationResolver;
-}
-export type CypherRootResolver = (field: CypherField, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
-export type RootResolver = (kind: RootKind, node: NodeType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
-export type NodeResolver = (id: string, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+import { GraphQLSchema } from 'graphql';
+import { GraphModel } from '../model/types.js';
+import { SchemaHooks } from './hooks.js';
 export declare function buildSchema(model: GraphModel, hooks: SchemaHooks): GraphQLSchema;

package/dist/schema/filters.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLInputObjectType, GraphQLInputType } from 'graphql';
+import { GraphModel, NodeType, RelationshipField, ScalarField } from '../model/types.js';
+import { BaseTypes } from './base.js';
+export declare function buildFilters(model: GraphModel, base: BaseTypes): {
+    inputTypeOf: (f: ScalarField) => GraphQLInputType;
+    whereOf: (typeName: string) => GraphQLInputObjectType;
+    polymorphic: (rel: RelationshipField) => boolean;
+    connectionWhere: (node: NodeType, rel: RelationshipField) => GraphQLInputObjectType;
+};
+export type Filters = ReturnType<typeof buildFilters>;

package/dist/schema/hooks.d.ts

@@ -0,0 +1,42 @@
+import { GraphQLFieldResolver, GraphQLResolveInfo, GraphQLScalarType } from 'graphql';
+import { RootKind } from '../compile/read/types.js';
+import { AbstractType, CustomField, CypherField, NodeType, ScalarField, SearchIndex } from '../model/types.js';
+import { MutationResolver } from './mutations.js';
+/** One event of a generated subscription. */
+export interface ChangeEvent {
+    operation: "CREATE" | "UPDATE" | "DELETE" | "CONNECT" | "DISCONNECT";
+    key: unknown;
+    /** When the write was committed, ISO-8601. */
+    timestamp?: string | undefined;
+    /** For CONNECT / DISCONNECT: the relationship and its other end. */
+    relationship?: {
+        field: string;
+        type: string;
+        relatedType: string;
+        relatedKey: unknown;
+    } | undefined;
+    /** Stored properties before the write (`previousState: true`). */
+    previous?: Record<string, unknown> | undefined;
+}
+export interface SchemaHooks {
+    resolveAbstract: (abstract: AbstractType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+    subscribe: (node: NodeType, args: Record<string, unknown>, context: unknown) => AsyncIterable<ChangeEvent>;
+    resolveChangedNode: (node: NodeType, event: ChangeEvent, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+    /**
+     * A `previousState` value as the subscriber may see it: throws when
+     * field-level @authentication refuses it, applies masks by the claims.
+     */
+    previousValue: (node: NodeType, field: ScalarField, value: unknown, context: unknown) => unknown;
+    /** Implementations of custom scalars, by name (the scalars option). */
+    scalars?: Readonly<Record<string, GraphQLScalarType>> | undefined;
+    /** The resolver of a `@customResolver` field (from the resolvers option). */
+    customResolver: (node: NodeType, field: CustomField) => GraphQLFieldResolver<Record<string, unknown>, unknown>;
+    resolveSearch: (node: NodeType, index: SearchIndex, info: GraphQLResolveInfo, context: unknown, connection: boolean) => Promise<unknown>;
+    resolveRoot: RootResolver;
+    resolveNode: NodeResolver;
+    resolveCypher: CypherRootResolver;
+    resolveMutation: MutationResolver;
+}
+export type CypherRootResolver = (field: CypherField, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+export type RootResolver = (kind: RootKind, node: NodeType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+export type NodeResolver = (id: string, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;