velocious 1.0.547 → 1.0.548

package/README.md

@@ -2354,6 +2354,8 @@ npx velocious db:tenants:migrate projectTenant
 npx velocious db:tenants:migrate projectTenant --parallel 20
 ```
 
+Tenant lifecycle commands print start and final counts, report each completed tenant, and emit a heartbeat every 30 seconds with completed and active tenant counts while work is still running.
+
 `afterMigrateTenant` hooks run inside the active default and tenant database connection scope for the tenant being migrated.
 
 At runtime, the apartment-style `Tenant` façade (`velocious/build/src/tenants/tenant.js`) is the single entry point: `Tenant.with(tenant, callback)` / `Tenant.current()` to switch into and read a tenant context, `Tenant.each({identifier, callback, parallel?, filter?})` to run a callback within every provider-listed tenant, and `Tenant.drop({identifier, tenant})` (plus the `db:tenants:drop` CLI command) to drop a tenant's database through the provider's `dropDatabase` hook. `Tenant.with` and `Tenant.each` run their callbacks inside `ensureConnections`, so switching into a tenant establishes its database connections (global + tenant) and passes them to the callback — the tenant is immediately queryable without the caller wiring up connections (already-open connections are reused, so nesting does not double-connect). `Tenant.with` is generic over its callback's return type, so a value returned from inside the tenant context comes back to the caller with its type preserved (no cast needed). `Tenant.aggregateAcross({identifier, aggregates, keyColumns, subquery, tenants?, filter?})` runs one aggregate over the same table across many tenant databases and returns the merged result — grouping tenants by server and using a single cross-database `UNION ALL` where the driver supports two-part `` `database`.`table` `` references (MySQL/MariaDB) or one query per tenant otherwise (PostgreSQL/SQLite/MSSQL).

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

@@ -2,19 +2,25 @@
 
 import TenantIterator from "../tenants/tenant-iterator.js"
 
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000
+
 export default class TenantDatabaseCommandHelper {
   /**
    * Runs constructor.
    * @param {object} args - Options object.
    * @param {import("./base-command.js").default} args.command - CLI command instance.
+   * @param {number} [args.heartbeatIntervalMs] - Interval between progress heartbeats.
    * @param {string | undefined} args.identifier - Tenant database identifier.
+   * @param {(message: string) => void} [args.output] - Progress output handler.
    */
-  constructor({command, identifier}) {
+  constructor({command, heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, identifier, output = console.log}) {
     if (!identifier) throw new Error("Missing tenant database identifier argument")
 
     this.command = command
     this.configuration = command.getConfiguration()
+    this.heartbeatIntervalMs = heartbeatIntervalMs
     this.identifier = identifier
+    this.output = output
     this.provider = this.configuration.getTenantDatabaseProvider(identifier)
   }
 
@@ -78,13 +84,42 @@ export default class TenantDatabaseCommandHelper {
    */
   async eachTenant(callback) {
     const tenants = await this.listTenants()
+    const commandName = this.command.processArgs?.[0] || "db:tenants"
+    const parallelCount = this.parallelCount()
+    const progressPrefix = `${commandName} ${this.identifier}`
+    let activeTenantCount = 0
+    let completedTenantCount = 0
     const iterator = new TenantIterator({
       configuration: this.configuration,
       identifier: this.identifier,
-      parallelCount: this.parallelCount()
+      parallelCount
     })
+    const progressHeartbeat = setInterval(() => {
+      this.output(`${progressPrefix}: heartbeat: ${completedTenantCount}/${tenants.length} completed, ${activeTenantCount} active`)
+    }, this.heartbeatIntervalMs)
+
+    progressHeartbeat.unref()
+    this.output(`${progressPrefix}: processing ${tenants.length} tenant(s) with parallelism ${parallelCount}`)
+
+    try {
+      const processedTenantCount = await iterator.run(tenants, async (args) => {
+        activeTenantCount++
+
+        try {
+          await callback(args)
+          completedTenantCount++
+          this.output(`${progressPrefix}: completed ${TenantIterator.tenantLabel(args.tenant)} (${completedTenantCount}/${tenants.length})`)
+        } finally {
+          activeTenantCount--
+        }
+      })
 
-    return await iterator.run(tenants, callback)
+      this.output(`${progressPrefix}: finished ${processedTenantCount}/${tenants.length} tenant(s)`)
+
+      return processedTenantCount
+    } finally {
+      clearInterval(progressHeartbeat)
+    }
   }
 
   /**

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

@@ -3,15 +3,21 @@ export default class TenantDatabaseCommandHelper {
      * Runs constructor.
      * @param {object} args - Options object.
      * @param {import("./base-command.js").default} args.command - CLI command instance.
+     * @param {number} [args.heartbeatIntervalMs] - Interval between progress heartbeats.
      * @param {string | undefined} args.identifier - Tenant database identifier.
+     * @param {(message: string) => void} [args.output] - Progress output handler.
      */
-    constructor({ command, identifier }: {
+    constructor({ command, heartbeatIntervalMs, identifier, output }: {
         command: import("./base-command.js").default;
+        heartbeatIntervalMs?: number | undefined;
         identifier: string | undefined;
+        output?: ((message: string) => void) | undefined;
     });
     command: import("./base-command.js").default;
     configuration: import("../configuration.js").default;
+    heartbeatIntervalMs: number;
     identifier: string;
+    output: (message: string) => void;
     provider: import("../configuration-types.js").TenantDatabaseProviderType;
     /**
      * Runs validate tenant database identifier.

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":"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"}
+{"version":3,"file":"tenant-database-command-helper.d.ts","sourceRoot":"","sources":["../../../src/cli/tenant-database-command-helper.js"],"names":[],"mappings":"AAMA;IACE;;;;;;;OAOG;IACH,kEALG;QAAkD,OAAO,EAAjD,OAAO,mBAAmB,EAAE,OAAO;QACrB,mBAAmB;QACR,UAAU,EAAnC,MAAM,GAAG,SAAS;QACe,MAAM,cAA7B,MAAM,KAAK,IAAI;KACnC,EAUA;IANC,6CAAsB;IACtB,qDAA+C;IAC/C,4BAA8C;IAC9C,mBAA4B;IAC5B,kBATmB,MAAM,KAAK,IAAI,CASd;IACpB,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,CAwC3B;IAED;;;OAGG;IACH,iBAFa,MAAM,CA0BlB;CACF"}

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

@@ -1,18 +1,23 @@
 // @ts-check
 import TenantIterator from "../tenants/tenant-iterator.js";
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
 export default class TenantDatabaseCommandHelper {
     /**
      * Runs constructor.
      * @param {object} args - Options object.
      * @param {import("./base-command.js").default} args.command - CLI command instance.
+     * @param {number} [args.heartbeatIntervalMs] - Interval between progress heartbeats.
      * @param {string | undefined} args.identifier - Tenant database identifier.
+     * @param {(message: string) => void} [args.output] - Progress output handler.
      */
-    constructor({ command, identifier }) {
+    constructor({ command, heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, identifier, output = console.log }) {
         if (!identifier)
             throw new Error("Missing tenant database identifier argument");
         this.command = command;
         this.configuration = command.getConfiguration();
+        this.heartbeatIntervalMs = heartbeatIntervalMs;
         this.identifier = identifier;
+        this.output = output;
         this.provider = this.configuration.getTenantDatabaseProvider(identifier);
     }
     /**
@@ -65,12 +70,39 @@ export default class TenantDatabaseCommandHelper {
      */
     async eachTenant(callback) {
         const tenants = await this.listTenants();
+        const commandName = this.command.processArgs?.[0] || "db:tenants";
+        const parallelCount = this.parallelCount();
+        const progressPrefix = `${commandName} ${this.identifier}`;
+        let activeTenantCount = 0;
+        let completedTenantCount = 0;
         const iterator = new TenantIterator({
             configuration: this.configuration,
             identifier: this.identifier,
-            parallelCount: this.parallelCount()
+            parallelCount
         });
-        return await iterator.run(tenants, callback);
+        const progressHeartbeat = setInterval(() => {
+            this.output(`${progressPrefix}: heartbeat: ${completedTenantCount}/${tenants.length} completed, ${activeTenantCount} active`);
+        }, this.heartbeatIntervalMs);
+        progressHeartbeat.unref();
+        this.output(`${progressPrefix}: processing ${tenants.length} tenant(s) with parallelism ${parallelCount}`);
+        try {
+            const processedTenantCount = await iterator.run(tenants, async (args) => {
+                activeTenantCount++;
+                try {
+                    await callback(args);
+                    completedTenantCount++;
+                    this.output(`${progressPrefix}: completed ${TenantIterator.tenantLabel(args.tenant)} (${completedTenantCount}/${tenants.length})`);
+                }
+                finally {
+                    activeTenantCount--;
+                }
+            });
+            this.output(`${progressPrefix}: finished ${processedTenantCount}/${tenants.length} tenant(s)`);
+            return processedTenantCount;
+        }
+        finally {
+            clearInterval(progressHeartbeat);
+        }
     }
     /**
      * Runs parallel count.
@@ -97,4 +129,4 @@ export default class TenantDatabaseCommandHelper {
         return parallelCount;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-database-command-helper.js","sourceRoot":"","sources":["../../../src/cli/tenant-database-command-helper.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,cAAc,MAAM,+BAA+B,CAAA;AAE1D,MAAM,CAAC,OAAO,OAAO,2BAA2B;IAC9C;;;;;OAKG;IACH,YAAY,EAAC,OAAO,EAAE,UAAU,EAAC;QAC/B,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;QAE/E,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAA;QAC/C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAA;IAC1E,CAAC;IAED;;yBAEqB;IACrB,gCAAgC;QAC9B,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,wBAAwB,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAE5F,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,2CAA2C,IAAI,CAAC,UAAU,EAAE,CAAC,CAAA;QAC/E,CAAC;QAED,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,UAAU,0CAA0C,CAAC,CAAA;QACnG,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,8BAA8B,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAC7E,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,CAAC,UAAU,yDAAyD,CAAC,CAAA;QACzH,CAAC;QAED,IAAI,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,CAAC,UAAU,0BAA0B,CAAC,CAAA;QAC5F,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,iBAAiB;QACrB,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAAC,IAAI,EAAE,YAAY,EAAC,CAAC,CAAA;IAC3D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW;QACf,IAAI,CAAC,gCAAgC,EAAE,CAAA;QACvC,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAA;QAE9B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAC,IAAI,EAAE,yBAAyB,IAAI,CAAC,UAAU,EAAE,EAAC,EAAE,KAAK,IAAI,EAAE;YACxH,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;gBACrC,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,CAAC,UAAU,wCAAwC,CAAC,CAAA;QAC1G,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,QAAQ;QACvB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAA;QACxC,MAAM,QAAQ,GAAG,IAAI,cAAc,CAAC;YAClC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE;SACpC,CAAC,CAAA;QAEF,OAAO,MAAM,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC9C,CAAC;IAED;;;OAGG;IACH,aAAa;QACX,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,iBAAiB,IAAI,EAAE,CAAA;QACpE,IAAI,WAAW,GAAG,iBAAiB,CAAC,QAAQ,CAAA;QAE5C,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAA;YAE9E,IAAI,gBAAgB,IAAI,CAAC,EAAE,CAAC;gBAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAA;gBAEhE,WAAW,GAAG,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAA;YACpE,CAAC;QACH,CAAC;QAED,IAAI,WAAW,KAAK,SAAS,IAAI,WAAW,KAAK,KAAK;YAAE,OAAO,CAAC,CAAA;QAChE,IAAI,WAAW,KAAK,IAAI;YAAE,OAAO,EAAE,CAAA;QAEnC,MAAM,aAAa,GAAG,MAAM,CAAC,WAAW,CAAC,CAAA;QAEzC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,mEAAmE,WAAW,EAAE,CAAC,CAAA;QACnG,CAAC;QAED,OAAO,aAAa,CAAA;IACtB,CAAC;CACF","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"]}
+//# 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\nconst DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000\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 {number} [args.heartbeatIntervalMs] - Interval between progress heartbeats.\n   * @param {string | undefined} args.identifier - Tenant database identifier.\n   * @param {(message: string) => void} [args.output] - Progress output handler.\n   */\n  constructor({command, heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, identifier, output = console.log}) {\n    if (!identifier) throw new Error(\"Missing tenant database identifier argument\")\n\n    this.command = command\n    this.configuration = command.getConfiguration()\n    this.heartbeatIntervalMs = heartbeatIntervalMs\n    this.identifier = identifier\n    this.output = output\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 commandName = this.command.processArgs?.[0] || \"db:tenants\"\n    const parallelCount = this.parallelCount()\n    const progressPrefix = `${commandName} ${this.identifier}`\n    let activeTenantCount = 0\n    let completedTenantCount = 0\n    const iterator = new TenantIterator({\n      configuration: this.configuration,\n      identifier: this.identifier,\n      parallelCount\n    })\n    const progressHeartbeat = setInterval(() => {\n      this.output(`${progressPrefix}: heartbeat: ${completedTenantCount}/${tenants.length} completed, ${activeTenantCount} active`)\n    }, this.heartbeatIntervalMs)\n\n    progressHeartbeat.unref()\n    this.output(`${progressPrefix}: processing ${tenants.length} tenant(s) with parallelism ${parallelCount}`)\n\n    try {\n      const processedTenantCount = await iterator.run(tenants, async (args) => {\n        activeTenantCount++\n\n        try {\n          await callback(args)\n          completedTenantCount++\n          this.output(`${progressPrefix}: completed ${TenantIterator.tenantLabel(args.tenant)} (${completedTenantCount}/${tenants.length})`)\n        } finally {\n          activeTenantCount--\n        }\n      })\n\n      this.output(`${progressPrefix}: finished ${processedTenantCount}/${tenants.length} tenant(s)`)\n\n      return processedTenantCount\n    } finally {\n      clearInterval(progressHeartbeat)\n    }\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/tenants/tenant-iterator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tenant-iterator.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant-iterator.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAmFE;;;;OAIG;IACH,2BAHW,OAAC,GACC,MAAM,CAYlB;IAjGD;;;OAGG;IACH,0DAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAC,EAM5G;IAHC,qDAAkC;IAClC,mBAA4B;IAC5B,sBAAkC;IAGpC;;;;;OAKG;IACH,aAJW,KAAK,CAAC,OAAC,CAAC,YACR,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,CAgD3B;IAED;;;;OAIG;IACH,wCAHW;QAAC,QAAQ,EAAE,CAAS,IAAiG,EAAjG;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,GAChJ,OAAO,CAAC,IAAI,CAAC,CAazB;CAkBF"}
+{"version":3,"file":"tenant-iterator.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant-iterator.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAmFE;;;;OAIG;IACH,2BAHW,OAAC,GACC,MAAM,CAiBlB;IAtGD;;;OAGG;IACH,0DAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAC,EAM5G;IAHC,qDAAkC;IAClC,mBAA4B;IAC5B,sBAAkC;IAGpC;;;;;OAKG;IACH,aAJW,KAAK,CAAC,OAAC,CAAC,YACR,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,CAgD3B;IAED;;;;OAIG;IACH,wCAHW;QAAC,QAAQ,EAAE,CAAS,IAAiG,EAAjG;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,GAChJ,OAAO,CAAC,IAAI,CAAC,CAazB;CAuBF"}

package/build/src/tenants/tenant-iterator.js

@@ -84,14 +84,16 @@ export default class TenantIterator {
     static 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);
+            for (const attributeName of /** @type {Array<"slug" | "name" | "id">} */ (["slug", "name", "id"])) {
+                const attributeOrAccessor = tenantObject[attributeName];
+                const attributeValue = typeof attributeOrAccessor === "function"
+                    ? attributeOrAccessor.call(tenant)
+                    : attributeOrAccessor;
+                if (attributeValue)
+                    return String(attributeValue);
+            }
         }
         return JSON.stringify(tenant);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-iterator.js","sourceRoot":"","sources":["../../../src/tenants/tenant-iterator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Runs a callback once within each tenant's context for a tenant database identifier,\n * optionally several tenants at a time. Each tenant is entered with `runWithTenant`, and a\n * tenant whose database identifier is inactive throws rather than running the callback\n * against the wrong connection. When iterating in parallel the per-tenant failures are\n * collected and rethrown together as an `AggregateError` so one bad tenant does not hide the\n * others. This is the iteration engine shared by the `db:tenants:*` CLI commands and the\n * runtime tenant façade; the caller is responsible for producing the tenant list.\n */\nexport default class TenantIterator {\n  /**\n   * Creates an iterator bound to a configuration and tenant database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, identifier: string, parallelCount?: number}} args - Tenant configuration, database identifier, and concurrency limit.\n   */\n  constructor({configuration, identifier, parallelCount = 1}) {\n    this.configuration = configuration\n    this.identifier = identifier\n    this.parallelCount = parallelCount\n  }\n\n  /**\n   * Runs `callback` within each tenant's context and returns how many tenants were processed.\n   * @param {Array<?>} tenants - Tenant descriptors to enter and process.\n   * @param {function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback - Per-tenant operation receiving the active database configuration.\n   * @returns {Promise<number>} - Number of processed tenants.\n   */\n  async run(tenants, callback) {\n    if (this.parallelCount <= 1) {\n      for (const tenant of tenants) {\n        await this.runTenantCallback({callback, tenant})\n      }\n\n      return tenants.length\n    }\n\n    /** @type {Array<{error: Error, tenant: ?}>} */\n    const failures = []\n    const workers = []\n    let tenantIndex = 0\n    const workerCount = Math.min(this.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) => TenantIterator.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   * Enters one tenant's context and runs the callback, asserting the database is active first.\n   * @param {{callback: function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>, tenant: ?}} args - Tenant descriptor and operation to run in its context.\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: ${TenantIterator.tenantLabel(tenant)}`)\n      }\n\n      await callback({\n        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),\n        tenant\n      })\n    })\n  }\n\n  /**\n   * Builds a human-readable label for a tenant for use in error messages.\n   * @param {?} tenant - Tenant descriptor to identify in an error.\n   * @returns {string} - Human-readable tenant label.\n   */\n  static 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-iterator.js","sourceRoot":"","sources":["../../../src/tenants/tenant-iterator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Runs a callback once within each tenant's context for a tenant database identifier,\n * optionally several tenants at a time. Each tenant is entered with `runWithTenant`, and a\n * tenant whose database identifier is inactive throws rather than running the callback\n * against the wrong connection. When iterating in parallel the per-tenant failures are\n * collected and rethrown together as an `AggregateError` so one bad tenant does not hide the\n * others. This is the iteration engine shared by the `db:tenants:*` CLI commands and the\n * runtime tenant façade; the caller is responsible for producing the tenant list.\n */\nexport default class TenantIterator {\n  /**\n   * Creates an iterator bound to a configuration and tenant database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, identifier: string, parallelCount?: number}} args - Tenant configuration, database identifier, and concurrency limit.\n   */\n  constructor({configuration, identifier, parallelCount = 1}) {\n    this.configuration = configuration\n    this.identifier = identifier\n    this.parallelCount = parallelCount\n  }\n\n  /**\n   * Runs `callback` within each tenant's context and returns how many tenants were processed.\n   * @param {Array<?>} tenants - Tenant descriptors to enter and process.\n   * @param {function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback - Per-tenant operation receiving the active database configuration.\n   * @returns {Promise<number>} - Number of processed tenants.\n   */\n  async run(tenants, callback) {\n    if (this.parallelCount <= 1) {\n      for (const tenant of tenants) {\n        await this.runTenantCallback({callback, tenant})\n      }\n\n      return tenants.length\n    }\n\n    /** @type {Array<{error: Error, tenant: ?}>} */\n    const failures = []\n    const workers = []\n    let tenantIndex = 0\n    const workerCount = Math.min(this.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) => TenantIterator.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   * Enters one tenant's context and runs the callback, asserting the database is active first.\n   * @param {{callback: function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>, tenant: ?}} args - Tenant descriptor and operation to run in its context.\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: ${TenantIterator.tenantLabel(tenant)}`)\n      }\n\n      await callback({\n        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),\n        tenant\n      })\n    })\n  }\n\n  /**\n   * Builds a human-readable label for a tenant for use in error messages.\n   * @param {?} tenant - Tenant descriptor to identify in an error.\n   * @returns {string} - Human-readable tenant label.\n   */\n  static tenantLabel(tenant) {\n    if (tenant && typeof tenant === \"object\") {\n      const tenantObject = /** @type {{id?: ?, name?: ?, slug?: ?}} */ (tenant)\n\n      for (const attributeName of /** @type {Array<\"slug\" | \"name\" | \"id\">} */ ([\"slug\", \"name\", \"id\"])) {\n        const attributeOrAccessor = tenantObject[attributeName]\n        const attributeValue = typeof attributeOrAccessor === \"function\"\n          ? attributeOrAccessor.call(tenant)\n          : attributeOrAccessor\n\n        if (attributeValue) return String(attributeValue)\n      }\n    }\n\n    return JSON.stringify(tenant)\n  }\n}\n"]}

package/build/tenants/tenant-iterator.js

@@ -101,9 +101,14 @@ export default class TenantIterator {
     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)
+      for (const attributeName of /** @type {Array<"slug" | "name" | "id">} */ (["slug", "name", "id"])) {
+        const attributeOrAccessor = tenantObject[attributeName]
+        const attributeValue = typeof attributeOrAccessor === "function"
+          ? attributeOrAccessor.call(tenant)
+          : attributeOrAccessor
+
+        if (attributeValue) return String(attributeValue)
+      }
     }
 
     return JSON.stringify(tenant)

package/package.json

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

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

@@ -2,19 +2,25 @@
 
 import TenantIterator from "../tenants/tenant-iterator.js"
 
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000
+
 export default class TenantDatabaseCommandHelper {
   /**
    * Runs constructor.
    * @param {object} args - Options object.
    * @param {import("./base-command.js").default} args.command - CLI command instance.
+   * @param {number} [args.heartbeatIntervalMs] - Interval between progress heartbeats.
    * @param {string | undefined} args.identifier - Tenant database identifier.
+   * @param {(message: string) => void} [args.output] - Progress output handler.
    */
-  constructor({command, identifier}) {
+  constructor({command, heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, identifier, output = console.log}) {
     if (!identifier) throw new Error("Missing tenant database identifier argument")
 
     this.command = command
     this.configuration = command.getConfiguration()
+    this.heartbeatIntervalMs = heartbeatIntervalMs
     this.identifier = identifier
+    this.output = output
     this.provider = this.configuration.getTenantDatabaseProvider(identifier)
   }
 
@@ -78,13 +84,42 @@ export default class TenantDatabaseCommandHelper {
    */
   async eachTenant(callback) {
     const tenants = await this.listTenants()
+    const commandName = this.command.processArgs?.[0] || "db:tenants"
+    const parallelCount = this.parallelCount()
+    const progressPrefix = `${commandName} ${this.identifier}`
+    let activeTenantCount = 0
+    let completedTenantCount = 0
     const iterator = new TenantIterator({
       configuration: this.configuration,
       identifier: this.identifier,
-      parallelCount: this.parallelCount()
+      parallelCount
     })
+    const progressHeartbeat = setInterval(() => {
+      this.output(`${progressPrefix}: heartbeat: ${completedTenantCount}/${tenants.length} completed, ${activeTenantCount} active`)
+    }, this.heartbeatIntervalMs)
+
+    progressHeartbeat.unref()
+    this.output(`${progressPrefix}: processing ${tenants.length} tenant(s) with parallelism ${parallelCount}`)
+
+    try {
+      const processedTenantCount = await iterator.run(tenants, async (args) => {
+        activeTenantCount++
+
+        try {
+          await callback(args)
+          completedTenantCount++
+          this.output(`${progressPrefix}: completed ${TenantIterator.tenantLabel(args.tenant)} (${completedTenantCount}/${tenants.length})`)
+        } finally {
+          activeTenantCount--
+        }
+      })
 
-    return await iterator.run(tenants, callback)
+      this.output(`${progressPrefix}: finished ${processedTenantCount}/${tenants.length} tenant(s)`)
+
+      return processedTenantCount
+    } finally {
+      clearInterval(progressHeartbeat)
+    }
   }
 
   /**

package/src/tenants/tenant-iterator.js

@@ -101,9 +101,14 @@ export default class TenantIterator {
     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)
+      for (const attributeName of /** @type {Array<"slug" | "name" | "id">} */ (["slug", "name", "id"])) {
+        const attributeOrAccessor = tenantObject[attributeName]
+        const attributeValue = typeof attributeOrAccessor === "function"
+          ? attributeOrAccessor.call(tenant)
+          : attributeOrAccessor
+
+        if (attributeValue) return String(attributeValue)
+      }
     }
 
     return JSON.stringify(tenant)