@loradb/lora-graphql 0.24.1 → 0.25.1

package/dist/execute/mutate/single-call.d.ts

@@ -0,0 +1,92 @@
+import { DriverTransaction, LoraDriver, QueryResult, RunOptions, Statement } from '../../driver.js';
+import { GraphModel } from '../../model/types.js';
+import { WritePlan } from './plan.js';
+/**
+ * A transaction that is one `driver.run()` call until `open()` makes it a
+ * real one. In its single form the first batch is the whole mutation: it
+ * is committed when the call returns, so `commit()` has nothing left to
+ * do, and a failure has already rolled everything back.
+ *
+ * With `single` false it is never one call, only late: the transaction
+ * begins with its first statement, so what a mutation works out before
+ * that (its plan, its `@populatedBy` callbacks) does not hold the lock.
+ */
+export declare class LazyTransaction implements DriverTransaction {
+    #private;
+    constructor(driver: LoraDriver, options: RunOptions, single?: boolean);
+    /**
+     * Whether the single call ran and committed: an error after that can
+     * no longer undo the write.
+     */
+    get committed(): boolean;
+    /** Whether the mutation is still one call. */
+    get single(): boolean;
+    /** The mutation needs more than one round trip: begin a transaction. */
+    open(): Promise<void>;
+    execute(statement: Statement): Promise<QueryResult>;
+    executeMany(statements: Statement[]): Promise<QueryResult[]>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    get isOpen(): boolean;
+}
+/**
+ * `err` without the position the binding appends to the error of a
+ * failing statement of a batch (`(statement 2 of 3)`): callers see the
+ * error a lone statement gives. An error whose message is read-only (the
+ * DOMException of an aborted request) is passed on as it is.
+ */
+export declare function withoutPosition(err: unknown): unknown;
+/**
+ * Whether the database has `assert()`: asked once per driver. Without it
+ * every mutation keeps its transaction and decides in JavaScript.
+ */
+export declare function supportsAssert(driver: LoraDriver): Promise<boolean>;
+/**
+ * Whether reading any node can be refused by a READ validate rule: a
+ * payload read would then need a decision after the write, which a single
+ * call cannot make.
+ */
+export declare function readCanBeRefused(model: GraphModel): boolean;
+/**
+ * What the guard of a single-call update that writes relationships stands
+ * for: the node is not there (or not the caller's to update), so the call
+ * rolled back and the mutation answers null, as a transaction would after
+ * finding nothing.
+ */
+export declare const NOT_THERE: unique symbol;
+/**
+ * Whether `plan`'s links can go out in a single call: when each is
+ * known to create its relationship. A transaction asks the database
+ * whether the pair was connected already, and applies other rules to a
+ * re-connect; here it must be certain beforehand. It is when one end is
+ * a node this plan creates (it has no relationships yet) and no two
+ * links name the same relationship (one from each side's field). An
+ * update's links ask the database instead (`plan.reconnects`). A
+ * property the rules refuse depends on what the link found, in
+ * JavaScript.
+ */
+export declare function linksInOne(plan: WritePlan): boolean;
+/** The message of an `assert()` that stands for a refused rule. */
+export declare function refusal(kind: "forbidden" | "hidden" | "taken", type: string, detail: string): string;
+/**
+ * The request error an assertion stood for, or `err` when it is not one
+ * of ours.
+ */
+export declare function refused(model: GraphModel, err: unknown): unknown;
+/**
+ * The assertions of one single call that stand for an error only this
+ * mutation can name (the row a check failed on, a target that is not
+ * there): each is numbered, and its number is its message.
+ */
+export declare class Assertions {
+    #private;
+    /**
+     * The message, a Cypher expression, of an assertion that stands for
+     * `error`: {@link Assertions.refusedBy} gives the error back. `detail`
+     * is an expression appended to it, for an error that names what the
+     * rows held.
+     */
+    failsAs(error: (detail: string) => unknown, detail?: string): string;
+    /** The error an assertion of {@link Assertions.failsAs} stood for, if `err` is one. */
+    refusedBy(err: unknown): unknown;
+}

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

@@ -0,0 +1,27 @@
+import { CompileContext } from '../../compile/context.js';
+import { Statement } from '../../driver.js';
+import { NodeType, Trigger, TriggerOperation } from '../../model/types.js';
+import { MutationEnv } from './env.js';
+import { Runner } from './runner.js';
+/** Whether the mutation may fire a trigger: a statement or a function. */
+export declare function hasTriggers(env: MutationEnv): boolean;
+/** Whether the mutation may call a trigger function. */
+export declare function hasTriggerFunctions(env: MutationEnv): boolean;
+/** The trigger statement for `keys`, with `this` bound to each node. */
+export declare function triggerStatement(ctx: CompileContext, node: NodeType, trigger: Trigger, operation: TriggerOperation, keys: unknown[]): Statement;
+/**
+ * The text ahead of a CONNECT or DISCONNECT trigger's statement: one row
+ * per pair of `pairs` (a list of `[this key, target key]`), with `this`
+ * and `target` bound.
+ */
+export declare function relationshipTriggerPrefix(node: NodeType, target: NodeType, pairs: string): string;
+/**
+ * Run the CREATE and UPDATE triggers for what the mutation wrote so far.
+ * A node the mutation created and then updated fires CREATE only.
+ */
+export declare function runWriteTriggers(runner: Runner): Promise<void>;
+/** Run the DELETE triggers of `doomed`, while the nodes still exist. */
+export declare function runDeleteTriggers(runner: Runner, doomed: ReadonlyArray<{
+    node: NodeType;
+    keys: unknown[];
+}>): Promise<void>;

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

@@ -14,5 +14,9 @@ export declare function checkUniqueTogetherOf(env: MutationEnv, tx: DriverTransa
  * 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).
+ *
+ * With `failing`, the statement fails instead of returning that node:
+ * `failing` gives the assertion's message, from an expression for the
+ * node's place in `keys`.
  */
-export declare function uniqueTogetherStatement(ctx: CompileContext, model: GraphModel, node: NodeType, u: UniqueTogether, keys: unknown[] | undefined): string;
+export declare function uniqueTogetherStatement(ctx: CompileContext, model: GraphModel, node: NodeType, u: UniqueTogether, keys: unknown[] | undefined, failing?: (index: string) => string): string;

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

@@ -0,0 +1,11 @@
+import { GraphModel, NodeType } from '../../model/types.js';
+import { MutationKind } from '../../schema/mutations.js';
+import { TypeValidator } from '../../standard-schema.js';
+export type Validators = Readonly<Record<string, TypeValidator>>;
+/**
+ * Refuse a mutation whose input breaks a field's rule or its type's
+ * validator, with every violation in one `BAD_USER_INPUT`. Values
+ * computed during the write (an `adjust`, a `@populatedBy` callback) are
+ * checked where they appear.
+ */
+export declare function validateInput(model: GraphModel, validators: Validators, op: MutationKind, node: NodeType, args: Record<string, unknown>): Promise<void>;

package/dist/execute/transaction.d.ts

@@ -2,8 +2,19 @@ import { DriverTransaction, QueryResult } from '../driver.js';
 import { WriteChange } from './changes.js';
 export declare class LoraTransaction {
     #private;
-    /** @internal Created by `LoraGraphQL.begin()`. */
-    constructor(tx: DriverTransaction, emit: (change: WriteChange) => void);
+    /**
+     * @internal Created by `LoraGraphQL.begin()`, and for a JavaScript
+     * trigger over the transaction of the mutation that fired it
+     * (`inTrigger`), which that mutation commits.
+     */
+    constructor(tx: DriverTransaction, emit: (change: WriteChange) => void, inTrigger?: boolean);
+    /**
+     * @internal Whether a trigger owns this handle: mutations run in it
+     * fire no trigger themselves.
+     */
+    get inTrigger(): boolean;
+    /** @internal The write-sets recorded so far, handed over. */
+    drain(): WriteChange[];
     /** @internal The driver transaction statements run in. */
     get driverTransaction(): DriverTransaction;
     /** False once committed, rolled back, or failed. */

package/dist/index.d.ts

@@ -15,11 +15,16 @@ 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/types.js';
 export type { EntityRef, RelationshipRef, WriteChange, } from './execute/changes.js';
-export type { MutationInfo, PopulatedByCallback, } from './execute/mutate/env.js';
+export type { MutationInfo, PopulatedByCallback, TriggerEvent, TriggerFunction, TriggerFunctions, } from './execute/mutate/env.js';
 export type { MutationKind } from './schema/mutations.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 type { Worker, WorkerOptions } from './events/worker.js';
+export { ModelError, formatProblem, isLoraGraphQLError, LORA_GRAPHQL_ERROR_CODES, type LoraGraphQLErrorCode, type ModelProblem, type Violation, } from './errors.js';
+export type { FieldConstraints } from './model/constraints.js';
+export { inputSchemas, type JsonSchema } from './analyze/input-schemas.js';
+export type { StoredReport, StoredViolation } from './analyze/stored.js';
+export type { StandardIssue, StandardResult, StandardSchemaV1, TypeValidator, } from './standard-schema.js';
 export { toGlobalId, fromGlobalId } from './schema/global-id.js';
 export type { Attributes, MetricsLike, ObservabilityOptions, SpanLike, StatementEndEvent, TracerLike, } from './observe.js';
 export { schemaHash, type ManifestOperation, type OperationManifest, } from './codegen.js';

package/dist/index.js

@@ -1,26 +1,27 @@
-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-CXKPLfkz.js";
-import { d as A } from "./diff-K8-GSeKH.js";
+import { D as r, L as e, a as o, b as i, M as l, c as n, d, e as t, f as m, g as p, h as c, i as f, j as L, k as h, l as R, p as D, r as u, s as E, m as G, t as b, v } from "./lora-graphql-RvZQdHNA.js";
+import { d as O } from "./diff-BZZNZs76.js";
 export {
   r as DEFAULT_GUARDS,
   e as LORA_GRAPHQL_ERROR_CODES,
   o as LoraGraphQL,
-  l as LoraTransaction,
-  i as ModelError,
-  d as buildModel,
-  n as checkPlans,
-  A as diffSchemas,
+  i as LoraTransaction,
+  l as ModelError,
+  n as buildModel,
+  d as checkPlans,
+  O as diffSchemas,
   t as directiveTypeDefs,
-  p as envelopPlugin,
-  f as formatProblem,
-  m as fromGlobalId,
-  L as inferRequirements,
-  c as isLoraGraphQLError,
+  m as envelopPlugin,
+  p as formatProblem,
+  c as fromGlobalId,
+  f as inferRequirements,
+  L as inputSchemas,
+  h as isLoraGraphQLError,
   R as loraDriver,
-  h as parseOptions,
-  D as requirementDdl,
+  D as parseOptions,
+  u as requirementDdl,
   E as scanExpands,
   G as schemaHash,
   b as toGlobalId,
-  u as validationRules
+  v as validationRules
 };
 //# sourceMappingURL=index.js.map