velocious 1.0.482 → 1.0.483

package/build/src/cli/tenant-database-command-helper.js

@@ -1,4 +1,5 @@
 // @ts-check
+import TenantIterator from "../tenants/tenant-iterator.js";
 export default class TenantDatabaseCommandHelper {
     /**
      * Runs constructor.
@@ -64,43 +65,12 @@ export default class TenantDatabaseCommandHelper {
      */
     async eachTenant(callback) {
         const tenants = await this.listTenants();
-        const parallelCount = this.parallelCount();
-        if (parallelCount <= 1) {
-            for (const tenant of tenants) {
-                await this.runTenantCallback({ callback, tenant });
-            }
-            return tenants.length;
-        }
-        /**
-         * Failures.
-         * @type {Array<{error: Error, tenant: ?}>} */
-        const failures = [];
-        const workers = [];
-        let tenantIndex = 0;
-        const workerCount = Math.min(parallelCount, tenants.length);
-        for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) {
-            workers.push((async () => {
-                while (tenantIndex < tenants.length) {
-                    const tenant = tenants[tenantIndex];
-                    tenantIndex++;
-                    try {
-                        await this.runTenantCallback({ callback, tenant });
-                    }
-                    catch (error) {
-                        failures.push({
-                            error: error instanceof Error ? error : new Error(String(error)),
-                            tenant
-                        });
-                    }
-                }
-            })());
-        }
-        await Promise.all(workers);
-        if (failures.length > 0) {
-            const failedTenantLabels = failures.map((failure) => this.tenantLabel(failure.tenant)).join(", ");
-            throw new AggregateError(failures.map((failure) => failure.error), `Failed tenant database command for tenant(s): ${failedTenantLabels}`);
-        }
-        return tenants.length;
+        const iterator = new TenantIterator({
+            configuration: this.configuration,
+            identifier: this.identifier,
+            parallelCount: this.parallelCount()
+        });
+        return await iterator.run(tenants, callback);
     }
     /**
      * Runs parallel count.
@@ -126,40 +96,5 @@ export default class TenantDatabaseCommandHelper {
         }
         return parallelCount;
     }
-    /**
-     * Runs run tenant callback.
-     * @param {object} args - Tenant callback args.
-     * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} args.callback - Callback.
-     * @param {?} args.tenant - Tenant.
-     * @returns {Promise<void>}
-     */
-    async runTenantCallback({ callback, tenant }) {
-        await this.configuration.runWithTenant(tenant, async () => {
-            if (!this.configuration.isDatabaseIdentifierActive(this.identifier)) {
-                throw new Error(`Tenant database identifier ${this.identifier} is inactive for tenant: ${this.tenantLabel(tenant)}`);
-            }
-            await callback({
-                databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),
-                tenant
-            });
-        });
-    }
-    /**
-     * Runs tenant label.
-     * @param {?} tenant - Tenant.
-     * @returns {string} - Human readable tenant label.
-     */
-    tenantLabel(tenant) {
-        if (tenant && typeof tenant === "object") {
-            const tenantObject = /** @type {{id?: ?, name?: ?, slug?: ?}} */ (tenant);
-            if (tenantObject.slug)
-                return String(tenantObject.slug);
-            if (tenantObject.name)
-                return String(tenantObject.name);
-            if (tenantObject.id)
-                return String(tenantObject.id);
-        }
-        return JSON.stringify(tenant);
-    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-database-command-helper.js","sourceRoot":"","sources":["../../../src/cli/tenant-database-command-helper.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nexport default class TenantDatabaseCommandHelper {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"./base-command.js\").default} args.command - CLI command instance.\n   * @param {string | undefined} args.identifier - Tenant database identifier.\n   */\n  constructor({command, identifier}) {\n    if (!identifier) throw new Error(\"Missing tenant database identifier argument\")\n\n    this.command = command\n    this.configuration = command.getConfiguration()\n    this.identifier = identifier\n    this.provider = this.configuration.getTenantDatabaseProvider(identifier)\n  }\n\n  /**\n   * Runs validate tenant database identifier.\n   * @returns {void} */\n  validateTenantDatabaseIdentifier() {\n    const databaseConfiguration = this.configuration.getDatabaseConfiguration()[this.identifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`No such database identifier configured: ${this.identifier}`)\n    }\n\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`Database identifier ${this.identifier} is not configured with tenantOnly: true`)\n    }\n\n    if (this.configuration.getDisabledDatabaseIdentifiers().has(this.identifier)) {\n      throw new Error(`Tenant database identifier ${this.identifier} is disabled by VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS`)\n    }\n\n    if (typeof this.provider.listTenants !== \"function\") {\n      throw new Error(`Tenant database provider for ${this.identifier} must define listTenants`)\n    }\n  }\n\n  /**\n   * Runs initialize runtime.\n   * @returns {Promise<void>} - Resolves when app runtime is initialized.\n   */\n  async initializeRuntime() {\n    await this.configuration.initialize({type: \"db-tenants\"})\n  }\n\n  /**\n   * Runs list tenants.\n   * @returns {Promise<Array<?>>} - Tenants.\n   */\n  async listTenants() {\n    this.validateTenantDatabaseIdentifier()\n    await this.initializeRuntime()\n\n    const tenants = await this.configuration.ensureConnections({name: `Tenant database list: ${this.identifier}`}, async () => {\n      return await this.provider.listTenants({\n        configuration: this.configuration,\n        identifier: this.identifier\n      })\n    })\n\n    if (!Array.isArray(tenants)) {\n      throw new Error(`Tenant database provider for ${this.identifier} must return an array from listTenants`)\n    }\n\n    return tenants\n  }\n\n  /**\n   * Runs each tenant.\n   * @param {function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback - Callback.\n   * @returns {Promise<number>} - Number of tenants processed.\n   */\n  async eachTenant(callback) {\n    const tenants = await this.listTenants()\n    const parallelCount = this.parallelCount()\n\n    if (parallelCount <= 1) {\n      for (const tenant of tenants) {\n        await this.runTenantCallback({callback, tenant})\n      }\n\n      return tenants.length\n    }\n\n    /**\n     * Failures.\n     * @type {Array<{error: Error, tenant: ?}>} */\n    const failures = []\n    const workers = []\n    let tenantIndex = 0\n    const workerCount = Math.min(parallelCount, tenants.length)\n\n    for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) {\n      workers.push((async () => {\n        while (tenantIndex < tenants.length) {\n          const tenant = tenants[tenantIndex]\n\n          tenantIndex++\n\n          try {\n            await this.runTenantCallback({callback, tenant})\n          } catch (error) {\n            failures.push({\n              error: error instanceof Error ? error : new Error(String(error)),\n              tenant\n            })\n          }\n        }\n      })())\n    }\n\n    await Promise.all(workers)\n\n    if (failures.length > 0) {\n      const failedTenantLabels = failures.map((failure) => this.tenantLabel(failure.tenant)).join(\", \")\n\n      throw new AggregateError(\n        failures.map((failure) => failure.error),\n        `Failed tenant database command for tenant(s): ${failedTenantLabels}`\n      )\n    }\n\n    return tenants.length\n  }\n\n  /**\n   * Runs parallel count.\n   * @returns {number} - Number of tenants to process concurrently.\n   */\n  parallelCount() {\n    const parsedProcessArgs = this.command.args?.parsedProcessArgs || {}\n    let parallelArg = parsedProcessArgs.parallel\n\n    if (parallelArg === undefined) {\n      const parallelArgIndex = this.command.processArgs?.indexOf(\"--parallel\") ?? -1\n\n      if (parallelArgIndex >= 0) {\n        const nextArg = this.command.processArgs?.[parallelArgIndex + 1]\n\n        parallelArg = nextArg && !nextArg.startsWith(\"-\") ? nextArg : true\n      }\n    }\n\n    if (parallelArg === undefined || parallelArg === false) return 1\n    if (parallelArg === true) return 20\n\n    const parallelCount = Number(parallelArg)\n\n    if (!Number.isInteger(parallelCount) || parallelCount < 1) {\n      throw new Error(`--parallel must be a positive integer when a value is provided: ${parallelArg}`)\n    }\n\n    return parallelCount\n  }\n\n  /**\n   * Runs run tenant callback.\n   * @param {object} args - Tenant callback args.\n   * @param {function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>} args.callback - Callback.\n   * @param {?} args.tenant - Tenant.\n   * @returns {Promise<void>}\n   */\n  async runTenantCallback({callback, tenant}) {\n    await this.configuration.runWithTenant(tenant, async () => {\n      if (!this.configuration.isDatabaseIdentifierActive(this.identifier)) {\n        throw new Error(`Tenant database identifier ${this.identifier} is inactive for tenant: ${this.tenantLabel(tenant)}`)\n      }\n\n      await callback({\n        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),\n        tenant\n      })\n    })\n  }\n\n  /**\n   * Runs tenant label.\n   * @param {?} tenant - Tenant.\n   * @returns {string} - Human readable tenant label.\n   */\n  tenantLabel(tenant) {\n    if (tenant && typeof tenant === \"object\") {\n      const tenantObject = /** @type {{id?: ?, name?: ?, slug?: ?}} */ (tenant)\n\n      if (tenantObject.slug) return String(tenantObject.slug)\n      if (tenantObject.name) return String(tenantObject.name)\n      if (tenantObject.id) return String(tenantObject.id)\n    }\n\n    return JSON.stringify(tenant)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-database-command-helper.js","sourceRoot":"","sources":["../../../src/cli/tenant-database-command-helper.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport TenantIterator from \"../tenants/tenant-iterator.js\"\n\nexport default class TenantDatabaseCommandHelper {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"./base-command.js\").default} args.command - CLI command instance.\n   * @param {string | undefined} args.identifier - Tenant database identifier.\n   */\n  constructor({command, identifier}) {\n    if (!identifier) throw new Error(\"Missing tenant database identifier argument\")\n\n    this.command = command\n    this.configuration = command.getConfiguration()\n    this.identifier = identifier\n    this.provider = this.configuration.getTenantDatabaseProvider(identifier)\n  }\n\n  /**\n   * Runs validate tenant database identifier.\n   * @returns {void} */\n  validateTenantDatabaseIdentifier() {\n    const databaseConfiguration = this.configuration.getDatabaseConfiguration()[this.identifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`No such database identifier configured: ${this.identifier}`)\n    }\n\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`Database identifier ${this.identifier} is not configured with tenantOnly: true`)\n    }\n\n    if (this.configuration.getDisabledDatabaseIdentifiers().has(this.identifier)) {\n      throw new Error(`Tenant database identifier ${this.identifier} is disabled by VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS`)\n    }\n\n    if (typeof this.provider.listTenants !== \"function\") {\n      throw new Error(`Tenant database provider for ${this.identifier} must define listTenants`)\n    }\n  }\n\n  /**\n   * Runs initialize runtime.\n   * @returns {Promise<void>} - Resolves when app runtime is initialized.\n   */\n  async initializeRuntime() {\n    await this.configuration.initialize({type: \"db-tenants\"})\n  }\n\n  /**\n   * Runs list tenants.\n   * @returns {Promise<Array<?>>} - Tenants.\n   */\n  async listTenants() {\n    this.validateTenantDatabaseIdentifier()\n    await this.initializeRuntime()\n\n    const tenants = await this.configuration.ensureConnections({name: `Tenant database list: ${this.identifier}`}, async () => {\n      return await this.provider.listTenants({\n        configuration: this.configuration,\n        identifier: this.identifier\n      })\n    })\n\n    if (!Array.isArray(tenants)) {\n      throw new Error(`Tenant database provider for ${this.identifier} must return an array from listTenants`)\n    }\n\n    return tenants\n  }\n\n  /**\n   * Runs each tenant.\n   * @param {function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback - Callback.\n   * @returns {Promise<number>} - Number of tenants processed.\n   */\n  async eachTenant(callback) {\n    const tenants = await this.listTenants()\n    const iterator = new TenantIterator({\n      configuration: this.configuration,\n      identifier: this.identifier,\n      parallelCount: this.parallelCount()\n    })\n\n    return await iterator.run(tenants, callback)\n  }\n\n  /**\n   * Runs parallel count.\n   * @returns {number} - Number of tenants to process concurrently.\n   */\n  parallelCount() {\n    const parsedProcessArgs = this.command.args?.parsedProcessArgs || {}\n    let parallelArg = parsedProcessArgs.parallel\n\n    if (parallelArg === undefined) {\n      const parallelArgIndex = this.command.processArgs?.indexOf(\"--parallel\") ?? -1\n\n      if (parallelArgIndex >= 0) {\n        const nextArg = this.command.processArgs?.[parallelArgIndex + 1]\n\n        parallelArg = nextArg && !nextArg.startsWith(\"-\") ? nextArg : true\n      }\n    }\n\n    if (parallelArg === undefined || parallelArg === false) return 1\n    if (parallelArg === true) return 20\n\n    const parallelCount = Number(parallelArg)\n\n    if (!Number.isInteger(parallelCount) || parallelCount < 1) {\n      throw new Error(`--parallel must be a positive integer when a value is provided: ${parallelArg}`)\n    }\n\n    return parallelCount\n  }\n}\n"]}

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/tenant-table-plan.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Describes how one table's rows are partitioned between tenants so a DataCopier can select
+ * the subset that belongs to a given tenant key.
+ *
+ * A row belongs to the tenant when its `keyColumn` equals the tenant key value, or — for
+ * tables that have no direct tenant column — when its `parentColumn` references a row of
+ * `parentTableName` that was itself already selected as belonging to the tenant. Exactly
+ * one of `keyColumn` or the (`parentTableName` + `parentColumn`) pair must be set; a
+ * parent-scoped entry must appear after its parent in the plan so the parent ids are known
+ * by the time the child is loaded.
+ */
+export type TenantTablePlanEntry = {
+    /**
+     * Name of the table whose rows are partitioned by tenant.
+     */
+    tableName: string;
+    /**
+     * Column matched directly against the tenant key value.
+     */
+    keyColumn?: string | undefined;
+    /**
+     * Earlier-in-plan table whose selected rows scope this one.
+     */
+    parentTableName?: string | undefined;
+    /**
+     * Column on this table referencing the parent table's primary key.
+     */
+    parentColumn?: string | undefined;
+};
+//# sourceMappingURL=tenant-table-plan.d.ts.map

package/build/src/database/tenants/tenant-table-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-table-plan.d.ts","sourceRoot":"","sources":["../../../../src/database/tenants/tenant-table-plan.js"],"names":[],"mappings":";;;;;;;;;;;;;;;eAac,MAAM"}

package/build/src/database/tenants/tenant-table-plan.js

@@ -0,0 +1,3 @@
+// @ts-check
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVuYW50LXRhYmxlLXBsYW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YWJhc2UvdGVuYW50cy90ZW5hbnQtdGFibGUtcGxhbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKlxuICogRGVzY3JpYmVzIGhvdyBvbmUgdGFibGUncyByb3dzIGFyZSBwYXJ0aXRpb25lZCBiZXR3ZWVuIHRlbmFudHMgc28gYSBEYXRhQ29waWVyIGNhbiBzZWxlY3RcbiAqIHRoZSBzdWJzZXQgdGhhdCBiZWxvbmdzIHRvIGEgZ2l2ZW4gdGVuYW50IGtleS5cbiAqXG4gKiBBIHJvdyBiZWxvbmdzIHRvIHRoZSB0ZW5hbnQgd2hlbiBpdHMgYGtleUNvbHVtbmAgZXF1YWxzIHRoZSB0ZW5hbnQga2V5IHZhbHVlLCBvciDigJQgZm9yXG4gKiB0YWJsZXMgdGhhdCBoYXZlIG5vIGRpcmVjdCB0ZW5hbnQgY29sdW1uIOKAlCB3aGVuIGl0cyBgcGFyZW50Q29sdW1uYCByZWZlcmVuY2VzIGEgcm93IG9mXG4gKiBgcGFyZW50VGFibGVOYW1lYCB0aGF0IHdhcyBpdHNlbGYgYWxyZWFkeSBzZWxlY3RlZCBhcyBiZWxvbmdpbmcgdG8gdGhlIHRlbmFudC4gRXhhY3RseVxuICogb25lIG9mIGBrZXlDb2x1bW5gIG9yIHRoZSAoYHBhcmVudFRhYmxlTmFtZWAgKyBgcGFyZW50Q29sdW1uYCkgcGFpciBtdXN0IGJlIHNldDsgYVxuICogcGFyZW50LXNjb3BlZCBlbnRyeSBtdXN0IGFwcGVhciBhZnRlciBpdHMgcGFyZW50IGluIHRoZSBwbGFuIHNvIHRoZSBwYXJlbnQgaWRzIGFyZSBrbm93blxuICogYnkgdGhlIHRpbWUgdGhlIGNoaWxkIGlzIGxvYWRlZC5cbiAqIEB0eXBlZGVmIHtvYmplY3R9IFRlbmFudFRhYmxlUGxhbkVudHJ5XG4gKiBAcHJvcGVydHkge3N0cmluZ30gdGFibGVOYW1lIE5hbWUgb2YgdGhlIHRhYmxlIHdob3NlIHJvd3MgYXJlIHBhcnRpdGlvbmVkIGJ5IHRlbmFudC5cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBba2V5Q29sdW1uXSBDb2x1bW4gbWF0Y2hlZCBkaXJlY3RseSBhZ2FpbnN0IHRoZSB0ZW5hbnQga2V5IHZhbHVlLlxuICogQHByb3BlcnR5IHtzdHJpbmd9IFtwYXJlbnRUYWJsZU5hbWVdIEVhcmxpZXItaW4tcGxhbiB0YWJsZSB3aG9zZSBzZWxlY3RlZCByb3dzIHNjb3BlIHRoaXMgb25lLlxuICogQHByb3BlcnR5IHtzdHJpbmd9IFtwYXJlbnRDb2x1bW5dIENvbHVtbiBvbiB0aGlzIHRhYmxlIHJlZmVyZW5jaW5nIHRoZSBwYXJlbnQgdGFibGUncyBwcmltYXJ5IGtleS5cbiAqL1xuXG5leHBvcnQge31cbiJdfQ==