velocious 1.0.481 → 1.0.483

package/build/database/tenants/schema-cloner.js

@@ -0,0 +1,390 @@
+// @ts-check
+
+import MigrationsLedger from "../migrations-ledger.js"
+import TableData from "../table-data/index.js"
+import TableIndex from "../table-data/table-index.js"
+
+const SIMPLE_DEFAULT_PATTERN = /^(?:-?\d+(?:\.\d+)?|[A-Za-z0-9 _.,:/@+-]*)$/
+
+/** @type {Record<string, number>} */
+const TEXT_TYPE_RANKS = {
+  tinytext: 1,
+  text: 2,
+  mediumtext: 3,
+  longtext: 4
+}
+
+/**
+ * Clones table structure (columns, text-type widening, indexes) from a source database
+ * into a target database for a given set of tables, then baselines the target's
+ * `schema_migrations` ledger to the source via {@link MigrationsLedger}. This is the
+ * mechanism multi-tenant apps use to provision a tenant database from a template/global
+ * database without re-running migrations: the structure is copied and the ledger is
+ * recorded as already-applied, so a later `db:tenants:migrate` does not re-run an
+ * `addColumn` whose column already exists.
+ *
+ * The cloner is intentionally policy-free — the caller decides which tables to sync and
+ * which databases are source/target. It is idempotent: missing tables are created,
+ * missing columns added, too-narrow text columns widened, and missing indexes created;
+ * an index whose definition diverges from the source is treated as drift and throws.
+ */
+export default class SchemaCloner {
+  /**
+   * Creates a cloner that copies table structure from `sourceDb` into `targetDb`.
+   * @param {{sourceDb: import("../drivers/base.js").default, targetDb: import("../drivers/base.js").default}} args
+   */
+  constructor({sourceDb, targetDb}) {
+    this.sourceDb = sourceDb
+    this.targetDb = targetDb
+  }
+
+  /**
+   * Clones every given table from the source into the target, then baselines the
+   * target's ledger so the cloned schema is recorded as already-migrated.
+   * @param {string[]} tableNames
+   * @returns {Promise<void>}
+   */
+  async syncTables(tableNames) {
+    for (const tableName of tableNames) {
+      await this.syncTable(tableName)
+    }
+
+    await this.reconcileLedger()
+  }
+
+  /**
+   * Clones a single table from the source into the target, creating it or adding and
+   * widening columns and indexes as needed.
+   * @param {string} tableName
+   * @returns {Promise<void>}
+   */
+  async syncTable(tableName) {
+    const sourceTable = await this.sourceDb.getTableByName(tableName)
+
+    if (!sourceTable) {
+      throw new Error(`Expected source table to exist: ${tableName}`)
+    }
+
+    if (!await this.targetDb.tableExists(tableName)) {
+      await this.createTargetTable({sourceTable, tableName})
+      return
+    }
+
+    const changedColumns = await this.ensureTargetColumns({sourceTable, tableName})
+
+    if (changedColumns) {
+      this.targetDb.clearSchemaCache()
+    }
+
+    await this.ensureTargetIndexes({sourceTable, tableName})
+  }
+
+  /**
+   * Creates the table in the target from the source table's columns and its
+   * non-primary-key indexes.
+   * @param {{sourceTable: import("../drivers/base-table.js").default, tableName: string}} args
+   * @returns {Promise<void>}
+   */
+  async createTargetTable({sourceTable, tableName}) {
+    const tableData = new TableData(tableName)
+
+    for (const sourceColumn of await sourceTable.getColumns()) {
+      tableData.addColumn(sourceColumn.getName(), this.columnArgsFromSourceColumn(sourceColumn, {isNewColumn: false}))
+    }
+
+    for (const sourceIndex of await sourceTable.getIndexes()) {
+      if (!sourceIndex.isPrimaryKey()) {
+        tableData.addIndex(this.tableDataIndexFromSourceIndex(sourceIndex))
+      }
+    }
+
+    await this.targetDb.createTable(tableData)
+    this.targetDb.clearSchemaCache()
+  }
+
+  /**
+   * Adds columns present on the source but missing from the target, and widens
+   * too-narrow target text columns.
+   * @param {{sourceTable: import("../drivers/base-table.js").default, tableName: string}} args
+   * @returns {Promise<boolean>} Whether any column was added or widened.
+   */
+  async ensureTargetColumns({sourceTable, tableName}) {
+    const sourceColumns = await sourceTable.getColumns()
+    const targetTable = await this.targetDb.getTableByNameOrFail(tableName)
+    const targetColumnsByName = new Map()
+    const missingColumns = []
+    const columnsNeedingWidening = []
+
+    for (const targetColumn of await targetTable.getColumns()) {
+      targetColumnsByName.set(targetColumn.getName(), targetColumn)
+    }
+
+    for (const sourceColumn of sourceColumns) {
+      const targetColumn = targetColumnsByName.get(sourceColumn.getName())
+
+      if (!targetColumn) {
+        missingColumns.push(sourceColumn)
+      } else if (this.columnNeedsWidening(sourceColumn, targetColumn)) {
+        columnsNeedingWidening.push(sourceColumn)
+      }
+    }
+
+    if (missingColumns.length <= 0 && columnsNeedingWidening.length <= 0) {
+      return false
+    }
+
+    const tableData = new TableData(tableName)
+
+    for (const sourceColumn of missingColumns) {
+      tableData.addColumn(sourceColumn.getName(), this.columnArgsFromSourceColumn(sourceColumn, {isNewColumn: true}))
+    }
+
+    for (const sourceColumn of columnsNeedingWidening) {
+      tableData.addColumn(sourceColumn.getName(), this.columnArgsFromSourceColumn(sourceColumn, {isNewColumn: false}))
+    }
+
+    for (const alterSql of await this.targetDb.alterTableSQLs(tableData)) {
+      await this.targetDb.query(alterSql)
+    }
+
+    return true
+  }
+
+  /**
+   * Creates non-primary-key indexes present on the source but missing from the target,
+   * and throws if an existing target index diverges from the source.
+   * @param {{sourceTable: import("../drivers/base-table.js").default, tableName: string}} args
+   * @returns {Promise<void>}
+   */
+  async ensureTargetIndexes({sourceTable, tableName}) {
+    const targetTable = await this.targetDb.getTableByNameOrFail(tableName)
+    /** @type {Map<string, import("../drivers/base-columns-index.js").default>} */
+    const targetIndexesByName = new Map()
+    const targetIndexSignatures = new Set()
+    let createdIndex = false
+
+    for (const targetIndex of await targetTable.getIndexes()) {
+      targetIndexesByName.set(targetIndex.getName(), targetIndex)
+      targetIndexSignatures.add(this.indexSignature(targetIndex))
+    }
+
+    for (const sourceIndex of await sourceTable.getIndexes()) {
+      if (sourceIndex.isPrimaryKey()) {
+        continue
+      }
+
+      const sourceIndexSignature = this.indexSignature(sourceIndex)
+
+      // SQLite index names are unique per-database, not per-table, so match cloned
+      // indexes by their column/uniqueness signature rather than their name.
+      if (this.targetDb.getType() === "sqlite" && targetIndexSignatures.has(sourceIndexSignature)) {
+        continue
+      }
+
+      const targetIndex = this.targetDb.getType() === "sqlite" ? undefined : targetIndexesByName.get(sourceIndex.getName())
+
+      if (!targetIndex) {
+        const createIndexSqls = await this.targetDb.createIndexSQLs(this.createIndexArgsFromSourceIndex({sourceIndex, tableName}))
+
+        for (const createIndexSql of createIndexSqls) {
+          await this.targetDb.query(createIndexSql)
+        }
+
+        createdIndex = true
+        targetIndexSignatures.add(sourceIndexSignature)
+        continue
+      }
+
+      if (!this.indexesMatch(sourceIndex, targetIndex)) {
+        throw new Error(`Schema clone index drift for ${tableName}.${sourceIndex.getName()}`)
+      }
+    }
+
+    if (createdIndex) {
+      this.targetDb.clearSchemaCache()
+    }
+  }
+
+  /**
+   * Baselines the target ledger so the cloned schema is recorded as already-applied.
+   * @returns {Promise<string[]>} The versions newly recorded on the target.
+   */
+  async reconcileLedger() {
+    return await MigrationsLedger.baselineFromDatabase({sourceDb: this.sourceDb, targetDb: this.targetDb})
+  }
+
+  /**
+   * Whether the target ledger is missing any version applied on the source — i.e. the
+   * target schema may have been advanced out of band without recording it.
+   * @returns {Promise<boolean>}
+   */
+  async ledgerDriftsFromSource() {
+    if (!await MigrationsLedger.tableExists(this.targetDb)) {
+      return true
+    }
+
+    const sourceVersions = await MigrationsLedger.appliedVersions(this.sourceDb)
+    const targetVersionSet = new Set(await MigrationsLedger.appliedVersions(this.targetDb))
+
+    return sourceVersions.some((version) => !targetVersionSet.has(version))
+  }
+
+  /**
+   * Maps a source index into a TableData index for table creation (SQLite omits the
+   * index name so the driver can generate a unique one).
+   * @param {import("../drivers/base-columns-index.js").default} sourceIndex
+   * @returns {TableIndex}
+   */
+  tableDataIndexFromSourceIndex(sourceIndex) {
+    /** @type {{name?: string, unique: boolean}} */
+    const args = {unique: sourceIndex.isUnique()}
+
+    // SQLite index names are unique per-database, not per-table, so let the driver
+    // generate one; other drivers preserve the source index name. Build the TableIndex
+    // directly (rather than via the driver's getTableDataIndex, which only MySQL and
+    // SQLite implement) so cloning a PostgreSQL or MS-SQL source table works too.
+    if (this.targetDb.getType() !== "sqlite") {
+      args.name = sourceIndex.getName()
+    }
+
+    return new TableIndex(sourceIndex.getColumnNames(), args)
+  }
+
+  /**
+   * Builds driver create-index args from a source index (the index name is omitted on
+   * SQLite, where index names are unique per-database rather than per-table).
+   * @param {{sourceIndex: import("../drivers/base-columns-index.js").default, tableName: string}} args
+   * @returns {{columns: string[], name?: string, tableName: string, unique: boolean}}
+   */
+  createIndexArgsFromSourceIndex({sourceIndex, tableName}) {
+    /** @type {{columns: string[], name?: string, tableName: string, unique: boolean}} */
+    const createIndexArgs = {
+      columns: sourceIndex.getColumnNames(),
+      tableName,
+      unique: sourceIndex.isUnique()
+    }
+
+    if (this.targetDb.getType() !== "sqlite") {
+      createIndexArgs.name = sourceIndex.getName()
+    }
+
+    return createIndexArgs
+  }
+
+  /**
+   * Whether two indexes have the same uniqueness and ordered column list.
+   * @param {import("../drivers/base-columns-index.js").default} sourceIndex
+   * @param {import("../drivers/base-columns-index.js").default} targetIndex
+   * @returns {boolean}
+   */
+  indexesMatch(sourceIndex, targetIndex) {
+    const sourceColumnNames = sourceIndex.getColumnNames()
+    const targetColumnNames = targetIndex.getColumnNames()
+
+    if (sourceIndex.isUnique() !== targetIndex.isUnique()) {
+      return false
+    }
+
+    if (sourceColumnNames.length !== targetColumnNames.length) {
+      return false
+    }
+
+    for (let columnIndex = 0; columnIndex < sourceColumnNames.length; columnIndex++) {
+      if (sourceColumnNames[columnIndex] !== targetColumnNames[columnIndex]) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * A stable signature for an index, used to match cloned indexes by shape.
+   * @param {import("../drivers/base-columns-index.js").default} index
+   * @returns {string}
+   */
+  indexSignature(index) {
+    return `${index.isUnique() ? "unique" : "index"}:${index.getColumnNames().join(",")}`
+  }
+
+  /**
+   * Normalizes a column type to its canonical lowercase form (`int` becomes `integer`).
+   * @param {string} columnType
+   * @returns {string}
+   */
+  normalizedColumnType(columnType) {
+    const normalizedType = columnType.toLowerCase()
+
+    if (normalizedType === "int") {
+      return "integer"
+    }
+
+    return normalizedType
+  }
+
+  /**
+   * The widening rank of a text column type (0 when not a text type).
+   * @param {string} columnType
+   * @returns {number}
+   */
+  textTypeRank(columnType) {
+    return TEXT_TYPE_RANKS[this.normalizedColumnType(columnType)] || 0
+  }
+
+  /**
+   * Whether the target's text column is narrower than the source's and must be widened.
+   * @param {import("../drivers/base-column.js").default} sourceColumn
+   * @param {import("../drivers/base-column.js").default} targetColumn
+   * @returns {boolean}
+   */
+  columnNeedsWidening(sourceColumn, targetColumn) {
+    const sourceRank = this.textTypeRank(sourceColumn.getType())
+    const targetRank = this.textTypeRank(targetColumn.getType())
+
+    return sourceRank > 0 && targetRank > 0 && sourceRank > targetRank
+  }
+
+  /**
+   * Builds TableData column args from a source column, copying type, nullability,
+   * length, notes, simple defaults and (for full clones) primary-key flag.
+   * @param {import("../drivers/base-column.js").default} sourceColumn
+   * @param {{isNewColumn: boolean}} args
+   * @returns {Record<string, unknown>}
+   */
+  columnArgsFromSourceColumn(sourceColumn, {isNewColumn}) {
+    /** @type {{autoIncrement?: boolean, default?: unknown, isNewColumn: boolean, maxLength?: number, notes?: string, null: boolean, primaryKey?: boolean, type: string}} */
+    const columnArgs = {
+      isNewColumn,
+      null: sourceColumn.getNull(),
+      type: this.normalizedColumnType(sourceColumn.getType())
+    }
+    const defaultValue = sourceColumn.getDefault()
+    const maxLength = sourceColumn.getMaxLength()
+    const notes = sourceColumn.getNotes()
+
+    if (!isNewColumn && sourceColumn.getPrimaryKey()) {
+      columnArgs.primaryKey = true
+    }
+
+    if (sourceColumn.getAutoIncrement()) {
+      columnArgs.autoIncrement = true
+    }
+
+    // A maxLength of -1 is the MS-SQL "max" sentinel (NVARCHAR(MAX) / VARBINARY(MAX),
+    // backing Velocious text/json/blob columns); the column type drives the unbounded
+    // SQL, so don't forward -1 as an explicit length (it would emit NVARCHAR(-1)).
+    if (maxLength !== undefined && maxLength >= 0) {
+      columnArgs.maxLength = maxLength
+    }
+
+    if (notes) {
+      columnArgs.notes = notes
+    }
+
+    if (defaultValue !== null && defaultValue !== undefined && SIMPLE_DEFAULT_PATTERN.test(String(defaultValue))) {
+      columnArgs.default = defaultValue
+    }
+
+    return columnArgs
+  }
+}

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

@@ -0,0 +1,20 @@
+// @ts-check
+
+/**
+ * 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.
+ * @typedef {object} TenantTablePlanEntry
+ * @property {string} tableName Name of the table whose rows are partitioned by tenant.
+ * @property {string} [keyColumn] Column matched directly against the tenant key value.
+ * @property {string} [parentTableName] Earlier-in-plan table whose selected rows scope this one.
+ * @property {string} [parentColumn] Column on this table referencing the parent table's primary key.
+ */
+
+export {}

package/build/src/cli/commands/db/tenants/drop.d.ts

@@ -0,0 +1,13 @@
+export default class DbTenantsDrop extends BaseCommand {
+    /**
+     * Drops the tenant database/schema for every listed tenant through the provider's
+     * `dropDatabase` hook.
+     * @returns {Promise<{identifier: string, tenantCount: number} | void>} - Result in test mode.
+     */
+    execute(): Promise<{
+        identifier: string;
+        tenantCount: number;
+    } | void>;
+}
+import BaseCommand from "../../../base-command.js";
+//# sourceMappingURL=drop.d.ts.map

package/build/src/cli/commands/db/tenants/drop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../../../../src/cli/commands/db/tenants/drop.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,WAFa,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAuBrE;CACF;wBA/BuB,0BAA0B"}

package/build/src/cli/commands/db/tenants/drop.js

@@ -0,0 +1,31 @@
+// @ts-check
+import BaseCommand from "../../../base-command.js";
+import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js";
+export default class DbTenantsDrop extends BaseCommand {
+    /**
+     * Drops the tenant database/schema for every listed tenant through the provider's
+     * `dropDatabase` hook.
+     * @returns {Promise<{identifier: string, tenantCount: number} | void>} - Result in test mode.
+     */
+    async execute() {
+        const helper = new TenantDatabaseCommandHelper({
+            command: this,
+            identifier: this.processArgs?.[1]
+        });
+        const provider = helper.provider;
+        if (typeof provider.dropDatabase !== "function") {
+            throw new Error(`Tenant database provider for ${helper.identifier} must define dropDatabase to use db:tenants:drop`);
+        }
+        const tenantCount = await helper.eachTenant(async ({ databaseConfiguration, tenant }) => {
+            await provider.dropDatabase?.({
+                configuration: this.getConfiguration(),
+                databaseConfiguration,
+                identifier: helper.identifier,
+                tenant
+            });
+        });
+        if (this.args.testing)
+            return { identifier: helper.identifier, tenantCount };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/cli/tenant-database-command-helper.d.ts

@@ -41,25 +41,5 @@ export default class TenantDatabaseCommandHelper {
      * @returns {number} - Number of tenants to process concurrently.
      */
     parallelCount(): number;
-    /**
-     * 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>}
-     */
-    runTenantCallback({ callback, tenant }: {
-        callback: (arg0: {
-            databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
-            tenant: unknown;
-        }) => Promise<void>;
-        tenant: unknown;
-    }): Promise<void>;
-    /**
-     * Runs tenant label.
-     * @param {?} tenant - Tenant.
-     * @returns {string} - Human readable tenant label.
-     */
-    tenantLabel(tenant: unknown): string;
 }
 //# sourceMappingURL=tenant-database-command-helper.d.ts.map

package/build/src/cli/tenant-database-command-helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tenant-database-command-helper.d.ts","sourceRoot":"","sources":["../../../src/cli/tenant-database-command-helper.js"],"names":[],"mappings":"AAEA;IACE;;;;;OAKG;IACH,qCAHG;QAAkD,OAAO,EAAjD,OAAO,mBAAmB,EAAE,OAAO;QACV,UAAU,EAAnC,MAAM,GAAG,SAAS;KAC5B,EAQA;IAJC,6CAAsB;IACtB,qDAA+C;IAC/C,mBAA4B;IAC5B,yEAAwE;IAG1E;;yBAEqB;IACrB,oCADa,IAAI,CAmBhB;IAED;;;OAGG;IACH,qBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,eAFa,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAkB7B;IAED;;;;OAIG;IACH,qBAHW,CAAS,IAAiG,EAAjG;QAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,GACzH,OAAO,CAAC,MAAM,CAAC,CAqD3B;IAED;;;OAGG;IACH,iBAFa,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,wCAJG;QAA0I,QAAQ,EAA1I,CAAS,IAAiG,EAAjG;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC;QACnH,MAAM,EAAd,OAAC;KACT,GAAU,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;;OAIG;IACH,oBAHW,OAAC,GACC,MAAM,CAYlB;CACF"}
+{"version":3,"file":"tenant-database-command-helper.d.ts","sourceRoot":"","sources":["../../../src/cli/tenant-database-command-helper.js"],"names":[],"mappings":"AAIA;IACE;;;;;OAKG;IACH,qCAHG;QAAkD,OAAO,EAAjD,OAAO,mBAAmB,EAAE,OAAO;QACV,UAAU,EAAnC,MAAM,GAAG,SAAS;KAC5B,EAQA;IAJC,6CAAsB;IACtB,qDAA+C;IAC/C,mBAA4B;IAC5B,yEAAwE;IAG1E;;yBAEqB;IACrB,oCADa,IAAI,CAmBhB;IAED;;;OAGG;IACH,qBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,eAFa,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAkB7B;IAED;;;;OAIG;IACH,qBAHW,CAAS,IAAiG,EAAjG;QAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,GACzH,OAAO,CAAC,MAAM,CAAC,CAW3B;IAED;;;OAGG;IACH,iBAFa,MAAM,CA0BlB;CACF"}

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"]}