velocious 1.0.482 → 1.0.484

package/build/src/tenants/tenant-iterator.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Runs a callback once within each tenant's context for a tenant database identifier,
+ * optionally several tenants at a time. Each tenant is entered with `runWithTenant`, and a
+ * tenant whose database identifier is inactive throws rather than running the callback
+ * against the wrong connection. When iterating in parallel the per-tenant failures are
+ * collected and rethrown together as an `AggregateError` so one bad tenant does not hide the
+ * others. This is the iteration engine shared by the `db:tenants:*` CLI commands and the
+ * runtime {@link Tenant} façade; the caller is responsible for producing the tenant list.
+ */
+export default class TenantIterator {
+    /**
+     * Builds a human-readable label for a tenant for use in error messages.
+     * @param {?} tenant
+     * @returns {string}
+     */
+    static tenantLabel(tenant: unknown): string;
+    /**
+     * Creates an iterator bound to a configuration and tenant database identifier.
+     * @param {{configuration: import("../configuration.js").default, identifier: string, parallelCount?: number}} args
+     */
+    constructor({ configuration, identifier, parallelCount }: {
+        configuration: import("../configuration.js").default;
+        identifier: string;
+        parallelCount?: number;
+    });
+    configuration: import("../configuration.js").default;
+    identifier: string;
+    parallelCount: number;
+    /**
+     * Runs `callback` within each tenant's context and returns how many tenants were processed.
+     * @param {Array<?>} tenants
+     * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback
+     * @returns {Promise<number>}
+     */
+    run(tenants: Array<unknown>, callback: (arg0: {
+        databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
+        tenant: unknown;
+    }) => Promise<void>): Promise<number>;
+    /**
+     * Enters one tenant's context and runs the callback, asserting the database is active first.
+     * @param {{callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, tenant: ?}} args
+     * @returns {Promise<void>}
+     */
+    runTenantCallback({ callback, tenant }: {
+        callback: (arg0: {
+            databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
+            tenant: unknown;
+        }) => Promise<void>;
+        tenant: unknown;
+    }): Promise<void>;
+}
+//# sourceMappingURL=tenant-iterator.d.ts.map

package/build/src/tenants/tenant-iterator.d.ts.map

@@ -0,0 +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"}

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

@@ -0,0 +1,97 @@
+// @ts-check
+/**
+ * Runs a callback once within each tenant's context for a tenant database identifier,
+ * optionally several tenants at a time. Each tenant is entered with `runWithTenant`, and a
+ * tenant whose database identifier is inactive throws rather than running the callback
+ * against the wrong connection. When iterating in parallel the per-tenant failures are
+ * collected and rethrown together as an `AggregateError` so one bad tenant does not hide the
+ * others. This is the iteration engine shared by the `db:tenants:*` CLI commands and the
+ * runtime {@link Tenant} façade; the caller is responsible for producing the tenant list.
+ */
+export default class TenantIterator {
+    /**
+     * Creates an iterator bound to a configuration and tenant database identifier.
+     * @param {{configuration: import("../configuration.js").default, identifier: string, parallelCount?: number}} args
+     */
+    constructor({ configuration, identifier, parallelCount = 1 }) {
+        this.configuration = configuration;
+        this.identifier = identifier;
+        this.parallelCount = parallelCount;
+    }
+    /**
+     * Runs `callback` within each tenant's context and returns how many tenants were processed.
+     * @param {Array<?>} tenants
+     * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback
+     * @returns {Promise<number>}
+     */
+    async run(tenants, callback) {
+        if (this.parallelCount <= 1) {
+            for (const tenant of tenants) {
+                await this.runTenantCallback({ callback, tenant });
+            }
+            return tenants.length;
+        }
+        /** @type {Array<{error: Error, tenant: ?}>} */
+        const failures = [];
+        const workers = [];
+        let tenantIndex = 0;
+        const workerCount = Math.min(this.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) => TenantIterator.tenantLabel(failure.tenant)).join(", ");
+            throw new AggregateError(failures.map((failure) => failure.error), `Failed tenant database command for tenant(s): ${failedTenantLabels}`);
+        }
+        return tenants.length;
+    }
+    /**
+     * Enters one tenant's context and runs the callback, asserting the database is active first.
+     * @param {{callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, tenant: ?}} args
+     * @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: ${TenantIterator.tenantLabel(tenant)}`);
+            }
+            await callback({
+                databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),
+                tenant
+            });
+        });
+    }
+    /**
+     * Builds a human-readable label for a tenant for use in error messages.
+     * @param {?} tenant
+     * @returns {string}
+     */
+    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);
+        }
+        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 {@link 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\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\n   * @param {function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback\n   * @returns {Promise<number>}\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\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\n   * @returns {string}\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"]}

package/build/src/tenants/tenant.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Apartment-style runtime façade for multi-tenant apps. A "tenant" is whatever descriptor
+ * object the app's `tenantDatabaseResolver` understands (an account, a project, …); this
+ * class is the single discoverable home for switching into a tenant's context, reading the
+ * current one, iterating every tenant of a database identifier, and dropping a tenant's
+ * database. Switching delegates to {@link Current} (which owns the async-context tenant
+ * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant
+ * makes its database immediately queryable — the apartment-style "switch" semantics — without
+ * the caller establishing connections itself; iteration and drop drive the app's tenant
+ * database provider hooks.
+ */
+export default class Tenant {
+    /**
+     * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.
+     * The callback runs inside `ensureConnections`, so every database identifier the tenant
+     * activates (the global database plus the tenant's database) has a checked-out connection
+     * available for the callback's duration: switching into a tenant makes it queryable without
+     * the caller wiring up connections. Already-checked-out connections are reused, so nesting
+     * `Tenant.with` calls does not open redundant connections. The callback receives the active
+     * connections keyed by identifier, the same as `ensureConnections`.
+     * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
+     * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<?>} callback
+     * @returns {Promise<?>}
+     */
+    static with(tenant: object, callback: (connections: Record<string, import("../database/drivers/base.js").default>) => Promise<unknown>): Promise<unknown>;
+    /**
+     * The current tenant descriptor, or undefined when running outside any tenant context.
+     * @returns {Record<string, unknown> | undefined}
+     */
+    static current(): Record<string, unknown> | undefined;
+    /**
+     * Lists the tenants for a database identifier through the provider and runs `callback`
+     * within each tenant's context, optionally filtered and several at a time. Like
+     * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's
+     * database is queryable without the caller wiring up connections. Returns how many tenants
+     * the callback ran for (after filtering).
+     * @param {{identifier: string, callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import("../configuration.js").default}} args
+     * @returns {Promise<number>}
+     */
+    static each({ identifier, callback, parallel, filter, configuration }: {
+        identifier: string;
+        callback: (arg0: {
+            databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
+            tenant: unknown;
+        }) => Promise<void>;
+        parallel?: number;
+        filter?: (tenant: unknown) => boolean;
+        configuration?: import("../configuration.js").default;
+    }): Promise<number>;
+    /**
+     * Drops one tenant's database/schema through the provider's `dropDatabase` hook.
+     * @param {{identifier: string, tenant: object, configuration?: import("../configuration.js").default}} args
+     * @returns {Promise<void>}
+     */
+    static drop({ identifier, tenant, configuration }: {
+        identifier: string;
+        tenant: object;
+        configuration?: import("../configuration.js").default;
+    }): Promise<void>;
+}
+//# sourceMappingURL=tenant.d.ts.map

package/build/src/tenants/tenant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;;;;OAWG;IACH,oBAJW,MAAM,YACN,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAC,CAAC,GACxF,OAAO,CAAC,OAAC,CAAC,CAMtB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,uEAHW;QAAC,UAAU,EAAE,MAAM,CAAC;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,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,OAAC,KAAK,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,GACpQ,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;;OAIG;IACH,mDAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,GACzF,OAAO,CAAC,IAAI,CAAC,CAyBzB;CACF"}

package/build/src/tenants/tenant.js

@@ -0,0 +1,93 @@
+// @ts-check
+import Current from "../current.js";
+import TenantIterator from "./tenant-iterator.js";
+/**
+ * Apartment-style runtime façade for multi-tenant apps. A "tenant" is whatever descriptor
+ * object the app's `tenantDatabaseResolver` understands (an account, a project, …); this
+ * class is the single discoverable home for switching into a tenant's context, reading the
+ * current one, iterating every tenant of a database identifier, and dropping a tenant's
+ * database. Switching delegates to {@link Current} (which owns the async-context tenant
+ * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant
+ * makes its database immediately queryable — the apartment-style "switch" semantics — without
+ * the caller establishing connections itself; iteration and drop drive the app's tenant
+ * database provider hooks.
+ */
+export default class Tenant {
+    /**
+     * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.
+     * The callback runs inside `ensureConnections`, so every database identifier the tenant
+     * activates (the global database plus the tenant's database) has a checked-out connection
+     * available for the callback's duration: switching into a tenant makes it queryable without
+     * the caller wiring up connections. Already-checked-out connections are reused, so nesting
+     * `Tenant.with` calls does not open redundant connections. The callback receives the active
+     * connections keyed by identifier, the same as `ensureConnections`.
+     * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
+     * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<?>} callback
+     * @returns {Promise<?>}
+     */
+    static async with(tenant, callback) {
+        const configuration = Current.configuration();
+        return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback));
+    }
+    /**
+     * The current tenant descriptor, or undefined when running outside any tenant context.
+     * @returns {Record<string, unknown> | undefined}
+     */
+    static current() {
+        return Current.tenant();
+    }
+    /**
+     * Lists the tenants for a database identifier through the provider and runs `callback`
+     * within each tenant's context, optionally filtered and several at a time. Like
+     * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's
+     * database is queryable without the caller wiring up connections. Returns how many tenants
+     * the callback ran for (after filtering).
+     * @param {{identifier: string, callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import("../configuration.js").default}} args
+     * @returns {Promise<number>}
+     */
+    static async each({ identifier, callback, parallel = 1, filter, configuration = Current.configuration() }) {
+        const provider = configuration.getTenantDatabaseProvider(identifier);
+        const listedTenants = await configuration.ensureConnections({ name: `Tenant.each: ${identifier}` }, async () => {
+            return await provider.listTenants({ configuration, identifier });
+        });
+        if (!Array.isArray(listedTenants)) {
+            throw new Error(`Tenant database provider for ${identifier} must return an array from listTenants`);
+        }
+        const tenants = filter ? listedTenants.filter(filter) : listedTenants;
+        const iterator = new TenantIterator({ configuration, identifier, parallelCount: parallel });
+        // Run each tenant's callback inside ensureConnections so the iterator stays
+        // connection-agnostic (the db:tenants:* CLI commands share TenantIterator and must run
+        // their callbacks, such as create, before the tenant database exists) while runtime
+        // iteration here gets the tenant's connections established the same way Tenant.with does.
+        return await iterator.run(tenants, async (callbackArgs) => {
+            await configuration.ensureConnections({ name: `Tenant.each: ${identifier}` }, async () => await callback(callbackArgs));
+        });
+    }
+    /**
+     * Drops one tenant's database/schema through the provider's `dropDatabase` hook.
+     * @param {{identifier: string, tenant: object, configuration?: import("../configuration.js").default}} args
+     * @returns {Promise<void>}
+     */
+    static async drop({ identifier, tenant, configuration = Current.configuration() }) {
+        const provider = configuration.getTenantDatabaseProvider(identifier);
+        if (typeof provider.dropDatabase !== "function") {
+            throw new Error(`Tenant database provider for ${identifier} must define dropDatabase to drop a tenant`);
+        }
+        await configuration.runWithTenant(tenant, async () => {
+            // Guard against an unresolved tenant. resolveDatabaseConfiguration falls back to the
+            // base (template/default) tenant database when the resolver returns nothing for this
+            // descriptor, so without this check a provider that drops by databaseConfiguration.name
+            // would drop the template database instead of rejecting the bad tenant.
+            if (!configuration.isDatabaseIdentifierActive(identifier)) {
+                throw new Error(`Tenant database identifier ${identifier} is inactive for tenant: ${TenantIterator.tenantLabel(tenant)}`);
+            }
+            await provider.dropDatabase?.({
+                configuration,
+                databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),
+                identifier,
+                tenant
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant.js","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Current from \"../current.js\"\nimport TenantIterator from \"./tenant-iterator.js\"\n\n/**\n * Apartment-style runtime façade for multi-tenant apps. A \"tenant\" is whatever descriptor\n * object the app's `tenantDatabaseResolver` understands (an account, a project, …); this\n * class is the single discoverable home for switching into a tenant's context, reading the\n * current one, iterating every tenant of a database identifier, and dropping a tenant's\n * database. Switching delegates to {@link Current} (which owns the async-context tenant\n * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant\n * makes its database immediately queryable — the apartment-style \"switch\" semantics — without\n * the caller establishing connections itself; iteration and drop drive the app's tenant\n * database provider hooks.\n */\nexport default class Tenant {\n  /**\n   * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.\n   * The callback runs inside `ensureConnections`, so every database identifier the tenant\n   * activates (the global database plus the tenant's database) has a checked-out connection\n   * available for the callback's duration: switching into a tenant makes it queryable without\n   * the caller wiring up connections. Already-checked-out connections are reused, so nesting\n   * `Tenant.with` calls does not open redundant connections. The callback receives the active\n   * connections keyed by identifier, the same as `ensureConnections`.\n   * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.\n   * @param {(connections: Record<string, import(\"../database/drivers/base.js\").default>) => Promise<?>} callback\n   * @returns {Promise<?>}\n   */\n  static async with(tenant, callback) {\n    const configuration = Current.configuration()\n\n    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))\n  }\n\n  /**\n   * The current tenant descriptor, or undefined when running outside any tenant context.\n   * @returns {Record<string, unknown> | undefined}\n   */\n  static current() {\n    return Current.tenant()\n  }\n\n  /**\n   * Lists the tenants for a database identifier through the provider and runs `callback`\n   * within each tenant's context, optionally filtered and several at a time. Like\n   * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's\n   * database is queryable without the caller wiring up connections. Returns how many tenants\n   * the callback ran for (after filtering).\n   * @param {{identifier: string, callback: function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import(\"../configuration.js\").default}} args\n   * @returns {Promise<number>}\n   */\n  static async each({identifier, callback, parallel = 1, filter, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n    const listedTenants = await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => {\n      return await provider.listTenants({configuration, identifier})\n    })\n\n    if (!Array.isArray(listedTenants)) {\n      throw new Error(`Tenant database provider for ${identifier} must return an array from listTenants`)\n    }\n\n    const tenants = filter ? listedTenants.filter(filter) : listedTenants\n    const iterator = new TenantIterator({configuration, identifier, parallelCount: parallel})\n\n    // Run each tenant's callback inside ensureConnections so the iterator stays\n    // connection-agnostic (the db:tenants:* CLI commands share TenantIterator and must run\n    // their callbacks, such as create, before the tenant database exists) while runtime\n    // iteration here gets the tenant's connections established the same way Tenant.with does.\n    return await iterator.run(tenants, async (callbackArgs) => {\n      await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => await callback(callbackArgs))\n    })\n  }\n\n  /**\n   * Drops one tenant's database/schema through the provider's `dropDatabase` hook.\n   * @param {{identifier: string, tenant: object, configuration?: import(\"../configuration.js\").default}} args\n   * @returns {Promise<void>}\n   */\n  static async drop({identifier, tenant, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n\n    if (typeof provider.dropDatabase !== \"function\") {\n      throw new Error(`Tenant database provider for ${identifier} must define dropDatabase to drop a tenant`)\n    }\n\n    await configuration.runWithTenant(tenant, async () => {\n      // Guard against an unresolved tenant. resolveDatabaseConfiguration falls back to the\n      // base (template/default) tenant database when the resolver returns nothing for this\n      // descriptor, so without this check a provider that drops by databaseConfiguration.name\n      // would drop the template database instead of rejecting the bad tenant.\n      if (!configuration.isDatabaseIdentifierActive(identifier)) {\n        throw new Error(`Tenant database identifier ${identifier} is inactive for tenant: ${TenantIterator.tenantLabel(tenant)}`)\n      }\n\n      await provider.dropDatabase?.({\n        configuration,\n        databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),\n        identifier,\n        tenant\n      })\n    })\n  }\n}\n"]}

package/build/tenants/tenant-iterator.js

@@ -0,0 +1,111 @@
+// @ts-check
+
+/**
+ * Runs a callback once within each tenant's context for a tenant database identifier,
+ * optionally several tenants at a time. Each tenant is entered with `runWithTenant`, and a
+ * tenant whose database identifier is inactive throws rather than running the callback
+ * against the wrong connection. When iterating in parallel the per-tenant failures are
+ * collected and rethrown together as an `AggregateError` so one bad tenant does not hide the
+ * others. This is the iteration engine shared by the `db:tenants:*` CLI commands and the
+ * runtime {@link Tenant} façade; the caller is responsible for producing the tenant list.
+ */
+export default class TenantIterator {
+  /**
+   * Creates an iterator bound to a configuration and tenant database identifier.
+   * @param {{configuration: import("../configuration.js").default, identifier: string, parallelCount?: number}} args
+   */
+  constructor({configuration, identifier, parallelCount = 1}) {
+    this.configuration = configuration
+    this.identifier = identifier
+    this.parallelCount = parallelCount
+  }
+
+  /**
+   * Runs `callback` within each tenant's context and returns how many tenants were processed.
+   * @param {Array<?>} tenants
+   * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback
+   * @returns {Promise<number>}
+   */
+  async run(tenants, callback) {
+    if (this.parallelCount <= 1) {
+      for (const tenant of tenants) {
+        await this.runTenantCallback({callback, tenant})
+      }
+
+      return tenants.length
+    }
+
+    /** @type {Array<{error: Error, tenant: ?}>} */
+    const failures = []
+    const workers = []
+    let tenantIndex = 0
+    const workerCount = Math.min(this.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) => TenantIterator.tenantLabel(failure.tenant)).join(", ")
+
+      throw new AggregateError(
+        failures.map((failure) => failure.error),
+        `Failed tenant database command for tenant(s): ${failedTenantLabels}`
+      )
+    }
+
+    return tenants.length
+  }
+
+  /**
+   * Enters one tenant's context and runs the callback, asserting the database is active first.
+   * @param {{callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, tenant: ?}} args
+   * @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: ${TenantIterator.tenantLabel(tenant)}`)
+      }
+
+      await callback({
+        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),
+        tenant
+      })
+    })
+  }
+
+  /**
+   * Builds a human-readable label for a tenant for use in error messages.
+   * @param {?} tenant
+   * @returns {string}
+   */
+  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)
+    }
+
+    return JSON.stringify(tenant)
+  }
+}

package/build/tenants/tenant.js

@@ -0,0 +1,104 @@
+// @ts-check
+
+import Current from "../current.js"
+import TenantIterator from "./tenant-iterator.js"
+
+/**
+ * Apartment-style runtime façade for multi-tenant apps. A "tenant" is whatever descriptor
+ * object the app's `tenantDatabaseResolver` understands (an account, a project, …); this
+ * class is the single discoverable home for switching into a tenant's context, reading the
+ * current one, iterating every tenant of a database identifier, and dropping a tenant's
+ * database. Switching delegates to {@link Current} (which owns the async-context tenant
+ * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant
+ * makes its database immediately queryable — the apartment-style "switch" semantics — without
+ * the caller establishing connections itself; iteration and drop drive the app's tenant
+ * database provider hooks.
+ */
+export default class Tenant {
+  /**
+   * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.
+   * The callback runs inside `ensureConnections`, so every database identifier the tenant
+   * activates (the global database plus the tenant's database) has a checked-out connection
+   * available for the callback's duration: switching into a tenant makes it queryable without
+   * the caller wiring up connections. Already-checked-out connections are reused, so nesting
+   * `Tenant.with` calls does not open redundant connections. The callback receives the active
+   * connections keyed by identifier, the same as `ensureConnections`.
+   * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
+   * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<?>} callback
+   * @returns {Promise<?>}
+   */
+  static async with(tenant, callback) {
+    const configuration = Current.configuration()
+
+    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))
+  }
+
+  /**
+   * The current tenant descriptor, or undefined when running outside any tenant context.
+   * @returns {Record<string, unknown> | undefined}
+   */
+  static current() {
+    return Current.tenant()
+  }
+
+  /**
+   * Lists the tenants for a database identifier through the provider and runs `callback`
+   * within each tenant's context, optionally filtered and several at a time. Like
+   * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's
+   * database is queryable without the caller wiring up connections. Returns how many tenants
+   * the callback ran for (after filtering).
+   * @param {{identifier: string, callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import("../configuration.js").default}} args
+   * @returns {Promise<number>}
+   */
+  static async each({identifier, callback, parallel = 1, filter, configuration = Current.configuration()}) {
+    const provider = configuration.getTenantDatabaseProvider(identifier)
+    const listedTenants = await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => {
+      return await provider.listTenants({configuration, identifier})
+    })
+
+    if (!Array.isArray(listedTenants)) {
+      throw new Error(`Tenant database provider for ${identifier} must return an array from listTenants`)
+    }
+
+    const tenants = filter ? listedTenants.filter(filter) : listedTenants
+    const iterator = new TenantIterator({configuration, identifier, parallelCount: parallel})
+
+    // Run each tenant's callback inside ensureConnections so the iterator stays
+    // connection-agnostic (the db:tenants:* CLI commands share TenantIterator and must run
+    // their callbacks, such as create, before the tenant database exists) while runtime
+    // iteration here gets the tenant's connections established the same way Tenant.with does.
+    return await iterator.run(tenants, async (callbackArgs) => {
+      await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => await callback(callbackArgs))
+    })
+  }
+
+  /**
+   * Drops one tenant's database/schema through the provider's `dropDatabase` hook.
+   * @param {{identifier: string, tenant: object, configuration?: import("../configuration.js").default}} args
+   * @returns {Promise<void>}
+   */
+  static async drop({identifier, tenant, configuration = Current.configuration()}) {
+    const provider = configuration.getTenantDatabaseProvider(identifier)
+
+    if (typeof provider.dropDatabase !== "function") {
+      throw new Error(`Tenant database provider for ${identifier} must define dropDatabase to drop a tenant`)
+    }
+
+    await configuration.runWithTenant(tenant, async () => {
+      // Guard against an unresolved tenant. resolveDatabaseConfiguration falls back to the
+      // base (template/default) tenant database when the resolver returns nothing for this
+      // descriptor, so without this check a provider that drops by databaseConfiguration.name
+      // would drop the template database instead of rejecting the bad tenant.
+      if (!configuration.isDatabaseIdentifierActive(identifier)) {
+        throw new Error(`Tenant database identifier ${identifier} is inactive for tenant: ${TenantIterator.tenantLabel(tenant)}`)
+      }
+
+      await provider.dropDatabase?.({
+        configuration,
+        databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),
+        identifier,
+        tenant
+      })
+    })
+  }
+}