@loradb/lora-graphql 0.17.0 → 0.19.0

package/dist/driver.d.ts

@@ -27,10 +27,15 @@ export interface RunOptions {
     signal?: AbortSignal | undefined;
     /**
      * A read the library vouches for: generated, or a @cypher statement
-     * checked read-only at startup. The driver may stream it outside a
+     * checked read-only at startup. The driver may run it outside a
      * read-only transaction.
      */
     verified?: boolean;
+    /**
+     * A verified read of at most one row, by an exact @key seek, projecting
+     * only stored properties. Cheap enough to run synchronously.
+     */
+    bounded?: boolean;
 }
 /** An open interactive transaction: statements see earlier writes. */
 export interface DriverTransaction {
@@ -82,20 +87,24 @@ export interface LoraDatabaseLike {
         timeoutMs?: number;
         signal?: AbortSignal;
     }): Promise<QueryResult[]>;
-    explain?(query: string, params?: never): Promise<QueryPlan>;
-    changes?(options?: {
-        fromLsn?: number;
+    execute?(query: string, params?: never, options?: {
+        timeoutMs?: number;
         signal?: AbortSignal;
-    }): AsyncIterable<DriverChangeBatch> & {
-        ready: Promise<void>;
-    };
+    }): Promise<QueryResult>;
     stream?(query: string, params?: never, options?: {
         timeoutMs?: number;
         signal?: AbortSignal;
     }): {
-        columns(): string[];
+        columns(): string[] | Promise<string[]>;
         toArray(): Promise<Array<Record<string, unknown>>>;
     };
+    explain?(query: string, params?: never): Promise<QueryPlan>;
+    changes?(options?: {
+        fromLsn?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<DriverChangeBatch> & {
+        ready: Promise<void>;
+    };
     begin?(mode?: "read_write" | "read_only"): Promise<{
         execute(query: string, params?: never, options?: {
             timeoutMs?: number;

package/dist/errors.d.ts

@@ -15,6 +15,6 @@ export declare class ModelError extends Error {
     constructor(problems: ModelProblem[]);
 }
 export declare function formatProblem(p: ModelProblem): string;
-export type LoraGraphQLErrorCode = "BAD_USER_INPUT" | "INVALID_CURSOR" | "LIMIT_EXCEEDED" | "COST_EXCEEDED" | "UNAUTHENTICATED" | "FORBIDDEN" | "NOT_FOUND" | "CONSTRAINT_VIOLATION" | "DATABASE_ERROR" | "PERSISTED_QUERY_ONLY";
+export type LoraGraphQLErrorCode = "BAD_USER_INPUT" | "INVALID_CURSOR" | "LIMIT_EXCEEDED" | "COST_EXCEEDED" | "UNAUTHENTICATED" | "FORBIDDEN" | "NOT_FOUND" | "CONSTRAINT_VIOLATION" | "DATABASE_ERROR" | "PERSISTED_QUERY_ONLY" | "WRONG_OPERATION_TYPE";
 /** A request-time error with a stable `extensions.code`. */
 export declare function requestError(code: LoraGraphQLErrorCode, message: string, cause?: unknown, extensions?: Record<string, unknown>): GraphQLError;

package/dist/execute/feed.d.ts

@@ -3,7 +3,7 @@ import { GraphModel } from '../model/types.js';
 import { WriteChange } from './changes.js';
 export declare class EngineFeed {
     #private;
-    constructor(driver: LoraDriver, model: GraphModel, emit: (change: WriteChange) => void);
+    constructor(driver: LoraDriver, model: GraphModel, emit: (change: WriteChange) => void, onError?: (err: unknown) => void);
     /** Subscribe; resolves once every later commit will be delivered. */
     start(): Promise<void>;
     stop(): void;

package/dist/guards.d.ts

@@ -1,7 +1,18 @@
 import { ParseOptions, ValidationRule } from 'graphql';
 export interface DocumentGuards {
-    /** Deepest field nesting, fragments followed. Default 12. */
+    /**
+     * Deepest field nesting, fragments followed. Default 12. An
+     * introspection field (`__schema`, `__type`) counts as one level here:
+     * its subtree follows the type-reference chain, not the graph, and is
+     * bounded by `maxIntrospectionDepth`.
+     */
     maxDepth?: number;
+    /**
+     * Deepest nesting under `__schema` or `__type`, the field included.
+     * Default 20: the standard introspection query (every option on) needs
+     * 15, and a runaway `ofType { ofType … }` chain is still refused.
+     */
+    maxIntrospectionDepth?: number;
     /** Aliased fields in one document. Default 30. */
     maxAliases?: number;
     /** Root fields in one operation. Default 20. */
@@ -16,6 +27,7 @@ export interface DocumentGuards {
 }
 export declare const DEFAULT_GUARDS: {
     readonly maxDepth: 12;
+    readonly maxIntrospectionDepth: 20;
     readonly maxAliases: 30;
     readonly maxRootFields: 20;
     readonly maxTokens: 5000;

package/dist/index.js

@@ -1,5 +1,5 @@
-import { D as e, L as r, a as o, M as l, b as i, c as d, d as n, e as t, f, g as m, i as p, l as c, p as h, r as D, s as b, h as u, t as v, v as L } from "./driver-BmnRtkpd.js";
-import { d as x } from "./diff-8nsBSSNP.js";
+import { D as e, L as r, a as o, M as l, b as i, c as d, d as n, e as t, f, g as m, i as p, l as c, p as h, r as D, s as b, h as u, t as v, v as L } from "./driver-CuXOoYWT.js";
+import { d as x } from "./diff-BH4Na9pC.js";
 export {
   e as DEFAULT_GUARDS,
   r as LoraGraphQL,

package/dist/lora-graphql.d.ts

@@ -81,14 +81,15 @@ export interface LoraGraphQLOptions extends ModelOptions, ObservabilityOptions {
     /** Called with every database error, masked or not. */
     onError?: (event: DatabaseErrorEvent) => void;
     /**
-     * Limits on the documents `execute()` and `persist()` accept: depth,
+     * 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()` refuse `source` and run only persisted operations
-     * by `id`. Default false.
+     * Make `execute()` and `subscribe()` refuse `source` and run only
+     * persisted operations by `id`. Default false.
      */
     persistedOnly?: boolean;
 }
@@ -105,7 +106,10 @@ export interface CostEvent {
 export interface DatabaseErrorEvent {
     /** Correlation id, also in the client error's `extensions.id`. */
     id: string;
-    /** The root field that failed. */
+    /**
+     * 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;
@@ -270,15 +274,30 @@ export declare class LoraGraphQL {
      */
     loadManifest(manifest: OperationManifest): void;
     /**
-     * Execute an operation against the schema. Parsed and validated
-     * documents are cached by source text; persisted ones by id.
+     * Execute a query or mutation against the schema. Parsed and validated
+     * documents are cached by source text; persisted ones by id. A
+     * subscription runs with {@link LoraGraphQL.subscribe}; given one, this
+     * returns a `WRONG_OPERATION_TYPE` error.
      */
     execute(args: ExecuteArgs): Promise<ExecutionResult>;
+    /**
+     * Run a subscription: an async iterable of results, one per event, or a
+     * single result with the errors when it cannot start (an unknown id, a
+     * validation error, a denied subscribe). Takes the same arguments as
+     * {@link LoraGraphQL.execute}, a persisted id included, with the same
+     * document cache and guards; a query or mutation gets a
+     * `WRONG_OPERATION_TYPE` error. End it with `return()` on the iterator
+     * or with an `AbortSignal` passed as `context.signal`: either ends it at
+     * once, without waiting for another event, and drops its listener. The
+     * cost limit applies to each event on its own.
+     */
+    subscribe(args: ExecuteArgs): Promise<AsyncIterableIterator<ExecutionResult> | ExecutionResult>;
     /** Called after every committed mutation with its exact write-set. */
     onWrite(listener: (change: WriteChange) => void): () => void;
     /**
      * Committed writes as an async iterator, e.g. for a subscription
-     * resolver. Only writes made through this instance are seen.
+     * resolver. Only writes made through this instance are seen. `return()`
+     * or aborting `signal` (already aborted included) ends it at once.
      */
     changes(options?: {
         signal?: AbortSignal;

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { graphql as h } from "graphql";
-import { L as w, l as u } from "./driver-BmnRtkpd.js";
+import { L as w, l as u } from "./driver-CuXOoYWT.js";
 async function L(l) {
   let s;
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loradb/lora-graphql",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Schema-first GraphQL for LoraDB: one annotated SDL becomes an executable, index-aware GraphQL API that compiles every operation to a single Cypher statement.",
   "license": "BUSL-1.1",
   "packageManager": "yarn@4.5.1",
@@ -61,10 +61,11 @@
     "lint:fix": "eslint src test bench --fix",
     "format": "prettier --write src test",
     "format:check": "prettier --check src test",
-    "bench": "vitest bench --run"
+    "bench": "vitest bench --run",
+    "bench:load": "node bench/load/main.mjs"
   },
   "peerDependencies": {
-    "@loradb/lora-node": "^0.17.0",
+    "@loradb/lora-node": "^0.19.0",
     "graphql": "^16.8.0 || ^17.0.0"
   },
   "devDependencies": {