velocious 1.0.481 → 1.0.483

package/build/src/database/tenants/data-copier.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Copies a single tenant's rows from a source database into a target database, following a
+ * table plan that partitions each table either by a direct tenant key column or by
+ * parent-id traversal. This is the row-level counterpart to schema cloning: multi-tenant
+ * apps that keep each tenant's data in its own database use it to (re)materialise the
+ * tenant's rows from a global/template database.
+ *
+ * The copy is delete-then-reinsert and therefore idempotent, and it mirrors the source
+ * snapshot: the rows to delete are the tenant's *current* rows in the target (selected with
+ * the same plan traversal run against the target), so a row that was removed from the source
+ * since the last copy is dropped from the target too rather than lingering. The deletes run
+ * children first and the source inserts parents first, all inside one target transaction with
+ * foreign-key enforcement disabled so the ordering never trips a constraint. Reads, deletes
+ * and inserts are chunked to bound statement size.
+ *
+ * The copier is policy-free: the caller supplies the plan, the source/target databases and
+ * the tenant key, and {@link DataCopier#copy} returns the loaded rows keyed by table name so
+ * the caller can perform any app-specific post-copy work (for example registering record
+ * locations) without that policy leaking into the framework.
+ */
+export default class DataCopier {
+    /**
+     * Creates a copier that moves tenant-owned rows from `sourceDb` into `targetDb`.
+     * @param {{
+     *   sourceDb: import("../drivers/base.js").default,
+     *   targetDb: import("../drivers/base.js").default,
+     *   tablePlan: import("./tenant-table-plan.js").TenantTablePlanEntry[],
+     *   idColumn?: string,
+     *   insertChunkSize?: number,
+     *   queryChunkSize?: number,
+     *   onProgress?: (message: string) => void
+     * }} args
+     */
+    constructor({ sourceDb, targetDb, tablePlan, idColumn, insertChunkSize, queryChunkSize, onProgress }: {
+        sourceDb: import("../drivers/base.js").default;
+        targetDb: import("../drivers/base.js").default;
+        tablePlan: import("./tenant-table-plan.js").TenantTablePlanEntry[];
+        idColumn?: string;
+        insertChunkSize?: number;
+        queryChunkSize?: number;
+        onProgress?: (message: string) => void;
+    });
+    sourceDb: import("../drivers/base.js").default;
+    targetDb: import("../drivers/base.js").default;
+    tablePlan: import("./tenant-table-plan.js").TenantTablePlanEntry[];
+    idColumn: string;
+    insertChunkSize: number;
+    queryChunkSize: number;
+    onProgress: ((message: string) => void) | undefined;
+    /**
+     * Copies every plan table's rows for `keyValue` from the source into the target and
+     * returns the copied source rows keyed by table name. The target's current tenant rows
+     * are deleted (children first) and the source rows inserted (parents first) in a single
+     * target transaction with foreign keys disabled.
+     * @param {string} keyValue
+     * @returns {Promise<Map<string, Record<string, unknown>[]>>}
+     */
+    copy(keyValue: string): Promise<Map<string, Record<string, unknown>[]>>;
+    /**
+     * Loads the rows for `keyValue` for every table in the plan from `db`, resolving
+     * parent-scoped tables from the ids already selected for their parent table. Used for
+     * both the source rows to copy and the target's current tenant rows to delete.
+     * @param {import("../drivers/base.js").default} db
+     * @param {string} keyValue
+     * @returns {Promise<Map<string, Record<string, unknown>[]>>}
+     */
+    loadRows(db: import("../drivers/base.js").default, keyValue: string): Promise<Map<string, Record<string, unknown>[]>>;
+    /**
+     * Selects all rows of `tableName` in `db` whose `columnName` is in `values`, chunked.
+     * @param {{columnName: string, db: import("../drivers/base.js").default, tableName: string, values: string[]}} args
+     * @returns {Promise<Record<string, unknown>[]>}
+     */
+    queryRowsByColumn({ columnName, db, tableName, values }: {
+        columnName: string;
+        db: import("../drivers/base.js").default;
+        tableName: string;
+        values: string[];
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Deletes the matching target rows for every plan table, children before parents, so the
+     * reinsert that follows starts from a clean slate without violating foreign keys.
+     * @param {Map<string, Record<string, unknown>[]>} rowsByTableName
+     * @returns {Promise<void>}
+     */
+    deleteTargetRows(rowsByTableName: Map<string, Record<string, unknown>[]>): Promise<void>;
+    /**
+     * Inserts the loaded source rows into the target for every plan table, parents before
+     * children, chunked to bound statement size.
+     * @param {Map<string, Record<string, unknown>[]>} rowsByTableName
+     * @returns {Promise<void>}
+     */
+    insertTargetRows(rowsByTableName: Map<string, Record<string, unknown>[]>): Promise<void>;
+    /**
+     * Quotes and comma-joins values for an SQL `IN (...)` list against the given database.
+     * @param {import("../drivers/base.js").default} db
+     * @param {string[]} values
+     * @returns {string}
+     */
+    quotedValuesSql(db: import("../drivers/base.js").default, values: string[]): string;
+    /**
+     * Runs a query without per-query logging, used for the high-volume copy statements.
+     * @param {import("../drivers/base.js").default} db
+     * @param {string} sql
+     * @returns {Promise<Record<string, unknown>[]>}
+     */
+    executeQuietQuery(db: import("../drivers/base.js").default, sql: string): Promise<Record<string, unknown>[]>;
+    /**
+     * Inserts column-aligned row tuples into a table without per-query logging.
+     * @param {{columns: string[], db: import("../drivers/base.js").default, rows: Array<Array<unknown>>, tableName: string}} args
+     * @returns {Promise<void>}
+     */
+    insertRowsQuietly({ columns, db, rows, tableName }: {
+        columns: string[];
+        db: import("../drivers/base.js").default;
+        rows: Array<Array<unknown>>;
+        tableName: string;
+    }): Promise<void>;
+    /**
+     * Forwards a progress message to the optional `onProgress` callback when one was given.
+     * @param {string} message
+     * @returns {void}
+     */
+    reportProgress(message: string): void;
+}
+//# sourceMappingURL=data-copier.d.ts.map

package/build/src/database/tenants/data-copier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-copier.d.ts","sourceRoot":"","sources":["../../../../src/database/tenants/data-copier.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACE;;;;;;;;;;;OAWG;IACH,sGAVW;QACN,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAC/C,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAC/C,SAAS,EAAE,OAAO,wBAAwB,EAAE,oBAAoB,EAAE,CAAC;QACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;KACvC,EAUH;IAPC,+CAAwB;IACxB,+CAAwB;IACxB,mEAA0B;IAC1B,iBAAwB;IACxB,wBAAsC;IACtC,uBAAoC;IACpC,uBAV0B,MAAM,KAAK,IAAI,cAUb;IAG9B;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAc3D;IAED;;;;;;;OAOG;IACH,aAJW,OAAO,oBAAoB,EAAE,OAAO,YACpC,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CA4C3D;IAED;;;;OAIG;IACH,yDAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAC,GACjG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAoB9C;IAED;;;;;OAKG;IACH,kCAHW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;OAKG;IACH,kCAHW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;OAKG;IACH,oBAJW,OAAO,oBAAoB,EAAE,OAAO,UACpC,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,OAAO,oBAAoB,EAAE,OAAO,OACpC,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAI9C;IAED;;;;OAIG;IACH,oDAHW;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,EAAE,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAC3G,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,IAAI,CAMhB;CACF"}

package/build/src/database/tenants/data-copier.js

@@ -0,0 +1,232 @@
+// @ts-check
+const DEFAULT_INSERT_CHUNK_SIZE = 100;
+const DEFAULT_QUERY_CHUNK_SIZE = 500;
+/**
+ * Splits an array into chunks of at most `chunkSize` items.
+ * @template T
+ * @param {T[]} values
+ * @param {number} chunkSize
+ * @returns {T[][]}
+ */
+function chunks(values, chunkSize) {
+    const chunkedValues = [];
+    for (let index = 0; index < values.length; index += chunkSize) {
+        chunkedValues.push(values.slice(index, index + chunkSize));
+    }
+    return chunkedValues;
+}
+/**
+ * Stringifies values and returns the distinct, non-blank ones, preserving first-seen order.
+ * @param {unknown[]} values
+ * @returns {string[]}
+ */
+function uniqueStrings(values) {
+    return Array.from(new Set(values.map((value) => String(value)).filter((value) => value.trim())));
+}
+/**
+ * Copies a single tenant's rows from a source database into a target database, following a
+ * table plan that partitions each table either by a direct tenant key column or by
+ * parent-id traversal. This is the row-level counterpart to schema cloning: multi-tenant
+ * apps that keep each tenant's data in its own database use it to (re)materialise the
+ * tenant's rows from a global/template database.
+ *
+ * The copy is delete-then-reinsert and therefore idempotent, and it mirrors the source
+ * snapshot: the rows to delete are the tenant's *current* rows in the target (selected with
+ * the same plan traversal run against the target), so a row that was removed from the source
+ * since the last copy is dropped from the target too rather than lingering. The deletes run
+ * children first and the source inserts parents first, all inside one target transaction with
+ * foreign-key enforcement disabled so the ordering never trips a constraint. Reads, deletes
+ * and inserts are chunked to bound statement size.
+ *
+ * The copier is policy-free: the caller supplies the plan, the source/target databases and
+ * the tenant key, and {@link DataCopier#copy} returns the loaded rows keyed by table name so
+ * the caller can perform any app-specific post-copy work (for example registering record
+ * locations) without that policy leaking into the framework.
+ */
+export default class DataCopier {
+    /**
+     * Creates a copier that moves tenant-owned rows from `sourceDb` into `targetDb`.
+     * @param {{
+     *   sourceDb: import("../drivers/base.js").default,
+     *   targetDb: import("../drivers/base.js").default,
+     *   tablePlan: import("./tenant-table-plan.js").TenantTablePlanEntry[],
+     *   idColumn?: string,
+     *   insertChunkSize?: number,
+     *   queryChunkSize?: number,
+     *   onProgress?: (message: string) => void
+     * }} args
+     */
+    constructor({ sourceDb, targetDb, tablePlan, idColumn = "id", insertChunkSize = DEFAULT_INSERT_CHUNK_SIZE, queryChunkSize = DEFAULT_QUERY_CHUNK_SIZE, onProgress }) {
+        this.sourceDb = sourceDb;
+        this.targetDb = targetDb;
+        this.tablePlan = tablePlan;
+        this.idColumn = idColumn;
+        this.insertChunkSize = insertChunkSize;
+        this.queryChunkSize = queryChunkSize;
+        this.onProgress = onProgress;
+    }
+    /**
+     * Copies every plan table's rows for `keyValue` from the source into the target and
+     * returns the copied source rows keyed by table name. The target's current tenant rows
+     * are deleted (children first) and the source rows inserted (parents first) in a single
+     * target transaction with foreign keys disabled.
+     * @param {string} keyValue
+     * @returns {Promise<Map<string, Record<string, unknown>[]>>}
+     */
+    async copy(keyValue) {
+        const sourceRowsByTableName = await this.loadRows(this.sourceDb, keyValue);
+        const targetRowsByTableName = await this.loadRows(this.targetDb, keyValue);
+        await this.targetDb.withDisabledForeignKeys(async () => {
+            await this.targetDb.transaction(async () => {
+                await this.deleteTargetRows(targetRowsByTableName);
+                await this.insertTargetRows(sourceRowsByTableName);
+            });
+        });
+        return sourceRowsByTableName;
+    }
+    /**
+     * Loads the rows for `keyValue` for every table in the plan from `db`, resolving
+     * parent-scoped tables from the ids already selected for their parent table. Used for
+     * both the source rows to copy and the target's current tenant rows to delete.
+     * @param {import("../drivers/base.js").default} db
+     * @param {string} keyValue
+     * @returns {Promise<Map<string, Record<string, unknown>[]>>}
+     */
+    async loadRows(db, keyValue) {
+        /** @type {Map<string, string[]>} */
+        const idsByTableName = new Map();
+        /** @type {Map<string, Record<string, unknown>[]>} */
+        const rowsByTableName = new Map();
+        for (const tableConfig of this.tablePlan) {
+            let rows;
+            if (tableConfig.keyColumn) {
+                rows = await this.queryRowsByColumn({
+                    columnName: tableConfig.keyColumn,
+                    db,
+                    tableName: tableConfig.tableName,
+                    values: [keyValue]
+                });
+            }
+            else {
+                if (!tableConfig.parentColumn || !tableConfig.parentTableName) {
+                    throw new Error(`Expected keyColumn or parentTableName+parentColumn for table ${tableConfig.tableName} in the tenant table plan.`);
+                }
+                if (!idsByTableName.has(tableConfig.parentTableName)) {
+                    throw new Error(`Tenant table plan entry ${tableConfig.tableName} references parent table ${tableConfig.parentTableName}, which has not been loaded; parent tables must appear before their children in the plan.`);
+                }
+                rows = await this.queryRowsByColumn({
+                    columnName: tableConfig.parentColumn,
+                    db,
+                    tableName: tableConfig.tableName,
+                    values: idsByTableName.get(tableConfig.parentTableName) || []
+                });
+            }
+            if (rows.length > 0) {
+                this.reportProgress(`${tableConfig.tableName}: loaded ${rows.length} row(s)`);
+            }
+            idsByTableName.set(tableConfig.tableName, uniqueStrings(rows.map((row) => row[this.idColumn])));
+            rowsByTableName.set(tableConfig.tableName, rows);
+        }
+        return rowsByTableName;
+    }
+    /**
+     * Selects all rows of `tableName` in `db` whose `columnName` is in `values`, chunked.
+     * @param {{columnName: string, db: import("../drivers/base.js").default, tableName: string, values: string[]}} args
+     * @returns {Promise<Record<string, unknown>[]>}
+     */
+    async queryRowsByColumn({ columnName, db, tableName, values }) {
+        const normalizedValues = uniqueStrings(values);
+        if (normalizedValues.length <= 0) {
+            return [];
+        }
+        const rows = [];
+        const quotedTable = db.quoteTable(tableName);
+        const quotedColumn = db.quoteColumn(columnName);
+        for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {
+            const sql = `SELECT ${quotedTable}.* FROM ${quotedTable} WHERE ${quotedColumn} IN (${this.quotedValuesSql(db, valuesChunk)})`;
+            rows.push(...await this.executeQuietQuery(db, sql));
+        }
+        return rows;
+    }
+    /**
+     * Deletes the matching target rows for every plan table, children before parents, so the
+     * reinsert that follows starts from a clean slate without violating foreign keys.
+     * @param {Map<string, Record<string, unknown>[]>} rowsByTableName
+     * @returns {Promise<void>}
+     */
+    async deleteTargetRows(rowsByTableName) {
+        for (const tableConfig of [...this.tablePlan].reverse()) {
+            const rowIds = uniqueStrings((rowsByTableName.get(tableConfig.tableName) || []).map((row) => row[this.idColumn]));
+            if (rowIds.length <= 0) {
+                continue;
+            }
+            const quotedTable = this.targetDb.quoteTable(tableConfig.tableName);
+            const quotedIdColumn = this.targetDb.quoteColumn(this.idColumn);
+            for (const rowIdsChunk of chunks(rowIds, this.queryChunkSize)) {
+                await this.executeQuietQuery(this.targetDb, `DELETE FROM ${quotedTable} WHERE ${quotedIdColumn} IN (${this.quotedValuesSql(this.targetDb, rowIdsChunk)})`);
+            }
+        }
+    }
+    /**
+     * Inserts the loaded source rows into the target for every plan table, parents before
+     * children, chunked to bound statement size.
+     * @param {Map<string, Record<string, unknown>[]>} rowsByTableName
+     * @returns {Promise<void>}
+     */
+    async insertTargetRows(rowsByTableName) {
+        for (const tableConfig of this.tablePlan) {
+            const rows = rowsByTableName.get(tableConfig.tableName) || [];
+            if (rows.length <= 0) {
+                continue;
+            }
+            const columns = Object.keys(rows[0]);
+            const insertChunks = chunks(rows, this.insertChunkSize);
+            this.reportProgress(`${tableConfig.tableName}: inserting ${rows.length} row(s) in ${insertChunks.length} chunk(s)`);
+            for (const rowsChunk of insertChunks) {
+                await this.insertRowsQuietly({
+                    columns,
+                    db: this.targetDb,
+                    rows: rowsChunk.map((row) => columns.map((column) => row[column])),
+                    tableName: tableConfig.tableName
+                });
+            }
+        }
+    }
+    /**
+     * Quotes and comma-joins values for an SQL `IN (...)` list against the given database.
+     * @param {import("../drivers/base.js").default} db
+     * @param {string[]} values
+     * @returns {string}
+     */
+    quotedValuesSql(db, values) {
+        return values.map((value) => db.quote(value)).join(", ");
+    }
+    /**
+     * Runs a query without per-query logging, used for the high-volume copy statements.
+     * @param {import("../drivers/base.js").default} db
+     * @param {string} sql
+     * @returns {Promise<Record<string, unknown>[]>}
+     */
+    async executeQuietQuery(db, sql) {
+        return await db.query(sql, { logQuery: false });
+    }
+    /**
+     * Inserts column-aligned row tuples into a table without per-query logging.
+     * @param {{columns: string[], db: import("../drivers/base.js").default, rows: Array<Array<unknown>>, tableName: string}} args
+     * @returns {Promise<void>}
+     */
+    async insertRowsQuietly({ columns, db, rows, tableName }) {
+        await this.executeQuietQuery(db, db.insertSql({ columns, tableName, rows }));
+    }
+    /**
+     * Forwards a progress message to the optional `onProgress` callback when one was given.
+     * @param {string} message
+     * @returns {void}
+     */
+    reportProgress(message) {
+        if (this.onProgress) {
+            this.onProgress(message);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-copier.js","sourceRoot":"","sources":["../../../../src/database/tenants/data-copier.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst DEFAULT_INSERT_CHUNK_SIZE = 100\nconst DEFAULT_QUERY_CHUNK_SIZE = 500\n\n/**\n * Splits an array into chunks of at most `chunkSize` items.\n * @template T\n * @param {T[]} values\n * @param {number} chunkSize\n * @returns {T[][]}\n */\nfunction chunks(values, chunkSize) {\n  const chunkedValues = []\n\n  for (let index = 0; index < values.length; index += chunkSize) {\n    chunkedValues.push(values.slice(index, index + chunkSize))\n  }\n\n  return chunkedValues\n}\n\n/**\n * Stringifies values and returns the distinct, non-blank ones, preserving first-seen order.\n * @param {unknown[]} values\n * @returns {string[]}\n */\nfunction uniqueStrings(values) {\n  return Array.from(new Set(values.map((value) => String(value)).filter((value) => value.trim())))\n}\n\n/**\n * Copies a single tenant's rows from a source database into a target database, following a\n * table plan that partitions each table either by a direct tenant key column or by\n * parent-id traversal. This is the row-level counterpart to schema cloning: multi-tenant\n * apps that keep each tenant's data in its own database use it to (re)materialise the\n * tenant's rows from a global/template database.\n *\n * The copy is delete-then-reinsert and therefore idempotent, and it mirrors the source\n * snapshot: the rows to delete are the tenant's *current* rows in the target (selected with\n * the same plan traversal run against the target), so a row that was removed from the source\n * since the last copy is dropped from the target too rather than lingering. The deletes run\n * children first and the source inserts parents first, all inside one target transaction with\n * foreign-key enforcement disabled so the ordering never trips a constraint. Reads, deletes\n * and inserts are chunked to bound statement size.\n *\n * The copier is policy-free: the caller supplies the plan, the source/target databases and\n * the tenant key, and {@link DataCopier#copy} returns the loaded rows keyed by table name so\n * the caller can perform any app-specific post-copy work (for example registering record\n * locations) without that policy leaking into the framework.\n */\nexport default class DataCopier {\n  /**\n   * Creates a copier that moves tenant-owned rows from `sourceDb` into `targetDb`.\n   * @param {{\n   *   sourceDb: import(\"../drivers/base.js\").default,\n   *   targetDb: import(\"../drivers/base.js\").default,\n   *   tablePlan: import(\"./tenant-table-plan.js\").TenantTablePlanEntry[],\n   *   idColumn?: string,\n   *   insertChunkSize?: number,\n   *   queryChunkSize?: number,\n   *   onProgress?: (message: string) => void\n   * }} args\n   */\n  constructor({sourceDb, targetDb, tablePlan, idColumn = \"id\", insertChunkSize = DEFAULT_INSERT_CHUNK_SIZE, queryChunkSize = DEFAULT_QUERY_CHUNK_SIZE, onProgress}) {\n    this.sourceDb = sourceDb\n    this.targetDb = targetDb\n    this.tablePlan = tablePlan\n    this.idColumn = idColumn\n    this.insertChunkSize = insertChunkSize\n    this.queryChunkSize = queryChunkSize\n    this.onProgress = onProgress\n  }\n\n  /**\n   * Copies every plan table's rows for `keyValue` from the source into the target and\n   * returns the copied source rows keyed by table name. The target's current tenant rows\n   * are deleted (children first) and the source rows inserted (parents first) in a single\n   * target transaction with foreign keys disabled.\n   * @param {string} keyValue\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>}\n   */\n  async copy(keyValue) {\n    const sourceRowsByTableName = await this.loadRows(this.sourceDb, keyValue)\n    const targetRowsByTableName = await this.loadRows(this.targetDb, keyValue)\n\n    await this.targetDb.withDisabledForeignKeys(async () => {\n      await this.targetDb.transaction(async () => {\n        await this.deleteTargetRows(targetRowsByTableName)\n        await this.insertTargetRows(sourceRowsByTableName)\n      })\n    })\n\n    return sourceRowsByTableName\n  }\n\n  /**\n   * Loads the rows for `keyValue` for every table in the plan from `db`, resolving\n   * parent-scoped tables from the ids already selected for their parent table. Used for\n   * both the source rows to copy and the target's current tenant rows to delete.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string} keyValue\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>}\n   */\n  async loadRows(db, keyValue) {\n    /** @type {Map<string, string[]>} */\n    const idsByTableName = new Map()\n    /** @type {Map<string, Record<string, unknown>[]>} */\n    const rowsByTableName = new Map()\n\n    for (const tableConfig of this.tablePlan) {\n      let rows\n\n      if (tableConfig.keyColumn) {\n        rows = await this.queryRowsByColumn({\n          columnName: tableConfig.keyColumn,\n          db,\n          tableName: tableConfig.tableName,\n          values: [keyValue]\n        })\n      } else {\n        if (!tableConfig.parentColumn || !tableConfig.parentTableName) {\n          throw new Error(`Expected keyColumn or parentTableName+parentColumn for table ${tableConfig.tableName} in the tenant table plan.`)\n        }\n\n        if (!idsByTableName.has(tableConfig.parentTableName)) {\n          throw new Error(`Tenant table plan entry ${tableConfig.tableName} references parent table ${tableConfig.parentTableName}, which has not been loaded; parent tables must appear before their children in the plan.`)\n        }\n\n        rows = await this.queryRowsByColumn({\n          columnName: tableConfig.parentColumn,\n          db,\n          tableName: tableConfig.tableName,\n          values: idsByTableName.get(tableConfig.parentTableName) || []\n        })\n      }\n\n      if (rows.length > 0) {\n        this.reportProgress(`${tableConfig.tableName}: loaded ${rows.length} row(s)`)\n      }\n\n      idsByTableName.set(tableConfig.tableName, uniqueStrings(rows.map((row) => row[this.idColumn])))\n      rowsByTableName.set(tableConfig.tableName, rows)\n    }\n\n    return rowsByTableName\n  }\n\n  /**\n   * Selects all rows of `tableName` in `db` whose `columnName` is in `values`, chunked.\n   * @param {{columnName: string, db: import(\"../drivers/base.js\").default, tableName: string, values: string[]}} args\n   * @returns {Promise<Record<string, unknown>[]>}\n   */\n  async queryRowsByColumn({columnName, db, tableName, values}) {\n    const normalizedValues = uniqueStrings(values)\n\n    if (normalizedValues.length <= 0) {\n      return []\n    }\n\n    const rows = []\n    const quotedTable = db.quoteTable(tableName)\n    const quotedColumn = db.quoteColumn(columnName)\n\n    for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {\n      const sql = `SELECT ${quotedTable}.* FROM ${quotedTable} WHERE ${quotedColumn} IN (${this.quotedValuesSql(db, valuesChunk)})`\n\n      rows.push(...await this.executeQuietQuery(db, sql))\n    }\n\n    return rows\n  }\n\n  /**\n   * Deletes the matching target rows for every plan table, children before parents, so the\n   * reinsert that follows starts from a clean slate without violating foreign keys.\n   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName\n   * @returns {Promise<void>}\n   */\n  async deleteTargetRows(rowsByTableName) {\n    for (const tableConfig of [...this.tablePlan].reverse()) {\n      const rowIds = uniqueStrings((rowsByTableName.get(tableConfig.tableName) || []).map((row) => row[this.idColumn]))\n\n      if (rowIds.length <= 0) {\n        continue\n      }\n\n      const quotedTable = this.targetDb.quoteTable(tableConfig.tableName)\n      const quotedIdColumn = this.targetDb.quoteColumn(this.idColumn)\n\n      for (const rowIdsChunk of chunks(rowIds, this.queryChunkSize)) {\n        await this.executeQuietQuery(\n          this.targetDb,\n          `DELETE FROM ${quotedTable} WHERE ${quotedIdColumn} IN (${this.quotedValuesSql(this.targetDb, rowIdsChunk)})`\n        )\n      }\n    }\n  }\n\n  /**\n   * Inserts the loaded source rows into the target for every plan table, parents before\n   * children, chunked to bound statement size.\n   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName\n   * @returns {Promise<void>}\n   */\n  async insertTargetRows(rowsByTableName) {\n    for (const tableConfig of this.tablePlan) {\n      const rows = rowsByTableName.get(tableConfig.tableName) || []\n\n      if (rows.length <= 0) {\n        continue\n      }\n\n      const columns = Object.keys(rows[0])\n      const insertChunks = chunks(rows, this.insertChunkSize)\n\n      this.reportProgress(`${tableConfig.tableName}: inserting ${rows.length} row(s) in ${insertChunks.length} chunk(s)`)\n\n      for (const rowsChunk of insertChunks) {\n        await this.insertRowsQuietly({\n          columns,\n          db: this.targetDb,\n          rows: rowsChunk.map((row) => columns.map((column) => row[column])),\n          tableName: tableConfig.tableName\n        })\n      }\n    }\n  }\n\n  /**\n   * Quotes and comma-joins values for an SQL `IN (...)` list against the given database.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string[]} values\n   * @returns {string}\n   */\n  quotedValuesSql(db, values) {\n    return values.map((value) => db.quote(value)).join(\", \")\n  }\n\n  /**\n   * Runs a query without per-query logging, used for the high-volume copy statements.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string} sql\n   * @returns {Promise<Record<string, unknown>[]>}\n   */\n  async executeQuietQuery(db, sql) {\n    return await db.query(sql, {logQuery: false})\n  }\n\n  /**\n   * Inserts column-aligned row tuples into a table without per-query logging.\n   * @param {{columns: string[], db: import(\"../drivers/base.js\").default, rows: Array<Array<unknown>>, tableName: string}} args\n   * @returns {Promise<void>}\n   */\n  async insertRowsQuietly({columns, db, rows, tableName}) {\n    await this.executeQuietQuery(db, db.insertSql({columns, tableName, rows}))\n  }\n\n  /**\n   * Forwards a progress message to the optional `onProgress` callback when one was given.\n   * @param {string} message\n   * @returns {void}\n   */\n  reportProgress(message) {\n    if (this.onProgress) {\n      this.onProgress(message)\n    }\n  }\n}\n"]}

package/build/src/database/tenants/schema-cloner.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Clones table structure (columns, text-type widening, indexes) from a source database
+ * into a target database for a given set of tables, then baselines the target's
+ * `schema_migrations` ledger to the source via {@link MigrationsLedger}. This is the
+ * mechanism multi-tenant apps use to provision a tenant database from a template/global
+ * database without re-running migrations: the structure is copied and the ledger is
+ * recorded as already-applied, so a later `db:tenants:migrate` does not re-run an
+ * `addColumn` whose column already exists.
+ *
+ * The cloner is intentionally policy-free — the caller decides which tables to sync and
+ * which databases are source/target. It is idempotent: missing tables are created,
+ * missing columns added, too-narrow text columns widened, and missing indexes created;
+ * an index whose definition diverges from the source is treated as drift and throws.
+ */
+export default class SchemaCloner {
+    /**
+     * Creates a cloner that copies table structure from `sourceDb` into `targetDb`.
+     * @param {{sourceDb: import("../drivers/base.js").default, targetDb: import("../drivers/base.js").default}} args
+     */
+    constructor({ sourceDb, targetDb }: {
+        sourceDb: import("../drivers/base.js").default;
+        targetDb: import("../drivers/base.js").default;
+    });
+    sourceDb: import("../drivers/base.js").default;
+    targetDb: import("../drivers/base.js").default;
+    /**
+     * Clones every given table from the source into the target, then baselines the
+     * target's ledger so the cloned schema is recorded as already-migrated.
+     * @param {string[]} tableNames
+     * @returns {Promise<void>}
+     */
+    syncTables(tableNames: string[]): Promise<void>;
+    /**
+     * Clones a single table from the source into the target, creating it or adding and
+     * widening columns and indexes as needed.
+     * @param {string} tableName
+     * @returns {Promise<void>}
+     */
+    syncTable(tableName: string): Promise<void>;
+    /**
+     * Creates the table in the target from the source table's columns and its
+     * non-primary-key indexes.
+     * @param {{sourceTable: import("../drivers/base-table.js").default, tableName: string}} args
+     * @returns {Promise<void>}
+     */
+    createTargetTable({ sourceTable, tableName }: {
+        sourceTable: import("../drivers/base-table.js").default;
+        tableName: string;
+    }): Promise<void>;
+    /**
+     * Adds columns present on the source but missing from the target, and widens
+     * too-narrow target text columns.
+     * @param {{sourceTable: import("../drivers/base-table.js").default, tableName: string}} args
+     * @returns {Promise<boolean>} Whether any column was added or widened.
+     */
+    ensureTargetColumns({ sourceTable, tableName }: {
+        sourceTable: import("../drivers/base-table.js").default;
+        tableName: string;
+    }): Promise<boolean>;
+    /**
+     * Creates non-primary-key indexes present on the source but missing from the target,
+     * and throws if an existing target index diverges from the source.
+     * @param {{sourceTable: import("../drivers/base-table.js").default, tableName: string}} args
+     * @returns {Promise<void>}
+     */
+    ensureTargetIndexes({ sourceTable, tableName }: {
+        sourceTable: import("../drivers/base-table.js").default;
+        tableName: string;
+    }): Promise<void>;
+    /**
+     * Baselines the target ledger so the cloned schema is recorded as already-applied.
+     * @returns {Promise<string[]>} The versions newly recorded on the target.
+     */
+    reconcileLedger(): Promise<string[]>;
+    /**
+     * Whether the target ledger is missing any version applied on the source — i.e. the
+     * target schema may have been advanced out of band without recording it.
+     * @returns {Promise<boolean>}
+     */
+    ledgerDriftsFromSource(): Promise<boolean>;
+    /**
+     * Maps a source index into a TableData index for table creation (SQLite omits the
+     * index name so the driver can generate a unique one).
+     * @param {import("../drivers/base-columns-index.js").default} sourceIndex
+     * @returns {TableIndex}
+     */
+    tableDataIndexFromSourceIndex(sourceIndex: import("../drivers/base-columns-index.js").default): TableIndex;
+    /**
+     * Builds driver create-index args from a source index (the index name is omitted on
+     * SQLite, where index names are unique per-database rather than per-table).
+     * @param {{sourceIndex: import("../drivers/base-columns-index.js").default, tableName: string}} args
+     * @returns {{columns: string[], name?: string, tableName: string, unique: boolean}}
+     */
+    createIndexArgsFromSourceIndex({ sourceIndex, tableName }: {
+        sourceIndex: import("../drivers/base-columns-index.js").default;
+        tableName: string;
+    }): {
+        columns: string[];
+        name?: string;
+        tableName: string;
+        unique: boolean;
+    };
+    /**
+     * Whether two indexes have the same uniqueness and ordered column list.
+     * @param {import("../drivers/base-columns-index.js").default} sourceIndex
+     * @param {import("../drivers/base-columns-index.js").default} targetIndex
+     * @returns {boolean}
+     */
+    indexesMatch(sourceIndex: import("../drivers/base-columns-index.js").default, targetIndex: import("../drivers/base-columns-index.js").default): boolean;
+    /**
+     * A stable signature for an index, used to match cloned indexes by shape.
+     * @param {import("../drivers/base-columns-index.js").default} index
+     * @returns {string}
+     */
+    indexSignature(index: import("../drivers/base-columns-index.js").default): string;
+    /**
+     * Normalizes a column type to its canonical lowercase form (`int` becomes `integer`).
+     * @param {string} columnType
+     * @returns {string}
+     */
+    normalizedColumnType(columnType: string): string;
+    /**
+     * The widening rank of a text column type (0 when not a text type).
+     * @param {string} columnType
+     * @returns {number}
+     */
+    textTypeRank(columnType: string): number;
+    /**
+     * Whether the target's text column is narrower than the source's and must be widened.
+     * @param {import("../drivers/base-column.js").default} sourceColumn
+     * @param {import("../drivers/base-column.js").default} targetColumn
+     * @returns {boolean}
+     */
+    columnNeedsWidening(sourceColumn: import("../drivers/base-column.js").default, targetColumn: import("../drivers/base-column.js").default): boolean;
+    /**
+     * Builds TableData column args from a source column, copying type, nullability,
+     * length, notes, simple defaults and (for full clones) primary-key flag.
+     * @param {import("../drivers/base-column.js").default} sourceColumn
+     * @param {{isNewColumn: boolean}} args
+     * @returns {Record<string, unknown>}
+     */
+    columnArgsFromSourceColumn(sourceColumn: import("../drivers/base-column.js").default, { isNewColumn }: {
+        isNewColumn: boolean;
+    }): Record<string, unknown>;
+}
+import TableIndex from "../table-data/table-index.js";
+//# sourceMappingURL=schema-cloner.d.ts.map

package/build/src/database/tenants/schema-cloner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-cloner.d.ts","sourceRoot":"","sources":["../../../../src/database/tenants/schema-cloner.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH;IACE;;;OAGG;IACH,oCAFW;QAAC,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAA;KAAC,EAK1G;IAFC,+CAAwB;IACxB,+CAAwB;IAG1B;;;;;OAKG;IACH,uBAHW,MAAM,EAAE,GACN,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAED;;;;;OAKG;IACH,8CAHW;QAAC,WAAW,EAAE,OAAO,0BAA0B,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAC1E,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;;;OAKG;IACH,gDAHW;QAAC,WAAW,EAAE,OAAO,0BAA0B,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAC1E,OAAO,CAAC,OAAO,CAAC,CA0C5B;IAED;;;;;OAKG;IACH,gDAHW;QAAC,WAAW,EAAE,OAAO,0BAA0B,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAC1E,OAAO,CAAC,IAAI,CAAC,CAiDzB;IAED;;;OAGG;IACH,mBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAI7B;IAED;;;;OAIG;IACH,0BAFa,OAAO,CAAC,OAAO,CAAC,CAW5B;IAED;;;;;OAKG;IACH,2CAHW,OAAO,kCAAkC,EAAE,OAAO,GAChD,UAAU,CAetB;IAED;;;;;OAKG;IACH,2DAHW;QAAC,WAAW,EAAE,OAAO,kCAAkC,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAClF;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,CAelF;IAED;;;;;OAKG;IACH,0BAJW,OAAO,kCAAkC,EAAE,OAAO,eAClD,OAAO,kCAAkC,EAAE,OAAO,GAChD,OAAO,CAqBnB;IAED;;;;OAIG;IACH,sBAHW,OAAO,kCAAkC,EAAE,OAAO,GAChD,MAAM,CAIlB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kCAJW,OAAO,2BAA2B,EAAE,OAAO,gBAC3C,OAAO,2BAA2B,EAAE,OAAO,GACzC,OAAO,CAOnB;IAED;;;;;;OAMG;IACH,yCAJW,OAAO,2BAA2B,EAAE,OAAO,mBAC3C;QAAC,WAAW,EAAE,OAAO,CAAA;KAAC,GACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCnC;CACF;uBAjYsB,8BAA8B"}