litedbmodel 1.2.10 → 2.0.1

package/dist/scp/fragment/model.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * ## The locked vocabulary (owner-specified — nothing else exists here)
+ *
+ * The portable artifact is ONLY a combination of **fragments**. There is NO
+ * abstract "Expression IR", NO relation-op / operator kinds for SQL structure,
+ * NO `FragmentTree` connector algebra, NO `{where}` splice marker. SQL structure
+ * (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast, batch shapes) lives
+ * ENTIRELY as TEXT inside `sql`.
+ *
+ *   fragment = { sql: string, params: Param[], skip?: PresenceCondition }
+ *
+ * - A query is an ordered list of fragments.
+ * - Assembling = concatenate the `sql` of every PRESENT fragment, and concatenate
+ *   their `params` in order. If a fragment's `skip` is satisfied, BOTH its `sql`
+ *   and its `params` are omitted.
+ *
+ *   Param = EITHER
+ *     (a) a **value-spec** — how to compute the bound value from input at runtime:
+ *         an input-ref / wire-ref / a small closed value-expression
+ *         (e.g. `coalesce(input.limit, 20)`). This computes the VALUE only.
+ *     OR
+ *     (b) a **nested fragment** — a raw SQL sub-piece with its own params. This is
+ *         how subqueries / sub-expressions are represented: NOT as IR constructs,
+ *         just a nested { sql, params }.
+ *
+ * Array-parameter placeholder expansion is DRIVER-side, not modeled here. On
+ * PostgreSQL an array param binds directly (`= ANY(?::int[])`), so the text is
+ * static and the array is ONE param. On MySQL/SQLite (no array binding) the DRIVER
+ * expands an array param into `(?, ?, …)` at bind time. The bundle stays
+ * "string + params" regardless.
+ *
+ * The whole model is plain JSON / serializable so a thin runtime in any language
+ * reads it identically.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFragment = isFragment;
+exports.isWhereGroup = isWhereGroup;
+exports.isInputRef = isInputRef;
+exports.isWireRef = isWireRef;
+exports.isLiteral = isLiteral;
+exports.isValueExpr = isValueExpr;
+// ============================================================================
+// Type guards (structural — a nested-fragment param has `sql`; value-specs don't)
+// ============================================================================
+function isFragment(p) {
+    return typeof p.sql === 'string';
+}
+function isWhereGroup(n) {
+    return Array.isArray(n.where);
+}
+function isInputRef(v) {
+    return Array.isArray(v.input);
+}
+function isWireRef(v) {
+    return Array.isArray(v.wire);
+}
+function isLiteral(v) {
+    return 'literal' in v;
+}
+function isValueExpr(v) {
+    return typeof v.op === 'string' && Array.isArray(v.args);
+}
+//# sourceMappingURL=model.js.map

package/dist/scp/fragment/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/scp/fragment/model.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;;AAyGH,gCAEC;AAED,oCAEC;AAED,gCAEC;AACD,8BAEC;AACD,8BAEC;AACD,kCAEC;AAvBD,+EAA+E;AAC/E,kFAAkF;AAClF,+EAA+E;AAE/E,SAAgB,UAAU,CAAC,CAAe;IACxC,OAAO,OAAQ,CAAc,CAAC,GAAG,KAAK,QAAQ,CAAC;AACjD,CAAC;AAED,SAAgB,YAAY,CAAC,CAAO;IAClC,OAAO,KAAK,CAAC,OAAO,CAAE,CAAgB,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC;AAED,SAAgB,UAAU,CAAC,CAAY;IACrC,OAAO,KAAK,CAAC,OAAO,CAAE,CAAc,CAAC,KAAK,CAAC,CAAC;AAC9C,CAAC;AACD,SAAgB,SAAS,CAAC,CAAY;IACpC,OAAO,KAAK,CAAC,OAAO,CAAE,CAAa,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AACD,SAAgB,SAAS,CAAC,CAAY;IACpC,OAAO,SAAS,IAAK,CAAkB,CAAC;AAC1C,CAAC;AACD,SAAgB,WAAW,CAAC,CAAY;IACtC,OAAO,OAAQ,CAAe,CAAC,EAAE,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAE,CAAe,CAAC,IAAI,CAAC,CAAC;AACzF,CAAC"}

package/dist/scp/fragment/pg-array-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PostgreSQL array-type inference for compile-time cast text.
+ *
+ * VERBATIM reuse of the ORIGINAL `LazyRelation.inferPgArrayType` logic so the
+ * `?::<type>[]` cast text a fragment carries is byte-identical to the tuned
+ * builder. sqlCast (from the target column's metadata) wins; otherwise the element
+ * type is inferred from the compile-time sample values.
+ *
+ * (This is TEXT chosen at build time; it is NOT an IR "kind". The array itself is
+ * bound as ONE param on PostgreSQL.)
+ */
+export declare function inferPgArrayTypeForCompile(values: unknown[], sqlCast?: string): string;
+//# sourceMappingURL=pg-array-type.d.ts.map

package/dist/scp/fragment/pg-array-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-array-type.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/pg-array-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAYtF"}

package/dist/scp/fragment/pg-array-type.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferPgArrayTypeForCompile = inferPgArrayTypeForCompile;
+/**
+ * PostgreSQL array-type inference for compile-time cast text.
+ *
+ * VERBATIM reuse of the ORIGINAL `LazyRelation.inferPgArrayType` logic so the
+ * `?::<type>[]` cast text a fragment carries is byte-identical to the tuned
+ * builder. sqlCast (from the target column's metadata) wins; otherwise the element
+ * type is inferred from the compile-time sample values.
+ *
+ * (This is TEXT chosen at build time; it is NOT an IR "kind". The array itself is
+ * bound as ONE param on PostgreSQL.)
+ */
+function inferPgArrayTypeForCompile(values, sqlCast) {
+    if (sqlCast)
+        return `${sqlCast}[]`;
+    if (values.length === 0)
+        return 'text[]';
+    const sample = values[0];
+    if (typeof sample === 'number') {
+        if (values.every((v) => Number.isInteger(v)))
+            return 'int[]';
+        return 'numeric[]';
+    }
+    if (typeof sample === 'bigint')
+        return 'bigint[]';
+    if (typeof sample === 'boolean')
+        return 'boolean[]';
+    if (sample instanceof Date)
+        return 'timestamp[]';
+    return 'text[]';
+}
+//# sourceMappingURL=pg-array-type.js.map

package/dist/scp/fragment/pg-array-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-array-type.js","sourceRoot":"","sources":["../../../src/scp/fragment/pg-array-type.ts"],"names":[],"mappings":";;AAWA,gEAYC;AAvBD;;;;;;;;;;GAUG;AACH,SAAgB,0BAA0B,CAAC,MAAiB,EAAE,OAAgB;IAC5E,IAAI,OAAO;QAAE,OAAO,GAAG,OAAO,IAAI,CAAC;IACnC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IACzC,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACzB,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,OAAO,CAAC;QAC7D,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,UAAU,CAAC;IAClD,IAAI,OAAO,MAAM,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IACpD,IAAI,MAAM,YAAY,IAAI;QAAE,OAAO,aAAa,CAAC;IACjD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/scp/guard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,134 @@
+"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

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