litedbmodel 1.2.10 → 2.0.1

package/dist/scp/typed-object.d.ts

@@ -0,0 +1,99 @@
+/**
+ * litedbmodel v2 SCP — typed-object result + hydrate factory + lazy relations (WS4, #24).
+ *
+ * v2's read result is a plain **typed-object** (spec §4 / §12): its OWN enumerable props are
+ * DATA ONLY (the projected columns + any declaratively-selected relations). It is NOT a
+ * DBModel instance — `JSON.stringify` / `Object.keys` / spread stay clean (feasibility §9).
+ *
+ * The v1 method-like UX is recovered via a graphddb-shaped {@link hydrate} factory
+ * (`(raw) => HostObject`): host-object construction is a CONSUMER concern that stays in the
+ * litedbmodel runtime and NEVER leaks into the portable IR/bundle (per the runtime boundary —
+ * the bundle carries the relation op + assembly shape only). `hydrate` is applied AFTER
+ * relation resolution and is NOT applied to `null` (a null single-relation), matching
+ * graphddb's `options.hydrate`.
+ *
+ * ## Lazy relations: prototype getter + non-enumerable Symbol batch context
+ *
+ * A typed-object gets a per-result-set prototype carrying a lazy getter per relation
+ * (feasibility §9 "prototype で良い"). The getter, on access, reads a NON-ENUMERABLE Symbol
+ * batch context (graphddb's `GRAPHDDB_KEY` technique — invisible to spread/JSON) shared by
+ * every sibling in the result set, and fires the SAME pre-compiled relation op ONCE over the
+ * whole sibling set (batch — so no N+1 even though it can't prefetch). A declaratively-selected
+ * relation is attached as an OWN property (`Post[]`/`Author`) and naturally SHADOWS the
+ * prototype getter (own prop wins) — the exact "宣言済み → データ / 未宣言 → lazy" unification
+ * from feasibility §9.
+ *
+ * Both surfaces resolve through {@link import('./relation').runRelationOp} — the identical
+ * compiled op — so there is one relation-execution code path, not two.
+ */
+import { type RelationOp, type RelationDriver } from './relation';
+/** The non-enumerable Symbol under which the shared lazy batch context is stashed. */
+export declare const RELATION_CONTEXT: unique symbol;
+/** A hydrate factory (graphddb-shaped): raw typed-object → host object. */
+export type HydrateFactory<R> = (raw: Record<string, unknown>) => R;
+/**
+ * The shared lazy batch context for one result set. Holds the sibling rows, the driver, the
+ * compiled relation ops (keyed by name), the (optional) hydrate factory, and a per-relation
+ * memo so a relation is batched at most ONCE across all siblings (structural no-N+1 for lazy).
+ * Stored as a non-enumerable Symbol prop so spread/JSON/`Object.keys` never see it (a spread
+ * or clone drops it — "designed degradation", feasibility §9).
+ */
+export declare class RelationContext {
+    private readonly siblings;
+    private readonly ops;
+    private readonly db;
+    private readonly hydrate?;
+    /** CROSS-DB (V0 R1): name → driver registry; a tagged relation routes to `connections[tag]`. */
+    private readonly connections?;
+    /** Per-relation resolved batch (name → grouping), memoized: one batch query per relation. */
+    private readonly resolved;
+    constructor(siblings: Record<string, unknown>[], ops: Readonly<Record<string, RelationOp>>, db: RelationDriver, hydrate?: HydrateFactory<unknown>, connections?: Readonly<Record<string, RelationDriver>>);
+    /** The driver a relation runs against: its tagged cross-DB connection, else the primary `db`. */
+    private driverFor;
+    /**
+     * Resolve `relationName` for `parent` (lazy access). The relation is batch-loaded across
+     * ALL siblings on first access and memoized, so N sibling accesses issue ONE query. Returns
+     * the hydrated child(ren) per cardinality (`hasMany` → array, else single-or-null).
+     */
+    resolve(relationName: string, parent: Record<string, unknown>): unknown;
+}
+/** Read the non-enumerable batch context off a typed-object (undefined if spread/cloned away). */
+export declare function readRelationContext(o: Record<string, unknown>): RelationContext | undefined;
+/**
+ * Read options bag (graphddb-shaped): declaratively-select relations to prefetch and/or a
+ * `hydrate` factory to recover host objects.
+ */
+export interface ReadOptions<R = Record<string, unknown>> {
+    /**
+     * Declarative select: relation name → `true`. Selected relations are batch-prefetched
+     * (staged) and attached as OWN props (shadowing the lazy getter). Unselected relations stay
+     * lazy on the prototype.
+     */
+    readonly with?: Readonly<Record<string, true>>;
+    /** Host-object factory applied AFTER relation resolution (not applied to `null`). */
+    readonly hydrate?: HydrateFactory<R>;
+    /**
+     * CROSS-DB relations (V0 R1): connection-name → driver registry. A relation whose compiled op
+     * carries a `connection` tag (its target model lives in a DIFFERENT DB — v1
+     * `TargetClass.getDriverType()`) is batch-loaded against `connections[tag]` instead of the
+     * primary `db`. Untagged (same-DB) relations ignore this. Omit for a single-DB read.
+     */
+    readonly connections?: Readonly<Record<string, RelationDriver>>;
+}
+/**
+ * Build the typed-object result set for a page of raw child rows plus the relation ops
+ * declared for this model. Every raw row becomes a typed-object whose:
+ *   - OWN enumerable props = the raw data columns (+ any declaratively-selected relation);
+ *   - PROTOTYPE carries a lazy getter per UNSELECTED relation (fires the same op at access);
+ *   - non-enumerable {@link RELATION_CONTEXT} Symbol = the shared lazy batch context.
+ *
+ * Declaratively-selected relations (`options.with`) are batch-prefetched HERE (one query per
+ * relation over the whole page — staged, no N+1) via the SAME {@link runRelationOp}, and
+ * attached as own props (so they shadow the prototype getter). `hydrate`, when supplied, is
+ * applied to each parent row AND to resolved relations.
+ *
+ * Returns the typed-objects (hydrated if `options.hydrate` given). This is the litedbmodel
+ * runtime concern; the bundle carries only the relation ops + assembly shape (no hydrate).
+ */
+export declare function buildResultSet<R = Record<string, unknown>>(rawRows: readonly Record<string, unknown>[], ops: Readonly<Record<string, RelationOp>>, db: RelationDriver, options?: ReadOptions<R>): R[];
+//# sourceMappingURL=typed-object.d.ts.map

package/dist/scp/typed-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-object.d.ts","sourceRoot":"","sources":["../../src/scp/typed-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAA+C,CAAC;AAEtF,2EAA2E;AAC3E,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAuC;IAC3D,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAiB;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA0B;IACnD,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAA2C;IACxE,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;gBAG3D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EACzC,EAAE,EAAE,cAAc,EAClB,OAAO,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,EACjC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IASxD,iGAAiG;IACjG,OAAO,CAAC,SAAS;IAIjB;;;;OAIG;IACH,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;CAYxE;AAeD,kGAAkG;AAClG,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,GAAG,SAAS,CAG3F;AAUD;;;GAGG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACtD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IAC/C,qFAAqF;IACrF,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;CACjE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxD,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC3C,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EACzC,EAAE,EAAE,cAAc,EAClB,OAAO,GAAE,WAAW,CAAC,CAAC,CAAM,GAC3B,CAAC,EAAE,CA+DL"}

package/dist/scp/typed-object.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — typed-object result + hydrate factory + lazy relations (WS4, #24).
+ *
+ * v2's read result is a plain **typed-object** (spec §4 / §12): its OWN enumerable props are
+ * DATA ONLY (the projected columns + any declaratively-selected relations). It is NOT a
+ * DBModel instance — `JSON.stringify` / `Object.keys` / spread stay clean (feasibility §9).
+ *
+ * The v1 method-like UX is recovered via a graphddb-shaped {@link hydrate} factory
+ * (`(raw) => HostObject`): host-object construction is a CONSUMER concern that stays in the
+ * litedbmodel runtime and NEVER leaks into the portable IR/bundle (per the runtime boundary —
+ * the bundle carries the relation op + assembly shape only). `hydrate` is applied AFTER
+ * relation resolution and is NOT applied to `null` (a null single-relation), matching
+ * graphddb's `options.hydrate`.
+ *
+ * ## Lazy relations: prototype getter + non-enumerable Symbol batch context
+ *
+ * A typed-object gets a per-result-set prototype carrying a lazy getter per relation
+ * (feasibility §9 "prototype で良い"). The getter, on access, reads a NON-ENUMERABLE Symbol
+ * batch context (graphddb's `GRAPHDDB_KEY` technique — invisible to spread/JSON) shared by
+ * every sibling in the result set, and fires the SAME pre-compiled relation op ONCE over the
+ * whole sibling set (batch — so no N+1 even though it can't prefetch). A declaratively-selected
+ * relation is attached as an OWN property (`Post[]`/`Author`) and naturally SHADOWS the
+ * prototype getter (own prop wins) — the exact "宣言済み → データ / 未宣言 → lazy" unification
+ * from feasibility §9.
+ *
+ * Both surfaces resolve through {@link import('./relation').runRelationOp} — the identical
+ * compiled op — so there is one relation-execution code path, not two.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationContext = exports.RELATION_CONTEXT = void 0;
+exports.readRelationContext = readRelationContext;
+exports.buildResultSet = buildResultSet;
+const relation_1 = require("./relation");
+/** The non-enumerable Symbol under which the shared lazy batch context is stashed. */
+exports.RELATION_CONTEXT = Symbol('litedbmodel:relation-context');
+/**
+ * The shared lazy batch context for one result set. Holds the sibling rows, the driver, the
+ * compiled relation ops (keyed by name), the (optional) hydrate factory, and a per-relation
+ * memo so a relation is batched at most ONCE across all siblings (structural no-N+1 for lazy).
+ * Stored as a non-enumerable Symbol prop so spread/JSON/`Object.keys` never see it (a spread
+ * or clone drops it — "designed degradation", feasibility §9).
+ */
+class RelationContext {
+    siblings;
+    ops;
+    db;
+    hydrate;
+    /** CROSS-DB (V0 R1): name → driver registry; a tagged relation routes to `connections[tag]`. */
+    connections;
+    /** Per-relation resolved batch (name → grouping), memoized: one batch query per relation. */
+    resolved = new Map();
+    constructor(siblings, ops, db, hydrate, connections) {
+        this.siblings = siblings;
+        this.ops = ops;
+        this.db = db;
+        this.hydrate = hydrate;
+        this.connections = connections;
+    }
+    /** The driver a relation runs against: its tagged cross-DB connection, else the primary `db`. */
+    driverFor(op) {
+        return op.connection === undefined ? this.db : driverForOp(op, this.connections);
+    }
+    /**
+     * Resolve `relationName` for `parent` (lazy access). The relation is batch-loaded across
+     * ALL siblings on first access and memoized, so N sibling accesses issue ONE query. Returns
+     * the hydrated child(ren) per cardinality (`hasMany` → array, else single-or-null).
+     */
+    resolve(relationName, parent) {
+        const op = this.ops[relationName];
+        if (op === undefined) {
+            throw new Error(`relation '${relationName}' is not declared on this result set`);
+        }
+        let batch = this.resolved.get(relationName);
+        if (batch === undefined) {
+            batch = (0, relation_1.runRelationOp)(op, this.siblings, this.driverFor(op)).batch;
+            this.resolved.set(relationName, batch);
+        }
+        return applyHydrate((0, relation_1.distributeToParent)(op, parent, batch), this.hydrate);
+    }
+}
+exports.RelationContext = RelationContext;
+/**
+ * The driver a CROSS-DB relation op (V0 R1) runs against: the registered `connections[tag]`. Loud
+ * failure when the tag has no registered driver (a real wiring bug — never a silent same-DB
+ * fallback, which would run the target's query on the wrong DB). Only called for a tagged op.
+ */
+function driverForOp(op, connections) {
+    const d = connections?.[op.connection];
+    if (d === undefined) {
+        throw new Error(`cross-DB relation '${op.name}': no driver registered for connection '${op.connection}' (pass it in ReadOptions.connections)`);
+    }
+    return d;
+}
+/** Read the non-enumerable batch context off a typed-object (undefined if spread/cloned away). */
+function readRelationContext(o) {
+    const v = o[exports.RELATION_CONTEXT];
+    return v instanceof RelationContext ? v : undefined;
+}
+/** Apply the hydrate factory to a resolved relation value (skip `null`; map arrays). */
+function applyHydrate(value, hydrate) {
+    if (hydrate === undefined)
+        return value;
+    if (value === null)
+        return null; // graphddb: hydrate is NOT applied to null
+    if (Array.isArray(value))
+        return value.map((v) => (v === null ? null : hydrate(v)));
+    return hydrate(value);
+}
+/**
+ * Build the typed-object result set for a page of raw child rows plus the relation ops
+ * declared for this model. Every raw row becomes a typed-object whose:
+ *   - OWN enumerable props = the raw data columns (+ any declaratively-selected relation);
+ *   - PROTOTYPE carries a lazy getter per UNSELECTED relation (fires the same op at access);
+ *   - non-enumerable {@link RELATION_CONTEXT} Symbol = the shared lazy batch context.
+ *
+ * Declaratively-selected relations (`options.with`) are batch-prefetched HERE (one query per
+ * relation over the whole page — staged, no N+1) via the SAME {@link runRelationOp}, and
+ * attached as own props (so they shadow the prototype getter). `hydrate`, when supplied, is
+ * applied to each parent row AND to resolved relations.
+ *
+ * Returns the typed-objects (hydrated if `options.hydrate` given). This is the litedbmodel
+ * runtime concern; the bundle carries only the relation ops + assembly shape (no hydrate).
+ */
+function buildResultSet(rawRows, ops, db, options = {}) {
+    const selected = options.with ?? {};
+    const hydrate = options.hydrate;
+    // The prototype carries a lazy getter for every relation NOT declaratively selected. A
+    // selected relation is an own prop, so it shadows the getter (feasibility §9 unification).
+    const proto = {};
+    for (const name of Object.keys(ops)) {
+        if (selected[name] === true)
+            continue;
+        Object.defineProperty(proto, name, {
+            enumerable: false,
+            configurable: true,
+            get() {
+                const ctx = readRelationContext(this);
+                if (ctx === undefined) {
+                    return Promise.reject(new Error(`lazy relation '${name}': the batch context was dropped (spread/clone/JSON); ` +
+                        `re-read through the query API or declaratively select it via { with: { ${name}: true } }`));
+                }
+                // v1 parity: `await post.author` yields a Promise (getter → relation-op launch,
+                // feasibility §9). The batch itself is synchronous (better-sqlite3) but memoized
+                // across siblings, so N accesses still issue ONE query (no N+1).
+                return Promise.resolve(ctx.resolve(name, this));
+            },
+        });
+    }
+    // The raw typed-objects (own props = data only), sharing `proto`.
+    const rows = rawRows.map((raw) => {
+        const o = Object.create(proto);
+        for (const k of Object.keys(raw))
+            o[k] = raw[k];
+        return o;
+    });
+    // The shared lazy batch context (non-enumerable Symbol) — the whole page is the sibling set.
+    const ctx = new RelationContext(rows, ops, db, hydrate, options.connections);
+    for (const o of rows) {
+        Object.defineProperty(o, exports.RELATION_CONTEXT, {
+            value: ctx,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    // Declarative select: batch-prefetch each selected relation ONCE (staged) and attach as an
+    // own prop (shadowing the lazy getter). SAME runRelationOp — identical compiled op + SQL.
+    for (const name of Object.keys(selected)) {
+        const op = ops[name];
+        if (op === undefined)
+            throw new Error(`declarative select: relation '${name}' is not declared on this model`);
+        // CROSS-DB (V0 R1): a tagged relation batches against its own connection; else the primary db.
+        const relDb = op.connection === undefined ? db : driverForOp(op, options.connections);
+        const { batch } = (0, relation_1.runRelationOp)(op, rows, relDb);
+        for (const o of rows) {
+            o[name] = applyHydrate((0, relation_1.distributeToParent)(op, o, batch), hydrate);
+        }
+    }
+    if (hydrate === undefined)
+        return rows;
+    return rows.map((o) => hydrate(o));
+}
+//# sourceMappingURL=typed-object.js.map

package/dist/scp/typed-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/scp/typed-object.ts"],"names":[],"mappings":"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"}

package/dist/scp/writes.d.ts

@@ -0,0 +1,251 @@
+/**
+ * litedbmodel v2 SCP — write-time relations declaration vocabulary (WS5, #25; spec §6 / §2.2).
+ *
+ * `entityWrites` / `edgeWrites` declare the **write-side invariants / effects required for
+ * an entity to stay consistent** when it is created / updated / removed — the SQL-backend
+ * counterpart of graphddb's `entityWrites` save contract (`graphddb/src/define/entity-writes.ts`,
+ * same shape: a per-lifecycle map of `w.lifecycle({requires,unique,derive,edges,emits,idempotency})`).
+ * This module produces a PORTABLE declaration (pure data, no closures): every value that
+ * references the write is a **path-rooted string** (`$.input.<field>` = the mutation input,
+ * `$.entity.<field>` = the written row's RETURNING result). {@link ../write-plan} lowers the
+ * declaration + a base write op into an ordered, gate-first SQL transaction plan (§6 table).
+ *
+ * ## Path roots (spec §6 example) — the SSoT for every derived value
+ *
+ * A leaf value binds to an explicit root so its source is unambiguous and no engine-code
+ * fallback is ever needed (hard rule: defaults live in the declaration):
+ *   - `$.input.<field>`  — the Command's input port value (bc flat scope: `{ref:['<field>']}`).
+ *   - `$.entity.<field>` — the just-written row (the body write's RETURNING row), exposed to
+ *     the derive/edges/emits stages under the reserved `{@link ENTITY_ROOT}` binding.
+ *
+ * The declaration is INITIAL-scope (spec §6 / §13): single-statement Command + fixed-order
+ * write-time relations. It does NOT model the complex DAG derivation (WS8).
+ */
+/** The reserved scope binding under which the body write's RETURNING row is exposed (`$.entity.*`). */
+export declare const ENTITY_ROOT = "__entity";
+/**
+ * The path root a write-relation value binds from:
+ *   - `input`  — the Command input port (bc flat scope).
+ *   - `entity` — the SOLE body write's RETURNING row (the WS5 single-base-write shorthand),
+ *     bound under {@link ENTITY_ROOT}.
+ *   - `ref`    — a NAMED upstream write's RETURNING row (`$.ref.<writeName>.<field>`, WS8a
+ *     composite/DAG scope). `entity` is exactly `ref` targeting the sole base write; keeping
+ *     it distinct preserves the WS5 vocabulary while composite writes address writes by name.
+ */
+export type PathRoot = 'input' | 'entity' | 'ref';
+/** A parsed, path-rooted write-relation value (`$.input.x` / `$.entity.x` / `$.ref.w.x`). */
+export interface EffectPath {
+    readonly root: PathRoot;
+    /**
+     * For `ref`: the upstream write's NAME (the statement whose RETURNING row is referenced).
+     * Absent for `input` / `entity` (those have a single implicit source).
+     */
+    readonly writeName?: string;
+    /** The field name after the root (a single physical column; no nested paths in α). */
+    readonly field: string;
+}
+/**
+ * Parse a path-rooted write-relation value string into an {@link EffectPath}. Fail-closed on
+ * a malformed path — a write-relation value MUST be `$.input.<field>`, `$.entity.<field>`, or
+ * `$.ref.<writeName>.<field>` (no free-form paths, no implicit root), so a typo is a loud build
+ * error, never a silent default (hard rule).
+ */
+export declare function parseEffectPath(value: string): EffectPath;
+/**
+ * A referential-integrity requirement (§6 `requires`): the named `table` must contain a row
+ * whose columns equal the bound keys. Lowered to a gate-first `SELECT 1 FROM <table> WHERE …`
+ * existence guard that ROLLBACKs when absent (spec §6 example line 1).
+ */
+export interface RequiresEffect {
+    readonly kind: 'requires';
+    /** The table whose row must exist. */
+    readonly table: string;
+    /** target column → path-rooted source value (the existence key). */
+    readonly keys: Readonly<Record<string, string>>;
+}
+/**
+ * A uniqueness guard (§6 `unique`): the combined `fields` must be unique within `scope`.
+ * Lowered to a guard-row `INSERT INTO <guardTable> … ON CONFLICT DO NOTHING` whose affected-
+ * row count is checked (0 rows ⇒ collision ⇒ ROLLBACK) — the SQL idiom of §6 (`ON CONFLICT
+ * DO NOTHING` + affected 検査).
+ */
+export interface UniqueEffect {
+    readonly kind: 'unique';
+    /** The guard-row name (its discriminator column value in the guard table). */
+    readonly name: string;
+    /** The guard table that materializes the uniqueness rows. */
+    readonly guardTable: string;
+    /** The scope the uniqueness is partitioned by (path-rooted values). */
+    readonly scope: readonly string[];
+    /** The fields whose combined value must be unique within the scope (path-rooted values). */
+    readonly fields: readonly string[];
+}
+/**
+ * A derived / cascading counter update (§6 `derive`): `SET <attribute> = <attribute> ± amount`
+ * on the `table` row keyed by `keys`. Lowered to `UPDATE <table> SET c = c + :amount WHERE …`
+ * (spec §6 example line "derive"). `amount` is the SSoT for the increment — never a code default.
+ */
+export interface DeriveEffect {
+    readonly kind: 'derive';
+    /** The table whose counter attribute is derived-updated. */
+    readonly table: string;
+    /** target column → path-rooted source value (the updated row's key). */
+    readonly keys: Readonly<Record<string, string>>;
+    /** The counter column to increment. */
+    readonly attribute: string;
+    /** The signed amount added to the counter (the declaration IS the source of truth). */
+    readonly amount: number;
+}
+/**
+ * An edge write (§6 `edges`). A many-to-many edge materializes as an intermediate-table
+ * `INSERT` (create) / `DELETE` (remove); a one-to-many edge as a foreign-key column `UPDATE`
+ * on the related table. Lowered per {@link EdgeEffect.relation} (spec §6 table row `edges`).
+ */
+export interface EdgeEffect {
+    readonly kind: 'edge';
+    /** `m2m` → intermediate-table INSERT/DELETE; `fk` → related-table FK column UPDATE. */
+    readonly relation: 'm2m' | 'fk';
+    /** The write action for this lifecycle: `set` (create/link) or `unset` (remove/unlink). */
+    readonly action: 'set' | 'unset';
+    /**
+     * For `m2m`: the intermediate (join) table. For `fk`: the related table whose FK column is set.
+     */
+    readonly table: string;
+    /**
+     * For `m2m`: the join-row columns → path-rooted source values (both endpoint keys).
+     * For `fk`: the FK column → path-rooted source value AND the matched-row key columns.
+     */
+    readonly columns: Readonly<Record<string, string>>;
+    /**
+     * For `fk` only: the WHERE key columns (matched-row identity) → path-rooted source values.
+     * `columns` then holds ONLY the FK column(s) to SET. For `m2m` this is absent.
+     */
+    readonly where?: Readonly<Record<string, string>>;
+}
+/**
+ * A domain event (§6 `emits`): an outbox `INSERT INTO <outboxTable>(type, payload)` in the
+ * SAME transaction (spec §6 example line "emits"). The payload is a path-rooted map serialized
+ * to a JSON text column at render time.
+ */
+export interface EmitEffect {
+    readonly kind: 'emit';
+    /** The event type discriminator (e.g. `PostCreated`). */
+    readonly name: string;
+    /** The outbox table the event row is inserted into. */
+    readonly outboxTable: string;
+    /** The event payload: field → path-rooted source value. */
+    readonly payload: Readonly<Record<string, string>>;
+}
+/**
+ * An idempotency guard (§6 `idempotency`): a client-token guard `INSERT INTO <table>(token)`
+ * whose UNIQUE violation detects a duplicate request (spec §6 example line "idempotency").
+ * Runs gate-first: a duplicate token short-circuits the whole transaction (no double write).
+ */
+export interface IdempotencyEffect {
+    readonly kind: 'idempotency';
+    /** The idempotency-key table (a single UNIQUE token column). */
+    readonly table: string;
+    /** The token column name. */
+    readonly column: string;
+    /** The path-rooted client-token value (e.g. `$.input.request_id`). */
+    readonly token: string;
+}
+/**
+ * The §6 effect set a {@link LifecycleContract} carries. Every field is optional; an omitted
+ * field is the empty effect set. Fixed derivation order (spec §6 example): gate-first
+ * (requires → idempotency → unique), body, then derive → edges → emits.
+ */
+export interface LifecycleEffects {
+    /** Referential-integrity requirements (→ gate-first existence guard). */
+    readonly requires?: readonly RequiresEffect[];
+    /** Idempotency guard (→ gate-first token INSERT; duplicate short-circuits). */
+    readonly idempotency?: IdempotencyEffect;
+    /** Uniqueness guards (→ gate-first guard-row INSERT ON CONFLICT DO NOTHING + affected check). */
+    readonly unique?: readonly UniqueEffect[];
+    /** Derived / cascading counter updates (→ UPDATE … SET c = c ± n). */
+    readonly derive?: readonly DeriveEffect[];
+    /** Edge writes (→ M:N intermediate INSERT/DELETE or 1:N FK UPDATE). */
+    readonly edges?: readonly EdgeEffect[];
+    /** Domain events (→ outbox INSERT, same tx). */
+    readonly emits?: readonly EmitEffect[];
+}
+/** One lifecycle's save contract — the §6 effect set for a single phase. */
+export interface LifecycleContract {
+    readonly effects: LifecycleEffects;
+}
+/** The lifecycle phase a save-contract entry declares (the Command intent selects it). */
+export type WriteLifecyclePhase = 'create' | 'update' | 'remove';
+/** A model's per-lifecycle save contract (`entityWrites(...)` result). */
+export interface EntityWritesDefinition {
+    readonly create?: LifecycleContract;
+    readonly update?: LifecycleContract;
+    readonly remove?: LifecycleContract;
+}
+/**
+ * The recorder handed to the {@link entityWrites} / {@link edgeWrites} builder. Each method
+ * builds ONE §6 effect (pure data). `w.lifecycle({...})` gathers the effect arrays into a
+ * {@link LifecycleContract}. Every path-rooted value is validated eagerly ({@link parseEffectPath}).
+ */
+export interface WriteRecorder {
+    /** Build one lifecycle's save contract from its §6 effect arrays (each field optional). */
+    lifecycle(effects?: LifecycleEffects): LifecycleContract;
+    /** `requires` — a referential-integrity existence guard (§6). */
+    exists(table: string, keys: Readonly<Record<string, string>>): RequiresEffect;
+    /** `unique` — a composite-scope uniqueness guard (§6). */
+    unique(spec: {
+        readonly name: string;
+        readonly guardTable: string;
+        readonly scope: readonly string[];
+        readonly fields: readonly string[];
+    }): UniqueEffect;
+    /** `derive` — a cascade counter increment (§6). `amount` is the SSoT (no code default). */
+    increment(table: string, keys: Readonly<Record<string, string>>, attribute: string, amount: number): DeriveEffect;
+    /** `edges` — a many-to-many intermediate-table link/unlink (§6). */
+    edge(spec: {
+        readonly relation: 'm2m';
+        readonly action: 'set' | 'unset';
+        readonly table: string;
+        readonly columns: Readonly<Record<string, string>>;
+    }): EdgeEffect;
+    /** `edges` — a one-to-many foreign-key column set/unset on a related row (§6). */
+    edge(spec: {
+        readonly relation: 'fk';
+        readonly action: 'set' | 'unset';
+        readonly table: string;
+        readonly columns: Readonly<Record<string, string>>;
+        readonly where: Readonly<Record<string, string>>;
+    }): EdgeEffect;
+    /** `emits` — a domain event into an outbox table, same tx (§6). */
+    event(name: string, outboxTable: string, payload: Readonly<Record<string, string>>): EmitEffect;
+    /** `idempotency` — a client-token duplicate guard (§6). */
+    idempotentBy(table: string, column: string, token: string): IdempotencyEffect;
+}
+/** The per-lifecycle map an {@link entityWrites} builder returns. */
+export interface EntityWritesShape {
+    readonly create?: LifecycleContract;
+    readonly update?: LifecycleContract;
+    readonly remove?: LifecycleContract;
+}
+/**
+ * Declare a model's reusable write-time-relations save contract (spec §2.2 / §6): a
+ * per-lifecycle map `{ create?, update?, remove? }`, each value a `w.lifecycle({...})`
+ * carrying the §6 effect arrays. Stored on the model as
+ * `static readonly writes = entityWrites<Model>((w) => ({ … }))`.
+ *
+ * @typeParam M documentary model type (the recorder is structural).
+ * @throws if no lifecycle is declared, or a lifecycle is not built with `w.lifecycle(...)`.
+ */
+export declare function entityWrites<M = unknown>(builder: (w: WriteRecorder) => EntityWritesShape): EntityWritesDefinition;
+/**
+ * Declare an adjacency entity's edge-only write contract (spec §2.2 / §6 — the `edgeWrites`
+ * counterpart of graphddb's #82). It is a thin specialization of {@link entityWrites} whose
+ * lifecycles carry ONLY `edges` effects — the write side of a many-to-many / one-to-many
+ * relation entity. Kept distinct so an author signals intent (an edge entity vs a full
+ * save contract), matching graphddb's two coexisting `writes` forms.
+ *
+ * @throws if a lifecycle declares a non-edge effect (an edge entity has only edge writes).
+ */
+export declare function edgeWrites<M = unknown>(builder: (w: WriteRecorder) => EntityWritesShape): EntityWritesDefinition;
+/** Resolve the {@link LifecycleContract} for a Command intent, or undefined if not declared. */
+export declare function lifecycleFor(def: EntityWritesDefinition, phase: WriteLifecyclePhase): LifecycleContract | undefined;
+//# sourceMappingURL=writes.d.ts.map

package/dist/scp/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../../src/scp/writes.ts"],"names":[],"mappings":"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"}