litedbmodel 2.0.0 → 2.0.2

package/dist/scp/fragment/assemble.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — fragment RUNTIME (assemble + bind).
+ *
+ * This is the thin runtime a bundle drives. It does exactly three things:
+ *
+ *   1. ASSEMBLE — walk the ordered fragment list; drop any fragment whose `skip`
+ *      is satisfied; concatenate the present fragments' `sql`, and their `params`
+ *      in order. Nested-fragment params splice their own `sql` at the `?` and
+ *      contribute their own params in order.
+ *   2. EVALUATE — turn each value-spec param into a concrete bound value using the
+ *      runtime `input` (and upstream `wire` results).
+ *   3. RENDER — the produced `{ sql, params }` uses `?`; a dialect step turns `?`
+ *      into `$N` for PostgreSQL (identical to the original driver's naive replace).
+ *
+ * NO SQL structure is generated here. The `sql` text is already complete; the
+ * runtime only splices nested-fragment text and fills `?`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSkipped = isSkipped;
+exports.evalValueSpec = evalValueSpec;
+exports.assembleFragment = assembleFragment;
+exports.assembleWhereGroup = assembleWhereGroup;
+exports.assemble = assemble;
+exports.toPostgres = toPostgres;
+const model_1 = require("./model");
+function readPath(root, path) {
+    let cur = root;
+    for (const seg of path) {
+        if (cur == null)
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}
+/** Is a fragment's `skip` satisfied (⇒ omit the fragment)? */
+function isSkipped(cond, scope) {
+    if (!cond)
+        return false;
+    const v = readPath(scope.input, cond.absent);
+    return v == null;
+}
+/** Evaluate a value-spec to its bound value against the runtime scope. */
+function evalValueSpec(spec, scope) {
+    if ((0, model_1.isInputRef)(spec))
+        return readPath(scope.input, spec.input);
+    if ((0, model_1.isWireRef)(spec)) {
+        const [node, ...rest] = spec.wire;
+        // A wire-ref reads a value an UPSTREAM node produced (WireRef doc). Fragments carrying a
+        // wire-ref are dropped by `isSkipped` when their upstream is skipped, so by evaluation time the
+        // node MUST be present. An absent node is a wiring/ordering bug — fail loudly, NEVER a silent
+        // `?? {}` → null (an unspec'd fallback that would swallow the bug).
+        if (scope.wire === undefined || !(node in scope.wire)) {
+            throw new Error(`scp assemble: wire-ref to node '${node}' has no produced result in scope ` +
+                `(wire keys: ${scope.wire === undefined ? '<no wire scope>' : Object.keys(scope.wire).join(', ')}). ` +
+                `A wire-ref must reference an upstream node that produced — this is a wiring/ordering bug, not a silent null.`);
+        }
+        return readPath(scope.wire[node], rest);
+    }
+    if ((0, model_1.isLiteral)(spec))
+        return spec.literal;
+    if ((0, model_1.isValueExpr)(spec)) {
+        if (spec.op === 'coalesce') {
+            for (const a of spec.args) {
+                const v = evalValueSpec(a, scope);
+                if (v != null)
+                    return v;
+            }
+            return null;
+        }
+        if (spec.op === 'add') {
+            return spec.args.reduce((acc, a) => acc + evalValueSpec(a, scope), 0);
+        }
+    }
+    throw new Error(`unknown value-spec: ${JSON.stringify(spec)}`);
+}
+/** Flatten one param (value-spec OR nested fragment) into sql text + bound params. */
+function assembleParam(param, scope) {
+    if ((0, model_1.isFragment)(param)) {
+        // Nested fragment: splice its own sql at the `?`, contribute its own params.
+        return assembleFragment(param, scope);
+    }
+    // Value-spec: this `?` is filled by a single bound value.
+    return { sql: '?', params: [evalValueSpec(param, scope)] };
+}
+/**
+ * Assemble a single fragment: interleave its literal `sql` (split on `?`) with the
+ * rendered text of each param, concatenating params in order.
+ */
+function assembleFragment(frag, scope) {
+    const chunks = frag.sql.split('?');
+    if (chunks.length - 1 !== frag.params.length) {
+        throw new Error(`fragment placeholder/param mismatch: ${chunks.length - 1} '?' vs ${frag.params.length} params in ${JSON.stringify(frag.sql)}`);
+    }
+    let sql = chunks[0];
+    const params = [];
+    for (let i = 0; i < frag.params.length; i++) {
+        const rendered = assembleParam(frag.params[i], scope);
+        sql += rendered.sql + chunks[i + 1];
+        params.push(...rendered.params);
+    }
+    return { sql, params };
+}
+/**
+ * Assemble a WHERE group: join present members with `" AND "`, prefix `" WHERE "`.
+ * If no member is present, produce the empty string (identical to the ORIGINAL
+ * `DBConditions.compile` → `parts.length === 0 ? '' : parts.join(' AND ')`, with the
+ * `" WHERE "` prefix owned by the caller/select in the original — here folded in).
+ */
+function assembleWhereGroup(group, scope) {
+    const parts = [];
+    const params = [];
+    for (const member of group.where) {
+        if (isSkipped(member.skip, scope))
+            continue;
+        const r = assembleFragment(member, scope);
+        parts.push(r.sql);
+        params.push(...r.params);
+    }
+    if (parts.length === 0)
+        return { sql: '', params: [] };
+    return { sql: ` WHERE ${parts.join(' AND ')}`, params };
+}
+/**
+ * Assemble an ordered fragment/WHERE-group list into a single `{ sql, params }`
+ * (with `?`). Fragments whose `skip` is satisfied are omitted entirely (sql AND
+ * params). A WHERE group joins its present members with the original's text glue.
+ */
+function assemble(nodes, scope) {
+    let sql = '';
+    const params = [];
+    for (const node of nodes) {
+        if ((0, model_1.isWhereGroup)(node)) {
+            const r = assembleWhereGroup(node, scope);
+            sql += r.sql;
+            params.push(...r.params);
+            continue;
+        }
+        if (isSkipped(node.skip, scope))
+            continue;
+        const r = assembleFragment(node, scope);
+        sql += r.sql;
+        params.push(...r.params);
+    }
+    return { sql, params };
+}
+/**
+ * PostgreSQL dialect render: `?` → `$1, $2, …`. Byte-identical to the original
+ * driver's `convertPlaceholders` (naive left-to-right replace; see
+ * `src/drivers/postgres.ts`).
+ */
+function toPostgres(sql) {
+    let index = 0;
+    return sql.replace(/\?/g, () => `$${++index}`);
+}
+//# sourceMappingURL=assemble.js.map

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

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

package/dist/scp/fragment/compile-pg.d.ts

@@ -0,0 +1,107 @@
+/**
+ * litedbmodel v2 SCP — PostgreSQL compile (build time, TS).
+ *
+ * Produces the fragment list for a query. Every fragment's `sql` text is emitted by
+ * REUSING the ORIGINAL tuned builders (`DBConditions`, `buildSelectSQL`,
+ * `LazyRelation`) so that ANY SKIP combination reassembles to exactly what the
+ * original builder would produce for that combination. The compiler runs at build
+ * time (TS); its OUTPUT (the fragment list) is the pure-JSON portable bundle.
+ *
+ * NO abstract IR is produced. Only `{ sql, params, skip }` fragments (+ nested
+ * fragment params where a subquery/sub-expression is needed).
+ */
+import type { Fragment, Node, ValueSpec } from './model';
+/**
+ * An authored optional WHERE equality: `<column> = <value from input.path>`,
+ * present only when `input.path` is non-null (else the fragment is skipped).
+ */
+export interface OptionalEq {
+    column: string;
+    inputPath: string[];
+}
+/**
+ * Compile one optional equality to a fragment carrying a `skip`.
+ *
+ * The condition core text (`<col> = ?`) is emitted by the ORIGINAL `DBConditions`,
+ * so it is byte-identical to the tuned builder. The leading `" AND "` is the exact
+ * connector the original uses when joining a present condition after an earlier
+ * (mandatory) part — see the byte-match invariant in {@link compileSelect}.
+ */
+export declare function compileOptionalEq(cond: OptionalEq): Fragment;
+/**
+ * belongsTo / single-key batch (PG): `SELECT … FROM t WHERE t.key = ANY(?::type[])`.
+ *
+ * This is byte-identical to `LazyRelation.batchLoadWithAnyArray`. The array of keys
+ * binds as ONE param (`keys` value-spec) — the `?::type[]` cast text is static,
+ * chosen at compile time by the ORIGINAL `inferPgArrayType`. Optional relation
+ * `where`-filters (config.conditions) are appended as `compileOptionalEq` fragments.
+ */
+export declare function compileBelongsTo(opts: {
+    tableName: string;
+    selectColumn?: string;
+    targetKey: string;
+    /** compile-time sample values used ONLY for cast-type inference. */
+    sampleKeys: unknown[];
+    /** value-spec producing the runtime key array (bound as one param). */
+    keys: ValueSpec;
+    sqlCast?: string;
+    filters?: OptionalEq[];
+}): Fragment[];
+/**
+ * hasMany + per-parent limit (PG): `CROSS JOIN LATERAL`.
+ *
+ * Byte-identical to `LazyRelation.batchLoadWithLateral`. The inner SELECT is emitted
+ * by the ORIGINAL `buildSelectSQL` (reproduced here as the same template it yields:
+ * `SELECT <sel> FROM t WHERE t.key = _keys.key[ AND <filters>] ORDER BY <order> LIMIT n`).
+ * The outer wraps it in `unnest(?::type[]) AS _keys(key) CROSS JOIN LATERAL (…)`.
+ *
+ * `limit` is inlined into the text (the original inlines it: `LIMIT ${limit}`), so it
+ * is NOT a param. The key array binds as ONE param.
+ */
+export declare function compileHasManyLimited(opts: {
+    tableName: string;
+    selectColumn?: string;
+    targetKey: string;
+    sampleKeys: unknown[];
+    keys: ValueSpec;
+    order: string;
+    limit: number;
+    sqlCast?: string;
+    filters?: OptionalEq[];
+}): Fragment[];
+/**
+ * hasMany / single-key batch WITHOUT limit (PG): `= ANY(?::type[])` + ORDER BY.
+ * Byte-identical to `batchLoadWithAnyArray` (used for hasMany when no limit) —
+ * same shape as {@link compileBelongsTo} plus a trailing ORDER BY carried on the
+ * base fragment (so optional filters slot BEFORE the ORDER BY, matching the
+ * original which appends conditions before the order clause).
+ */
+export declare function compileHasManyAny(opts: {
+    tableName: string;
+    selectColumn?: string;
+    targetKey: string;
+    sampleKeys: unknown[];
+    keys: ValueSpec;
+    order?: string;
+    sqlCast?: string;
+    filters?: OptionalEq[];
+}): Fragment[];
+/**
+ * A plain `SELECT <sel> FROM t` with a WHERE built only from optional conditions.
+ *
+ * The WHERE is a {@link WhereGroup}: each member fragment carries the BARE condition
+ * core (`"status = ?"`, NO leading connector), emitted by the ORIGINAL
+ * `DBConditions`, and its own `skip`. At assemble time the group joins the SURVIVORS
+ * with `" AND "` and prefixes `" WHERE "` — byte-identical to the original
+ * `DBConditions.compile` → `parts.join(' AND ')` for EVERY present/absent subset,
+ * including when the first condition is skipped (the group's join, not a static
+ * connector, decides the leading text). No new SQL-structure vocabulary: the join is
+ * pure text glue, exactly the original's algorithm.
+ */
+export declare function compileBaseSelect(opts: {
+    tableName: string;
+    selectColumn?: string;
+    /** ordered optional equality conditions */
+    conditions: OptionalEq[];
+}): Node[];
+//# sourceMappingURL=compile-pg.d.ts.map

package/dist/scp/fragment/compile-pg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-pg.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/compile-pg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAqB,SAAS,EAAE,MAAM,SAAS,CAAC;AAM5E;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAU5D;AAMD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,uEAAuE;IACvE,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,QAAQ,EAAE,CAQb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,QAAQ,EAAE,CAsBb;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,QAAQ,EAAE,CAUb;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B,GAAG,IAAI,EAAE,CAeT"}

package/dist/scp/fragment/compile-pg.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — PostgreSQL compile (build time, TS).
+ *
+ * Produces the fragment list for a query. Every fragment's `sql` text is emitted by
+ * REUSING the ORIGINAL tuned builders (`DBConditions`, `buildSelectSQL`,
+ * `LazyRelation`) so that ANY SKIP combination reassembles to exactly what the
+ * original builder would produce for that combination. The compiler runs at build
+ * time (TS); its OUTPUT (the fragment list) is the pure-JSON portable bundle.
+ *
+ * NO abstract IR is produced. Only `{ sql, params, skip }` fragments (+ nested
+ * fragment params where a subquery/sub-expression is needed).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileOptionalEq = compileOptionalEq;
+exports.compileBelongsTo = compileBelongsTo;
+exports.compileHasManyLimited = compileHasManyLimited;
+exports.compileHasManyAny = compileHasManyAny;
+exports.compileBaseSelect = compileBaseSelect;
+const DBConditions_1 = require("../../DBConditions");
+const pg_array_type_1 = require("./pg-array-type");
+/**
+ * Compile one optional equality to a fragment carrying a `skip`.
+ *
+ * The condition core text (`<col> = ?`) is emitted by the ORIGINAL `DBConditions`,
+ * so it is byte-identical to the tuned builder. The leading `" AND "` is the exact
+ * connector the original uses when joining a present condition after an earlier
+ * (mandatory) part — see the byte-match invariant in {@link compileSelect}.
+ */
+function compileOptionalEq(cond) {
+    const probe = [];
+    const core = new DBConditions_1.DBConditions({ [cond.column]: '__probe__' }).compile(probe);
+    // core === `<col> = ?`   (source of the text is the original builder)
+    const param = { input: cond.inputPath };
+    return {
+        sql: ` AND ${core}`,
+        params: [param],
+        skip: { absent: cond.inputPath },
+    };
+}
+// ============================================================================
+// Relation batch-load fragments — text emitted by the ORIGINAL LazyRelation paths.
+// ============================================================================
+/**
+ * belongsTo / single-key batch (PG): `SELECT … FROM t WHERE t.key = ANY(?::type[])`.
+ *
+ * This is byte-identical to `LazyRelation.batchLoadWithAnyArray`. The array of keys
+ * binds as ONE param (`keys` value-spec) — the `?::type[]` cast text is static,
+ * chosen at compile time by the ORIGINAL `inferPgArrayType`. Optional relation
+ * `where`-filters (config.conditions) are appended as `compileOptionalEq` fragments.
+ */
+function compileBelongsTo(opts) {
+    const select = opts.selectColumn || '*';
+    const pgType = (0, pg_array_type_1.inferPgArrayTypeForCompile)(opts.sampleKeys, opts.sqlCast);
+    const base = {
+        sql: `SELECT ${select} FROM ${opts.tableName} WHERE ${opts.tableName}.${opts.targetKey} = ANY(?::${pgType})`,
+        params: [opts.keys],
+    };
+    return [base, ...(opts.filters ?? []).map(compileOptionalEq)];
+}
+/**
+ * hasMany + per-parent limit (PG): `CROSS JOIN LATERAL`.
+ *
+ * Byte-identical to `LazyRelation.batchLoadWithLateral`. The inner SELECT is emitted
+ * by the ORIGINAL `buildSelectSQL` (reproduced here as the same template it yields:
+ * `SELECT <sel> FROM t WHERE t.key = _keys.key[ AND <filters>] ORDER BY <order> LIMIT n`).
+ * The outer wraps it in `unnest(?::type[]) AS _keys(key) CROSS JOIN LATERAL (…)`.
+ *
+ * `limit` is inlined into the text (the original inlines it: `LIMIT ${limit}`), so it
+ * is NOT a param. The key array binds as ONE param.
+ */
+function compileHasManyLimited(opts) {
+    const select = opts.selectColumn || '*';
+    const pgType = (0, pg_array_type_1.inferPgArrayTypeForCompile)(opts.sampleKeys, opts.sqlCast);
+    const filterFrags = (opts.filters ?? []).map(compileOptionalEq);
+    // The full inner+outer text (byte-identical to batchLoadWithLateral) is split into
+    // three fragments so optional filters slot in AFTER the mandatory `t.key=_keys.key`
+    // predicate and BEFORE the ORDER BY, exactly where the original appends them:
+    //   head:   ... CROSS JOIN LATERAL (SELECT * FROM t WHERE t.key = _keys.key
+    //   [filters]  each `" AND <core>"` (skip-guarded)
+    //   tail:    ORDER BY <order> LIMIT <n>) t
+    const head = {
+        sql: `SELECT ${opts.tableName}.* FROM unnest(?::${pgType}) AS _keys(key) CROSS JOIN LATERAL (` +
+            `SELECT ${select} FROM ${opts.tableName} WHERE ${opts.tableName}.${opts.targetKey} = _keys.key`,
+        params: [opts.keys],
+    };
+    const tail = {
+        sql: ` ORDER BY ${opts.order} LIMIT ${opts.limit}) ${opts.tableName}`,
+        params: [],
+    };
+    return [head, ...filterFrags, tail];
+}
+/**
+ * hasMany / single-key batch WITHOUT limit (PG): `= ANY(?::type[])` + ORDER BY.
+ * Byte-identical to `batchLoadWithAnyArray` (used for hasMany when no limit) —
+ * same shape as {@link compileBelongsTo} plus a trailing ORDER BY carried on the
+ * base fragment (so optional filters slot BEFORE the ORDER BY, matching the
+ * original which appends conditions before the order clause).
+ */
+function compileHasManyAny(opts) {
+    const select = opts.selectColumn || '*';
+    const pgType = (0, pg_array_type_1.inferPgArrayTypeForCompile)(opts.sampleKeys, opts.sqlCast);
+    const head = {
+        sql: `SELECT ${select} FROM ${opts.tableName} WHERE ${opts.tableName}.${opts.targetKey} = ANY(?::${pgType})`,
+        params: [opts.keys],
+    };
+    const filterFrags = (opts.filters ?? []).map(compileOptionalEq);
+    const tail = opts.order ? [{ sql: ` ORDER BY ${opts.order}`, params: [] }] : [];
+    return [head, ...filterFrags, ...tail];
+}
+// ============================================================================
+// Base SELECT + WHERE (all-optional conditions, no mandatory predicate).
+// ============================================================================
+/**
+ * A plain `SELECT <sel> FROM t` with a WHERE built only from optional conditions.
+ *
+ * The WHERE is a {@link WhereGroup}: each member fragment carries the BARE condition
+ * core (`"status = ?"`, NO leading connector), emitted by the ORIGINAL
+ * `DBConditions`, and its own `skip`. At assemble time the group joins the SURVIVORS
+ * with `" AND "` and prefixes `" WHERE "` — byte-identical to the original
+ * `DBConditions.compile` → `parts.join(' AND ')` for EVERY present/absent subset,
+ * including when the first condition is skipped (the group's join, not a static
+ * connector, decides the leading text). No new SQL-structure vocabulary: the join is
+ * pure text glue, exactly the original's algorithm.
+ */
+function compileBaseSelect(opts) {
+    const select = opts.selectColumn || '*';
+    const base = { sql: `SELECT ${select} FROM ${opts.tableName}`, params: [] };
+    const group = {
+        where: opts.conditions.map((c) => {
+            const probe = [];
+            const core = new DBConditions_1.DBConditions({ [c.column]: '__probe__' }).compile(probe);
+            return {
+                sql: core, // bare core, e.g. `status = ?` — connector belongs to the join
+                params: [{ input: c.inputPath }],
+                skip: { absent: c.inputPath },
+            };
+        }),
+    };
+    return [base, group];
+}
+//# sourceMappingURL=compile-pg.js.map

package/dist/scp/fragment/compile-pg.js.map

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

package/dist/scp/fragment/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * Public surface: the fragment types, the compile helpers (build-time TS, reuse the
+ * original tuned builders), and the runtime assembler (thin, language-portable).
+ *
+ * There is NO abstract IR here. The portable artifact is ONLY a combination of
+ * `{ sql, params, skip }` fragments, with params being either value-specs or nested
+ * fragments. SQL structure (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast)
+ * is TEXT inside `sql`, never a modeled construct.
+ */
+export * from './model';
+export * from './assemble';
+export * from './compile-pg';
+export { inferPgArrayTypeForCompile } from './pg-array-type';
+//# sourceMappingURL=index.d.ts.map

package/dist/scp/fragment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/scp/fragment/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * Public surface: the fragment types, the compile helpers (build-time TS, reuse the
+ * original tuned builders), and the runtime assembler (thin, language-portable).
+ *
+ * There is NO abstract IR here. The portable artifact is ONLY a combination of
+ * `{ sql, params, skip }` fragments, with params being either value-specs or nested
+ * fragments. SQL structure (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast)
+ * is TEXT inside `sql`, never a modeled construct.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferPgArrayTypeForCompile = void 0;
+__exportStar(require("./model"), exports);
+__exportStar(require("./assemble"), exports);
+__exportStar(require("./compile-pg"), exports);
+var pg_array_type_1 = require("./pg-array-type");
+Object.defineProperty(exports, "inferPgArrayTypeForCompile", { enumerable: true, get: function () { return pg_array_type_1.inferPgArrayTypeForCompile; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scp/fragment/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;;;;;;;;;;;;;;;AAEH,0CAAwB;AACxB,6CAA2B;AAC3B,+CAA6B;AAC7B,iDAA6D;AAApD,2HAAA,0BAA0B,OAAA"}

package/dist/scp/fragment/model.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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.
+ */
+/** Read a value from runtime input by path, e.g. `{ input: ["authorId"] }`. */
+export interface InputRef {
+    input: string[];
+}
+/** Read a value produced by an upstream node/wire, e.g. `{ wire: ["node1", "id"] }`. */
+export interface WireRef {
+    wire: string[];
+}
+/** A literal constant value baked into the bundle (e.g. an array of keys, or 20). */
+export interface LiteralValue {
+    literal: unknown;
+}
+/**
+ * A small CLOSED value-expression. It computes a value from other value-specs.
+ * This is deliberately tiny: `coalesce` and `add` are enough for the LIMIT / key
+ * shapes in this slice. It is NOT an SQL-structure IR — it never emits SQL.
+ */
+export interface ValueExpr {
+    op: 'coalesce' | 'add';
+    args: ValueSpec[];
+}
+/** Param variant (a): a value-spec. */
+export type ValueSpec = InputRef | WireRef | LiteralValue | ValueExpr;
+/**
+ * Param variant (b): a nested fragment. A subquery / sub-expression is just a
+ * `{ sql, params }` embedded as a param — its `sql` is spliced into the parent's
+ * `?` position, its params flow into the parent's param stream in order. This is
+ * how subqueries are represented WITHOUT any IR construct.
+ */
+export type Param = ValueSpec | Fragment;
+/**
+ * A presence condition for `skip`. When SATISFIED, the fragment (sql + params)
+ * is OMITTED. Deliberately closed and tiny: "the input at this path is absent /
+ * null / undefined". SKIP is not an operator — it is the ABSENCE of the fragment.
+ */
+export interface PresenceCondition {
+    /** Skip the fragment when the input at this path is null/undefined. */
+    absent: string[];
+}
+/**
+ * The one and only structural type: `{ sql, params, skip? }`.
+ *
+ * `sql` is literal SQL text (leading connector included where relevant, e.g.
+ * `" AND status = ?"`) with `?` placeholders. `params` are 1:1 with the `?`
+ * (a value-spec fills one `?`; a nested-fragment param splices its own `sql`,
+ * which itself may contain further `?`). `skip`, when present and satisfied,
+ * omits the whole fragment.
+ */
+export interface Fragment {
+    sql: string;
+    params: Param[];
+    skip?: PresenceCondition;
+}
+/**
+ * A WHERE clause is an ordered list of condition fragments joined by the SAME text
+ * glue the ORIGINAL `DBConditions.compile` uses: present members are joined with
+ * `" AND "` and the whole is prefixed with `" WHERE "` — and if NO member is
+ * present, the clause degenerates to the empty string (exactly the original's
+ * `parts.length === 0 → ''`).
+ *
+ * This is the "tree" form of the fragment model (a query is an ordered list/tree of
+ * fragments). It carries NO SQL-structure vocabulary — the join is pure text glue,
+ * identical to the original builder's `parts.join(' AND ')`. Each member fragment's
+ * `sql` is the bare condition core (`"status = ?"`, NO leading connector); the
+ * connector belongs to the join, so it is SKIP-stable regardless of which members
+ * survive.
+ *
+ * Members carry their own `skip`; a skipped member contributes neither text nor
+ * params, and the join simply closes over the survivors (so the first survivor never
+ * emits a stray leading `" AND "`).
+ */
+export interface WhereGroup {
+    where: Fragment[];
+}
+/** A member of an assembled query: a plain fragment or a WHERE group. */
+export type Node = Fragment | WhereGroup;
+export declare function isFragment(p: Param | Node): p is Fragment;
+export declare function isWhereGroup(n: Node): n is WhereGroup;
+export declare function isInputRef(v: ValueSpec): v is InputRef;
+export declare function isWireRef(v: ValueSpec): v is WireRef;
+export declare function isLiteral(v: ValueSpec): v is LiteralValue;
+export declare function isValueExpr(v: ValueSpec): v is ValueExpr;
+//# sourceMappingURL=model.d.ts.map

package/dist/scp/fragment/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAOH,+EAA+E;AAC/E,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,wFAAwF;AACxF,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,qFAAqF;AACrF,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAED,uCAAuC;AACvC,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,CAAC;AAMtE;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAMzC;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,iBAAiB,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,yEAAyE;AACzE,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,UAAU,CAAC;AAMzC,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEzD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,QAAQ,CAEtD;AACD,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,OAAO,CAEpD;AACD,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,SAAS,CAExD"}