@loradb/lora-graphql 0.23.0 → 0.24.0

package/dist/execute/cypher-mutation.d.ts

@@ -1,7 +1,7 @@
 import { FieldNode } from 'graphql';
 import { Statement } from '../driver.js';
 import { CypherField } from '../model/types.js';
-import { MutationEnv } from './mutate.js';
+import { MutationEnv } from './mutate/env.js';
 export declare function executeCypherMutation(env: MutationEnv, field: CypherField, args: Record<string, unknown>, fieldNodes: readonly FieldNode[], 
 /** The field's `viewer` rules, checked in the transaction first. */
 guard?: Statement): Promise<unknown>;

package/dist/execute/mutate/adjust.d.ts

@@ -0,0 +1,5 @@
+import { CompileContext } from '../../compile/context.js';
+import { NodeType } from '../../model/types.js';
+import { Input } from './plan.js';
+/** `n.p = <expr>` assignments for an `adjust` input. */
+export declare function compileAdjust(ctx: CompileContext, node: NodeType, adjust: Input | undefined): string[];

package/dist/execute/mutate/checks.d.ts

@@ -0,0 +1,21 @@
+import { WritePlan } from './plan.js';
+import { Runner } from './runner.js';
+/**
+ * A single relationship field allows one related node, whichever side
+ * the relationship was created from. Check every node that gained one.
+ */
+export declare function checkCardinality(runner: Runner, plan: WritePlan): Promise<void>;
+/**
+ * `@uniqueTogether`: after every write of the mutation, no two nodes of
+ * a constrained type share a combination. Checks the nodes it created
+ * or updated and the nodes whose constrained relationships it connected
+ * or disconnected, from either side, against the nodes reachable
+ * through the same ends. For every caller: a data invariant, not a
+ * rule, so the bypass does not skip it.
+ */
+export declare function checkUniqueTogether(runner: Runner): Promise<void>;
+/**
+ * A required single relationship stays set: disconnecting from the other
+ * side must not leave the owner without one.
+ */
+export declare function checkRequired(runner: Runner): Promise<void>;

package/dist/execute/mutate/delete.d.ts

@@ -0,0 +1,7 @@
+import { NodeType } from '../../model/types.js';
+import { Runner } from './runner.js';
+/**
+ * Delete nodes by key, with what `onDelete: CASCADE` reaches. Checks
+ * BEFORE rules, RESTRICT, and required relationships of the survivors.
+ */
+export declare function deleteNodes(runner: Runner, root: NodeType, keys: unknown[]): Promise<void>;

package/dist/execute/mutate/env.d.ts

@@ -0,0 +1,73 @@
+import { Statistics } from '../../analyze/statistics.js';
+import { SelectionContext } from '../../compile/selection.js';
+import { DriverTransaction, LoraDriver, QueryResult, Statement } from '../../driver.js';
+import { GraphModel, NodeType } from '../../model/types.js';
+import { WriteChange } from '../changes.js';
+/** Computes a `@populatedBy` field. */
+export type PopulatedByCallback = (args: {
+    operation: "CREATE" | "UPDATE";
+    /** Node type and field being populated. */
+    type: string;
+    field: string;
+    key: unknown;
+    /** The node's input in this mutation. */
+    input: Record<string, unknown>;
+    /** The GraphQL context. */
+    context: unknown;
+}) => unknown;
+export interface MutationEnv {
+    model: GraphModel;
+    driver: LoraDriver;
+    /** The caller's node's @key, for @key(scope: VIEWER) (see executeMutation). */
+    viewerKey?: unknown;
+    selection: SelectionContext;
+    jwt: Record<string, unknown> | undefined;
+    /** The GraphQL context, for `$context` in rules and for callbacks. */
+    requestContext: unknown;
+    timeoutMs: number;
+    signal: AbortSignal | undefined;
+    degrees: ReadonlyMap<string, number>;
+    /**
+     * Most nodes one mutation may create, update or delete, nested ones
+     * included; relationships written, ten times as many.
+     */
+    maxBatch: number;
+    /** Most items a @cypher list argument takes without `@size(max:)`. */
+    maxListArgument?: number | undefined;
+    /** Relationship levels one `where` may nest. */
+    maxFilterDepth?: number | undefined;
+    /** Items an `in` filter operand may hold. */
+    maxListFilter?: number | undefined;
+    /** Characters a string filter operand may hold. */
+    maxStringFilter?: number | undefined;
+    /** Statistics from `analyze()`, for filter costs. */
+    statistics?: Statistics | undefined;
+    callbacks: Readonly<Record<string, PopulatedByCallback>>;
+    /**
+     * A caller-owned transaction: run inside it and leave the commit to the
+     * caller. A failed mutation rolls it back, so it is never half-applied.
+     */
+    transaction?: DriverTransaction | undefined;
+    /** Observes every statement, for logging and tests. */
+    onStatement?: ((statement: Statement) => void) | undefined;
+    /** Runs a statement under timing, tracing and metrics, when configured. */
+    observe?: ((statement: Statement, run: () => Promise<QueryResult>) => Promise<QueryResult>) | undefined;
+    /**
+     * Called inside the transaction once a delete knows every node it
+     * removes, before any is removed: subscribers' checks of the nodes as
+     * they were (a deleted node cannot be checked after the commit).
+     */
+    beforeDelete?: ((change: WriteChange, doomed: ReadonlyArray<{
+        node: NodeType;
+        keys: unknown[];
+    }>, run: (statement: Statement) => Promise<QueryResult>) => Promise<void>) | undefined;
+}
+/** Run `statement` in `tx`, reporting it before and observing it during. */
+export declare function runStatement(env: MutationEnv, tx: DriverTransaction, statement: Statement): Promise<QueryResult>;
+export interface MutationInfo {
+    nodesCreated: number;
+    nodesUpdated: number;
+    nodesDeleted: number;
+    relationshipsCreated: number;
+    relationshipsDeleted: number;
+}

package/dist/execute/mutate/errors.d.ts

@@ -0,0 +1,7 @@
+import { GraphModel, NodeType, RelationshipField } from '../../model/types.js';
+export declare function notConnected(owner: NodeType, rel: RelationshipField, target: NodeType, to: unknown): import('graphql').GraphQLError;
+/** In place of the key of a node the caller cannot read, in messages. */
+export declare const HIDDEN: unique symbol;
+export declare function requiredMissing(owner: NodeType, field: RelationshipField, target: string, key: unknown): import('graphql').GraphQLError;
+/** Turn engine constraint errors into CONSTRAINT_VIOLATION naming the field. */
+export declare function mapWriteError(model: GraphModel, err: unknown): unknown;

package/dist/execute/mutate/fragments.d.ts

@@ -0,0 +1,37 @@
+import { CompileContext } from '../../compile/context.js';
+import { Expr } from '../../compile/cypher.js';
+import { Field, GraphModel, NodeType, RelationshipField } from '../../model/types.js';
+import { RelationshipRef } from '../changes.js';
+/** `@timestamp` fields for `op`: [property, now-expression]. */
+export declare function timestamps(node: {
+    fields: ReadonlyMap<string, Field>;
+}, op: "CREATE" | "UPDATE"): Array<[string, string]>;
+/** `, r.p = <now>` for a relationship's `@timestamp(operations: [UPDATE])`s. */
+export declare function edgeStamps(model: GraphModel, rel: RelationshipField): string;
+/** `-[r:T]->(b:Target)` in the direction the owner's field declares. */
+export declare function arrow(rel: RelationshipField, r: string, b: string, target: NodeType | undefined): string;
+/**
+ * `b:Label`: LoraDB 0.15 ignores the labels of every node after the first
+ * in a MATCH pattern, so expansions test them explicitly.
+ */
+export declare function labelTest(variable: string, node: NodeType): string;
+/**
+ * `MATCH (a:Owner) WHERE a.key = <key>` then `MATCH (a)-[r:T]->(b:Target)
+ * WHERE b:Target`, for callers to extend with ` AND ...`. The key test gets
+ * its own MATCH so it becomes an index seek: LoraDB 0.15 only seeks when
+ * the test sits directly on a node scan, and one pattern with the test in
+ * its WHERE expands every relationship of the type first.
+ */
+export declare function seekThenExpand(a: string, owner: NodeType, key: string, rel: RelationshipField, r: string, b: string, target: NodeType): string;
+/** `row.fresh OR (<expr>)`: a filter that nodes this mutation creates skip. */
+export declare const orFresh: (e: Expr | undefined) => Expr | undefined;
+/** `AND (<expr>)`, or nothing. */
+export declare const andText: (e: Expr | undefined) => string;
+/** Fields on the other side of `rel`'s relationship type, pointing back. */
+export declare function inverseFields(model: GraphModel, rel: RelationshipField): RelationshipField[];
+/** Whether the caller can read `variable` (a `node`): a boolean expression. */
+export declare function readable(ctx: CompileContext, node: NodeType, variable: string): string;
+/** `x:A OR x:B`: the field's target types (one, or an abstract's members). */
+export declare function memberTest(model: GraphModel, variable: string, field: RelationshipField): string;
+export declare function dedupe(keys: unknown[]): unknown[];
+export declare function relRef(rel: RelationshipField, from: unknown, to: unknown): RelationshipRef;

package/dist/execute/mutate/plan.d.ts

@@ -0,0 +1,95 @@
+import { CompileContext } from '../../compile/context.js';
+import { GraphModel, NodeType, RelationshipField, ScalarField } from '../../model/types.js';
+import { MutationEnv } from './env.js';
+export type Input = Record<string, unknown>;
+export interface Link {
+    rel: RelationshipField;
+    /** @key of the node declaring the field. */
+    from: unknown;
+    /** @key of the target node. */
+    to: unknown;
+    /** Relationship properties the input sets. */
+    props: Record<string, unknown>;
+    /** `@default`s of the properties it leaves out: for a new relationship only. */
+    defaults: Record<string, unknown>;
+    /**
+     * Relationship properties the input sets whose rules refuse it when the
+     * relationship is new (`create`) or already exists (`update`): known
+     * only once the MERGE ran, so the check follows it (and rolls back).
+     */
+    refused?: {
+        create?: Error;
+        update?: Error;
+    };
+}
+export interface CreateRow {
+    key: unknown;
+    props: Input;
+    /**
+     * Fields the input sets. Field rules guard these only: a `@default`,
+     * `@populatedBy` value or generated key is the server's, not the
+     * caller's write (G-22).
+     */
+    written: Set<string>;
+}
+export interface EdgeUpdate {
+    rel: RelationshipField;
+    from: unknown;
+    /** Target key; undefined for a single relationship's current target. */
+    to: unknown;
+    set: Input;
+    remove: string[];
+}
+export interface NodeUpdate {
+    rel: RelationshipField;
+    from: unknown;
+    to: unknown;
+    input: Input;
+}
+/** Writes planned from one mutation's input. */
+export declare class WritePlan {
+    readonly env: MutationEnv;
+    readonly ctx: CompileContext;
+    creates: Map<NodeType, CreateRow[]>;
+    links: Link[];
+    disconnects: Array<{
+        rel: RelationshipField;
+        from: unknown;
+        /** Keys to disconnect; undefined: every current target (single fields). */
+        to: unknown[] | undefined;
+        /**
+         * Replacing a single relationship: the target being connected, whose
+         * relationship (and its properties) stays if it is already there.
+         */
+        keep?: unknown;
+    }>;
+    edgeUpdates: EdgeUpdate[];
+    nodeUpdates: NodeUpdate[];
+    /** `update: { rel: { delete } }`: connected nodes to delete. */
+    nestedDeletes: Array<{
+        rel: RelationshipField;
+        from: unknown;
+        where: Input | undefined;
+        limit: number | undefined;
+    }>;
+    /** `@populatedBy` callbacks for planned creates. */
+    pending: Array<() => Promise<void>>;
+    constructor(env: MutationEnv, ctx: CompileContext);
+    get model(): GraphModel;
+    /**
+     * Whether this plan creates the `type` node with `key`. Creates run
+     * before links, so such a node has only the relationships this plan
+     * gives it.
+     */
+    isFresh(type: string, key: unknown): boolean;
+    /**
+     * Plan a node creation (and its nested writes); returns its key.
+     * `parent` is the relationship a nested create hangs from: it satisfies
+     * the new node's required field pointing back.
+     */
+    create(node: NodeType, input: Input, parent?: RelationshipField): unknown;
+    callback(f: ScalarField, operation: "CREATE" | "UPDATE", node: NodeType, key: unknown, input: Input): Promise<unknown>;
+    /** Plan connect / create / update / disconnect under one relationship field. */
+    relate(owner: NodeType, ownerKey: unknown, rel: RelationshipField, value: Input, update: boolean): void;
+}
+export declare function assertUniqueKeys(plan: WritePlan): void;

package/dist/execute/mutate/runner.d.ts

@@ -0,0 +1,129 @@
+import { SelectionSetNode } from 'graphql';
+import { CompileContext } from '../../compile/context.js';
+import { DriverTransaction } from '../../driver.js';
+import { NodeType, RelationshipField, ScalarField } from '../../model/types.js';
+import { RelationshipRef, WriteChange } from '../changes.js';
+import { MutationEnv, MutationInfo } from './env.js';
+import { WritePlan, Input } from './plan.js';
+export declare class Runner {
+    readonly env: MutationEnv;
+    readonly tx: DriverTransaction;
+    readonly change: WriteChange;
+    info: MutationInfo;
+    connected: RelationshipRef[];
+    disconnected: RelationshipRef[];
+    /** Nodes updated per type, for AFTER validation. */
+    updated: Map<NodeType, {
+        keys: unknown[];
+        fields: Set<string>;
+    }>;
+    /**
+     * A type this mutation creates under a key held by a node the caller
+     * cannot read; see {@link Runner.moveHiddenKeys}.
+     */
+    hiddenKey: NodeType | undefined;
+    /**
+     * A @unique value this mutation creates that another node holds; see
+     * {@link Runner.moveTakenUniques}.
+     */
+    takenUnique: {
+        node: NodeType;
+        field: ScalarField;
+    } | undefined;
+    constructor(env: MutationEnv, tx: DriverTransaction, change: WriteChange);
+    ctx(): CompileContext;
+    run(text: string, ctx: CompileContext): Promise<Array<Record<string, unknown>>>;
+    plan(): WritePlan;
+    /** Every planned write, in order, with the checks that follow them. */
+    apply(plan: WritePlan): Promise<void>;
+    /**
+     * `maxBatch` over the whole mutation: nodes created and updated so far
+     * plus those `plan` creates and updates (nested `update` entries
+     * included), and relationships written so far plus those `plan`
+     * connects, disconnects (each listed key) and updates, at most ten per
+     * node allowed. Checked before any of the plan's writes.
+     */
+    assertBatch(plan?: WritePlan, updating?: number): void;
+    /**
+     * A create under a key held by a node the caller cannot read must not
+     * tell them the key exists (G-20). The unique constraint would fail it
+     * with CONSTRAINT_VIOLATION before the rules run, while a free key gets
+     * the rules' answer: an existence oracle. So the hidden node moves to a
+     * placeholder key for the rest of the transaction, and the mutation runs
+     * on a graph that differs from the free-key case only in that hidden
+     * key: every error it raises is the one a free key gets. When it would
+     * succeed, `executeMutation` fails it with the FORBIDDEN of a denied
+     * create. Either way the transaction rolls back, and the key with it.
+     */
+    moveHiddenKeys(plan: WritePlan): Promise<void>;
+    /**
+     * The G-20 treatment for @unique values: a create under rules whose
+     * unique value another node holds would fail the constraint before the
+     * rules answer, telling a caller who may not create the node that the
+     * value is taken. The holder's value moves aside for the transaction,
+     * so every error is the one a free value gets; when the mutation would
+     * succeed, `executeMutation` fails it with the constraint violation a
+     * permitted caller gets. The transaction rolls back either way. Types
+     * without CREATE rules skip this: there is nothing to leak.
+     */
+    moveTakenUniques(plan: WritePlan): Promise<void>;
+    applyCreates(plan: WritePlan): Promise<void>;
+    applyDisconnects(plan: WritePlan): Promise<void>;
+    applyLinks(plan: WritePlan): Promise<void>;
+    /**
+     * Rules on the relationship field (and on a field declaring the same
+     * relationship from the other side) for `op`, on each pair's
+     * relationship as it stands: after the write for CONNECT and
+     * UPDATE_EDGE, before it for DISCONNECT. FORBIDDEN when any fails; the
+     * mutation rolls back.
+     */
+    checkRelationshipRules(op: "CONNECT" | "DISCONNECT" | "UPDATE_EDGE", rel: RelationshipField, pairs: Array<{
+        from: unknown;
+        to: unknown;
+    }>): Promise<void>;
+    /** Whether either end has validate rules for `op` at `when`. */
+    endRules(owner: NodeType, target: NodeType, op: "CREATE_RELATIONSHIP" | "DELETE_RELATIONSHIP", when: "BEFORE" | "AFTER"): boolean;
+    /**
+     * Validate rules for connecting or disconnecting, on both ends of each
+     * pair: FORBIDDEN when either end fails them.
+     */
+    checkEnds(op: "CREATE_RELATIONSHIP" | "DELETE_RELATIONSHIP", owner: NodeType, target: NodeType, pairs: Array<{
+        from: unknown;
+        to: unknown;
+    }>, when: "BEFORE" | "AFTER"): Promise<void>;
+    /** `update: [{ key, edge }]`: properties of connected pairs, in place. */
+    applyEdgeUpdates(plan: WritePlan): Promise<void>;
+    /**
+     * `delete: { where, limit }`: the connected nodes `where` matches, under
+     * their DELETE rules, deleted like a bulk delete (onDelete followed). More
+     * than `limit` (default `maxBatch`) is an error, not a truncation.
+     */
+    applyNestedDeletes(plan: WritePlan): Promise<void>;
+    /** `update: [{ key, node }]`: connected nodes, through the update path. */
+    applyNodeUpdates(plan: WritePlan): Promise<void>;
+    /**
+     * Update nodes by key: visibility (filter rules) and BEFORE rules, then
+     * one SET per shape of input. Returns the keys it updated; keys the
+     * caller cannot see are skipped. Relationship inputs go into `plan`.
+     */
+    update(plan: WritePlan, node: NodeType, rows: Array<{
+        key: unknown;
+        input: Input;
+    }>, adjust?: Input): Promise<unknown[]>;
+    /**
+     * AFTER rules on created nodes: the type's rules on every row, a field's
+     * rules on the rows whose input sets the field. Rows are checked in
+     * groups that set the same guarded fields.
+     */
+    validateCreated(plan: WritePlan): Promise<void>;
+    validateUpdated(): Promise<void>;
+    /** AFTER rules for `op` on the nodes with `keys` (and written fields). */
+    validateAfter(node: NodeType, keys: unknown[], op: "CREATE" | "UPDATE", fields: Set<string>): Promise<void>;
+    /** Nodes by key, projected for the payload, inside the transaction. */
+    payload(node: NodeType, keys: unknown[], sets: SelectionSetNode[]): Promise<unknown[]>;
+    /**
+     * Keys of the nodes `where` matches, under the filter rules for `op`.
+     * More than `limit` is an error: bulk writes are bounded, not truncated.
+     */
+    resolveKeys(node: NodeType, where: Input, op: "UPDATE" | "DELETE", limit: number): Promise<unknown[]>;
+}

package/dist/execute/mutate/unique-together.d.ts

@@ -0,0 +1,18 @@
+import { CompileContext } from '../../compile/context.js';
+import { DriverTransaction } from '../../driver.js';
+import { GraphModel, NodeType, UniqueTogether } from '../../model/types.js';
+import { MutationEnv } from './env.js';
+export declare function notUniqueTogether(node: NodeType, u: UniqueTogether, key: unknown): import('graphql').GraphQLError;
+/**
+ * `@uniqueTogether` after a write whose write-set is unknown (a `@cypher`
+ * mutation): every node of each type in `nodes` is compared, in `tx`.
+ */
+export declare function checkUniqueTogetherOf(env: MutationEnv, tx: DriverTransaction, nodes: readonly NodeType[]): Promise<void>;
+/**
+ * The first node among `keys` whose `@uniqueTogether` combination another
+ * node of its type shares: seeks each by key, binds its combination, then
+ * compares it with the nodes that share its first relationship end (or,
+ * with scalars only, its first scalar's value) — never a scan of the type.
+ * Without `keys`, every node of the type is compared (a scan).
+ */
+export declare function uniqueTogetherStatement(ctx: CompileContext, model: GraphModel, node: NodeType, u: UniqueTogether, keys: unknown[] | undefined): string;

package/dist/execute/mutate.d.ts

@@ -1,87 +1,10 @@
 import { FieldNode } from 'graphql';
-import { Statistics } from '../analyze/statistics.js';
-import { SelectionContext } from '../compile/selection.js';
-import { DriverTransaction, LoraDriver, QueryResult, Statement } from '../driver.js';
-import { GraphModel, NodeType } from '../model/types.js';
+import { NodeType } from '../model/types.js';
 import { MutationKind } from '../schema/mutations.js';
 import { WriteChange } from './changes.js';
-/** Computes a `@populatedBy` field. */
-export type PopulatedByCallback = (args: {
-    operation: "CREATE" | "UPDATE";
-    /** Node type and field being populated. */
-    type: string;
-    field: string;
-    key: unknown;
-    /** The node's input in this mutation. */
-    input: Record<string, unknown>;
-    /** The GraphQL context. */
-    context: unknown;
-}) => unknown;
-export interface MutationEnv {
-    model: GraphModel;
-    driver: LoraDriver;
-    /** The caller's node's @key, for @key(scope: VIEWER) (see executeMutation). */
-    viewerKey?: unknown;
-    selection: SelectionContext;
-    jwt: Record<string, unknown> | undefined;
-    /** The GraphQL context, for `$context` in rules and for callbacks. */
-    requestContext: unknown;
-    timeoutMs: number;
-    signal: AbortSignal | undefined;
-    degrees: ReadonlyMap<string, number>;
-    /**
-     * Most nodes one mutation may create, update or delete, nested ones
-     * included; relationships written, ten times as many.
-     */
-    maxBatch: number;
-    /** Most items a @cypher list argument takes without `@size(max:)`. */
-    maxListArgument?: number | undefined;
-    /** Relationship levels one `where` may nest. */
-    maxFilterDepth?: number | undefined;
-    /** Items an `in` filter operand may hold. */
-    maxListFilter?: number | undefined;
-    /** Characters a string filter operand may hold. */
-    maxStringFilter?: number | undefined;
-    /** Statistics from `analyze()`, for filter costs. */
-    statistics?: Statistics | undefined;
-    callbacks: Readonly<Record<string, PopulatedByCallback>>;
-    /**
-     * A caller-owned transaction: run inside it and leave the commit to the
-     * caller. A failed mutation rolls it back, so it is never half-applied.
-     */
-    transaction?: DriverTransaction | undefined;
-    /** Observes every statement, for logging and tests. */
-    onStatement?: ((statement: Statement) => void) | undefined;
-    /** Runs a statement under timing, tracing and metrics, when configured. */
-    observe?: ((statement: Statement, run: () => Promise<QueryResult>) => Promise<QueryResult>) | undefined;
-    /**
-     * Called inside the transaction once a delete knows every node it
-     * removes, before any is removed: subscribers' checks of the nodes as
-     * they were (a deleted node cannot be checked after the commit).
-     */
-    beforeDelete?: ((change: WriteChange, doomed: ReadonlyArray<{
-        node: NodeType;
-        keys: unknown[];
-    }>, run: (statement: Statement) => Promise<QueryResult>) => Promise<void>) | undefined;
-}
-/** Run `statement` in `tx`, reporting it before and observing it during. */
-export declare function runStatement(env: MutationEnv, tx: DriverTransaction, statement: Statement): Promise<QueryResult>;
-export interface MutationInfo {
-    nodesCreated: number;
-    nodesUpdated: number;
-    nodesDeleted: number;
-    relationshipsCreated: number;
-    relationshipsDeleted: number;
-}
-/**
- * `@uniqueTogether` after a write whose write-set is unknown (a `@cypher`
- * mutation): every node of each type in `nodes` is compared, in `tx`.
- */
-export declare function checkUniqueTogetherOf(env: MutationEnv, tx: DriverTransaction, nodes: readonly NodeType[]): Promise<void>;
+import { MutationEnv } from './mutate/env.js';
 export interface MutationResult {
     payload: unknown;
     change: WriteChange;
 }
 export declare function executeMutation(env: MutationEnv, op: MutationKind, node: NodeType, args: Record<string, unknown>, fieldNodes: readonly FieldNode[], fieldName: string): Promise<MutationResult>;
-/** Turn engine constraint errors into CONSTRAINT_VIOLATION naming the field. */
-export declare function mapWriteError(model: GraphModel, err: unknown): unknown;

package/dist/index.d.ts

@@ -1,19 +1,23 @@
-export { LoraGraphQL, type AssertSchemaOptions, type CheckOptions, type CheckReport, type CostEvent, type DatabaseErrorEvent, type ExecuteArgs, type ExecutionTiming, type LoraGraphQLContext, type LoraGraphQLOptions, type LoraExecutionResult, type SchemaAssertion, type StatementEvent, } from './lora-graphql.js';
+export { LoraGraphQL } from './lora-graphql.js';
+export { type AssertSchemaOptions, type CheckOptions, type CostEvent, type DatabaseErrorEvent, type ExecuteArgs, type LoraGraphQLContext, type LoraGraphQLOptions, type StatementEvent, } from './options.js';
+export { type CheckReport, type ExecutionTiming, type LoraExecutionResult, type SchemaAssertion, } from './results.js';
 export { loraDriver, type DriverTransaction, type LoraDatabaseLike, type LoraDriver, type QueryPlan, type QueryResult, type RunOptions, type Statement, } from './driver.js';
 export { directiveTypeDefs } from './model/directives.js';
-export { buildModel, type ModelOptions } from './model/build.js';
+export { buildModel } from './model/build.js';
+export { type ModelOptions } from './model/build/limits.js';
 export type * from './model/types.js';
 export { inferRequirements, requirementDdl, type SchemaRequirement, } from './analyze/indexes.js';
 export { checkPlans, scanExpands, type PlanFinding, type PlanReport, } from './analyze/plans.js';
 export type { DegreeStats, Statistics } from './analyze/statistics.js';
-export type { AccessEntry, AccessVerdict, OperationAccess, RootFieldAccess, } from './analyze/access.js';
+export type { AccessEntry, AccessVerdict } from './analyze/verdicts.js';
+export type { OperationAccess, RootFieldAccess } from './analyze/access.js';
 export type { CypherFinding } from './analyze/cypher-check.js';
 export { diffSchemas, type ApiChange, type SchemaDiff, } from './analyze/diff.js';
-export type { CompiledRead, ReadSet, SeekExpectation } from './compile/read.js';
+export type { CompiledRead, ReadSet, SeekExpectation, } from './compile/read/types.js';
 export type { EntityRef, RelationshipRef, WriteChange, } from './execute/changes.js';
-export type { MutationInfo, PopulatedByCallback } from './execute/mutate.js';
+export type { MutationInfo, PopulatedByCallback, } from './execute/mutate/env.js';
 export type { MutationKind } from './schema/mutations.js';
-export type { ChangeEvent } from './schema/build.js';
+export type { ChangeEvent } from './schema/hooks.js';
 export { LoraTransaction } from './execute/transaction.js';
 export { ModelError, formatProblem, isLoraGraphQLError, LORA_GRAPHQL_ERROR_CODES, type LoraGraphQLErrorCode, type ModelProblem, } from './errors.js';
 export { toGlobalId, fromGlobalId } from './schema/global-id.js';

package/dist/index.js

@@ -1,5 +1,5 @@
-import { D as r, L as e, a as o, b as l, M as i, c as d, d as n, e as t, f as p, g as f, h as m, i as L, j as c, l as R, p as h, r as D, s as E, k as G, t as b, v as u } from "./driver-C5dSoSD8.js";
-import { d as A } from "./diff-B9iDdELF.js";
+import { D as r, L as e, a as o, b as l, M as i, c as d, d as n, e as t, f as p, g as f, h as m, i as L, j as c, l as R, p as h, r as D, s as E, k as G, t as b, v as u } from "./driver-DSnytFsU.js";
+import { d as A } from "./diff-aDivqYqr.js";
 export {
   r as DEFAULT_GUARDS,
   e as LORA_GRAPHQL_ERROR_CODES,