velocious 1.0.535 → 1.0.537

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

@@ -1,6 +1,7 @@
 // @ts-check
 const DEFAULT_INSERT_CHUNK_SIZE = 100;
 const DEFAULT_QUERY_CHUNK_SIZE = 500;
+const DEFAULT_STREAM_BATCH_SIZE = 1000;
 /**
  * Splits an array into chunks of at most `chunkSize` items.
  * @template T
@@ -182,6 +183,149 @@ export default class DataCopier {
         }
         return { idsByTableName, rowsByTableName };
     }
+    /**
+     * The plan tables referenced as a parent by some child entry. Their ids must be retained
+     * while streaming so their children can be scoped; leaf tables — typically the high-volume
+     * ones — are never in this set and so are never accumulated in memory.
+     * @returns {Set<string>} - Table names that are a parent of another plan entry.
+     */
+    parentTableNames() {
+        /** @type {Set<string>} */
+        const names = new Set();
+        for (const tableConfig of this.tablePlan) {
+            if (tableConfig.parentTableName) {
+                names.add(tableConfig.parentTableName);
+            }
+        }
+        return names;
+    }
+    /**
+     * Streams every plan table's source rows scoped to `keyValue` in bounded `batchSize` batches,
+     * following parent/child chaining. Each table is read through a real
+     * {@link import("../drivers/base.js").default#queryStream} cursor, so a large table is never
+     * buffered; only the ids of tables that are themselves a parent are retained (to scope their
+     * children). `selectColumns` bounds each row's projection — pass `[idColumn]` for a light
+     * id-only scan, or omit it to stream full rows — and must include the id column for any table
+     * that has children. Memory stays bounded to one batch plus the retained parent-table ids.
+     * @param {import("../drivers/base.js").default} db - Source database to stream.
+     * @param {string} keyValue - Tenant key selecting the root plan rows.
+     * @param {{batchSize: number, selectColumns?: string[]}} options - Batch size and optional projection.
+     * @yields {{rows: Record<string, unknown>[], tableName: string}} - Successive row batches per table.
+     */
+    async *streamPlanSourceBatches(db, keyValue, { batchSize, selectColumns }) {
+        /** @type {Map<string, string[]>} */
+        const retainedIdsByTableName = new Map();
+        const parentTableNames = this.parentTableNames();
+        for (const tableConfig of this.tablePlan) {
+            /** @type {string} */
+            let scopeColumn;
+            /** @type {string[]} */
+            let scopeValues;
+            if (tableConfig.keyColumn) {
+                scopeColumn = tableConfig.keyColumn;
+                scopeValues = [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 (!retainedIdsByTableName.has(tableConfig.parentTableName)) {
+                    throw new Error(`Tenant table plan entry ${tableConfig.tableName} references parent table ${tableConfig.parentTableName}, which has not been streamed; parent tables must appear before their children in the plan.`);
+                }
+                scopeColumn = tableConfig.parentColumn;
+                scopeValues = retainedIdsByTableName.get(tableConfig.parentTableName) || [];
+            }
+            /** @type {string[] | null} */
+            const retainedIds = parentTableNames.has(tableConfig.tableName) ? [] : null;
+            const quotedTable = db.quoteTable(tableConfig.tableName);
+            const quotedScope = db.quoteColumn(scopeColumn);
+            const selectList = selectColumns
+                ? selectColumns.map((column) => `${quotedTable}.${db.quoteColumn(column)}`).join(", ")
+                : `${quotedTable}.*`;
+            /** @type {Record<string, unknown>[]} */
+            let batch = [];
+            for (const scopeChunk of chunks(uniqueStrings(scopeValues), this.queryChunkSize)) {
+                const sql = `SELECT ${selectList} FROM ${quotedTable} WHERE ${quotedScope} IN (${this.quotedValuesSql(db, scopeChunk)})`;
+                for await (const row of db.queryStream(sql)) {
+                    batch.push(row);
+                    if (retainedIds) {
+                        retainedIds.push(String(row[this.idColumn]));
+                    }
+                    if (batch.length >= batchSize) {
+                        yield { rows: batch, tableName: tableConfig.tableName };
+                        batch = [];
+                    }
+                }
+            }
+            if (batch.length > 0) {
+                yield { rows: batch, tableName: tableConfig.tableName };
+            }
+            retainedIdsByTableName.set(tableConfig.tableName, retainedIds || []);
+        }
+    }
+    /**
+     * Returns which of `ids` currently exist in `tableName` in `db`. `ids` is one already-bounded
+     * batch, so it is probed with a single `IN (...)` lookup.
+     * @param {{db: import("../drivers/base.js").default, ids: string[], tableName: string}} args - Database, ids to probe, and table.
+     * @returns {Promise<Set<string>>} - The subset of `ids` present in the table.
+     */
+    async queryExistingIds({ db, ids, tableName }) {
+        if (ids.length <= 0) {
+            return new Set();
+        }
+        const quotedTable = db.quoteTable(tableName);
+        const quotedId = db.quoteColumn(this.idColumn);
+        const rows = await this.executeQuietQuery(db, `SELECT ${quotedTable}.${quotedId} FROM ${quotedTable} WHERE ${quotedId} IN (${this.quotedValuesSql(db, ids)})`);
+        return new Set(rows.map((row) => String(row[this.idColumn])));
+    }
+    /**
+     * Streams the source ids for `keyValue` and returns the first table found to be missing rows in
+     * the target, with that batch's missing ids — stopping at the first shortfall instead of
+     * enumerating every missing row. Callers verifying a tenant already holds every source row (for
+     * example before deleting the source copies) treat an empty result as the go-ahead and any entry
+     * as a hard stop; failing fast keeps memory bounded to a single batch even when the target is
+     * far behind.
+     * @param {string} keyValue - Tenant key selecting the source rows to check.
+     * @param {{batchSize?: number}} [options] - Streaming batch size.
+     * @returns {Promise<Map<string, string[]>>} - The first table missing rows and that batch's missing ids, or empty when the target holds everything.
+     */
+    async findMissingRowIds(keyValue, { batchSize = DEFAULT_STREAM_BATCH_SIZE } = {}) {
+        /** @type {Map<string, string[]>} */
+        const missingByTableName = new Map();
+        for await (const { rows, tableName } of this.streamPlanSourceBatches(this.sourceDb, keyValue, { batchSize, selectColumns: [this.idColumn] })) {
+            const ids = rows.map((row) => String(row[this.idColumn]));
+            const existingIds = await this.queryExistingIds({ db: this.targetDb, ids, tableName });
+            const missingIds = ids.filter((id) => !existingIds.has(id));
+            if (missingIds.length > 0) {
+                missingByTableName.set(tableName, missingIds);
+                break;
+            }
+        }
+        return missingByTableName;
+    }
+    /**
+     * Streams the source rows for `keyValue` and copies into the target, batch by batch, only the
+     * rows missing there. Because the full rows travel in the stream, each batch's missing rows are
+     * inserted as it arrives — nothing is accumulated, and no second source query runs while the
+     * source connection is held by the stream — so a table with large columns stays bounded to one
+     * batch even when the target is empty. Intended for single-table plans (or plans whose per-table,
+     * parent-first insert order is foreign-key safe).
+     * @param {string} keyValue - Tenant key selecting the source rows to reconcile.
+     * @param {{batchSize?: number}} [options] - Streaming batch size.
+     * @returns {Promise<number>} - The number of rows copied into the target.
+     */
+    async copyMissingRows(keyValue, { batchSize = DEFAULT_STREAM_BATCH_SIZE } = {}) {
+        let copiedCount = 0;
+        for await (const { rows, tableName } of this.streamPlanSourceBatches(this.sourceDb, keyValue, { batchSize })) {
+            const existingIds = await this.queryExistingIds({ db: this.targetDb, ids: rows.map((row) => String(row[this.idColumn])), tableName });
+            const missingRows = rows.filter((row) => !existingIds.has(String(row[this.idColumn])));
+            if (missingRows.length > 0) {
+                await this.insertTargetRows(new Map([[tableName, missingRows]]));
+                copiedCount += missingRows.length;
+            }
+        }
+        return copiedCount;
+    }
     /**
      * Selects `tableName` rows in `db` whose `columnName` is in `values`, chunked. `selectColumns`
      * bounds the projection and defaults to every column.
@@ -286,4 +430,4 @@ export default class DataCopier {
         }
     }
 }
-//# 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 - Ordered items to partition.\n * @param {number} chunkSize - Maximum items per chunk.\n * @returns {T[][]} - Consecutive chunks preserving input order.\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 - Candidate database identifiers to stringify and deduplicate.\n * @returns {string[]} - Distinct non-blank identifiers in first-seen order.\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 - Source, target, traversal plan, chunk limits, and progress handler.\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 - Tenant key selecting the rows to copy.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - Copied source rows grouped by table name.\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   * Deletes one tenant's rows from the target database, children before parents, with\n   * foreign keys disabled inside a single transaction. This is `copy` without the reinsert:\n   * the same plan traversal selects the tenant's current target rows and `deleteTargetRows`\n   * removes them children-first so the ordering never trips a foreign key. Multi-tenant apps\n   * use it to purge a tenant — for example clearing the tenant's master copy in the\n   * global/default database on teardown, so foreign keys stop referencing the tenant's\n   * about-to-be-removed root row.\n   *\n   * Returns the deleted rows keyed by table name so the caller can perform any app-specific\n   * post-delete work (record-location cleanup, auditing) without that policy leaking into the\n   * framework.\n   * @param {string} keyValue - Tenant key whose rows should be removed from the target.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - The deleted rows by table name.\n   */\n  async deleteTenantRows(keyValue) {\n    const rowsByTableName = await this.loadRows(this.targetDb, keyValue)\n\n    await this.targetDb.withDisabledForeignKeys(async () => {\n      await this.targetDb.transaction(async () => {\n        await this.deleteTargetRows(rowsByTableName)\n      })\n    })\n\n    return rowsByTableName\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 - Source or target database to traverse.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - Loaded rows grouped by table name.\n   */\n  async loadRows(db, keyValue) {\n    return (await this.traversePlan(db, keyValue)).rowsByTableName\n  }\n\n  /**\n   * Loads only the ids for `keyValue` for every table in the plan from `db`, using the same\n   * parent/child traversal as {@link DataCopier#loadRows} but selecting just the id column.\n   * Callers that only need to compare row membership — for example verifying a tenant already\n   * holds every default row before a cleanup delete — should use this instead of loadRows so\n   * they never materialise full rows; for large tenants that is the difference between a few\n   * kilobytes of ids and gigabytes of row data.\n   * @param {import(\"../drivers/base.js\").default} db - Source or target database to traverse.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @returns {Promise<Map<string, string[]>>} - Loaded ids grouped by table name.\n   */\n  async loadRowIds(db, keyValue) {\n    return (await this.traversePlan(db, keyValue, [this.idColumn])).idsByTableName\n  }\n\n  /**\n   * Traverses the table plan for `keyValue`, querying each table by its tenant key column or\n   * (for child tables) by the ids already selected for its parent, and returns both the ids\n   * and the loaded rows grouped by table name. `selectColumns` bounds the columns each query\n   * selects; pass `[idColumn]` for an id-only traversal, or omit it to load full rows.\n   * @param {import(\"../drivers/base.js\").default} db - Source or target database to traverse.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @param {string[]} [selectColumns] - Columns to select; defaults to every column.\n   * @returns {Promise<{idsByTableName: Map<string, string[]>, rowsByTableName: Map<string, Record<string, unknown>[]>}>} - Ids and rows grouped by table name.\n   */\n  async traversePlan(db, keyValue, selectColumns) {\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          selectColumns,\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          selectColumns,\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 {idsByTableName, rowsByTableName}\n  }\n\n  /**\n   * Selects `tableName` rows in `db` whose `columnName` is in `values`, chunked. `selectColumns`\n   * bounds the projection and defaults to every column.\n   * @param {{columnName: string, db: import(\"../drivers/base.js\").default, selectColumns?: string[], tableName: string, values: string[]}} args - Table, column, projection, database, and values for the chunked lookup.\n   * @returns {Promise<Record<string, unknown>[]>} - Rows matching the supplied column values.\n   */\n  async queryRowsByColumn({columnName, db, selectColumns, 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    const selectList = selectColumns\n      ? selectColumns.map((column) => `${quotedTable}.${db.quoteColumn(column)}`).join(\", \")\n      : `${quotedTable}.*`\n\n    for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {\n      const sql = `SELECT ${selectList} 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 - Rows grouped by table name.\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 - Rows grouped by table name.\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 - Database whose quoting rules format the values.\n   * @param {string[]} values - Values to quote for the `IN` list.\n   * @returns {string} - Quoted SQL value list.\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 - Database on which to execute the copy query.\n   * @param {string} sql - Copy-related SQL statement to execute quietly.\n   * @returns {Promise<Record<string, unknown>[]>} - Query result rows.\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 - Destination table and column-aligned row values to insert.\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 - Copy progress message to forward when reporting is enabled.\n   * @returns {void}\n   */\n  reportProgress(message) {\n    if (this.onProgress) {\n      this.onProgress(message)\n    }\n  }\n}\n"]}
+//# 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\nconst DEFAULT_STREAM_BATCH_SIZE = 1000\n\n/**\n * Splits an array into chunks of at most `chunkSize` items.\n * @template T\n * @param {T[]} values - Ordered items to partition.\n * @param {number} chunkSize - Maximum items per chunk.\n * @returns {T[][]} - Consecutive chunks preserving input order.\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 - Candidate database identifiers to stringify and deduplicate.\n * @returns {string[]} - Distinct non-blank identifiers in first-seen order.\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 - Source, target, traversal plan, chunk limits, and progress handler.\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 - Tenant key selecting the rows to copy.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - Copied source rows grouped by table name.\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   * Deletes one tenant's rows from the target database, children before parents, with\n   * foreign keys disabled inside a single transaction. This is `copy` without the reinsert:\n   * the same plan traversal selects the tenant's current target rows and `deleteTargetRows`\n   * removes them children-first so the ordering never trips a foreign key. Multi-tenant apps\n   * use it to purge a tenant — for example clearing the tenant's master copy in the\n   * global/default database on teardown, so foreign keys stop referencing the tenant's\n   * about-to-be-removed root row.\n   *\n   * Returns the deleted rows keyed by table name so the caller can perform any app-specific\n   * post-delete work (record-location cleanup, auditing) without that policy leaking into the\n   * framework.\n   * @param {string} keyValue - Tenant key whose rows should be removed from the target.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - The deleted rows by table name.\n   */\n  async deleteTenantRows(keyValue) {\n    const rowsByTableName = await this.loadRows(this.targetDb, keyValue)\n\n    await this.targetDb.withDisabledForeignKeys(async () => {\n      await this.targetDb.transaction(async () => {\n        await this.deleteTargetRows(rowsByTableName)\n      })\n    })\n\n    return rowsByTableName\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 - Source or target database to traverse.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - Loaded rows grouped by table name.\n   */\n  async loadRows(db, keyValue) {\n    return (await this.traversePlan(db, keyValue)).rowsByTableName\n  }\n\n  /**\n   * Loads only the ids for `keyValue` for every table in the plan from `db`, using the same\n   * parent/child traversal as {@link DataCopier#loadRows} but selecting just the id column.\n   * Callers that only need to compare row membership — for example verifying a tenant already\n   * holds every default row before a cleanup delete — should use this instead of loadRows so\n   * they never materialise full rows; for large tenants that is the difference between a few\n   * kilobytes of ids and gigabytes of row data.\n   * @param {import(\"../drivers/base.js\").default} db - Source or target database to traverse.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @returns {Promise<Map<string, string[]>>} - Loaded ids grouped by table name.\n   */\n  async loadRowIds(db, keyValue) {\n    return (await this.traversePlan(db, keyValue, [this.idColumn])).idsByTableName\n  }\n\n  /**\n   * Traverses the table plan for `keyValue`, querying each table by its tenant key column or\n   * (for child tables) by the ids already selected for its parent, and returns both the ids\n   * and the loaded rows grouped by table name. `selectColumns` bounds the columns each query\n   * selects; pass `[idColumn]` for an id-only traversal, or omit it to load full rows.\n   * @param {import(\"../drivers/base.js\").default} db - Source or target database to traverse.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @param {string[]} [selectColumns] - Columns to select; defaults to every column.\n   * @returns {Promise<{idsByTableName: Map<string, string[]>, rowsByTableName: Map<string, Record<string, unknown>[]>}>} - Ids and rows grouped by table name.\n   */\n  async traversePlan(db, keyValue, selectColumns) {\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          selectColumns,\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          selectColumns,\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 {idsByTableName, rowsByTableName}\n  }\n\n  /**\n   * The plan tables referenced as a parent by some child entry. Their ids must be retained\n   * while streaming so their children can be scoped; leaf tables — typically the high-volume\n   * ones — are never in this set and so are never accumulated in memory.\n   * @returns {Set<string>} - Table names that are a parent of another plan entry.\n   */\n  parentTableNames() {\n    /** @type {Set<string>} */\n    const names = new Set()\n\n    for (const tableConfig of this.tablePlan) {\n      if (tableConfig.parentTableName) {\n        names.add(tableConfig.parentTableName)\n      }\n    }\n\n    return names\n  }\n\n  /**\n   * Streams every plan table's source rows scoped to `keyValue` in bounded `batchSize` batches,\n   * following parent/child chaining. Each table is read through a real\n   * {@link import(\"../drivers/base.js\").default#queryStream} cursor, so a large table is never\n   * buffered; only the ids of tables that are themselves a parent are retained (to scope their\n   * children). `selectColumns` bounds each row's projection — pass `[idColumn]` for a light\n   * id-only scan, or omit it to stream full rows — and must include the id column for any table\n   * that has children. Memory stays bounded to one batch plus the retained parent-table ids.\n   * @param {import(\"../drivers/base.js\").default} db - Source database to stream.\n   * @param {string} keyValue - Tenant key selecting the root plan rows.\n   * @param {{batchSize: number, selectColumns?: string[]}} options - Batch size and optional projection.\n   * @yields {{rows: Record<string, unknown>[], tableName: string}} - Successive row batches per table.\n   */\n  async *streamPlanSourceBatches(db, keyValue, {batchSize, selectColumns}) {\n    /** @type {Map<string, string[]>} */\n    const retainedIdsByTableName = new Map()\n    const parentTableNames = this.parentTableNames()\n\n    for (const tableConfig of this.tablePlan) {\n      /** @type {string} */\n      let scopeColumn\n      /** @type {string[]} */\n      let scopeValues\n\n      if (tableConfig.keyColumn) {\n        scopeColumn = tableConfig.keyColumn\n        scopeValues = [keyValue]\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 (!retainedIdsByTableName.has(tableConfig.parentTableName)) {\n          throw new Error(`Tenant table plan entry ${tableConfig.tableName} references parent table ${tableConfig.parentTableName}, which has not been streamed; parent tables must appear before their children in the plan.`)\n        }\n\n        scopeColumn = tableConfig.parentColumn\n        scopeValues = retainedIdsByTableName.get(tableConfig.parentTableName) || []\n      }\n\n      /** @type {string[] | null} */\n      const retainedIds = parentTableNames.has(tableConfig.tableName) ? [] : null\n      const quotedTable = db.quoteTable(tableConfig.tableName)\n      const quotedScope = db.quoteColumn(scopeColumn)\n      const selectList = selectColumns\n        ? selectColumns.map((column) => `${quotedTable}.${db.quoteColumn(column)}`).join(\", \")\n        : `${quotedTable}.*`\n      /** @type {Record<string, unknown>[]} */\n      let batch = []\n\n      for (const scopeChunk of chunks(uniqueStrings(scopeValues), this.queryChunkSize)) {\n        const sql = `SELECT ${selectList} FROM ${quotedTable} WHERE ${quotedScope} IN (${this.quotedValuesSql(db, scopeChunk)})`\n\n        for await (const row of db.queryStream(sql)) {\n          batch.push(row)\n\n          if (retainedIds) {\n            retainedIds.push(String(row[this.idColumn]))\n          }\n\n          if (batch.length >= batchSize) {\n            yield {rows: batch, tableName: tableConfig.tableName}\n            batch = []\n          }\n        }\n      }\n\n      if (batch.length > 0) {\n        yield {rows: batch, tableName: tableConfig.tableName}\n      }\n\n      retainedIdsByTableName.set(tableConfig.tableName, retainedIds || [])\n    }\n  }\n\n  /**\n   * Returns which of `ids` currently exist in `tableName` in `db`. `ids` is one already-bounded\n   * batch, so it is probed with a single `IN (...)` lookup.\n   * @param {{db: import(\"../drivers/base.js\").default, ids: string[], tableName: string}} args - Database, ids to probe, and table.\n   * @returns {Promise<Set<string>>} - The subset of `ids` present in the table.\n   */\n  async queryExistingIds({db, ids, tableName}) {\n    if (ids.length <= 0) {\n      return new Set()\n    }\n\n    const quotedTable = db.quoteTable(tableName)\n    const quotedId = db.quoteColumn(this.idColumn)\n    const rows = await this.executeQuietQuery(db, `SELECT ${quotedTable}.${quotedId} FROM ${quotedTable} WHERE ${quotedId} IN (${this.quotedValuesSql(db, ids)})`)\n\n    return new Set(rows.map((row) => String(row[this.idColumn])))\n  }\n\n  /**\n   * Streams the source ids for `keyValue` and returns the first table found to be missing rows in\n   * the target, with that batch's missing ids — stopping at the first shortfall instead of\n   * enumerating every missing row. Callers verifying a tenant already holds every source row (for\n   * example before deleting the source copies) treat an empty result as the go-ahead and any entry\n   * as a hard stop; failing fast keeps memory bounded to a single batch even when the target is\n   * far behind.\n   * @param {string} keyValue - Tenant key selecting the source rows to check.\n   * @param {{batchSize?: number}} [options] - Streaming batch size.\n   * @returns {Promise<Map<string, string[]>>} - The first table missing rows and that batch's missing ids, or empty when the target holds everything.\n   */\n  async findMissingRowIds(keyValue, {batchSize = DEFAULT_STREAM_BATCH_SIZE} = {}) {\n    /** @type {Map<string, string[]>} */\n    const missingByTableName = new Map()\n\n    for await (const {rows, tableName} of this.streamPlanSourceBatches(this.sourceDb, keyValue, {batchSize, selectColumns: [this.idColumn]})) {\n      const ids = rows.map((row) => String(row[this.idColumn]))\n      const existingIds = await this.queryExistingIds({db: this.targetDb, ids, tableName})\n      const missingIds = ids.filter((id) => !existingIds.has(id))\n\n      if (missingIds.length > 0) {\n        missingByTableName.set(tableName, missingIds)\n        break\n      }\n    }\n\n    return missingByTableName\n  }\n\n  /**\n   * Streams the source rows for `keyValue` and copies into the target, batch by batch, only the\n   * rows missing there. Because the full rows travel in the stream, each batch's missing rows are\n   * inserted as it arrives — nothing is accumulated, and no second source query runs while the\n   * source connection is held by the stream — so a table with large columns stays bounded to one\n   * batch even when the target is empty. Intended for single-table plans (or plans whose per-table,\n   * parent-first insert order is foreign-key safe).\n   * @param {string} keyValue - Tenant key selecting the source rows to reconcile.\n   * @param {{batchSize?: number}} [options] - Streaming batch size.\n   * @returns {Promise<number>} - The number of rows copied into the target.\n   */\n  async copyMissingRows(keyValue, {batchSize = DEFAULT_STREAM_BATCH_SIZE} = {}) {\n    let copiedCount = 0\n\n    for await (const {rows, tableName} of this.streamPlanSourceBatches(this.sourceDb, keyValue, {batchSize})) {\n      const existingIds = await this.queryExistingIds({db: this.targetDb, ids: rows.map((row) => String(row[this.idColumn])), tableName})\n      const missingRows = rows.filter((row) => !existingIds.has(String(row[this.idColumn])))\n\n      if (missingRows.length > 0) {\n        await this.insertTargetRows(new Map([[tableName, missingRows]]))\n        copiedCount += missingRows.length\n      }\n    }\n\n    return copiedCount\n  }\n\n  /**\n   * Selects `tableName` rows in `db` whose `columnName` is in `values`, chunked. `selectColumns`\n   * bounds the projection and defaults to every column.\n   * @param {{columnName: string, db: import(\"../drivers/base.js\").default, selectColumns?: string[], tableName: string, values: string[]}} args - Table, column, projection, database, and values for the chunked lookup.\n   * @returns {Promise<Record<string, unknown>[]>} - Rows matching the supplied column values.\n   */\n  async queryRowsByColumn({columnName, db, selectColumns, 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    const selectList = selectColumns\n      ? selectColumns.map((column) => `${quotedTable}.${db.quoteColumn(column)}`).join(\", \")\n      : `${quotedTable}.*`\n\n    for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {\n      const sql = `SELECT ${selectList} 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 - Rows grouped by table name.\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 - Rows grouped by table name.\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 - Database whose quoting rules format the values.\n   * @param {string[]} values - Values to quote for the `IN` list.\n   * @returns {string} - Quoted SQL value list.\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 - Database on which to execute the copy query.\n   * @param {string} sql - Copy-related SQL statement to execute quietly.\n   * @returns {Promise<Record<string, unknown>[]>} - Query result rows.\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 - Destination table and column-aligned row values to insert.\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 - Copy progress message to forward when reporting is enabled.\n   * @returns {void}\n   */\n  reportProgress(message) {\n    if (this.onProgress) {\n      this.onProgress(message)\n    }\n  }\n}\n"]}

package/build/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../index.js","../bin/velocious.js","../src/application.js","../src/configuration-resolver.js","../src/configuration-types.js","../src/configuration.js","../src/controller.js","../src/current-configuration.js","../src/current.js","../src/error-logger.js","../src/frontend-model-controller.js","../src/initializer.js","../src/logger.js","../src/mailer.js","../src/record-payload-values.js","../src/time-zone.js","../src/velocious-error.js","../src/authorization/ability.js","../src/authorization/base-resource.js","../src/background-jobs/client.js","../src/background-jobs/cron-expression.js","../src/background-jobs/forked-runner-child.js","../src/background-jobs/job-record.js","../src/background-jobs/job-registry.js","../src/background-jobs/job-runner.js","../src/background-jobs/job.js","../src/background-jobs/json-socket.js","../src/background-jobs/main.js","../src/background-jobs/normalize-error.js","../src/background-jobs/pooled-runner-child.js","../src/background-jobs/runner-process-title.js","../src/background-jobs/scheduler.js","../src/background-jobs/socket-request.js","../src/background-jobs/status-reporter.js","../src/background-jobs/store.js","../src/background-jobs/types.js","../src/background-jobs/worker.js","../src/background-jobs/web/authorization.js","../src/background-jobs/web/controller.js","../src/background-jobs/web/index.js","../src/background-jobs/web/path-matcher.js","../src/background-jobs/web/registry.js","../src/beacon/client.js","../src/beacon/in-process-broker.js","../src/beacon/in-process-client.js","../src/beacon/server.js","../src/beacon/types.js","../src/cli/base-command.js","../src/cli/browser-cli.js","../src/cli/index.js","../src/cli/tenant-database-command-helper.js","../src/cli/use-browser-cli.js","../src/cli/commands/background-jobs-main.js","../src/cli/commands/background-jobs-runner.js","../src/cli/commands/background-jobs-worker.js","../src/cli/commands/beacon.js","../src/cli/commands/console.js","../src/cli/commands/init.js","../src/cli/commands/routes.js","../src/cli/commands/run-script.js","../src/cli/commands/runner.js","../src/cli/commands/server.js","../src/cli/commands/test.js","../src/cli/commands/db/base-command.js","../src/cli/commands/db/create.js","../src/cli/commands/db/drop.js","../src/cli/commands/db/migrate.js","../src/cli/commands/db/reset.js","../src/cli/commands/db/rollback.js","../src/cli/commands/db/seed.js","../src/cli/commands/db/schema/dump.js","../src/cli/commands/db/schema/load.js","../src/cli/commands/db/tenants/check.js","../src/cli/commands/db/tenants/create.js","../src/cli/commands/db/tenants/drop.js","../src/cli/commands/db/tenants/migrate.js","../src/cli/commands/destroy/migration.js","../src/cli/commands/generate/base-models.js","../src/cli/commands/generate/frontend-models.js","../src/cli/commands/generate/migration.js","../src/cli/commands/generate/model.js","../src/cli/commands/lint/relationships.js","../src/database/advisory-lock-runner.js","../src/database/annotations-async-hooks.js","../src/database/annotations.js","../src/database/column-types.js","../src/database/datetime-storage.js","../src/database/handler.js","../src/database/initializer-from-require-context.js","../src/database/live-query.js","../src/database/migrations-ledger.js","../src/database/migrator.js","../src/database/record-changes.js","../src/database/use-database.js","../src/database/use-live-query.js","../src/database/drivers/base-column.js","../src/database/drivers/base-columns-index.js","../src/database/drivers/base-foreign-key.js","../src/database/drivers/base-table.js","../src/database/drivers/base.js","../src/database/drivers/mssql/column.js","../src/database/drivers/mssql/columns-index.js","../src/database/drivers/mssql/connect-connection.js","../src/database/drivers/mssql/foreign-key.js","../src/database/drivers/mssql/index.js","../src/database/drivers/mssql/options.js","../src/database/drivers/mssql/query-parser.js","../src/database/drivers/mssql/structure-sql.js","../src/database/drivers/mssql/table.js","../src/database/drivers/mssql/sql/alter-table.js","../src/database/drivers/mssql/sql/create-database.js","../src/database/drivers/mssql/sql/create-index.js","../src/database/drivers/mssql/sql/create-table.js","../src/database/drivers/mssql/sql/delete.js","../src/database/drivers/mssql/sql/drop-database.js","../src/database/drivers/mssql/sql/drop-table.js","../src/database/drivers/mssql/sql/insert.js","../src/database/drivers/mssql/sql/remove-index.js","../src/database/drivers/mssql/sql/update.js","../src/database/drivers/mssql/sql/upsert.js","../src/database/drivers/mysql/column.js","../src/database/drivers/mysql/columns-index.js","../src/database/drivers/mysql/foreign-key.js","../src/database/drivers/mysql/index.js","../src/database/drivers/mysql/options.js","../src/database/drivers/mysql/query-parser.js","../src/database/drivers/mysql/query.js","../src/database/drivers/mysql/structure-sql.js","../src/database/drivers/mysql/table.js","../src/database/drivers/mysql/sql/alter-table.js","../src/database/drivers/mysql/sql/create-database.js","../src/database/drivers/mysql/sql/create-index.js","../src/database/drivers/mysql/sql/create-table.js","../src/database/drivers/mysql/sql/delete.js","../src/database/drivers/mysql/sql/drop-database.js","../src/database/drivers/mysql/sql/drop-table.js","../src/database/drivers/mysql/sql/insert.js","../src/database/drivers/mysql/sql/remove-index.js","../src/database/drivers/mysql/sql/update.js","../src/database/drivers/mysql/sql/upsert.js","../src/database/drivers/pgsql/column.js","../src/database/drivers/pgsql/columns-index.js","../src/database/drivers/pgsql/foreign-key.js","../src/database/drivers/pgsql/index.js","../src/database/drivers/pgsql/options.js","../src/database/drivers/pgsql/query-parser.js","../src/database/drivers/pgsql/structure-sql.js","../src/database/drivers/pgsql/table.js","../src/database/drivers/pgsql/sql/alter-table.js","../src/database/drivers/pgsql/sql/create-database.js","../src/database/drivers/pgsql/sql/create-index.js","../src/database/drivers/pgsql/sql/create-table.js","../src/database/drivers/pgsql/sql/delete.js","../src/database/drivers/pgsql/sql/drop-database.js","../src/database/drivers/pgsql/sql/drop-table.js","../src/database/drivers/pgsql/sql/insert.js","../src/database/drivers/pgsql/sql/remove-index.js","../src/database/drivers/pgsql/sql/update.js","../src/database/drivers/pgsql/sql/upsert.js","../src/database/drivers/sqlite/base.js","../src/database/drivers/sqlite/column.js","../src/database/drivers/sqlite/columns-index.js","../src/database/drivers/sqlite/connection-sql-js.js","../src/database/drivers/sqlite/foreign-key.js","../src/database/drivers/sqlite/index.js","../src/database/drivers/sqlite/index.native.js","../src/database/drivers/sqlite/index.web.js","../src/database/drivers/sqlite/options.js","../src/database/drivers/sqlite/query-parser.js","../src/database/drivers/sqlite/query.js","../src/database/drivers/sqlite/query.native.js","../src/database/drivers/sqlite/query.web.js","../src/database/drivers/sqlite/structure-sql.js","../src/database/drivers/sqlite/table-rebuilder.js","../src/database/drivers/sqlite/table.js","../src/database/drivers/sqlite/web-persistence.js","../src/database/drivers/sqlite/sql/alter-table.js","../src/database/drivers/sqlite/sql/create-index.js","../src/database/drivers/sqlite/sql/create-table.js","../src/database/drivers/sqlite/sql/delete.js","../src/database/drivers/sqlite/sql/drop-table.js","../src/database/drivers/sqlite/sql/insert.js","../src/database/drivers/sqlite/sql/remove-index.js","../src/database/drivers/sqlite/sql/update.js","../src/database/drivers/sqlite/sql/upsert.js","../src/database/drivers/structure-sql/utils.js","../src/database/migration/index.js","../src/database/migrator/files-finder.js","../src/database/migrator/types.js","../src/database/pool/async-tracked-multi-connection.js","../src/database/pool/base-methods-forward.js","../src/database/pool/base.js","../src/database/pool/single-multi-use.js","../src/database/query/alter-table-base.js","../src/database/query/base.js","../src/database/query/create-database-base.js","../src/database/query/create-index-base.js","../src/database/query/create-table-base.js","../src/database/query/delete-base.js","../src/database/query/drop-database-base.js","../src/database/query/drop-table-base.js","../src/database/query/from-base.js","../src/database/query/from-plain.js","../src/database/query/from-table.js","../src/database/query/index.js","../src/database/query/insert-base.js","../src/database/query/join-base.js","../src/database/query/join-object.js","../src/database/query/join-plain.js","../src/database/query/join-tracker.js","../src/database/query/model-class-query.js","../src/database/query/order-base.js","../src/database/query/order-column.js","../src/database/query/order-plain.js","../src/database/query/preloader.js","../src/database/query/query-data.js","../src/database/query/remove-index-base.js","../src/database/query/select-base.js","../src/database/query/select-plain.js","../src/database/query/select-table-and-column.js","../src/database/query/update-base.js","../src/database/query/upsert-base.js","../src/database/query/where-base.js","../src/database/query/where-combinator.js","../src/database/query/where-hash.js","../src/database/query/where-model-class-hash.js","../src/database/query/where-not.js","../src/database/query/where-plain.js","../src/database/query/with-count.js","../src/database/query/preloader/belongs-to.js","../src/database/query/preloader/ensure-model-class-initialized.js","../src/database/query/preloader/has-many.js","../src/database/query/preloader/has-one.js","../src/database/query/preloader/selection.js","../src/database/query-parser/base-query-parser.js","../src/database/query-parser/from-parser.js","../src/database/query-parser/group-parser.js","../src/database/query-parser/joins-parser.js","../src/database/query-parser/limit-parser.js","../src/database/query-parser/options.js","../src/database/query-parser/order-parser.js","../src/database/query-parser/select-parser.js","../src/database/query-parser/where-parser.js","../src/database/record/acts-as-list.js","../src/database/record/auditing.js","../src/database/record/counter-cache-magnitude.js","../src/database/record/index.js","../src/database/record/record-not-found-error.js","../src/database/record/state-machine.js","../src/database/record/user-module.js","../src/database/record/validation-messages.js","../src/database/record/attachments/attachment-record.js","../src/database/record/attachments/download.js","../src/database/record/attachments/handle.js","../src/database/record/attachments/normalize-input.js","../src/database/record/attachments/store.js","../src/database/record/attachments/storage-drivers/filesystem.js","../src/database/record/attachments/storage-drivers/native.js","../src/database/record/attachments/storage-drivers/s3.js","../src/database/record/instance-relationships/base.js","../src/database/record/instance-relationships/belongs-to.js","../src/database/record/instance-relationships/has-many.js","../src/database/record/instance-relationships/has-one.js","../src/database/record/relationships/base.js","../src/database/record/relationships/belongs-to.js","../src/database/record/relationships/has-many.js","../src/database/record/relationships/has-one.js","../src/database/record/validators/base.js","../src/database/record/validators/format.js","../src/database/record/validators/length.js","../src/database/record/validators/presence.js","../src/database/record/validators/uniqueness.js","../src/database/table-data/index.js","../src/database/table-data/table-column.js","../src/database/table-data/table-foreign-key.js","../src/database/table-data/table-index.js","../src/database/table-data/table-reference.js","../src/database/tenants/data-copier.js","../src/database/tenants/schema-cloner.js","../src/database/tenants/tenant-table-plan.js","../src/environment-handlers/base.js","../src/environment-handlers/browser.js","../src/environment-handlers/node.js","../src/environment-handlers/node/cli/commands/background-jobs-main.js","../src/environment-handlers/node/cli/commands/background-jobs-runner.js","../src/environment-handlers/node/cli/commands/background-jobs-worker.js","../src/environment-handlers/node/cli/commands/beacon.js","../src/environment-handlers/node/cli/commands/cli-command-context.js","../src/environment-handlers/node/cli/commands/console.js","../src/environment-handlers/node/cli/commands/init.js","../src/environment-handlers/node/cli/commands/routes.js","../src/environment-handlers/node/cli/commands/run-script.js","../src/environment-handlers/node/cli/commands/runner.js","../src/environment-handlers/node/cli/commands/server.js","../src/environment-handlers/node/cli/commands/test.js","../src/environment-handlers/node/cli/commands/db/seed.js","../src/environment-handlers/node/cli/commands/db/schema/dump.js","../src/environment-handlers/node/cli/commands/db/schema/load.js","../src/environment-handlers/node/cli/commands/destroy/migration.js","../src/environment-handlers/node/cli/commands/generate/base-models.js","../src/environment-handlers/node/cli/commands/generate/frontend-models.js","../src/environment-handlers/node/cli/commands/generate/generated-file-banner.js","../src/environment-handlers/node/cli/commands/generate/migration.js","../src/environment-handlers/node/cli/commands/generate/model.js","../src/environment-handlers/node/cli/commands/lint/relationships.js","../src/error-reporting/request-details.js","../src/frontend-model-resource/base-resource.js","../src/frontend-model-resource/velocious-attachment-resource.js","../src/frontend-models/base.js","../src/frontend-models/built-in-resources.js","../src/frontend-models/clear-pending-debounced-callback.js","../src/frontend-models/event-hook-models.js","../src/frontend-models/model-registry.js","../src/frontend-models/outgoing-event-buffer.js","../src/frontend-models/preloader.js","../src/frontend-models/query.js","../src/frontend-models/resource-config-validation.js","../src/frontend-models/resource-definition.js","../src/frontend-models/transport-serialization.js","../src/frontend-models/use-created-event.js","../src/frontend-models/use-destroyed-event.js","../src/frontend-models/use-model-class-event.js","../src/frontend-models/use-updated-event.js","../src/frontend-models/websocket-channel.js","../src/frontend-models/websocket-publishers.js","../src/http-client/header.js","../src/http-client/index.js","../src/http-client/request.js","../src/http-client/response.js","../src/http-client/websocket-client.js","../src/http-server/cookie.js","../src/http-server/development-reloader.js","../src/http-server/index.js","../src/http-server/remote-address.js","../src/http-server/server-client.js","../src/http-server/server-lock.js","../src/http-server/websocket-channel-subscribers.js","../src/http-server/websocket-channel.js","../src/http-server/websocket-connection.js","../src/http-server/websocket-event-log-store.js","../src/http-server/websocket-events-host.js","../src/http-server/websocket-events.js","../src/http-server/client/index.js","../src/http-server/client/params-to-object.js","../src/http-server/client/request-parser.js","../src/http-server/client/request-runner.js","../src/http-server/client/request-timing.js","../src/http-server/client/request.js","../src/http-server/client/response.js","../src/http-server/client/websocket-request.js","../src/http-server/client/websocket-session.js","../src/http-server/client/request-buffer/form-data-part.js","../src/http-server/client/request-buffer/header.js","../src/http-server/client/request-buffer/index.js","../src/http-server/client/uploaded-file/memory-uploaded-file.js","../src/http-server/client/uploaded-file/temporary-uploaded-file.js","../src/http-server/client/uploaded-file/uploaded-file.js","../src/http-server/worker-handler/channel-subscriber-dispatch.js","../src/http-server/worker-handler/in-process.js","../src/http-server/worker-handler/index.js","../src/http-server/worker-handler/worker-script.js","../src/http-server/worker-handler/worker-thread.js","../src/jobs/mail-delivery.js","../src/jobs/prune-terminal-background-jobs.js","../src/logger/base-logger.js","../src/logger/console-logger.js","../src/logger/file-logger.js","../src/logger/outputs/array-output.js","../src/logger/outputs/console-output.js","../src/logger/outputs/file-output.js","../src/logger/outputs/stdout-output.js","../src/mailer/base.js","../src/mailer/delivery.js","../src/mailer/index.js","../src/mailer/backends/smtp.js","../src/packages/velocious-package.js","../src/plugins/sqljs-wasm-route-controller.js","../src/plugins/sqljs-wasm-route.js","../src/routes/app-routes.js","../src/routes/base-route.js","../src/routes/basic-route.js","../src/routes/get-route.js","../src/routes/index.js","../src/routes/namespace-route.js","../src/routes/plugin-routes.js","../src/routes/post-route.js","../src/routes/resolver.js","../src/routes/resource-route.js","../src/routes/root-route.js","../src/routes/built-in/api-manifest/controller.js","../src/routes/built-in/debug/controller.js","../src/routes/built-in/errors/controller.js","../src/routes/hooks/frontend-model-command-route-hook.js","../src/sync/conflict-strategy.js","../src/sync/device-identity.js","../src/sync/local-mutation-log.js","../src/sync/offline-grant.js","../src/sync/peer-mutation-bundle.js","../src/sync/query-scope.js","../src/sync/server-change-feed.js","../src/sync/server-sequence-allocator.js","../src/sync/stable-json.js","../src/sync/sync-api-client-types.js","../src/sync/sync-api-client.js","../src/sync/sync-api-controller.js","../src/sync/sync-change-fanout.js","../src/sync/sync-channel-name.js","../src/sync/sync-client-registry.js","../src/sync/sync-client-types.js","../src/sync/sync-client.js","../src/sync/sync-envelope-replay-service.js","../src/sync/sync-model-change-feed-service.js","../src/sync/sync-publish-suppression.js","../src/sync/sync-publisher-types.js","../src/sync/sync-publisher.js","../src/sync/sync-realtime-bridge.js","../src/sync/sync-replay-upsert-applier.js","../src/sync/sync-resource-base.js","../src/sync/sync-scope-attributes.js","../src/sync/sync-scope-store.js","../src/sync/sync-websocket-channel.js","../src/tenants/default-tenant-database-provisioning.js","../src/tenants/tenant-aggregator.js","../src/tenants/tenant-iterator.js","../src/tenants/tenant.js","../src/testing/base-expect.js","../src/testing/browser-frontend-model-event-hook-scenarios.js","../src/testing/browser-test-app.js","../src/testing/expect-to-change.js","../src/testing/expect-utils.js","../src/testing/expect.js","../src/testing/request-client.js","../src/testing/test-files-finder.js","../src/testing/test-filter-parser.js","../src/testing/test-runner.js","../src/testing/test-suite-splitter.js","../src/testing/test.js","../src/types/external-modules.d.ts","../src/utils/backtrace-cleaner-node.js","../src/utils/backtrace-cleaner.js","../src/utils/deburr-column-name.js","../src/utils/event-emitter.js","../src/utils/file-exists.js","../src/utils/format-value.js","../src/utils/is-date.js","../src/utils/model-scope.js","../src/utils/nest-callbacks.js","../src/utils/plain-object.js","../src/utils/ransack.js","../src/utils/rest-args-error.js","../src/utils/singularize-model-name.js","../src/utils/split-sql-statements.js","../src/utils/to-import-specifier.js","../src/utils/with-tracked-stack-async-hooks.js","../src/utils/with-tracked-stack.js"],"version":"6.0.3"}
+{"root":["../index.js","../bin/velocious.js","../src/application.js","../src/configuration-resolver.js","../src/configuration-types.js","../src/configuration.js","../src/controller.js","../src/current-configuration.js","../src/current.js","../src/error-logger.js","../src/frontend-model-controller.js","../src/initializer.js","../src/logger.js","../src/mailer.js","../src/record-payload-values.js","../src/time-zone.js","../src/velocious-error.js","../src/authorization/ability.js","../src/authorization/base-resource.js","../src/background-jobs/client.js","../src/background-jobs/cron-expression.js","../src/background-jobs/forked-runner-child.js","../src/background-jobs/job-record.js","../src/background-jobs/job-registry.js","../src/background-jobs/job-runner.js","../src/background-jobs/job.js","../src/background-jobs/json-socket.js","../src/background-jobs/main.js","../src/background-jobs/normalize-error.js","../src/background-jobs/pooled-runner-child.js","../src/background-jobs/runner-process-title.js","../src/background-jobs/scheduler.js","../src/background-jobs/socket-request.js","../src/background-jobs/status-reporter.js","../src/background-jobs/store.js","../src/background-jobs/types.js","../src/background-jobs/worker.js","../src/background-jobs/web/authorization.js","../src/background-jobs/web/controller.js","../src/background-jobs/web/index.js","../src/background-jobs/web/path-matcher.js","../src/background-jobs/web/registry.js","../src/beacon/client.js","../src/beacon/in-process-broker.js","../src/beacon/in-process-client.js","../src/beacon/server.js","../src/beacon/types.js","../src/cli/base-command.js","../src/cli/browser-cli.js","../src/cli/index.js","../src/cli/tenant-database-command-helper.js","../src/cli/use-browser-cli.js","../src/cli/commands/background-jobs-main.js","../src/cli/commands/background-jobs-runner.js","../src/cli/commands/background-jobs-worker.js","../src/cli/commands/beacon.js","../src/cli/commands/console.js","../src/cli/commands/init.js","../src/cli/commands/routes.js","../src/cli/commands/run-script.js","../src/cli/commands/runner.js","../src/cli/commands/server.js","../src/cli/commands/test.js","../src/cli/commands/db/base-command.js","../src/cli/commands/db/create.js","../src/cli/commands/db/drop.js","../src/cli/commands/db/migrate.js","../src/cli/commands/db/reset.js","../src/cli/commands/db/rollback.js","../src/cli/commands/db/seed.js","../src/cli/commands/db/schema/dump.js","../src/cli/commands/db/schema/load.js","../src/cli/commands/db/tenants/check.js","../src/cli/commands/db/tenants/create.js","../src/cli/commands/db/tenants/drop.js","../src/cli/commands/db/tenants/migrate.js","../src/cli/commands/destroy/migration.js","../src/cli/commands/generate/base-models.js","../src/cli/commands/generate/frontend-models.js","../src/cli/commands/generate/migration.js","../src/cli/commands/generate/model.js","../src/cli/commands/lint/relationships.js","../src/database/advisory-lock-runner.js","../src/database/annotations-async-hooks.js","../src/database/annotations.js","../src/database/column-types.js","../src/database/datetime-storage.js","../src/database/handler.js","../src/database/initializer-from-require-context.js","../src/database/live-query.js","../src/database/migrations-ledger.js","../src/database/migrator.js","../src/database/record-changes.js","../src/database/use-database.js","../src/database/use-live-query.js","../src/database/drivers/base-column.js","../src/database/drivers/base-columns-index.js","../src/database/drivers/base-foreign-key.js","../src/database/drivers/base-table.js","../src/database/drivers/base.js","../src/database/drivers/mssql/column.js","../src/database/drivers/mssql/columns-index.js","../src/database/drivers/mssql/connect-connection.js","../src/database/drivers/mssql/foreign-key.js","../src/database/drivers/mssql/index.js","../src/database/drivers/mssql/options.js","../src/database/drivers/mssql/query-parser.js","../src/database/drivers/mssql/structure-sql.js","../src/database/drivers/mssql/table.js","../src/database/drivers/mssql/sql/alter-table.js","../src/database/drivers/mssql/sql/create-database.js","../src/database/drivers/mssql/sql/create-index.js","../src/database/drivers/mssql/sql/create-table.js","../src/database/drivers/mssql/sql/delete.js","../src/database/drivers/mssql/sql/drop-database.js","../src/database/drivers/mssql/sql/drop-table.js","../src/database/drivers/mssql/sql/insert.js","../src/database/drivers/mssql/sql/remove-index.js","../src/database/drivers/mssql/sql/update.js","../src/database/drivers/mssql/sql/upsert.js","../src/database/drivers/mysql/column.js","../src/database/drivers/mysql/columns-index.js","../src/database/drivers/mysql/foreign-key.js","../src/database/drivers/mysql/index.js","../src/database/drivers/mysql/options.js","../src/database/drivers/mysql/query-parser.js","../src/database/drivers/mysql/query-stream.js","../src/database/drivers/mysql/query.js","../src/database/drivers/mysql/structure-sql.js","../src/database/drivers/mysql/table.js","../src/database/drivers/mysql/sql/alter-table.js","../src/database/drivers/mysql/sql/create-database.js","../src/database/drivers/mysql/sql/create-index.js","../src/database/drivers/mysql/sql/create-table.js","../src/database/drivers/mysql/sql/delete.js","../src/database/drivers/mysql/sql/drop-database.js","../src/database/drivers/mysql/sql/drop-table.js","../src/database/drivers/mysql/sql/insert.js","../src/database/drivers/mysql/sql/remove-index.js","../src/database/drivers/mysql/sql/update.js","../src/database/drivers/mysql/sql/upsert.js","../src/database/drivers/pgsql/column.js","../src/database/drivers/pgsql/columns-index.js","../src/database/drivers/pgsql/foreign-key.js","../src/database/drivers/pgsql/index.js","../src/database/drivers/pgsql/options.js","../src/database/drivers/pgsql/query-parser.js","../src/database/drivers/pgsql/structure-sql.js","../src/database/drivers/pgsql/table.js","../src/database/drivers/pgsql/sql/alter-table.js","../src/database/drivers/pgsql/sql/create-database.js","../src/database/drivers/pgsql/sql/create-index.js","../src/database/drivers/pgsql/sql/create-table.js","../src/database/drivers/pgsql/sql/delete.js","../src/database/drivers/pgsql/sql/drop-database.js","../src/database/drivers/pgsql/sql/drop-table.js","../src/database/drivers/pgsql/sql/insert.js","../src/database/drivers/pgsql/sql/remove-index.js","../src/database/drivers/pgsql/sql/update.js","../src/database/drivers/pgsql/sql/upsert.js","../src/database/drivers/sqlite/base.js","../src/database/drivers/sqlite/column.js","../src/database/drivers/sqlite/columns-index.js","../src/database/drivers/sqlite/connection-sql-js.js","../src/database/drivers/sqlite/foreign-key.js","../src/database/drivers/sqlite/index.js","../src/database/drivers/sqlite/index.native.js","../src/database/drivers/sqlite/index.web.js","../src/database/drivers/sqlite/options.js","../src/database/drivers/sqlite/query-parser.js","../src/database/drivers/sqlite/query.js","../src/database/drivers/sqlite/query.native.js","../src/database/drivers/sqlite/query.web.js","../src/database/drivers/sqlite/structure-sql.js","../src/database/drivers/sqlite/table-rebuilder.js","../src/database/drivers/sqlite/table.js","../src/database/drivers/sqlite/web-persistence.js","../src/database/drivers/sqlite/sql/alter-table.js","../src/database/drivers/sqlite/sql/create-index.js","../src/database/drivers/sqlite/sql/create-table.js","../src/database/drivers/sqlite/sql/delete.js","../src/database/drivers/sqlite/sql/drop-table.js","../src/database/drivers/sqlite/sql/insert.js","../src/database/drivers/sqlite/sql/remove-index.js","../src/database/drivers/sqlite/sql/update.js","../src/database/drivers/sqlite/sql/upsert.js","../src/database/drivers/structure-sql/utils.js","../src/database/migration/index.js","../src/database/migrator/files-finder.js","../src/database/migrator/types.js","../src/database/pool/async-tracked-multi-connection.js","../src/database/pool/base-methods-forward.js","../src/database/pool/base.js","../src/database/pool/single-multi-use.js","../src/database/query/alter-table-base.js","../src/database/query/base.js","../src/database/query/create-database-base.js","../src/database/query/create-index-base.js","../src/database/query/create-table-base.js","../src/database/query/delete-base.js","../src/database/query/drop-database-base.js","../src/database/query/drop-table-base.js","../src/database/query/from-base.js","../src/database/query/from-plain.js","../src/database/query/from-table.js","../src/database/query/index.js","../src/database/query/insert-base.js","../src/database/query/join-base.js","../src/database/query/join-object.js","../src/database/query/join-plain.js","../src/database/query/join-tracker.js","../src/database/query/model-class-query.js","../src/database/query/order-base.js","../src/database/query/order-column.js","../src/database/query/order-plain.js","../src/database/query/preloader.js","../src/database/query/query-data.js","../src/database/query/remove-index-base.js","../src/database/query/select-base.js","../src/database/query/select-plain.js","../src/database/query/select-table-and-column.js","../src/database/query/update-base.js","../src/database/query/upsert-base.js","../src/database/query/where-base.js","../src/database/query/where-combinator.js","../src/database/query/where-hash.js","../src/database/query/where-model-class-hash.js","../src/database/query/where-not.js","../src/database/query/where-plain.js","../src/database/query/with-count.js","../src/database/query/preloader/belongs-to.js","../src/database/query/preloader/ensure-model-class-initialized.js","../src/database/query/preloader/has-many.js","../src/database/query/preloader/has-one.js","../src/database/query/preloader/selection.js","../src/database/query-parser/base-query-parser.js","../src/database/query-parser/from-parser.js","../src/database/query-parser/group-parser.js","../src/database/query-parser/joins-parser.js","../src/database/query-parser/limit-parser.js","../src/database/query-parser/options.js","../src/database/query-parser/order-parser.js","../src/database/query-parser/select-parser.js","../src/database/query-parser/where-parser.js","../src/database/record/acts-as-list.js","../src/database/record/auditing.js","../src/database/record/counter-cache-magnitude.js","../src/database/record/index.js","../src/database/record/record-not-found-error.js","../src/database/record/state-machine.js","../src/database/record/user-module.js","../src/database/record/validation-messages.js","../src/database/record/attachments/attachment-record.js","../src/database/record/attachments/download.js","../src/database/record/attachments/handle.js","../src/database/record/attachments/normalize-input.js","../src/database/record/attachments/store.js","../src/database/record/attachments/storage-drivers/filesystem.js","../src/database/record/attachments/storage-drivers/native.js","../src/database/record/attachments/storage-drivers/s3.js","../src/database/record/instance-relationships/base.js","../src/database/record/instance-relationships/belongs-to.js","../src/database/record/instance-relationships/has-many.js","../src/database/record/instance-relationships/has-one.js","../src/database/record/relationships/base.js","../src/database/record/relationships/belongs-to.js","../src/database/record/relationships/has-many.js","../src/database/record/relationships/has-one.js","../src/database/record/validators/base.js","../src/database/record/validators/format.js","../src/database/record/validators/length.js","../src/database/record/validators/presence.js","../src/database/record/validators/uniqueness.js","../src/database/table-data/index.js","../src/database/table-data/table-column.js","../src/database/table-data/table-foreign-key.js","../src/database/table-data/table-index.js","../src/database/table-data/table-reference.js","../src/database/tenants/data-copier.js","../src/database/tenants/schema-cloner.js","../src/database/tenants/tenant-table-plan.js","../src/environment-handlers/base.js","../src/environment-handlers/browser.js","../src/environment-handlers/node.js","../src/environment-handlers/node/cli/commands/background-jobs-main.js","../src/environment-handlers/node/cli/commands/background-jobs-runner.js","../src/environment-handlers/node/cli/commands/background-jobs-worker.js","../src/environment-handlers/node/cli/commands/beacon.js","../src/environment-handlers/node/cli/commands/cli-command-context.js","../src/environment-handlers/node/cli/commands/console.js","../src/environment-handlers/node/cli/commands/init.js","../src/environment-handlers/node/cli/commands/routes.js","../src/environment-handlers/node/cli/commands/run-script.js","../src/environment-handlers/node/cli/commands/runner.js","../src/environment-handlers/node/cli/commands/server.js","../src/environment-handlers/node/cli/commands/test.js","../src/environment-handlers/node/cli/commands/db/seed.js","../src/environment-handlers/node/cli/commands/db/schema/dump.js","../src/environment-handlers/node/cli/commands/db/schema/load.js","../src/environment-handlers/node/cli/commands/destroy/migration.js","../src/environment-handlers/node/cli/commands/generate/base-models.js","../src/environment-handlers/node/cli/commands/generate/frontend-models.js","../src/environment-handlers/node/cli/commands/generate/generated-file-banner.js","../src/environment-handlers/node/cli/commands/generate/migration.js","../src/environment-handlers/node/cli/commands/generate/model.js","../src/environment-handlers/node/cli/commands/lint/relationships.js","../src/error-reporting/request-details.js","../src/frontend-model-resource/base-resource.js","../src/frontend-model-resource/velocious-attachment-resource.js","../src/frontend-models/base.js","../src/frontend-models/built-in-resources.js","../src/frontend-models/clear-pending-debounced-callback.js","../src/frontend-models/event-hook-models.js","../src/frontend-models/model-registry.js","../src/frontend-models/outgoing-event-buffer.js","../src/frontend-models/preloader.js","../src/frontend-models/query.js","../src/frontend-models/resource-config-validation.js","../src/frontend-models/resource-definition.js","../src/frontend-models/transport-serialization.js","../src/frontend-models/use-created-event.js","../src/frontend-models/use-destroyed-event.js","../src/frontend-models/use-model-class-event.js","../src/frontend-models/use-updated-event.js","../src/frontend-models/websocket-channel.js","../src/frontend-models/websocket-publishers.js","../src/http-client/header.js","../src/http-client/index.js","../src/http-client/request.js","../src/http-client/response.js","../src/http-client/websocket-client.js","../src/http-server/cookie.js","../src/http-server/development-reloader.js","../src/http-server/index.js","../src/http-server/remote-address.js","../src/http-server/server-client.js","../src/http-server/server-lock.js","../src/http-server/websocket-channel-subscribers.js","../src/http-server/websocket-channel.js","../src/http-server/websocket-connection.js","../src/http-server/websocket-event-log-store.js","../src/http-server/websocket-events-host.js","../src/http-server/websocket-events.js","../src/http-server/client/index.js","../src/http-server/client/params-to-object.js","../src/http-server/client/request-parser.js","../src/http-server/client/request-runner.js","../src/http-server/client/request-timing.js","../src/http-server/client/request.js","../src/http-server/client/response.js","../src/http-server/client/websocket-request.js","../src/http-server/client/websocket-session.js","../src/http-server/client/request-buffer/form-data-part.js","../src/http-server/client/request-buffer/header.js","../src/http-server/client/request-buffer/index.js","../src/http-server/client/uploaded-file/memory-uploaded-file.js","../src/http-server/client/uploaded-file/temporary-uploaded-file.js","../src/http-server/client/uploaded-file/uploaded-file.js","../src/http-server/worker-handler/channel-subscriber-dispatch.js","../src/http-server/worker-handler/in-process.js","../src/http-server/worker-handler/index.js","../src/http-server/worker-handler/worker-script.js","../src/http-server/worker-handler/worker-thread.js","../src/jobs/mail-delivery.js","../src/jobs/prune-terminal-background-jobs.js","../src/logger/base-logger.js","../src/logger/console-logger.js","../src/logger/file-logger.js","../src/logger/outputs/array-output.js","../src/logger/outputs/console-output.js","../src/logger/outputs/file-output.js","../src/logger/outputs/stdout-output.js","../src/mailer/base.js","../src/mailer/delivery.js","../src/mailer/index.js","../src/mailer/backends/smtp.js","../src/packages/velocious-package.js","../src/plugins/sqljs-wasm-route-controller.js","../src/plugins/sqljs-wasm-route.js","../src/routes/app-routes.js","../src/routes/base-route.js","../src/routes/basic-route.js","../src/routes/get-route.js","../src/routes/index.js","../src/routes/namespace-route.js","../src/routes/plugin-routes.js","../src/routes/post-route.js","../src/routes/resolver.js","../src/routes/resource-route.js","../src/routes/root-route.js","../src/routes/built-in/api-manifest/controller.js","../src/routes/built-in/debug/controller.js","../src/routes/built-in/errors/controller.js","../src/routes/hooks/frontend-model-command-route-hook.js","../src/sync/conflict-strategy.js","../src/sync/device-identity.js","../src/sync/local-mutation-log.js","../src/sync/offline-grant.js","../src/sync/peer-mutation-bundle.js","../src/sync/query-scope.js","../src/sync/server-change-feed.js","../src/sync/server-sequence-allocator.js","../src/sync/stable-json.js","../src/sync/sync-api-client-types.js","../src/sync/sync-api-client.js","../src/sync/sync-api-controller.js","../src/sync/sync-change-fanout.js","../src/sync/sync-channel-name.js","../src/sync/sync-client-registry.js","../src/sync/sync-client-types.js","../src/sync/sync-client.js","../src/sync/sync-envelope-replay-service.js","../src/sync/sync-model-change-feed-service.js","../src/sync/sync-publish-suppression.js","../src/sync/sync-publisher-types.js","../src/sync/sync-publisher.js","../src/sync/sync-realtime-bridge.js","../src/sync/sync-replay-upsert-applier.js","../src/sync/sync-resource-base.js","../src/sync/sync-scope-attributes.js","../src/sync/sync-scope-store.js","../src/sync/sync-websocket-channel.js","../src/tenants/default-tenant-database-provisioning.js","../src/tenants/tenant-aggregator.js","../src/tenants/tenant-iterator.js","../src/tenants/tenant.js","../src/testing/base-expect.js","../src/testing/browser-frontend-model-event-hook-scenarios.js","../src/testing/browser-test-app.js","../src/testing/expect-to-change.js","../src/testing/expect-utils.js","../src/testing/expect.js","../src/testing/request-client.js","../src/testing/test-files-finder.js","../src/testing/test-filter-parser.js","../src/testing/test-runner.js","../src/testing/test-suite-splitter.js","../src/testing/test.js","../src/types/external-modules.d.ts","../src/utils/backtrace-cleaner-node.js","../src/utils/backtrace-cleaner.js","../src/utils/deburr-column-name.js","../src/utils/event-emitter.js","../src/utils/file-exists.js","../src/utils/format-value.js","../src/utils/is-date.js","../src/utils/model-scope.js","../src/utils/nest-callbacks.js","../src/utils/plain-object.js","../src/utils/ransack.js","../src/utils/rest-args-error.js","../src/utils/singularize-model-name.js","../src/utils/split-sql-statements.js","../src/utils/to-import-specifier.js","../src/utils/with-tracked-stack-async-hooks.js","../src/utils/with-tracked-stack.js"],"version":"6.0.3"}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.535",
+  "version": "1.0.537",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/database/drivers/base.js

@@ -47,6 +47,7 @@
  * @typedef {object} RetryableDatabaseErrorResult
  * @property {boolean} retry - Whether the error should be retried.
  * @property {boolean} reconnect - Whether to reconnect before retrying.
+ * @property {boolean} [deadlock] - Whether the error is a transaction deadlock/lock-wait-timeout that should retry the whole transaction.
  * @property {number} [maxTries] - Override the max retry attempts.
  * @property {number} [waitMs] - Wait time before retrying in milliseconds.
  */
@@ -851,11 +852,50 @@ export default class VelociousDatabaseDriversBase {
   }
 
   /**
-   * Runs transaction.
+   * Runs a callback inside a database transaction (or a savepoint when already inside one).
+   * The outermost transaction retries the whole callback on a deadlock / lock-wait-timeout,
+   * because such errors roll the entire transaction back and the standard recovery is to
+   * restart it. Nested savepoints let the deadlock bubble up to this outer retry.
    * @param {() => Promise<void>} callback - Callback function.
-   * @returns {Promise<?>} - Resolves with the transaction.
+   * @returns {Promise<?>} - Resolves with the transaction result.
    */
   async transaction(callback) {
+    if (this._transactionsCount > 0) {
+      return await this._runTransactionAttempt(callback)
+    }
+
+    const maxAttempts = 5
+    let attempt = 0
+
+    while (true) {
+      attempt++
+
+      try {
+        return await this._runTransactionAttempt(callback)
+      } catch (error) {
+        const retryInfo = error instanceof Error ? this.retryableDatabaseError(error) : {retry: false, reconnect: false}
+
+        if (retryInfo.deadlock && attempt < maxAttempts && this._transactionsCount == 0) {
+          const baseWaitMs = typeof retryInfo.waitMs == "number" && retryInfo.waitMs > 0 ? retryInfo.waitMs : 50
+
+          this.logger.warn(`Retrying transaction after deadlock (attempt ${attempt}/${maxAttempts})`)
+          await wait(baseWaitMs * attempt)
+          continue
+        }
+
+        throw error
+      }
+    }
+  }
+
+  /**
+   * Runs a single transaction attempt: starts a transaction (or a savepoint when nested), runs
+   * `callback`, and commits — rolling back on error. {@link transaction} wraps this with deadlock
+   * retry at the outermost level.
+   * @param {() => Promise<void>} callback - Callback function.
+   * @returns {Promise<?>} - Resolves with the transaction result.
+   */
+  async _runTransactionAttempt(callback) {
     const savePointName = this.generateSavePointName()
     /**
      * Callback frame.
@@ -919,7 +959,11 @@ export default class VelociousDatabaseDriversBase {
         }
       }
 
-      if (transactionStarted && !transactionRolledBack) {
+      // Only roll back if a transaction is still open. A nested savepoint whose rollback failed
+      // falls back to rolling back the whole transaction (above), which already closed it and
+      // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive
+      // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.
+      if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {
         this.logger.debug("Rollback transaction")
         await this.rollbackTransaction()
       }
@@ -1014,6 +1058,23 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * Streams the rows of `sql` one at a time instead of buffering the whole result set, so a
+   * caller can process an arbitrarily large result with bounded memory. This base implementation
+   * falls back to a buffered {@link query} and yields its rows; drivers backed by a cursor-capable
+   * client (the MySQL driver) override it with true server-side streaming.
+   * @param {string} sql - SQL string to stream.
+   * @param {QueryOptions} [options] - Query options, as for {@link query}.
+   * @yields {Record<string, unknown>} - The result rows, one at a time.
+   */
+  async *queryStream(sql, options = {}) {
+    const rows = await this.query(sql, options)
+
+    for (const row of Array.isArray(rows) ? rows : []) {
+      yield row
+    }
+  }
+
   /**
    * Runs query.
    * @param {string} sql - SQL string.