litedbmodel 2.0.2 → 2.2.0

package/dist/scp/guard.d.ts

@@ -1,43 +0,0 @@
-/**
- * litedbmodel v2 SCP — param/fragment portability guard (WS1, #21).
- *
- * Fail-closed enforcement of the hard rule: every Expression IR node this backend emits
- * (param slots, fragment `when` guards) uses ONLY bc's closed operator set
- * (`PORTABLE_EXPR_OPERATORS`). A single-key object whose key is not a known operator is
- * an un-lowerable construct — it must go through the Raw SQL escape hatch (spec §13), NOT
- * a fake opcode. This wraps bc's `assertPortable` (no functions/Date/Promise residue)
- * plus the operator-set check.
- */
-import { type Component, type ComponentGraphIR } from 'behavior-contracts';
-/** A bc Expression IR node (closed operator set). Structural alias — a JSON expression tree. */
-export type ExprNode = unknown;
-/**
- * Assert one Expression IR node is portable: no residue (functions/Date/…) and every
- * operator-node key is in bc's closed set. Literals (number/string/bool/null) and arrays
- * pass structurally.
- *
- * A single-key object is an OPERATOR node only when its key is a known operator
- * (∈ {@link PORTABLE_EXPR_OPERATORS}); its value is then recursed as operator args. A
- * single-key object whose key is NOT a known operator is a real portability violation and
- * is rejected fail-closed (an un-lowerable pseudo-opcode → must use the Raw SQL escape
- * hatch, spec §13). This mirrors bc's `assertPortableComponentGraph` operator-position
- * semantics exactly — see {@link walkExpr} for the `obj` field-map special case.
- */
-export declare function assertExprPortable(node: ExprNode, path?: string): void;
-/**
- * Assert every Expression IR node in ONE lowered component's port wiring is portable
- * (WS2 AC). Walks every `componentRef`/`map` node's `ports` (and `map.over` / `map.when`)
- * and every `cond` node's `if`/`then`/`else`, applying {@link assertExprPortable} — so any
- * operator outside bc's closed set is rejected fail-closed at compile time. This is the
- * litedbmodel-owned portability layer the authoring lower path auto-applies, over and
- * above bc's own `assertPortableComponentGraph` self-check.
- */
-export declare function assertComponentPortable(component: Component): void;
-/**
- * Assert every component of a lowered Component-graph IR is portable (WS2 AC). The
- * authoring lower path ({@link publishBehaviors} / {@link compileEager}) invokes this
- * automatically so a non-portable opcode anywhere in the emitted IR is a fail-closed
- * compile error. Throws {@link PortabilityError} on the first violation.
- */
-export declare function assertComponentGraphPortable(ir: ComponentGraphIR): void;
-//# sourceMappingURL=guard.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/scp/guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAmF,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE5J,gGAAgG;AAChG,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,SAAM,GAAG,IAAI,CAGnE;AAgDD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAgBlE;AAoBD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,gBAAgB,GAAG,IAAI,CAEvE"}

package/dist/scp/guard.js

@@ -1,134 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP — param/fragment portability guard (WS1, #21).
- *
- * Fail-closed enforcement of the hard rule: every Expression IR node this backend emits
- * (param slots, fragment `when` guards) uses ONLY bc's closed operator set
- * (`PORTABLE_EXPR_OPERATORS`). A single-key object whose key is not a known operator is
- * an un-lowerable construct — it must go through the Raw SQL escape hatch (spec §13), NOT
- * a fake opcode. This wraps bc's `assertPortable` (no functions/Date/Promise residue)
- * plus the operator-set check.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertExprPortable = assertExprPortable;
-exports.assertComponentPortable = assertComponentPortable;
-exports.assertComponentGraphPortable = assertComponentGraphPortable;
-const behavior_contracts_1 = require("behavior-contracts");
-/**
- * Assert one Expression IR node is portable: no residue (functions/Date/…) and every
- * operator-node key is in bc's closed set. Literals (number/string/bool/null) and arrays
- * pass structurally.
- *
- * A single-key object is an OPERATOR node only when its key is a known operator
- * (∈ {@link PORTABLE_EXPR_OPERATORS}); its value is then recursed as operator args. A
- * single-key object whose key is NOT a known operator is a real portability violation and
- * is rejected fail-closed (an un-lowerable pseudo-opcode → must use the Raw SQL escape
- * hatch, spec §13). This mirrors bc's `assertPortableComponentGraph` operator-position
- * semantics exactly — see {@link walkExpr} for the `obj` field-map special case.
- */
-function assertExprPortable(node, path = '$') {
-    (0, behavior_contracts_1.assertPortable)(node, path);
-    walkExpr(node, path);
-}
-function walkExpr(node, path) {
-    if (node === null || typeof node !== 'object')
-        return;
-    if (Array.isArray(node)) {
-        node.forEach((el, i) => walkExpr(el, `${path}[${i}]`));
-        return;
-    }
-    const keys = Object.keys(node);
-    if (keys.length === 1) {
-        // Single-key object = OPERATOR-position node. The key must be a known opcode
-        // (fail-closed on unknown opcodes — a real portability violation).
-        const op = keys[0];
-        if (!behavior_contracts_1.PORTABLE_EXPR_OPERATORS.has(op)) {
-            throw new behavior_contracts_1.PortabilityError(path, `Portability Guard: '${op}' is not a portable Expression IR operator (closed set: ${[...behavior_contracts_1.PORTABLE_EXPR_OPERATORS].join(', ')})`);
-        }
-        const arg = node[op];
-        // `obj` is the construction node: its arg is a FIELD MAP whose KEYS are data field
-        // names (NOT opcodes) and whose VALUES are ExprNodes. Recurse into the values ONLY —
-        // never apply the operator heuristic to the field map itself (aligns with bc's
-        // assertPortableExpr / evaluate() so a single-field {obj:{one:…}} is not misread as an
-        // unknown opcode). See behavior-contracts guard.ts `op === "obj"` branch.
-        if (op === 'obj') {
-            if (arg === null || typeof arg !== 'object' || Array.isArray(arg)) {
-                throw new behavior_contracts_1.PortabilityError(`${path}.obj`, `Portability Guard: {obj: ...} expects an object (at ${path}.obj)`);
-            }
-            for (const [k, v] of Object.entries(arg)) {
-                // Static fail-closed (defense-in-depth): own key "__proto__" is rejected here as it
-                // is by bc's guard/evaluator (prototype pollution / cross-language divergence).
-                if (k === behavior_contracts_1.FORBIDDEN_OBJECT_KEY) {
-                    throw new behavior_contracts_1.PortabilityError(`${path}.obj`, `Portability Guard: object key "${behavior_contracts_1.FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed) at ${path}.obj`);
-                }
-                walkExpr(v, `${path}.obj.${k}`);
-            }
-            return;
-        }
-        // Any other operator: recurse its arg (array of args or a nested expr node).
-        walkExpr(arg, `${path}.${op}`);
-        return;
-    }
-    // Multi-key objects are not operator nodes (operator nodes are single-key). Recurse each
-    // value structurally so nested operator nodes are still checked (assertPortable above has
-    // already rejected any function/Date/Promise residue across the whole subtree).
-    for (const k of keys)
-        walkExpr(node[k], `${path}.${k}`);
-}
-// ── Authoring→IR lower guard (WS2, #22 — auto-applied on the single compile path) ─────
-/**
- * Assert every Expression IR node in ONE lowered component's port wiring is portable
- * (WS2 AC). Walks every `componentRef`/`map` node's `ports` (and `map.over` / `map.when`)
- * and every `cond` node's `if`/`then`/`else`, applying {@link assertExprPortable} — so any
- * operator outside bc's closed set is rejected fail-closed at compile time. This is the
- * litedbmodel-owned portability layer the authoring lower path auto-applies, over and
- * above bc's own `assertPortableComponentGraph` self-check.
- */
-function assertComponentPortable(component) {
-    const at = `component '${component.name}'`;
-    for (const n of component.body) {
-        if ('map' in n) {
-            assertExprPortable(n.map.over, `${at}/${n.id}.map.over`);
-            assertPortsPortable(n.map.ports, `${at}/${n.id}.map.ports`);
-            if (n.map.when !== undefined)
-                assertExprPortable(n.map.when, `${at}/${n.id}.map.when`);
-        }
-        else if ('cond' in n) {
-            assertExprPortable(n.cond.if, `${at}/${n.id}.cond.if`);
-            assertExprPortable(n.cond.then, `${at}/${n.id}.cond.then`);
-            assertExprPortable(n.cond.else, `${at}/${n.id}.cond.else`);
-        }
-        else {
-            assertPortsPortable(n.ports, `${at}/${n.id}.ports`);
-        }
-    }
-    assertExprPortable(component.output, `${at}.output`);
-}
-/**
- * A component node's `ports` (and a `map.ports`) is a FIELD MAP — port NAME → ExprNode — not an
- * Expression node itself. Walk each port VALUE as an expression, never the ports object as a whole:
- * a SINGLE-port node (`{ table: 'posts' }`, e.g. a `Count` with only `table`) would otherwise be
- * misread by {@link walkExpr}'s single-key = OPERATOR heuristic as an unknown-opcode `{table:…}`
- * node. Recursing the values sidesteps that (same rationale bc's guard applies to `{obj:{…}}`).
- */
-function assertPortsPortable(ports, path) {
-    if (ports === null || typeof ports !== 'object' || Array.isArray(ports)) {
-        // Not a ports map (shouldn't happen for a well-formed node) — defer to the expr walker.
-        assertExprPortable(ports, path);
-        return;
-    }
-    for (const [name, value] of Object.entries(ports)) {
-        assertExprPortable(value, `${path}.${name}`);
-    }
-}
-/**
- * Assert every component of a lowered Component-graph IR is portable (WS2 AC). The
- * authoring lower path ({@link publishBehaviors} / {@link compileEager}) invokes this
- * automatically so a non-portable opcode anywhere in the emitted IR is a fail-closed
- * compile error. Throws {@link PortabilityError} on the first violation.
- */
-function assertComponentGraphPortable(ir) {
-    for (const c of ir.components)
-        assertComponentPortable(c);
-}
-//# sourceMappingURL=guard.js.map

package/dist/scp/guard.js.map

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

package/dist/scp/makesql/authoring-compile.d.ts

@@ -1,90 +0,0 @@
-/**
- * litedbmodel v2 SCP — the AUTHORING → `makeSQL` bundle path (Phase A of epic #43/#45).
- *
- * WS2 (`../authoring.ts`) lowers BOTH the SCP declaration blocks and the eager public
- * API through ONE bc compile path (`publishBehaviors` / `compileEager`) into ONE
- * portable `ComponentGraphIR` — a Component's body carries `componentRef` / `map` nodes
- * whose SQL-structural ports (`table`, `select`, `where`, `values.<field>`, `set.<field>`,
- * `order`, `limit`, …) are closed-set bc Expression IR (spec §7). Until now the ONLY
- * consumer of that authored IR was the REDUCED spine (`../bridge.ts` → `../compile-sqlite.ts`
- * → `CompiledOperation`).
- *
- * This module is the ADDITIVE makeSQL producer for the SAME authored IR: it reads a
- * node's ports STRUCTURALLY (exactly the closed-set decoding `../bridge.ts` performs —
- * same operators, same IN-sentinel, same SKIP-`cond` collapse, no invented opcode) and,
- * given the concrete Input Port values, routes WHERE / CRUD / relation through
- * `./compile*` + `./json-array` / `./json-batch` to emit a **`makeSQL` bundle** (composed
- * `makeSQL` components). The value slots are resolved HANDLER-SIDE (spec §11 item 4): a bc
- * `makeSQL` catalog leaf whose handler holds the concrete port values from bc's
- * `runBehavior` and calls `./compile*` to build the byte-tuned SQL — so the emitted SQL is
- * v1-tuned by construction (PG byte-match; MySQL/SQLite single-JSON-param parity).
- *
- * ## Single compile path (spec §9 — preserved)
- *
- * Both the eager public-API path (`compileEager`) and the declaration path
- * (`publishBehaviors`) produce byte-identical authored component IR (pinned by
- * `test/scp/authoring.test.ts`). Because {@link compileAuthoredBehavior} is a pure function
- * of that IR + the concrete input, feeding EITHER path's contract through it yields a
- * byte-identical `makeSQL` bundle — the single-compile-path invariant carries over to the
- * makeSQL target with no second interpreter.
- *
- * Coverage (Phase A): a read behavior (Select + belongsTo `.map` + hasMany-limit `.map`),
- * a write behavior (Insert), and a SKIP-optional condition. The three dialects share this
- * routing; PG stays byte-identical to v1, MySQL/SQLite use the single-JSON-param forms.
- */
-import { type Scope } from 'behavior-contracts';
-import type { ComponentRefNode, MapNode } from '../authoring';
-import type { BehaviorModelContract } from '../authoring';
-import type { MakeSQL } from './makesql';
-import { assembleMakeSQL } from './makesql';
-import type { Dialect } from './handler';
-/** A bc body node that references a catalog component (`componentRef` or `map`). */
-type RefLike = ComponentRefNode | MapNode;
-/**
- * Compile ONE authored catalog `componentRef`/`map` node into a `makeSQL` bundle, given
- * the concrete input `scope`. Routes WHERE / CRUD through `./compile*`. The value slots
- * are the bc-evaluated concrete values (handler-side), so the emitted SQL text/params
- * come STRAIGHT from the v1 builders (`compileSelect` / `compileInsert` / …) —
- * byte-parity by construction.
- */
-export declare function compileAuthoredNode(node: RefLike, scope: Scope, dialect: Dialect): MakeSQL;
-/** A relation `.map` compiled against the resolved PARENT rows (the batch key source). */
-export interface RelationMapInput {
-    /** The parent result rows (from executing the parent Select node). */
-    parentRows: Record<string, unknown>[];
-    /** Per-parent limit (undefined ⇒ unlimited batch load). */
-    limit?: number;
-}
-/**
- * Compile a relation `.map` node into a batch-load `makeSQL` bundle. The map's inner
- * `where` names the target key column (`eq($p.<k>, …)`); the batch key VALUES are the
- * distinct `parentKey` values across `parentRows`. Extra (non-key) where members become
- * the relation's merged `conditions` filter.
- *
- * @param parentKey the parent-row field whose values key the batch (e.g. `author_id`).
- */
-export declare function compileRelationMap(node: MapNode, input: RelationMapInput, dialect: Dialect, parentKey: string): MakeSQL;
-/** The compiled makeSQL artifact of one authored behavior method. */
-export interface AuthoredMakeSQL {
-    /** The behavior (component) name. */
-    readonly name: string;
-    /** The PRIMARY read/write query bundle (the root catalog node of the method). */
-    readonly primary: MakeSQL;
-    /** The relation `.map` nodes of the method (batch loads), in body order (unresolved). */
-    readonly relations: MapNode[];
-}
-/**
- * Compile the PRIMARY read/write query of an authored behavior method into a `makeSQL`
- * bundle, given the concrete Input Port `scope`. The "primary" node is the method's root
- * catalog `componentRef` (the Select the relations map over, or the write). Relation
- * `.map` nodes are returned unresolved (their batch keys come from executing `primary`
- * first — {@link compileRelationMap}).
- *
- * This is a PURE function of the authored component IR + the input, so `publishBehaviors`
- * (declaration) and `compileEager` (eager) — which produce byte-identical component IR —
- * yield a byte-identical `primary` bundle (single-compile-path invariant, spec §9).
- */
-export declare function compileAuthoredBehavior(contract: BehaviorModelContract, scope: Scope, dialect: Dialect, entry?: string): AuthoredMakeSQL;
-/** Assemble + dialect-render a compiled `makeSQL` bundle (thin convenience for callers). */
-export { assembleMakeSQL };
-//# sourceMappingURL=authoring-compile.d.ts.map

package/dist/scp/makesql/authoring-compile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring-compile.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/authoring-compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAsB,KAAK,KAAK,EAAc,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAa,gBAAgB,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAO5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,oFAAoF;AACpF,KAAK,OAAO,GAAG,gBAAgB,GAAG,OAAO,CAAC;AAyN1C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAoD1F;AAaD,0FAA0F;AAC1F,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtC,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CA2CT;AAqBD,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,yFAAyF;IACzF,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,qBAAqB,EAC/B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,MAAM,GACb,eAAe,CA6BjB;AAiED,4FAA4F;AAC5F,OAAO,EAAE,eAAe,EAAE,CAAC"}