velocious 1.0.483 → 1.0.485

package/README.md

@@ -2242,6 +2242,6 @@ npx velocious db:tenants:migrate projectTenant --parallel 20
 
 `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.
+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).
 
 See [docs/tenant-databases.md](docs/tenant-databases.md) for the full configuration and migration pattern.

package/build/current.js

@@ -70,9 +70,10 @@ export default class Current {
 
   /**
    * Runs with tenant.
+   * @template T
    * @param {object} tenant - Tenant. Any caller-defined object shape; read back (and narrowed) via tenant().
-   * @param {() => Promise<?>} callback - Callback.
-   * @returns {Promise<?>} - Callback result.
+   * @param {() => Promise<T>} callback - Callback.
+   * @returns {Promise<T>} - Callback result.
    */
   static async withTenant(tenant, callback) {
     return await this.configuration().runWithTenant(tenant, callback)

package/build/src/current.d.ts

@@ -35,10 +35,11 @@ export default class Current {
     static setTenant(tenant: object): void;
     /**
      * Runs with tenant.
+     * @template T
      * @param {object} tenant - Tenant. Any caller-defined object shape; read back (and narrowed) via tenant().
-     * @param {() => Promise<?>} callback - Callback.
-     * @returns {Promise<?>} - Callback result.
+     * @param {() => Promise<T>} callback - Callback.
+     * @returns {Promise<T>} - Callback result.
      */
-    static withTenant(tenant: object, callback: () => Promise<unknown>): Promise<unknown>;
+    static withTenant<T>(tenant: object, callback: () => Promise<T>): Promise<T>;
 }
 //# sourceMappingURL=current.d.ts.map

package/build/src/current.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"current.d.ts","sourceRoot":"","sources":["../../src/current.js"],"names":[],"mappings":"AAKA;IACE;;;OAGG;IACH,wBAFa,OAAO,oBAAoB,EAAE,OAAO,CAIhD;IAED;;;OAGG;IACH,kBAFa,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,CAUpE;IAED;;;;OAIG;IACH,2BAHW,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,GACtD,IAAI,CAIhB;IAED;;;;;OAKG;IACH,4BAJW,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,YACxD,MAAM,OAAO,CAAC,OAAC,CAAC,GACd,OAAO,CAAC,OAAC,CAAC,CAItB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAU/C;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,YACN,MAAM,OAAO,CAAC,OAAC,CAAC,GACd,OAAO,CAAC,OAAC,CAAC,CAItB;CACF"}
+{"version":3,"file":"current.d.ts","sourceRoot":"","sources":["../../src/current.js"],"names":[],"mappings":"AAKA;IACE;;;OAGG;IACH,wBAFa,OAAO,oBAAoB,EAAE,OAAO,CAIhD;IAED;;;OAGG;IACH,kBAFa,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,CAUpE;IAED;;;;OAIG;IACH,2BAHW,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,GACtD,IAAI,CAIhB;IAED;;;;;OAKG;IACH,4BAJW,OAAO,4BAA4B,EAAE,OAAO,GAAG,SAAS,YACxD,MAAM,OAAO,CAAC,OAAC,CAAC,GACd,OAAO,CAAC,OAAC,CAAC,CAItB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAU/C;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,kBALa,CAAC,UACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC,CAAC,CAAC,CAItB;CACF"}

package/build/src/current.js

@@ -64,12 +64,13 @@ export default class Current {
     }
     /**
      * Runs with tenant.
+     * @template T
      * @param {object} tenant - Tenant. Any caller-defined object shape; read back (and narrowed) via tenant().
-     * @param {() => Promise<?>} callback - Callback.
-     * @returns {Promise<?>} - Callback result.
+     * @param {() => Promise<T>} callback - Callback.
+     * @returns {Promise<T>} - Callback result.
      */
     static async withTenant(tenant, callback) {
         return await this.configuration().runWithTenant(tenant, callback);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,18 +3,27 @@
  * 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/reading delegate to {@link Current} (which owns the async-context
- * tenant state), so they compose with the existing connection pools and request lifecycle;
- * iteration and drop drive the app's tenant database provider hooks.
+ * 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`.
+     * @template T
      * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
-     * @param {() => Promise<?>} callback
-     * @returns {Promise<?>}
+     * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<T>} callback
+     * @returns {Promise<T>}
      */
-    static with(tenant: object, callback: () => Promise<unknown>): Promise<unknown>;
+    static with<T>(tenant: object, callback: (connections: Record<string, import("../database/drivers/base.js").default>) => Promise<T>): Promise<T>;
     /**
      * The current tenant descriptor, or undefined when running outside any tenant context.
      * @returns {Record<string, unknown> | undefined}
@@ -22,8 +31,10 @@ export default class Tenant {
     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. Returns how
-     * many tenants the callback ran for (after filtering).
+     * 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>}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH;IACE;;;;;OAKG;IACH,oBAJW,MAAM,YACN,MAAM,OAAO,CAAC,OAAC,CAAC,GACd,OAAO,CAAC,OAAC,CAAC,CAItB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;;;;OAMG;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,CAgB3B;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"}
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;;;;;OAYG;IACH,YALa,CAAC,UACH,MAAM,YACN,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,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

@@ -6,19 +6,29 @@ import TenantIterator from "./tenant-iterator.js";
  * 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/reading delegate to {@link Current} (which owns the async-context
- * tenant state), so they compose with the existing connection pools and request lifecycle;
- * iteration and drop drive the app's tenant database provider hooks.
+ * 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`.
+     * @template T
      * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
-     * @param {() => Promise<?>} callback
-     * @returns {Promise<?>}
+     * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<T>} callback
+     * @returns {Promise<T>}
      */
     static async with(tenant, callback) {
-        return await Current.withTenant(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.
@@ -29,8 +39,10 @@ export default class 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. Returns how
-     * many tenants the callback ran for (after filtering).
+     * 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>}
      */
@@ -44,7 +56,13 @@ export default class Tenant {
         }
         const tenants = filter ? listedTenants.filter(filter) : listedTenants;
         const iterator = new TenantIterator({ configuration, identifier, parallelCount: parallel });
-        return await iterator.run(tenants, callback);
+        // 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.
@@ -73,4 +91,4 @@ export default class Tenant {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant.js","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,OAAO,MAAM,eAAe,CAAA;AACnC,OAAO,cAAc,MAAM,sBAAsB,CAAA;AAEjD;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ;QAChC,OAAO,MAAM,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACnD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,OAAO,CAAC,MAAM,EAAE,CAAA;IACzB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,QAAQ,EAAE,QAAQ,GAAG,CAAC,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE,EAAC;QACrG,MAAM,QAAQ,GAAG,aAAa,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAA;QACpE,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,iBAAiB,CAAC,EAAC,IAAI,EAAE,gBAAgB,UAAU,EAAE,EAAC,EAAE,KAAK,IAAI,EAAE;YAC3G,OAAO,MAAM,QAAQ,CAAC,WAAW,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,CAAC,CAAA;QAChE,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,gCAAgC,UAAU,wCAAwC,CAAC,CAAA;QACrG,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,aAAa,CAAA;QACrE,MAAM,QAAQ,GAAG,IAAI,cAAc,CAAC,EAAC,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,EAAC,CAAC,CAAA;QAEzF,OAAO,MAAM,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC9C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE,EAAC;QAC7E,MAAM,QAAQ,GAAG,aAAa,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAA;QAEpE,IAAI,OAAO,QAAQ,CAAC,YAAY,KAAK,UAAU,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,gCAAgC,UAAU,4CAA4C,CAAC,CAAA;QACzG,CAAC;QAED,MAAM,aAAa,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE;YACnD,qFAAqF;YACrF,qFAAqF;YACrF,wFAAwF;YACxF,wEAAwE;YACxE,IAAI,CAAC,aAAa,CAAC,0BAA0B,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC1D,MAAM,IAAI,KAAK,CAAC,8BAA8B,UAAU,4BAA4B,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;YAC3H,CAAC;YAED,MAAM,QAAQ,CAAC,YAAY,EAAE,CAAC;gBAC5B,aAAa;gBACb,qBAAqB,EAAE,aAAa,CAAC,4BAA4B,CAAC,UAAU,CAAC;gBAC7E,UAAU;gBACV,MAAM;aACP,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;CACF","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/reading delegate to {@link Current} (which owns the async-context\n * tenant state), so they compose with the existing connection pools and request lifecycle;\n * iteration and drop drive the app's tenant database provider hooks.\n */\nexport default class Tenant {\n  /**\n   * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.\n   * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.\n   * @param {() => Promise<?>} callback\n   * @returns {Promise<?>}\n   */\n  static async with(tenant, callback) {\n    return await Current.withTenant(tenant, 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. Returns how\n   * many tenants 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    return await iterator.run(tenants, callback)\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"]}
+//# 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   * @template T\n   * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.\n   * @param {(connections: Record<string, import(\"../database/drivers/base.js\").default>) => Promise<T>} callback\n   * @returns {Promise<T>}\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.js

@@ -8,19 +8,30 @@ import TenantIterator from "./tenant-iterator.js"
  * 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/reading delegate to {@link Current} (which owns the async-context
- * tenant state), so they compose with the existing connection pools and request lifecycle;
- * iteration and drop drive the app's tenant database provider hooks.
+ * 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`.
+   * @template T
    * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
-   * @param {() => Promise<?>} callback
-   * @returns {Promise<?>}
+   * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<T>} callback
+   * @returns {Promise<T>}
    */
   static async with(tenant, callback) {
-    return await Current.withTenant(tenant, callback)
+    const configuration = Current.configuration()
+
+    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))
   }
 
   /**
@@ -33,8 +44,10 @@ export default class 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. Returns how
-   * many tenants the callback ran for (after filtering).
+   * 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>}
    */
@@ -51,7 +64,13 @@ export default class Tenant {
     const tenants = filter ? listedTenants.filter(filter) : listedTenants
     const iterator = new TenantIterator({configuration, identifier, parallelCount: parallel})
 
-    return await iterator.run(tenants, callback)
+    // 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))
+    })
   }
 
   /**

package/package.json

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

package/src/current.js

@@ -70,9 +70,10 @@ export default class Current {
 
   /**
    * Runs with tenant.
+   * @template T
    * @param {object} tenant - Tenant. Any caller-defined object shape; read back (and narrowed) via tenant().
-   * @param {() => Promise<?>} callback - Callback.
-   * @returns {Promise<?>} - Callback result.
+   * @param {() => Promise<T>} callback - Callback.
+   * @returns {Promise<T>} - Callback result.
    */
   static async withTenant(tenant, callback) {
     return await this.configuration().runWithTenant(tenant, callback)

package/src/tenants/tenant.js

@@ -8,19 +8,30 @@ import TenantIterator from "./tenant-iterator.js"
  * 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/reading delegate to {@link Current} (which owns the async-context
- * tenant state), so they compose with the existing connection pools and request lifecycle;
- * iteration and drop drive the app's tenant database provider hooks.
+ * 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`.
+   * @template T
    * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
-   * @param {() => Promise<?>} callback
-   * @returns {Promise<?>}
+   * @param {(connections: Record<string, import("../database/drivers/base.js").default>) => Promise<T>} callback
+   * @returns {Promise<T>}
    */
   static async with(tenant, callback) {
-    return await Current.withTenant(tenant, callback)
+    const configuration = Current.configuration()
+
+    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))
   }
 
   /**
@@ -33,8 +44,10 @@ export default class 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. Returns how
-   * many tenants the callback ran for (after filtering).
+   * 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>}
    */
@@ -51,7 +64,13 @@ export default class Tenant {
     const tenants = filter ? listedTenants.filter(filter) : listedTenants
     const iterator = new TenantIterator({configuration, identifier, parallelCount: parallel})
 
-    return await iterator.run(tenants, callback)
+    // 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))
+    })
   }
 
   /**