litedbmodel 2.0.0 → 2.0.2

package/dist/scp/render.js

@@ -1,170 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP — fragment-tree render + param assembly (WS1, #21).
- *
- * The NORMATIVE reference implementation of `docs/proposal/sql-dynamic-expansion-spec.md`.
- * Given a compiled operation and a bound input scope, it deterministically produces the
- * final SQLite SQL text (`?` placeholders) and the flat params array. Every multi-language
- * runtime (WS3) must reproduce this byte-for-byte; this TS implementation is the golden
- * reference the conformance harness pins.
- *
- * The three moving parts (dynamic-expansion spec):
- *   §2 SKIP → fragment existence: a fragment with `when` is present iff `when` evaluates
- *       to a present (non-null / true) binding; an absent fragment contributes NO SQL and
- *       NO params.
- *   §3 empty-WHERE degeneration: if no fragment is present the whole `{where}` splice
- *       (including the ` WHERE ` keyword) collapses to the empty string.
- *   §4 AND/OR structure + parenthesization: a nested tree renders `(… <connector> …)`.
- *   §5 IN-list array expansion: a fragment slot marked `expand` turns its `(?)` into
- *       `(?, ?, …)` for each element of the bound array (0 elements → the `1 = 0`
- *       always-false degeneration, byte-identical to litedbmodel v1's empty-IN handling).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderOperation = renderOperation;
-const behavior_contracts_1 = require("behavior-contracts");
-const ir_1 = require("./ir");
-const dialect_1 = require("./dialect");
-/** A fragment tree carries a `connector`; a fragment carries `sql`. */
-function isTree(node) {
-    return 'connector' in node;
-}
-/**
- * SKIP existence rule (dynamic-expansion spec §2): a fragment is present iff it is
- * `always`, or its `when` Expression evaluates to a PRESENT binding — `null` and `false`
- * are absent; everything else (including `0`, `""`) is present. This mirrors bc's
- * strict-bool discipline: `when` is expected to be an explicit presence/bool Expression
- * (e.g. `{ne:[{refOpt:["status"]}, null]}` in bc's flat scope), evaluated fail-closed by
- * evaluateExpression.
- */
-function fragmentPresent(f, scope) {
-    if (f.always === true)
-        return true;
-    if (f.when === undefined)
-        return false; // fail-closed: neither always nor when
-    const v = (0, behavior_contracts_1.evaluateExpression)(f.when, scope);
-    return v !== null && v !== false;
-}
-/**
- * Render one leaf fragment's SQL + params into the accumulators. Handles IN-list
- * expansion (spec §5): the slot at `expand` is an array; its `(?)` in `sql` becomes
- * `(?, ?, …)` and each element is pushed as its own param.
- */
-function renderFragment(f, scope, params) {
-    if (f.expand === undefined) {
-        for (const slot of f.params)
-            params.push((0, behavior_contracts_1.evaluateExpression)(slot, scope));
-        return f.sql;
-    }
-    // IN-list expansion. Evaluate all slots; the `expand` slot must be an array.
-    let sql = f.sql;
-    for (let i = 0; i < f.params.length; i++) {
-        const v = (0, behavior_contracts_1.evaluateExpression)(f.params[i], scope);
-        if (i === f.expand) {
-            if (!Array.isArray(v)) {
-                throw new Error(`IN-list expansion slot ${i} did not bind to an array (got ${v === null ? 'null' : typeof v})`);
-            }
-            if (v.length === 0) {
-                // Empty-array degeneration (dynamic-expansion spec §5): the whole `col IN (?)`
-                // fragment collapses to the always-false sentinel `1 = 0` — byte-identical to
-                // litedbmodel v1's DBConditions (an empty IN pushes NO params). The `col IN`
-                // prefix and the `(?)` slot are BOTH replaced.
-                sql = '1 = 0';
-                // no params pushed for this slot
-            }
-            else {
-                // Replace the single `(?)` with `(?, ?, …)` sized to the array; push each element.
-                sql = sql.replace('(?)', `(${v.map(() => '?').join(', ')})`);
-                for (const el of v)
-                    params.push(el);
-            }
-        }
-        else {
-            params.push(v);
-        }
-    }
-    return sql;
-}
-/**
- * Render a fragment tree into a WHERE clause body (no leading ` WHERE ` keyword).
- * Present fragments are joined by ` <connector> `; a nested tree is parenthesized
- * (spec §4). Returns the empty string when NO fragment is present (degeneration, §3).
- *
- * Each fragment's `sql` already carries its own leading connector prefix when authored as
- * a chained condition (e.g. `" AND status = ?"`), so this function STRIPS the accumulated
- * connector from the first present fragment to avoid a dangling leading `AND`/`OR`, then
- * joins the rest as-authored. To keep the golden output identical to litedbmodel v1 (which
- * builds `parts.join(' AND ')` with no leading connector), fragment `sql` at the top level
- * is authored WITHOUT a leading connector and joined here.
- */
-function renderTree(tree, scope, params) {
-    const parts = [];
-    for (const node of tree.fragments) {
-        if (isTree(node)) {
-            const inner = renderTree(node, scope, params);
-            if (inner !== '')
-                parts.push(`(${inner})`);
-        }
-        else if (fragmentPresent(node, scope)) {
-            parts.push(renderFragment(node, scope, params));
-        }
-    }
-    if (parts.length === 0)
-        return '';
-    return parts.join(` ${tree.connector} `);
-}
-/**
- * Render a compiled operation to final SQLite SQL + params for a bound input scope.
- *
- * Param order (matches SQL text order, dynamic-expansion spec §6): the compiled `sql`
- * splices the WHERE tree at `{where}`; static params before the marker are emitted first,
- * then the fragment params in tree order, then static params after the marker. WS1's CRUD
- * shapes place all pre-WHERE statics (Insert values, Update SET) before `{where}` and all
- * post-WHERE statics (LIMIT / OFFSET) after — so a single left-to-right walk of the
- * spliced SQL yields the canonical `?` order.
- */
-function renderOperation(op, input, dialect = dialect_1.SQLITE) {
-    const params = [];
-    const markerIdx = op.sql.indexOf(ir_1.WHERE_SLOT);
-    if (markerIdx === -1) {
-        // No dynamic WHERE: all params are static, in position order.
-        for (const slot of op.params)
-            params.push((0, behavior_contracts_1.evaluateExpression)(slot, input));
-        return { sql: finalize(op.sql, dialect), params };
-    }
-    const before = op.sql.slice(0, markerIdx);
-    const after = op.sql.slice(markerIdx + ir_1.WHERE_SLOT.length);
-    // Static params are partitioned by whether their `?` sits before or after the marker.
-    const beforeQ = countPlaceholders(before);
-    const preStatics = op.params.slice(0, beforeQ);
-    const postStatics = op.params.slice(beforeQ);
-    for (const slot of preStatics)
-        params.push((0, behavior_contracts_1.evaluateExpression)(slot, input));
-    let whereSql = '';
-    if (op.where !== null) {
-        const body = renderTree(op.where, input, params);
-        if (body !== '')
-            whereSql = ` WHERE ${body}`; // degeneration §3: drop keyword when empty
-    }
-    for (const slot of postStatics)
-        params.push((0, behavior_contracts_1.evaluateExpression)(slot, input));
-    return { sql: finalize(before + whereSql + after, dialect), params };
-}
-/**
- * Apply the dialect's final placeholder pass over the FULLY-assembled SQL text (spec §8): for
- * Postgres this converts `?`→`$1,$2,…` in ONE left-to-right pass (the number-reassignment
- * problem is designed out — it runs once, after IN-list expansion + fragment splicing are all
- * done); for SQLite/MySQL it is identity. This is the single place the `?`→`$N` conversion
- * happens, so `params` order (already position-ordered by the walk above) matches `$N` order.
- */
-function finalize(sql, dialect) {
-    return dialect.finalizePlaceholders(sql);
-}
-/** Count `?` placeholders in a static SQL segment (no fragment markers present). */
-function countPlaceholders(sql) {
-    let n = 0;
-    for (const ch of sql)
-        if (ch === '?')
-            n++;
-    return n;
-}
-//# sourceMappingURL=render.js.map

package/dist/scp/render.js.map

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

package/dist/scp/write-plan.d.ts

@@ -1,161 +0,0 @@
-/**
- * litedbmodel v2 SCP — write-time relations → ordered SQL transaction plan (WS5, #25; spec §6).
- *
- * Derives a declarative {@link LifecycleContract} (the §6 effect arrays) + a base write op
- * (the Command's `Insert`/`Update`/`Delete`, e.g. `Insert(Post, {onWrite: Post.writes.create})`)
- * into ONE ordered, gate-first multi-statement transaction plan — exactly the §6 example:
- *
- * ```
- * BEGIN;
- *   -- Gate First (short-circuit + ROLLBACK before any body write)
- *   requires:    SELECT 1 FROM users WHERE id = :author_id;        -- absent ⇒ fail
- *   idempotency: INSERT INTO idem(token) VALUES(:request_id);      -- duplicate ⇒ short-circuit
- *   unique:      INSERT INTO uniq(...) ON CONFLICT DO NOTHING; …   -- collision ⇒ fail
- *   -- Body
- *   INSERT INTO posts(author_id,title) VALUES(:author_id,:title) RETURNING id;
- *   derive:  UPDATE users SET post_count = post_count + 1 WHERE id = :author_id;
- *   edges:   … (M:N intermediate INSERT/DELETE  or  1:N FK UPDATE) …
- *   emits:   INSERT INTO outbox(type,payload) VALUES('PostCreated', :payload);
- * COMMIT;
- * ```
- *
- * The plan is PURE JSON (each statement is a WS1 {@link CompiledOperation} rendered by the
- * SAME {@link import('./render').renderOperation}), so it serializes into the §8 bundle and a
- * thin per-language runtime honors the SAME ordering + gate-first (no re-derivation, spec §6:
- * "多言語 runtime は同一計画を honor"). `Transaction` は公開仕様にしない — this plan is DERIVED
- * from the Command's declared intent, never authored.
- *
- * ## Gate-first is a real execution behavior, not a text ordering (spec §6 "Gate First")
- *
- * Each gate statement carries a {@link GateRule} the runtime evaluates AFTER executing it: a
- * failing gate short-circuits — the remaining statements (body + derive + edges + emits) never
- * execute and the transaction ROLLBACKs. This is semantically-invariant early termination
- * ({@link import('./write-runtime').executeTransaction} proves it with real query counts + DB state).
- *
- * ## Path lowering (spec §6) — `$.input.*` / `$.entity.*` → closed-set Expression IR
- *
- * A `$.input.<field>` value lowers to `{ref:['<field>']}` (bc flat input scope); a
- * `$.entity.<field>` value lowers to `{ref:['__entity','<field>']}` (the body write's
- * RETURNING row, exposed to the derive/edges/emits stages under {@link ENTITY_ROOT}). Only
- * bc's closed operator set (`ref`) is emitted — no invented opcode (hard rule).
- *
- * ## Transaction derivation (spec §6 / §14) — tx-DAG + gate-first
- *
- * A Command carries one or more named base writes, each with its §6 effects. Statements form a
- * data-dependency DAG (`$.ref.<writeName>.<field>` consumes an earlier write's RETURNING row,
- * exposed via `TxStatement.binds`), with a gate-first constraint (every gate precedes every
- * body/derive/edge/emit). The DAG is topologically ordered (Kahn, stable ascending declaration
- * `seq` tie-break) into a single-transaction statement plan. Underivable shapes (dependency
- * cycle, dangling `$.ref`, referenced write without RETURNING, duplicate bind, composite
- * `$.entity`) are LOUD rejects — never a silently mis-ordered plan.
- */
-import type { CompiledOperation } from './ir';
-import { type Dialect } from './dialect';
-import { type LifecycleContract, type LifecycleEffects, type WriteLifecyclePhase } from './writes';
-/** The role a transaction statement plays (drives the runtime's gate-first interpretation). */
-export type StatementRole = 'gate:requires' | 'gate:idempotency' | 'gate:unique' | 'body' | 'derive' | 'edge' | 'emit';
-/**
- * The gate rule the runtime evaluates on a gate statement's result to decide short-circuit
- * (spec §6 "Gate First"):
- *   - `existsElseRollback` — the statement is a `SELECT 1 …` existence probe; ZERO rows ⇒
- *     the required row is absent ⇒ short-circuit + ROLLBACK (`requires`).
- *   - `insertedElseRollback` — the statement is a guard `INSERT … ON CONFLICT DO NOTHING`;
- *     ZERO affected rows ⇒ a collision ⇒ short-circuit + ROLLBACK (`unique`).
- *   - `insertedElseNoop` — the statement is an idempotency-token `INSERT … ON CONFLICT DO
- *     NOTHING`; ZERO affected rows ⇒ a DUPLICATE request ⇒ short-circuit WITHOUT error
- *     (idempotent: the prior write already happened; the tx commits the no-op / rolls back
- *     the empty body per {@link TransactionPlan.onIdempotentHit}).
- */
-export type GateRule = 'existsElseRollback' | 'insertedElseRollback' | 'insertedElseNoop';
-/** One ordered statement of a transaction plan (pure JSON — a WS1 compiled op + its role). */
-export interface TxStatement {
-    /** Stable statement id (ordering key + diagnostics). */
-    readonly id: string;
-    /** The statement's role in the §6 derivation order. */
-    readonly role: StatementRole;
-    /** The compiled SQL op (rendered by the normative {@link import('./render').renderOperation}). */
-    readonly op: CompiledOperation;
-    /** For a gate statement: the short-circuit rule. Absent for body/derive/edge/emit. */
-    readonly gate?: GateRule;
-    /**
-     * For a composite (multi-write) body statement: the scope binding under which THIS statement's
-     * RETURNING row is exposed to LATER statements — a downstream `$.ref.<binds>.<field>` resolves
-     * to `scope[<binds>][<field>]` (spec §6 nested write). This is the DAG's data-dependency edge,
-     * self-describing so the 5 runtimes just bind the row and continue (no re-derivation). Absent for
-     * a statement no later statement depends on; the WS5 single-base write additionally exposes its
-     * row under {@link TransactionPlan.entityFrom} / {@link ENTITY_ROOT} for `$.entity.*` back-compat.
-     */
-    readonly binds?: string;
-    /** Human label (diagnostics; e.g. `requires users`, `derive users.post_count`). */
-    readonly label: string;
-}
-/** How the runtime resolves an idempotency short-circuit hit (a duplicate request). */
-export type IdempotentHitPolicy = 'rollback';
-/**
- * A derived write-time-relations transaction plan (spec §6 / §8 `transaction plan`). Pure JSON:
- * ordered statements + gate-first rules + the body-write's `entity` exposure. Serializes into
- * the §8 bundle so a WS7 runtime executes the SAME plan.
- */
-export interface TransactionPlan {
-    /** The lifecycle phase this plan realizes (`create` / `update` / `remove`). */
-    readonly phase: WriteLifecyclePhase;
-    /**
-     * The statement id whose RETURNING row is exposed to later stages under `$.entity.*`
-     * ({@link ENTITY_ROOT}). Always the body write. `null` when the body has no RETURNING
-     * (then no later stage may reference `$.entity.*` — validated at derivation time).
-     */
-    readonly entityFrom: string | null;
-    /** The ordered statements (gate-first, then body, then derive/edges/emits). */
-    readonly statements: readonly TxStatement[];
-    /** What a duplicate-idempotency-token short-circuit does (α: rollback the empty tx). */
-    readonly onIdempotentHit: IdempotentHitPolicy;
-}
-/**
- * The base write op the Command declares (`Insert`/`Update`/`Delete` with `onWrite`). This is
- * the Command body statement the plan wraps in a transaction. A Command may declare ONE base
- * write (WS5 single-statement scope) OR several (WS8a composite / nested write, spec §6:
- * "多対多や nested write（親作成と同時に子作成）は edges/追加 write で表現し、同一 tx にまとめる").
- */
-export interface BaseWrite {
-    /** The compiled base write op (from the bridge, e.g. `compileNode` of the Insert node). */
-    readonly op: CompiledOperation;
-    /** The body statement's role (always `body`). */
-    readonly label: string;
-    /**
-     * The write's stable NAME (WS8a composite scope) — later statements reference its RETURNING row
-     * as `$.ref.<name>.<field>`, and the derived body statement `binds` this name. Omitted for the
-     * WS5 single-base write (its row is addressed as `$.entity.*` under {@link ENTITY_ROOT}).
-     */
-    readonly name?: string;
-    /**
-     * The write's OWN save-contract effects (WS8a composite scope): its gates/derive/edges/emits.
-     * For the WS5 single-base write, the lifecycle is passed as the top-level `lifecycle` arg and
-     * this is omitted. When a base write carries `effects`, the derivation treats it as one DAG
-     * node group (its gates → its body → its after-effects), then topologically orders ALL groups.
-     */
-    readonly effects?: LifecycleEffects;
-}
-/**
- * Derive the ORDERED, gate-first {@link TransactionPlan} from a Command's base write(s) + its
- * lifecycle save contract (spec §6 / §14).
- *
- * ## Single base write (WS5 scope)
- *
- * One base write + a top-level `lifecycle`; the order is the fixed §6 group
- * (requires → idempotency → unique → BODY → derive → edges → emits). `$.entity.*` references in
- * derive/edges/emits require the body write to RETURN the entity row (else a loud build error).
- *
- * ## Composite / nested write (WS8a scope) — real DAG derivation
- *
- * Multiple base writes, each carrying its OWN {@link BaseWrite.effects} and a `name`. A later
- * write references an earlier write's RETURNING row via `$.ref.<name>.<field>` (e.g. a child
- * INSERT keyed by the parent's returned id). The derivation builds the data-dependency graph
- * (statement → the writes it references) + the gate-first constraint, TOPOLOGICALLY orders it
- * (deterministic, stable tie-break), and emits ONE ordered gate-first transaction plan. A cycle
- * or dangling reference is ESCALATED (no silent mis-derivation).
- *
- * @throws if a `$.entity.*` reference lacks a RETURNING body, a `$.ref.*` is dangling, two writes
- *   bind the same name, or the dependency graph has a cycle.
- */
-export declare function deriveTransactionPlan(phase: WriteLifecyclePhase, bases: readonly BaseWrite[], lifecycle: LifecycleContract, dialect?: Dialect): TransactionPlan;
-//# sourceMappingURL=write-plan.d.ts.map

package/dist/scp/write-plan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-plan.d.ts","sourceRoot":"","sources":["../../src/scp/write-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAY,MAAM,MAAM,CAAC;AAGxD,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAOL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAGrB,KAAK,mBAAmB,EACzB,MAAM,UAAU,CAAC;AAElB,+FAA+F;AAC/F,MAAM,MAAM,aAAa,GACrB,eAAe,GACf,kBAAkB,GAClB,aAAa,GACb,MAAM,GACN,QAAQ,GACR,MAAM,GACN,MAAM,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,GAAG,oBAAoB,GAAG,sBAAsB,GAAG,kBAAkB,CAAC;AAE1F,8FAA8F;AAC9F,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kGAAkG;IAClG,QAAQ,CAAC,EAAE,EAAE,iBAAiB,CAAC;IAC/B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,uFAAuF;AACvF,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC;AAE7C;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,SAAS,WAAW,EAAE,CAAC;IAC5C,wFAAwF;IACxF,QAAQ,CAAC,eAAe,EAAE,mBAAmB,CAAC;CAC/C;AAiMD;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,EAAE,iBAAiB,CAAC;IAC/B,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAuJD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,SAAS,EAAE,iBAAiB,EAC5B,OAAO,GAAE,OAAgB,GACxB,eAAe,CA2DjB"}