litedbmodel 2.0.0 → 2.0.2

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

@@ -0,0 +1,133 @@
+/**
+ * litedbmodel v2 SCP — CRUD compile → `makeSQL` bundles, by driving the ORIGINAL
+ * dialect SQL builders (`postgresSqlBuilder` / `mysqlSqlBuilder` / `sqliteSqlBuilder`)
+ * and the original single-row UPDATE/DELETE text. The produced `{ sql, params }` is
+ * byte-identical to what the original library sends, for every dialect and every
+ * shape:
+ *
+ *   INSERT single (+per-col `?::sqlCast` on PG) & batch (PG UNNEST + type inference /
+ *   MySQL·SQLite multi-VALUES) + ON CONFLICT (DO NOTHING / DO UPDATE incl. `= 'all'`
+ *   → all columns) + RETURNING (bare / `t.col` alias / `table.col` / MySQL simulate);
+ *   UPDATE single (`SET c = ?::sqlCast`) & batch (PG UNNEST / MySQL JOIN-VALUES /
+ *   SQLite CASE-WHEN) + SKIP-column; DELETE; and the SELECT tail (LIMIT/OFFSET inline,
+ *   FOR UPDATE, GROUP BY/HAVING) via `buildSelectSQL`.
+ *
+ * These delegate to the SAME builders the runtime uses, so parity is by construction.
+ */
+import type { SqlBuilder, InsertBuildOptions, UpdateManyBuildOptions } from '../../drivers/types';
+import type { ConditionObject } from '../../DBConditions';
+import type { MakeSQL } from './makesql';
+import type { Dialect } from './handler';
+/** The original dialect builder for a dialect (the exact object the runtime uses). */
+export declare function builderFor(dialect: Dialect): SqlBuilder;
+/**
+ * Compile INSERT (single or batch) to a `makeSQL` bundle via the original
+ * `buildInsert`. Single-row on PG carries per-col `?::sqlCast`; batch on PG uses UNNEST
+ * with type inference; MySQL/SQLite use multi-VALUES. ON CONFLICT / RETURNING are the
+ * original's exact verbs. `onConflictUpdate: 'all'` expands to every column (the
+ * builder's fallback), so an empty DO-UPDATE never breaks.
+ */
+export declare function compileInsert(dialect: Dialect, options: InsertBuildOptions): MakeSQL;
+/**
+ * Options for a heterogeneous `createMany`, mirroring the inputs `DBModel._insert` has
+ * AFTER serialization: the serialized `records`, their paired `rawRecords`, the shared
+ * `sqlCastMap` / ON CONFLICT / RETURNING. The per-group `columns` are DERIVED here (not
+ * supplied) — this is the whole point of the grouping.
+ */
+export interface InsertManyBuildOptions {
+    tableName: string;
+    /** Serialized records (as `DBModel._insert` holds them after `serializeRecord`). */
+    records: Record<string, unknown>[];
+    /** Raw records before serialization, paired 1:1 with `records` (PG UNNEST path). */
+    rawRecords?: Record<string, unknown>[];
+    sqlCastMap?: Map<string, string>;
+    onConflict?: string[];
+    onConflictIgnore?: boolean;
+    onConflictUpdate?: 'all' | string[];
+    returning?: string;
+}
+/**
+ * Compile a (possibly heterogeneous) `createMany` into a COMPOSITION of `makeSQL`
+ * INSERT components — one per column-set group, exactly as `DBModel._insert`
+ * (`src/DBModel.ts:928-1020`) groups records and emits one `buildInsert` per group.
+ *
+ * A `createMany` whose rows carry DIFFERENT column subsets is not one INSERT: the
+ * production write path groups rows by their sorted-column-set pattern
+ * (`patternKey = recordColumns.sort().join(',')`) so each batch INSERT is homogeneous
+ * (no DEFAULT keyword), and emits ONE statement per group. In the `makeSQL` model that
+ * is precisely a composition of several INSERT components — no new vocabulary. This
+ * function reproduces that grouping byte-for-byte:
+ *
+ *  - column detection per row drops `undefined` and DEFAULT immediates, exactly as
+ *    `_insert:940-946 / 958-964`;
+ *  - columns are CANONICAL sorted (`recordColumns.sort()`), the pattern key is the
+ *    joined sorted columns, group order is first-seen insertion order (`Map`), and each
+ *    group carries its serialized + raw records paired — mirroring `_insert:955-975`;
+ *  - each group's SQL text comes from the SAME original `buildInsert` (`compileInsert`),
+ *    so every component is byte-identical to the statement `_insert` sends for that
+ *    group.
+ *
+ * The composition of the returned components (via `composeMakeSQL`) is the full
+ * multi-statement `createMany` the production path executes.
+ */
+export declare function compileInsertMany(dialect: Dialect, options: InsertManyBuildOptions): MakeSQL[];
+/**
+ * Compile batch UPDATE to a `makeSQL` bundle via the original `buildUpdateMany`: PG
+ * UNNEST (`SET c = v.c FROM UNNEST(?::t[],…) AS v(cols) WHERE t.k = v.k`), MySQL
+ * JOIN-VALUES (`JOIN (VALUES ROW(…)) AS v(…) ON … SET …`), SQLite CASE-WHEN
+ * (`SET c = CASE WHEN k = ? THEN ? … END … WHERE k IN (…)`), with SKIP-column handling
+ * (PG `CASE WHEN v._skip_c` / MySQL `IF(v._skip_c,…)` / SQLite `WHEN … THEN t.col`).
+ */
+export declare function compileUpdateMany(dialect: Dialect, options: UpdateManyBuildOptions): MakeSQL;
+/**
+ * Compile a single-row UPDATE to a `makeSQL` bundle, reproducing the original
+ * `DBModel._update` text byte-for-byte: `UPDATE <t> SET <c = ?[::cast] | token>, … WHERE
+ * <cond>[ RETURNING …]`. `serializedValues` is the already-serialized value map
+ * (DBToken values compile via their own `.compile`, matching the original), and
+ * `sqlCastMap` drives the per-column `?::sqlCast` on PG (skipping timestamp/date, as
+ * the original does). Throws `UPDATE requires conditions` when the WHERE is empty
+ * (v1 anchor: WHERE mandatory).
+ */
+export declare function compileUpdateSingle(opts: {
+    dialect: Dialect;
+    tableName: string;
+    serializedValues: Record<string, unknown>;
+    conditions: ConditionObject;
+    sqlCastMap?: Map<string, string>;
+    returning?: string;
+}): MakeSQL;
+/**
+ * Compile DELETE to a `makeSQL` bundle, reproducing the original `DBModel._delete`
+ * text: `DELETE FROM <t> WHERE <cond>[ RETURNING …]`. Throws `DELETE requires
+ * conditions` when the WHERE is empty (v1 anchor: WHERE mandatory — the .rs "delete
+ * everything" behavior is NOT reproduced).
+ */
+export declare function compileDelete(opts: {
+    dialect: Dialect;
+    tableName: string;
+    conditions: ConditionObject;
+    returning?: string;
+}): MakeSQL;
+/**
+ * Compile a `deleteMany` — delete the rows whose primary key is in a given SET of key values — as a
+ * COMPOSITION of `makeSQL` DELETE components (one per PK column-set group, mirroring the createMany
+ * grouping contract). A single-column PK reduces to ONE DELETE with the v1 IN-list condition
+ * (`{ pk: [values] }` → PG `= ANY` / MySQL·SQLite JSON-subquery via `conditionsFor`); a COMPOSITE PK
+ * groups the key-tuples by their present key set and emits ONE DELETE per group whose WHERE is the
+ * v1 conjunction of per-column IN-lists (each group homogeneous). Every group's WHERE text comes
+ * from the SAME original `DBConditions`/`conditionsFor` builder ({@link compileDelete}) — NEVER a
+ * hand-roll — so the deleteMany SQL is byte-identical to what the v1 condition path emits.
+ *
+ * The returned components compose (via the batch tx plan) into the full multi-statement `deleteMany`
+ * the production path would execute. An empty key set yields NO components (nothing to delete).
+ */
+export declare function compileDeleteMany(opts: {
+    dialect: Dialect;
+    tableName: string;
+    /** The PK column names (single or composite). */
+    keyColumns: string[];
+    /** The key-tuples to delete: each row maps every PK column → its value. */
+    keys: Record<string, unknown>[];
+    returning?: string;
+}): MakeSQL[];
+//# sourceMappingURL=compile-crud.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile-crud.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/compile-crud.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EACV,UAAU,EACV,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CASvD;AAMD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAGpF;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACvC,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,EAAE,CAwE9F;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAoB5F;AAMD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CA2BV;AAMD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,eAAe,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CASV;AAOD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,EAAE,CA8BZ"}

package/dist/scp/makesql/compile-crud.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — CRUD compile → `makeSQL` bundles, by driving the ORIGINAL
+ * dialect SQL builders (`postgresSqlBuilder` / `mysqlSqlBuilder` / `sqliteSqlBuilder`)
+ * and the original single-row UPDATE/DELETE text. The produced `{ sql, params }` is
+ * byte-identical to what the original library sends, for every dialect and every
+ * shape:
+ *
+ *   INSERT single (+per-col `?::sqlCast` on PG) & batch (PG UNNEST + type inference /
+ *   MySQL·SQLite multi-VALUES) + ON CONFLICT (DO NOTHING / DO UPDATE incl. `= 'all'`
+ *   → all columns) + RETURNING (bare / `t.col` alias / `table.col` / MySQL simulate);
+ *   UPDATE single (`SET c = ?::sqlCast`) & batch (PG UNNEST / MySQL JOIN-VALUES /
+ *   SQLite CASE-WHEN) + SKIP-column; DELETE; and the SELECT tail (LIMIT/OFFSET inline,
+ *   FOR UPDATE, GROUP BY/HAVING) via `buildSelectSQL`.
+ *
+ * These delegate to the SAME builders the runtime uses, so parity is by construction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builderFor = builderFor;
+exports.compileInsert = compileInsert;
+exports.compileInsertMany = compileInsertMany;
+exports.compileUpdateMany = compileUpdateMany;
+exports.compileUpdateSingle = compileUpdateSingle;
+exports.compileDelete = compileDelete;
+exports.compileDeleteMany = compileDeleteMany;
+const PostgresSqlBuilder_1 = require("../../drivers/PostgresSqlBuilder");
+const MysqlSqlBuilder_1 = require("../../drivers/MysqlSqlBuilder");
+const SqliteSqlBuilder_1 = require("../../drivers/SqliteSqlBuilder");
+const DBValues_1 = require("../../DBValues");
+const compile_1 = require("./compile");
+const json_array_1 = require("./json-array");
+const json_batch_1 = require("./json-batch");
+/** The original dialect builder for a dialect (the exact object the runtime uses). */
+function builderFor(dialect) {
+    switch (dialect) {
+        case 'postgres':
+            return PostgresSqlBuilder_1.postgresSqlBuilder;
+        case 'mysql':
+            return MysqlSqlBuilder_1.mysqlSqlBuilder;
+        case 'sqlite':
+            return SqliteSqlBuilder_1.sqliteSqlBuilder;
+    }
+}
+// ============================================================================
+// INSERT (single & batch) — driven by the original `buildInsert`.
+// ============================================================================
+/**
+ * Compile INSERT (single or batch) to a `makeSQL` bundle via the original
+ * `buildInsert`. Single-row on PG carries per-col `?::sqlCast`; batch on PG uses UNNEST
+ * with type inference; MySQL/SQLite use multi-VALUES. ON CONFLICT / RETURNING are the
+ * original's exact verbs. `onConflictUpdate: 'all'` expands to every column (the
+ * builder's fallback), so an empty DO-UPDATE never breaks.
+ */
+function compileInsert(dialect, options) {
+    const { sql, params } = builderFor(dialect).buildInsert(options);
+    return { sql, params };
+}
+/**
+ * Compile a (possibly heterogeneous) `createMany` into a COMPOSITION of `makeSQL`
+ * INSERT components — one per column-set group, exactly as `DBModel._insert`
+ * (`src/DBModel.ts:928-1020`) groups records and emits one `buildInsert` per group.
+ *
+ * A `createMany` whose rows carry DIFFERENT column subsets is not one INSERT: the
+ * production write path groups rows by their sorted-column-set pattern
+ * (`patternKey = recordColumns.sort().join(',')`) so each batch INSERT is homogeneous
+ * (no DEFAULT keyword), and emits ONE statement per group. In the `makeSQL` model that
+ * is precisely a composition of several INSERT components — no new vocabulary. This
+ * function reproduces that grouping byte-for-byte:
+ *
+ *  - column detection per row drops `undefined` and DEFAULT immediates, exactly as
+ *    `_insert:940-946 / 958-964`;
+ *  - columns are CANONICAL sorted (`recordColumns.sort()`), the pattern key is the
+ *    joined sorted columns, group order is first-seen insertion order (`Map`), and each
+ *    group carries its serialized + raw records paired — mirroring `_insert:955-975`;
+ *  - each group's SQL text comes from the SAME original `buildInsert` (`compileInsert`),
+ *    so every component is byte-identical to the statement `_insert` sends for that
+ *    group.
+ *
+ * The composition of the returned components (via `composeMakeSQL`) is the full
+ * multi-statement `createMany` the production path executes.
+ */
+function compileInsertMany(dialect, options) {
+    const { records, rawRecords, tableName, sqlCastMap, onConflict, onConflictIgnore, onConflictUpdate, returning } = options;
+    // Group records by their sorted-column-set pattern — mirrors DBModel._insert:928-975
+    // exactly (fast single-record path + multi-record Map grouping, same DEFAULT/undefined
+    // filtering, same canonical sort, same first-seen group order, same raw/serialized pair).
+    const grouped = new Map();
+    if (records.length === 1) {
+        const record = records[0];
+        const recordColumns = [];
+        for (const key of Object.keys(record)) {
+            const val = record[key];
+            if (val !== undefined && !(val instanceof DBValues_1.DBImmediateValue && val.value === 'DEFAULT')) {
+                recordColumns.push(key);
+            }
+        }
+        recordColumns.sort();
+        grouped.set('_', { columns: recordColumns, records: [record], rawRecords: [rawRecords ? rawRecords[0] : record] });
+    }
+    else {
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            const recordColumns = [];
+            for (const key of Object.keys(record)) {
+                const val = record[key];
+                if (val !== undefined && !(val instanceof DBValues_1.DBImmediateValue && val.value === 'DEFAULT')) {
+                    recordColumns.push(key);
+                }
+            }
+            recordColumns.sort();
+            const patternKey = recordColumns.join(',');
+            if (!grouped.has(patternKey)) {
+                grouped.set(patternKey, { columns: recordColumns, records: [], rawRecords: [] });
+            }
+            const group = grouped.get(patternKey);
+            group.records.push(record);
+            group.rawRecords.push(rawRecords ? rawRecords[i] : record);
+        }
+    }
+    // One makeSQL INSERT component per group.
+    //
+    //  - PostgreSQL: UNCHANGED — the original `buildInsert` (UNNEST batch, byte-identical).
+    //  - MySQL/SQLite: the single-JSON-param form (JSON_TABLE / json_each), UNLESS the
+    //    group carries a DBToken value (e.g. `NOW()`) which can't be JSON-encoded — then it
+    //    falls back to the original `buildInsert` multi-VALUES for that group (correctness).
+    const components = [];
+    for (const { columns, records: groupRecords, rawRecords: groupRawRecords } of grouped.values()) {
+        if (dialect !== 'postgres' && !(0, json_batch_1.rowsHaveDbToken)(groupRecords, columns)) {
+            const jsonOpts = { tableName, columns, records: groupRecords, onConflict, onConflictIgnore, onConflictUpdate, returning };
+            components.push(dialect === 'mysql' ? (0, json_batch_1.mysqlInsertJson)(jsonOpts) : (0, json_batch_1.sqliteInsertJson)(jsonOpts));
+            continue;
+        }
+        components.push(compileInsert(dialect, {
+            tableName,
+            columns,
+            records: groupRecords,
+            rawRecords: groupRawRecords,
+            sqlCastMap,
+            onConflict,
+            onConflictIgnore,
+            onConflictUpdate,
+            returning,
+        }));
+    }
+    return components;
+}
+// ============================================================================
+// UPDATE batch — driven by the original `buildUpdateMany`.
+// ============================================================================
+/**
+ * Compile batch UPDATE to a `makeSQL` bundle via the original `buildUpdateMany`: PG
+ * UNNEST (`SET c = v.c FROM UNNEST(?::t[],…) AS v(cols) WHERE t.k = v.k`), MySQL
+ * JOIN-VALUES (`JOIN (VALUES ROW(…)) AS v(…) ON … SET …`), SQLite CASE-WHEN
+ * (`SET c = CASE WHEN k = ? THEN ? … END … WHERE k IN (…)`), with SKIP-column handling
+ * (PG `CASE WHEN v._skip_c` / MySQL `IF(v._skip_c,…)` / SQLite `WHEN … THEN t.col`).
+ */
+function compileUpdateMany(dialect, options) {
+    // PostgreSQL: UNCHANGED (UNNEST). MySQL/SQLite: single-JSON-param form (JSON_TABLE
+    // join / CASE-over-json_each) with SKIP preserved — unless a DBToken value is present
+    // (can't be JSON-encoded), in which case fall back to the original builder.
+    if (dialect !== 'postgres') {
+        const allCols = [...options.keyColumns, ...options.updateColumns];
+        if (!(0, json_batch_1.rowsHaveDbToken)(options.records, allCols)) {
+            const jsonOpts = {
+                tableName: options.tableName,
+                keyColumns: options.keyColumns,
+                updateColumns: options.updateColumns,
+                records: options.records,
+                skipMap: options.skipMap,
+                returning: options.returning,
+            };
+            return dialect === 'mysql' ? (0, json_batch_1.mysqlUpdateManyJson)(jsonOpts) : (0, json_batch_1.sqliteUpdateManyJson)(jsonOpts);
+        }
+    }
+    const { sql, params } = builderFor(dialect).buildUpdateMany(options);
+    return { sql, params };
+}
+// ============================================================================
+// UPDATE single — reproduces the ORIGINAL `_update` SET-clause + WHERE text exactly.
+// ============================================================================
+/**
+ * Compile a single-row UPDATE to a `makeSQL` bundle, reproducing the original
+ * `DBModel._update` text byte-for-byte: `UPDATE <t> SET <c = ?[::cast] | token>, … WHERE
+ * <cond>[ RETURNING …]`. `serializedValues` is the already-serialized value map
+ * (DBToken values compile via their own `.compile`, matching the original), and
+ * `sqlCastMap` drives the per-column `?::sqlCast` on PG (skipping timestamp/date, as
+ * the original does). Throws `UPDATE requires conditions` when the WHERE is empty
+ * (v1 anchor: WHERE mandatory).
+ */
+function compileUpdateSingle(opts) {
+    const params = [];
+    const formatter = opts.dialect === 'postgres' ? (0, compile_1.formatterFor)(opts.dialect) : undefined;
+    const sqlCastMap = opts.sqlCastMap ?? new Map();
+    const setClauses = [];
+    for (const [col, val] of Object.entries(opts.serializedValues)) {
+        if (val instanceof DBValues_1.DBToken) {
+            setClauses.push(`${col} = ${val.compile(params, undefined, formatter)}`);
+        }
+        else {
+            params.push(val);
+            const sqlCast = sqlCastMap.get(col);
+            if (sqlCast && formatter && sqlCast !== 'timestamp' && sqlCast !== 'date') {
+                setClauses.push(`${col} = ${formatter('?', sqlCast)}`);
+            }
+            else {
+                setClauses.push(`${col} = ?`);
+            }
+        }
+    }
+    const whereClause = (0, json_array_1.conditionsFor)(opts.conditions, opts.dialect).compile(params, formatter);
+    if (!whereClause)
+        throw new Error('UPDATE requires conditions');
+    let sql = `UPDATE ${opts.tableName} SET ${setClauses.join(', ')} WHERE ${whereClause}`;
+    if (opts.returning)
+        sql += ` RETURNING ${opts.returning}`;
+    return { sql, params };
+}
+// ============================================================================
+// DELETE single — reproduces the ORIGINAL `_delete` text exactly.
+// ============================================================================
+/**
+ * Compile DELETE to a `makeSQL` bundle, reproducing the original `DBModel._delete`
+ * text: `DELETE FROM <t> WHERE <cond>[ RETURNING …]`. Throws `DELETE requires
+ * conditions` when the WHERE is empty (v1 anchor: WHERE mandatory — the .rs "delete
+ * everything" behavior is NOT reproduced).
+ */
+function compileDelete(opts) {
+    const params = [];
+    const formatter = opts.dialect === 'postgres' ? (0, compile_1.formatterFor)(opts.dialect) : undefined;
+    const whereClause = (0, json_array_1.conditionsFor)(opts.conditions, opts.dialect).compile(params, formatter);
+    if (!whereClause)
+        throw new Error('DELETE requires conditions');
+    let sql = `DELETE FROM ${opts.tableName} WHERE ${whereClause}`;
+    if (opts.returning)
+        sql += ` RETURNING ${opts.returning}`;
+    return { sql, params };
+}
+// ============================================================================
+// DELETE batch (deleteMany) — a single DELETE keyed by a PK-set IN-list, driven
+// by the ORIGINAL v1 condition builder (compileDelete → DBConditions/conditionsFor).
+// ============================================================================
+/**
+ * Compile a `deleteMany` — delete the rows whose primary key is in a given SET of key values — as a
+ * COMPOSITION of `makeSQL` DELETE components (one per PK column-set group, mirroring the createMany
+ * grouping contract). A single-column PK reduces to ONE DELETE with the v1 IN-list condition
+ * (`{ pk: [values] }` → PG `= ANY` / MySQL·SQLite JSON-subquery via `conditionsFor`); a COMPOSITE PK
+ * groups the key-tuples by their present key set and emits ONE DELETE per group whose WHERE is the
+ * v1 conjunction of per-column IN-lists (each group homogeneous). Every group's WHERE text comes
+ * from the SAME original `DBConditions`/`conditionsFor` builder ({@link compileDelete}) — NEVER a
+ * hand-roll — so the deleteMany SQL is byte-identical to what the v1 condition path emits.
+ *
+ * The returned components compose (via the batch tx plan) into the full multi-statement `deleteMany`
+ * the production path would execute. An empty key set yields NO components (nothing to delete).
+ */
+function compileDeleteMany(opts) {
+    const { dialect, tableName, keyColumns, keys, returning } = opts;
+    if (keyColumns.length === 0)
+        throw new Error('compileDeleteMany: keyColumns must be non-empty');
+    if (keys.length === 0)
+        return [];
+    if (keyColumns.length === 1) {
+        // Single PK → ONE DELETE with a v1 IN-list condition (`{ pk: [values] }`).
+        const col = keyColumns[0];
+        const values = keys.map((k) => k[col]);
+        const conditions = { [col]: values };
+        return [compileDelete({ dialect, tableName, conditions, returning })];
+    }
+    // Composite PK → group key-tuples by their present-column set (mirrors createMany grouping), one
+    // DELETE per group whose WHERE is the v1 conjunction of per-column IN-lists (each group homogeneous).
+    const grouped = new Map();
+    for (const key of keys) {
+        const present = keyColumns.filter((c) => key[c] !== undefined).sort();
+        const patternKey = present.join(',');
+        if (!grouped.has(patternKey))
+            grouped.set(patternKey, []);
+        grouped.get(patternKey).push(key);
+    }
+    const components = [];
+    for (const group of grouped.values()) {
+        const present = keyColumns.filter((c) => group[0][c] !== undefined);
+        const conditions = {};
+        for (const c of present)
+            conditions[c] = group.map((k) => k[c]);
+        components.push(compileDelete({ dialect, tableName, conditions, returning }));
+    }
+    return components;
+}
+//# sourceMappingURL=compile-crud.js.map

package/dist/scp/makesql/compile-crud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-crud.js","sourceRoot":"","sources":["../../../src/scp/makesql/compile-crud.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AAyBH,gCASC;AAaD,sCAGC;AA6CD,8CAwEC;AAaD,8CAoBC;AAeD,kDAkCC;AAYD,sCAcC;AAoBD,8CAsCC;AA3UD,yEAAsE;AACtE,mEAAgE;AAChE,qEAAkE;AAOlE,6CAAkF;AAElF,uCAAyC;AACzC,6CAA6C;AAC7C,6CAMsB;AAGtB,sFAAsF;AACtF,SAAgB,UAAU,CAAC,OAAgB;IACzC,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,UAAU;YACb,OAAO,uCAAkB,CAAC;QAC5B,KAAK,OAAO;YACV,OAAO,iCAAe,CAAC;QACzB,KAAK,QAAQ;YACX,OAAO,mCAAgB,CAAC;IAC5B,CAAC;AACH,CAAC;AAED,+EAA+E;AAC/E,kEAAkE;AAClE,+EAA+E;AAE/E;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,OAAgB,EAAE,OAA2B;IACzE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACjE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;AACzB,CAAC;AAqBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,iBAAiB,CAAC,OAAgB,EAAE,OAA+B;IACjF,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAE1H,qFAAqF;IACrF,uFAAuF;IACvF,0FAA0F;IAC1F,MAAM,OAAO,GAAG,IAAI,GAAG,EAInB,CAAC;IAEL,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,aAAa,GAAa,EAAE,CAAC;QACnC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACtC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACxB,IAAI,GAAG,KAAK,SAAS,IAAI,CAAC,CAAC,GAAG,YAAY,2BAAgB,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,EAAE,CAAC;gBACvF,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;QACD,aAAa,CAAC,IAAI,EAAE,CAAC;QACrB,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACrH,CAAC;SAAM,CAAC;QACN,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC1B,MAAM,aAAa,GAAa,EAAE,CAAC;YACnC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBACxB,IAAI,GAAG,KAAK,SAAS,IAAI,CAAC,CAAC,GAAG,YAAY,2BAAgB,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,EAAE,CAAC;oBACvF,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC1B,CAAC;YACH,CAAC;YACD,aAAa,CAAC,IAAI,EAAE,CAAC;YACrB,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC7B,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;YACnF,CAAC;YACD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC;YACvC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC3B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAED,0CAA0C;IAC1C,EAAE;IACF,wFAAwF;IACxF,mFAAmF;IACnF,wFAAwF;IACxF,yFAAyF;IACzF,MAAM,UAAU,GAAc,EAAE,CAAC;IACjC,KAAK,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QAC/F,IAAI,OAAO,KAAK,UAAU,IAAI,CAAC,IAAA,4BAAe,EAAC,YAAY,EAAE,OAAO,CAAC,EAAE,CAAC;YACtE,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,SAAS,EAAE,CAAC;YAC1H,UAAU,CAAC,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,IAAA,4BAAe,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAA,6BAAgB,EAAC,QAAQ,CAAC,CAAC,CAAC;YAC9F,SAAS;QACX,CAAC;QACD,UAAU,CAAC,IAAI,CACb,aAAa,CAAC,OAAO,EAAE;YACrB,SAAS;YACT,OAAO;YACP,OAAO,EAAE,YAAY;YACrB,UAAU,EAAE,eAAe;YAC3B,UAAU;YACV,UAAU;YACV,gBAAgB;YAChB,gBAAgB;YAChB,SAAS;SACV,CAAC,CACH,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,+EAA+E;AAC/E,2DAA2D;AAC3D,+EAA+E;AAE/E;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,OAAgB,EAAE,OAA+B;IACjF,mFAAmF;IACnF,sFAAsF;IACtF,4EAA4E;IAC5E,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;QAC3B,MAAM,OAAO,GAAG,CAAC,GAAG,OAAO,CAAC,UAAU,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QAClE,IAAI,CAAC,IAAA,4BAAe,EAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;YAC/C,MAAM,QAAQ,GAAG;gBACf,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,SAAS,EAAE,OAAO,CAAC,SAAS;aAC7B,CAAC;YACF,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,IAAA,gCAAmB,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAA,iCAAoB,EAAC,QAAQ,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;IACD,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACrE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;AACzB,CAAC;AAED,+EAA+E;AAC/E,qFAAqF;AACrF,+EAA+E;AAE/E;;;;;;;;GAQG;AACH,SAAgB,mBAAmB,CAAC,IAOnC;IACC,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,MAAM,SAAS,GACb,IAAI,CAAC,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,IAAA,sBAAY,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,GAAG,EAAkB,CAAC;IAEhE,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC/D,IAAI,GAAG,YAAY,kBAAO,EAAE,CAAC;YAC3B,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;QAC3E,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACjB,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,IAAI,OAAO,IAAI,SAAS,IAAI,OAAO,KAAK,WAAW,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;gBAC1E,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,MAAM,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;YACzD,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,WAAW,GAAG,IAAA,0BAAa,EAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC5F,IAAI,CAAC,WAAW;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAEhE,IAAI,GAAG,GAAG,UAAU,IAAI,CAAC,SAAS,QAAQ,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,WAAW,EAAE,CAAC;IACvF,IAAI,IAAI,CAAC,SAAS;QAAE,GAAG,IAAI,cAAc,IAAI,CAAC,SAAS,EAAE,CAAC;IAC1D,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;AACzB,CAAC;AAED,+EAA+E;AAC/E,kEAAkE;AAClE,+EAA+E;AAE/E;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,IAK7B;IACC,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,IAAA,sBAAY,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACvF,MAAM,WAAW,GAAG,IAAA,0BAAa,EAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC5F,IAAI,CAAC,WAAW;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAEhE,IAAI,GAAG,GAAG,eAAe,IAAI,CAAC,SAAS,UAAU,WAAW,EAAE,CAAC;IAC/D,IAAI,IAAI,CAAC,SAAS;QAAE,GAAG,IAAI,cAAc,IAAI,CAAC,SAAS,EAAE,CAAC;IAC1D,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;AACzB,CAAC;AAED,+EAA+E;AAC/E,gFAAgF;AAChF,qFAAqF;AACrF,+EAA+E;AAE/E;;;;;;;;;;;;GAYG;AACH,SAAgB,iBAAiB,CAAC,IAQjC;IACC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IACjE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IAChG,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEjC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,2EAA2E;QAC3E,MAAM,GAAG,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACvC,MAAM,UAAU,GAAoB,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;QACtD,OAAO,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IACxE,CAAC;IAED,iGAAiG;IACjG,sGAAsG;IACtG,MAAM,OAAO,GAAG,IAAI,GAAG,EAAqC,CAAC;IAC7D,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC;QACtE,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAC1D,OAAO,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IACD,MAAM,UAAU,GAAc,EAAE,CAAC;IACjC,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QACrC,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;QACpE,MAAM,UAAU,GAAoB,EAAE,CAAC;QACvC,KAAK,MAAM,CAAC,IAAI,OAAO;YAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}

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

@@ -0,0 +1,157 @@
+/**
+ * litedbmodel v2 SCP — RELATION batch-load compile → `makeSQL`, reproducing the
+ * ORIGINAL `LazyRelation` SQL text byte-for-byte across all shapes and dialects:
+ *
+ *   single-key, unlimited:
+ *     PG           `SELECT … FROM t WHERE t.key = ANY(?::type[])[ AND <filters>][ ORDER BY …]`
+ *     MySQL/SQLite `SELECT … FROM t WHERE t.key IN (?, …)[ AND <filters>][ ORDER BY …]`
+ *   single-key, per-parent limit:
+ *     PG           `SELECT t.* FROM unnest(?::type[]) AS _keys(key) CROSS JOIN LATERAL
+ *                    (SELECT * FROM t WHERE t.key = _keys.key[ AND <filters>] ORDER BY … LIMIT n) t`
+ *     MySQL/SQLite `WITH ranked AS (SELECT *, ROW_NUMBER() OVER (PARTITION BY key ORDER BY …) AS _rn
+ *                    FROM t WHERE key IN (?, …)[ AND <filters>]) SELECT * FROM ranked WHERE _rn <= n`
+ *   composite-key, unlimited:
+ *     PG           `SELECT … FROM t JOIN unnest(?::t1[], ?::t2[]) AS _u(a1, a2) ON t.k1=_u.a1 AND …`
+ *     MySQL/SQLite `SELECT … FROM t WHERE (k1, k2) IN ((?, ?), …)`
+ *   composite-key, per-parent limit: PG LATERAL composite / others ROW_NUMBER composite.
+ *
+ * The PG type text (`?::type[]`) comes from the ORIGINAL `inferPgArrayType` (sqlCast
+ * wins, else element-type inference). The .rs regressions are NOT reproduced: PG
+ * per-parent-limit is LATERAL (not ROW_NUMBER), and PG types are sqlCast-driven (not
+ * text-folded).
+ *
+ * Inner SELECTs reuse {@link compileSelect} — the same text `buildSelectSQL` yields —
+ * so the whole shape is byte-faithful to the original relation builder.
+ */
+import { type ConditionObject } from '../../DBConditions';
+import type { MakeSQL } from './makesql';
+import type { Dialect } from './handler';
+/**
+ * Reproduce the ORIGINAL `LazyRelation.inferPgArrayType`: sqlCast wins (`<cast>[]`);
+ * otherwise infer the element type from the sample values. Byte-identical to the
+ * original (which is the PG anchor — NOT the .rs coarse text-folding).
+ */
+export declare function inferPgArrayType(values: unknown[], sqlCast?: string): string;
+/**
+ * The DEFERRED PG array-cast token (#46): a placeholder emitted in the STATIC SQL text where
+ * the `= ANY(?::<T>[])` / `UNNEST(?::<T>[])` element type `<T>` cannot be known at symbolic
+ * compile time (a schema-less `whereIn`, or a relation batch compiled without concrete keys).
+ * The render/handler layer resolves it from the BOUND values via {@link inferPgArrayType} — a
+ * mechanical dialect-render step, the same category as the `?`→`$N` placeholder render. This
+ * reproduces v1's live-PG-correct cast (`::int[]` for int keys, etc.), which v1 got because
+ * `inferPgArrayType` saw the real values at runtime.
+ *
+ * A byte sequence no legitimate SQL identifier/type text contains, so the resolve is a safe
+ * literal substring replace (never a regex over user text).
+ */
+export declare const PG_ARRAY_CAST_TOKEN = "@@PG_ARRAY_CAST@@";
+/**
+ * Resolve the FIRST unresolved {@link PG_ARRAY_CAST_TOKEN} in a PG SQL fragment to the element
+ * type inferred from the bound `values` (v1 `inferPgArrayType`). Called at render time, once per
+ * array param, left-to-right — so each deferred array cast binds the type of its own value set.
+ * SQL with no token is returned unchanged (every non-deferred cast is already concrete).
+ */
+export declare function resolvePgArrayCast(sql: string, values: unknown[]): string;
+export interface RelationCompileBase {
+    dialect: Dialect;
+    tableName: string;
+    /** SELECT column list (default `*`). */
+    select?: string;
+    /** Optional relation `where`-filter conditions (`config.conditions`), merged in. */
+    conditions?: ConditionObject;
+    /** ORDER BY clause (raw text), or undefined. */
+    order?: string;
+    /** Per-column sqlCast map (drives PG `?::type[]`). */
+    sqlCastMap?: Map<string, string>;
+    /**
+     * Emit the {@link PG_ARRAY_CAST_TOKEN} for the PG `?::<T>[]` element type instead of inferring
+     * it from `values` NOW (#46). Set when the SQL text is compiled SYMBOLICALLY (placeholder keys),
+     * so the element type is resolved at render from the REAL bound keys — never baked to `text[]`.
+     * A `sqlCast` (concrete column type) still wins over the token.
+     */
+    deferPgArrayCast?: boolean;
+}
+/**
+ * The STATIC composite-key batch forms (#47 item 1) — length-INDEPENDENT so the compiled `op.sql`
+ * is fixed (one param per column on PG; ONE JSON param on MySQL/SQLite), the SAME static-op
+ * property the single-key relation forms have. PG stays byte-identical to v1's `unnest`-JOIN
+ * (`batchLoadWithUnnestJoin`), with the element-type cast DEFERRED (#46) to render from the real
+ * keys. MySQL/SQLite use the single-JSON tuple form (the owner-approved deviation the single-key
+ * IN-list and the batch UPDATE composite already use — RESULT parity, NOT byte-identity): a
+ * `JSON_TABLE`/`json_each` subquery over one JSON array-of-tuples param. The v1 literal
+ * `(k1,k2) IN ((?,?),…)` byte-form stays proven by the golden `compileCompositeKeyUnlimited`.
+ *
+ * The JSON tuple param is `[[k1a,k2a],[k1b,k2b],…]` (positional element arrays), read back by
+ * ordinal path (`$[0]`, `$[1]`, …) so no per-column JSON key names are needed.
+ */
+export declare function compileCompositeKeyStaticUnlimited(opts: RelationCompileBase & {
+    targetKeys: string[];
+}): MakeSQL;
+/**
+ * `= ANY(?::type[])` (PG) / `IN (?, …)` (MySQL/SQLite) single-key unlimited batch load.
+ * Reproduces `batchLoadWithAnyArray` (PG) and `batchLoadWithIn` (others).
+ *
+ * The key array binds as ONE param on PG (`values` is a single array param); on
+ * MySQL/SQLite the original passes the array to `DBConditions` which expands it to
+ * `IN (?, ?, …)` with one param per element — reproduced here verbatim.
+ */
+export declare function compileSingleKeyUnlimited(opts: RelationCompileBase & {
+    targetKey: string;
+    values: unknown[];
+}): MakeSQL;
+/**
+ * Per-parent-limit single-key batch load: PG `CROSS JOIN LATERAL` (the v1 anchor —
+ * NOT the .rs ROW_NUMBER regression); MySQL/SQLite `ROW_NUMBER() OVER (PARTITION BY …)`.
+ * Reproduces `batchLoadWithLateral` / `batchLoadWithRowNumber`.
+ */
+export declare function compileSingleKeyLimited(opts: RelationCompileBase & {
+    targetKey: string;
+    values: unknown[];
+    limit: number;
+}): MakeSQL;
+/**
+ * Composite-key unlimited batch load: PG `JOIN unnest(?::t1[], ?::t2[]) AS _u(a,b) ON …`
+ * (reproduces `batchLoadWithUnnestJoin`); MySQL/SQLite `(k1, k2) IN ((?, ?), …)`
+ * (reproduces `batchLoadWithCompositeIn` via `DBTupleIn`).
+ */
+export declare function compileCompositeKeyUnlimited(opts: RelationCompileBase & {
+    targetKeys: string[];
+    tuples: unknown[][];
+}): MakeSQL;
+/**
+ * Composite-key per-parent-limit: PG LATERAL composite (reproduces
+ * `batchLoadWithLateralComposite`); MySQL/SQLite ROW_NUMBER composite (reproduces
+ * `batchLoadWithRowNumberComposite`).
+ */
+export declare function compileCompositeKeyLimited(opts: RelationCompileBase & {
+    targetKeys: string[];
+    tuples: unknown[][];
+    limit: number;
+}): MakeSQL;
+/**
+ * The STATIC composite-key per-parent-LIMIT batch form (#47 last completeness gap) — the
+ * length-INDEPENDENT sibling of {@link compileCompositeKeyLimited}, so the compiled `op.sql` is
+ * FIXED (one array param per key column on PG; ONE JSON array-of-tuples param on MySQL/SQLite) and
+ * can be a STATIC bundle op — exactly the property {@link compileSingleKeyLimited} and
+ * {@link compileCompositeKeyStaticUnlimited} already have.
+ *
+ * The per-parent window is IDENTICAL to the single-key-limited path:
+ *   - **PG**: `CROSS JOIN LATERAL` over `unnest(?::t1[], ?::t2[])` — BYTE-identical to v1's
+ *     `batchLoadWithLateralComposite` (the composite LATERAL is already structurally
+ *     length-independent; only the element-type cast was value-derived, and that is DEFERRED (#46)
+ *     to render from the real keys via {@link PG_ARRAY_CAST_TOKEN}). No deviation on PG.
+ *   - **MySQL/SQLite**: the SAME `ROW_NUMBER() OVER (PARTITION BY <keys> ORDER BY <order>)` CTE +
+ *     `_rn <= limit` filter v1's `batchLoadWithRowNumberComposite` emits — but the CTE membership
+ *     WHERE is the STATIC JSON-tuple predicate ({@link compositeJsonMembership}) instead of v1's
+ *     value-dependent `(k1,k2) IN ((?,?),…)`. This is the owner-sanctioned static deviation the
+ *     composite UNLIMITED form ({@link compileCompositeKeyStaticUnlimited}) and the single-key
+ *     IN-list already use: the JSON subquery selects the SAME child rows the tuple-IN would, the
+ *     window partitions/orders identically, so it is RESULT-parity to v1 (proven live). The v1
+ *     literal `(k1,k2) IN ((?,?),…)` byte-form stays proven by the golden
+ *     {@link compileCompositeKeyLimited}.
+ */
+export declare function compileCompositeKeyStaticLimited(opts: RelationCompileBase & {
+    targetKeys: string[];
+    limit: number;
+}): MakeSQL;
+//# sourceMappingURL=compile-relation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile-relation.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/compile-relation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAY5E;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAIzE;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GACnD,OAAO,CAmCT;AA4BD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,GACnE,OAAO,CAyBT;AAMD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,mBAAmB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClF,OAAO,CAoCT;AAWD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAA;CAAE,GACxE,OAAO,CAuCT;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACvF,OAAO,CA+CT;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClE,OAAO,CA6CT"}