velocious 1.0.557 → 1.0.559

package/build/src/http-client/websocket-client.d.ts

@@ -11,6 +11,9 @@ export default class VelociousWebsocketClient extends SnapReqWebSocketClient {
      * @param {Partial<ConstructorParameters<typeof SnapReqWebSocketClient>[0]>} [args] - Options forwarded to `SnapReqWebSocketClient`.
      */
     constructor(args?: Partial<ConstructorParameters<typeof SnapReqWebSocketClient>[0]>);
+    reconnectGeneration: number;
+    /** @type {Set<Promise<void>>} */
+    runningReconnectTasks: Set<Promise<void>>;
 }
 import SnapReqWebSocketClient from "snapreq/websocket";
 //# sourceMappingURL=websocket-client.d.ts.map

package/build/src/http-client/websocket-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-client.d.ts","sourceRoot":"","sources":["../../../src/http-client/websocket-client.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,mBAFW,OAAO,CAAC,qBAAqB,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,EAQ1E;CACF;mCAxBkC,mBAAmB"}
+{"version":3,"file":"websocket-client.d.ts","sourceRoot":"","sources":["../../../src/http-client/websocket-client.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,mBAFW,OAAO,CAAC,qBAAqB,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,EAW1E;IAHC,4BAA4B;IAC5B,iCAAiC;IACjC,uBADW,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CACS;CA+CzC;mCAxEkC,mBAAmB"}

package/build/src/http-client/websocket-client.js

@@ -20,6 +20,47 @@ export default class VelociousWebsocketClient extends SnapReqWebSocketClient {
             url: args.url ?? DEFAULT_URL,
             deserialize: args.deserialize ?? deserializeFrontendModelTransportValue
         });
+        this.reconnectGeneration = 0;
+        /** @type {Set<Promise<void>>} */
+        this.runningReconnectTasks = new Set();
+    }
+    /**
+     * Ignores an online result resolved after reconnect teardown began.
+     * @returns {Promise<boolean>} - Whether this client generation is online.
+     */
+    async _isOnline() {
+        const generation = this.reconnectGeneration;
+        const isOnline = await super._isOnline();
+        return generation === this.reconnectGeneration && isOnline;
+    }
+    /**
+     * Tracks automatic reconnect work so teardown can drain stale attempts.
+     * @returns {Promise<void>} - Resolves after the reconnect attempt settles.
+     */
+    async _attemptReconnect() {
+        const reconnectTask = super._attemptReconnect();
+        this.runningReconnectTasks.add(reconnectTask);
+        try {
+            await reconnectTask;
+        }
+        finally {
+            this.runningReconnectTasks.delete(reconnectTask);
+        }
+    }
+    /**
+     * Stops reconnect, drains work that already passed SnapReq's reconnect guard,
+     * and clears state changed by a stale attempt while it settled.
+     * @returns {Promise<void>} - Resolves once no reconnect can resurrect a socket.
+     */
+    async disconnectAndStopReconnect() {
+        this.reconnectGeneration += 1;
+        await super.disconnectAndStopReconnect();
+        if (this.runningReconnectTasks.size === 0)
+            return;
+        while (this.runningReconnectTasks.size > 0) {
+            await Promise.all(this.runningReconnectTasks);
+        }
+        await super.disconnectAndStopReconnect();
     }
 }
-//# 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

@@ -4,19 +4,21 @@
  * 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
+ * state) and additionally runs the callback inside `ensureConnections`, initializing registered
+ * tenant-switched models whose tables exist before the callback runs. Entering a tenant therefore
  * 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.
+ * the caller establishing connections or model metadata 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
+     * available for the callback's duration. Registered tenant-switched models whose tables exist
+     * are initialized before the callback runs, so switching into a tenant makes it queryable
+     * without the caller wiring up connections or model metadata. Already-checked-out connections
+     * and in-progress model initialization promises are reused. 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.
@@ -24,6 +26,14 @@ export default class Tenant {
      * @returns {Promise<T>} - Callback result from within the tenant context.
      */
     static with<T>(tenant: object, callback: (connections: Record<string, import("../database/drivers/base.js").default>) => Promise<T>): Promise<T>;
+    /**
+     * Initializes registered tenant-switched models whose tables exist in the
+     * current tenant before runtime callbacks can build synchronous query scopes.
+     * Models for absent optional tables remain deferred until they are used.
+     * @param {import("../configuration.js").default} configuration - Current configuration.
+     * @returns {Promise<void>} - Resolves when available tenant models are initialized.
+     */
+    static _ensureCurrentTenantModelsInitialized(configuration: import("../configuration.js").default): Promise<void>;
     /**
      * The current tenant descriptor, or undefined when running outside any tenant context.
      * @returns {Record<string, unknown> | undefined} - Current async-context tenant descriptor, if any.
@@ -32,9 +42,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. 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).
+     * {@link Tenant.with}, the callback runs inside `ensureConnections` after available
+     * tenant-switched models are initialized, so each tenant's database is queryable without the
+     * caller wiring up connections or model metadata. 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 - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.
      * @returns {Promise<number>} - Number of processed tenants.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAOA;;;;;;;;;;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;;;;;;;;;;;OAWG;IACH,gCAHW,OAAO,wBAAwB,EAAE,sBAAsB,GACrD,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAC,CAI7C;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,CAwBzB;CACF"}
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH;IACE;;;;;;;;;;;;;OAaG;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,CAUtB;IAED;;;;;;OAMG;IACH,4DAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;;;;;;;OASG;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,CAyB3B;IAED;;;;;;;;;;;OAWG;IACH,gCAHW,OAAO,wBAAwB,EAAE,sBAAsB,GACrD,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAC,CAI7C;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,CAwBzB;CACF"}

package/build/src/tenants/tenant.js

@@ -9,19 +9,21 @@ import TenantIterator from "./tenant-iterator.js";
  * 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
+ * state) and additionally runs the callback inside `ensureConnections`, initializing registered
+ * tenant-switched models whose tables exist before the callback runs. Entering a tenant therefore
  * 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.
+ * the caller establishing connections or model metadata 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
+     * available for the callback's duration. Registered tenant-switched models whose tables exist
+     * are initialized before the callback runs, so switching into a tenant makes it queryable
+     * without the caller wiring up connections or model metadata. Already-checked-out connections
+     * and in-progress model initialization promises are reused. 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.
@@ -30,7 +32,36 @@ export default class Tenant {
      */
     static async with(tenant, callback) {
         const configuration = Current.configuration();
-        return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback));
+        return await Current.withTenant(tenant, async () => await configuration.ensureConnections(async (connections) => {
+            await this._ensureCurrentTenantModelsInitialized(configuration);
+            return await callback(connections);
+        }));
+    }
+    /**
+     * Initializes registered tenant-switched models whose tables exist in the
+     * current tenant before runtime callbacks can build synchronous query scopes.
+     * Models for absent optional tables remain deferred until they are used.
+     * @param {import("../configuration.js").default} configuration - Current configuration.
+     * @returns {Promise<void>} - Resolves when available tenant models are initialized.
+     */
+    static async _ensureCurrentTenantModelsInitialized(configuration) {
+        for (const modelClass of Object.values(configuration.getModelClasses())) {
+            if (modelClass.isInitialized() || !modelClass.hasTenantDatabaseIdentifierResolver())
+                continue;
+            const databaseIdentifier = modelClass.getTenantDatabaseIdentifier();
+            if (!databaseIdentifier || !configuration.isDatabaseIdentifierActive(databaseIdentifier))
+                continue;
+            const connection = modelClass.connection();
+            const table = await connection.getTableByName(modelClass.tableName(), { throwError: false });
+            if (!table)
+                continue;
+            if (Object.keys(modelClass.getTranslationsMap()).length > 0) {
+                const translationsTable = await connection.getTableByName(modelClass.getTranslationsTableName(), { throwError: false });
+                if (!translationsTable)
+                    continue;
+            }
+            await modelClass.ensureInitialized({ configuration });
+        }
     }
     /**
      * The current tenant descriptor, or undefined when running outside any tenant context.
@@ -42,9 +73,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. 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).
+     * {@link Tenant.with}, the callback runs inside `ensureConnections` after available
+     * tenant-switched models are initialized, so each tenant's database is queryable without the
+     * caller wiring up connections or model metadata. 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 - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.
      * @returns {Promise<number>} - Number of processed tenants.
      */
@@ -63,7 +95,10 @@ export default class Tenant {
         // 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));
+            await configuration.ensureConnections({ name: `Tenant.each: ${identifier}` }, async () => {
+                await this._ensureCurrentTenantModelsInitialized(configuration);
+                await callback(callbackArgs);
+            });
         });
     }
     /**
@@ -108,4 +143,4 @@ export default class 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 {dropTenantDatabase} from \"./default-tenant-database-provisioning.js\"\nimport TenantAggregator from \"./tenant-aggregator.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 - Operation to run with the tenant's active connections.\n   * @returns {Promise<T>} - Callback result from within the tenant context.\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} - Current async-context tenant descriptor, if any.\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 - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.\n   * @returns {Promise<number>} - Number of processed tenants.\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   * Runs one aggregate query across many tenant databases and returns the merged result. The\n   * tenants may be co-located on the default server or spread across other servers, and can be\n   * created or dropped at runtime; the live tenant list is resolved (from `tenants` or the\n   * provider's `listTenants`), grouped by server, aggregated with a single cross-database\n   * `UNION ALL` where the driver supports it (MySQL/MSSQL) or one query per tenant otherwise\n   * (PostgreSQL/SQLite), and merged with each aggregate's own operation. The caller writes only one\n   * per-tenant subquery and declares the key columns and aggregates; see\n   * {@link import(\"./tenant-aggregator.js\").TenantAggregateOptions}.\n   * @param {import(\"./tenant-aggregator.js\").TenantAggregateOptions} options - Aggregate configuration.\n   * @returns {Promise<Array<Record<string, ?>>>} - One merged row per distinct key-column combination.\n   */\n  static async aggregateAcross(options) {\n    return await new TenantAggregator(options).run()\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 - Tenant descriptor and database identifier to drop.\n   * @returns {Promise<void>}\n   */\n  static async drop({identifier, tenant, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n    const dropDatabase = typeof provider.dropDatabase === \"function\"\n      ? provider.dropDatabase.bind(provider)\n      : dropTenantDatabase\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 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 {dropTenantDatabase} from \"./default-tenant-database-provisioning.js\"\nimport TenantAggregator from \"./tenant-aggregator.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`, initializing registered\n * tenant-switched models whose tables exist before the callback runs. Entering a tenant therefore\n * makes its database immediately queryable — the apartment-style \"switch\" semantics — without\n * the caller establishing connections or model metadata itself; iteration and drop drive the\n * 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   * 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. Registered tenant-switched models whose tables exist\n   * are initialized before the callback runs, so switching into a tenant makes it queryable\n   * without the caller wiring up connections or model metadata. Already-checked-out connections\n   * and in-progress model initialization promises are reused. 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 - Operation to run with the tenant's active connections.\n   * @returns {Promise<T>} - Callback result from within the tenant context.\n   */\n  static async with(tenant, callback) {\n    const configuration = Current.configuration()\n\n    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(async (connections) => {\n      await this._ensureCurrentTenantModelsInitialized(configuration)\n\n      return await callback(connections)\n    }))\n  }\n\n  /**\n   * Initializes registered tenant-switched models whose tables exist in the\n   * current tenant before runtime callbacks can build synchronous query scopes.\n   * Models for absent optional tables remain deferred until they are used.\n   * @param {import(\"../configuration.js\").default} configuration - Current configuration.\n   * @returns {Promise<void>} - Resolves when available tenant models are initialized.\n   */\n  static async _ensureCurrentTenantModelsInitialized(configuration) {\n    for (const modelClass of Object.values(configuration.getModelClasses())) {\n      if (modelClass.isInitialized() || !modelClass.hasTenantDatabaseIdentifierResolver()) continue\n\n      const databaseIdentifier = modelClass.getTenantDatabaseIdentifier()\n\n      if (!databaseIdentifier || !configuration.isDatabaseIdentifierActive(databaseIdentifier)) continue\n\n      const connection = modelClass.connection()\n      const table = await connection.getTableByName(modelClass.tableName(), {throwError: false})\n\n      if (!table) continue\n\n      if (Object.keys(modelClass.getTranslationsMap()).length > 0) {\n        const translationsTable = await connection.getTableByName(modelClass.getTranslationsTableName(), {throwError: false})\n\n        if (!translationsTable) continue\n      }\n\n      await modelClass.ensureInitialized({configuration})\n    }\n  }\n\n  /**\n   * The current tenant descriptor, or undefined when running outside any tenant context.\n   * @returns {Record<string, unknown> | undefined} - Current async-context tenant descriptor, if any.\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` after available\n   * tenant-switched models are initialized, so each tenant's database is queryable without the\n   * caller wiring up connections or model metadata. Returns how many tenants the callback ran\n   * 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 - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.\n   * @returns {Promise<number>} - Number of processed tenants.\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 () => {\n        await this._ensureCurrentTenantModelsInitialized(configuration)\n        await callback(callbackArgs)\n      })\n    })\n  }\n\n  /**\n   * Runs one aggregate query across many tenant databases and returns the merged result. The\n   * tenants may be co-located on the default server or spread across other servers, and can be\n   * created or dropped at runtime; the live tenant list is resolved (from `tenants` or the\n   * provider's `listTenants`), grouped by server, aggregated with a single cross-database\n   * `UNION ALL` where the driver supports it (MySQL/MSSQL) or one query per tenant otherwise\n   * (PostgreSQL/SQLite), and merged with each aggregate's own operation. The caller writes only one\n   * per-tenant subquery and declares the key columns and aggregates; see\n   * {@link import(\"./tenant-aggregator.js\").TenantAggregateOptions}.\n   * @param {import(\"./tenant-aggregator.js\").TenantAggregateOptions} options - Aggregate configuration.\n   * @returns {Promise<Array<Record<string, ?>>>} - One merged row per distinct key-column combination.\n   */\n  static async aggregateAcross(options) {\n    return await new TenantAggregator(options).run()\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 - Tenant descriptor and database identifier to drop.\n   * @returns {Promise<void>}\n   */\n  static async drop({identifier, tenant, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n    const dropDatabase = typeof provider.dropDatabase === \"function\"\n      ? provider.dropDatabase.bind(provider)\n      : dropTenantDatabase\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 dropDatabase({\n        configuration,\n        databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),\n        identifier,\n        tenant\n      })\n    })\n  }\n}\n"]}

package/build/src/testing/factory/factory-registry.d.ts

@@ -187,8 +187,7 @@ export default class FactoryRegistry {
      */
     _runList(strategy: "attributesFor" | "build" | "create", factoryName: string, count: number, args: Array<unknown>): Promise<Array<unknown>>;
     /**
-     * Compiles and runs a factory invocation under a strategy, tracking active
-     * evaluations for the mutation guard.
+     * Compiles and runs a factory invocation under a strategy.
      * @param {object} args - Options.
      * @param {string} args.factoryName - Factory name.
      * @param {string[]} args.traits - Ordered traits.
@@ -196,12 +195,32 @@ export default class FactoryRegistry {
      * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
      * @returns {Promise<?>} - The strategy result.
      */
-    _runFactory({ factoryName, traits, overrides, strategy }: {
+    _runFactory(args: {
         factoryName: string;
         traits: string[];
         overrides: Record<string, unknown>;
         strategy: "attributesFor" | "build" | "create";
     }): Promise<unknown>;
+    /**
+     * Runs one event-tracked invocation, optionally reusing declaration planning.
+     * @param {object} args - Options.
+     * @param {string} args.factoryName - Factory name.
+     * @param {string[]} args.traits - Ordered traits.
+     * @param {Record<string, ?>} args.overrides - Overrides.
+     * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
+     * @param {import("./factory-runner.js").CompiledPlan} [args.planTemplate] - Reusable declaration plan.
+     * @returns {Promise<{result: ?, planTemplate: import("./factory-runner.js").CompiledPlan}>} - Result and declaration plan.
+     */
+    _runFactoryInvocation({ factoryName, traits, overrides, strategy, planTemplate }: {
+        factoryName: string;
+        traits: string[];
+        overrides: Record<string, unknown>;
+        strategy: "attributesFor" | "build" | "create";
+        planTemplate?: import("./factory-runner.js").CompiledPlan | undefined;
+    }): Promise<{
+        result: unknown;
+        planTemplate: import("./factory-runner.js").CompiledPlan;
+    }>;
     /**
      * Registers an immutable factory definition and its aliases.
      * @param {import("./factory-definition.js").default} definition - Compiled factory.

package/build/src/testing/factory/factory-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory-registry.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/factory-registry.js"],"names":[],"mappings":"AAuCA;;;;GAIG;AACH;IAGI,8FAA8F;IAC9F,YADW,GAAG,CAAC,MAAM,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,CACtC;IAE3B,oFAAoF;IACpF,eADW,GAAG,CAAC,MAAM,EAAE,OAAO,uBAAuB,EAAE,OAAO,CAAC,CACjC;IAE9B,2FAA2F;IAC3F,YADW,GAAG,CAAC,MAAM,EAAE,OAAO,eAAe,EAAE,OAAO,CAAC,CAC5B;IAE3B,oGAAoG;IACpG,mBADW,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,eAAe,EAAE,OAAO,CAAC,CAAC,CAClC;IAElC,+FAA+F;IAC/F,qBADW,OAAO,mBAAmB,EAAE,WAAW,EAAE,CACvB;IAE7B,oEAAoE;IACpE,oBADW,MAAM,CACU;IAE3B,6CAA6C;IAC7C,SADW,aAAa,CACc;IAEtC,qEAAqE;IACrE,SADW,mBAAmB,CACU;IAExC,2HAA2H;IAC3H,aADW;QAAC,aAAa,EAAE,qBAAqB,CAAC;QAAC,KAAK,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,cAAc,CAAA;KAAC,CAK9F;IAGH;;;;OAIG;IACH,iBAHW,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACvB,IAAI,CAOhB;IAED;;;;;OAKG;IACH,iBAHW,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACvB,IAAI,CAOhB;IAED;;;;;OAKG;IACH,eAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;OAKG;IACH,UAJW,MAAM,WACN,CAAC,OAAO,EAAE;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAC,CAAA;KAAC,KAAK,IAAI,GAC5H,IAAI,CAMhB;IAED;;;;;OAKG;IACH,WAJW,MAAM,WACN,CAAC,OAAO,EAAE,OAAC,KAAK,IAAI,GAClB,IAAI,CAMhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAMtC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,OAAC,CAAC,CAMtB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,OAAC,CAAC,CAMtB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,SACN,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAC,CAI7C;IAED;;;;;;OAMG;IACH,uBALW,MAAM,SACN,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAI7B;IAED;;;;;;OAMG;IACH,wBALW,MAAM,SACN,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAI7B;IAED;;;;;OAKG;IACH,+BAJW,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAC,CAI7C;IAED;;;;;OAKG;IACH,uBAJW,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAI7B;IAED;;;;;OAKG;IACH,wBAJW,MAAM,WACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAI7B;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,OAAO,CAAC,OAAC,CAAC,CAItB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAW7B;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAKhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,IAAI,CAKhB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAUhB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAUhB;IAED;;;;;;;OAOG;IACH,mBANW,eAAe,GAAG,OAAO,GAAG,QAAQ,eACpC,MAAM,SACN,MAAM,QACN,KAAK,CAAC,OAAC,CAAC,GACN,OAAO,CAAC,KAAK,CAAC,OAAC,CAAC,CAAC,CAY7B;IAED;;;;;;;;;OASG;IACH,0DANG;QAAqB,WAAW,EAAxB,MAAM;QACS,MAAM,EAArB,MAAM,EAAE;QACgB,SAAS,EAAjC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QAC0B,QAAQ,EAAnD,eAAe,GAAG,OAAO,GAAG,QAAQ;KAC5C,GAAU,OAAO,CAAC,OAAC,CAAC,CAwBtB;IAED;;;;OAIG;IACH,uCAHW,OAAO,yBAAyB,EAAE,OAAO,GACvC,IAAI,CAYhB;IAED;;;;;OAKG;IACH,sCAHW,OAAO,yBAAyB,EAAE,OAAO,GACvC,IAAI,CAMhB;IAED;;;;OAIG;IACH,4BAHW,OAAO,uBAAuB,EAAE,OAAO,GACrC,IAAI,CAQhB;IAED;;;;;OAKG;IACH,4BAJW,OAAO,eAAe,EAAE,OAAO,gBAC/B,MAAM,GAAG,IAAI,GACX,IAAI,CAsBhB;IAED;;;;OAIG;IACH,mCAHW,OAAO,mBAAmB,EAAE,WAAW,GACrC,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,cACN,MAAM,EAAE,GACN,OAAO,CAAC,OAAC,CAAC,CAYtB;IAED;;;;OAIG;IACH,qCAHW,MAAM,GACJ,OAAO,eAAe,EAAE,OAAO,CAU3C;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,IAAI,CAMhB;CACF;0BA3eyB,qBAAqB;gCAFf,aAAa;kCAJX,gCAAgC;0BACxC,uBAAuB;2BACtB,wBAAwB"}
+{"version":3,"file":"factory-registry.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/factory-registry.js"],"names":[],"mappings":"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"}