velocious 1.0.577 → 1.0.579

package/build/src/tenants/tenant-model-scope.js

@@ -0,0 +1,115 @@
+// @ts-check
+import TenantHandle from "./tenant-handle.js";
+/**
+ * Model query/create scope bound to one immutable tenant handle.
+ * @template {typeof import("../database/record/index.js").default} MC
+ */
+export default class TenantModelScope {
+    /**
+     * Runs constructor.
+     * @param {object} args - Scope arguments.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {MC} args.modelClass - Model class to bind.
+     * @param {object} args.tenant - Ordinary or null-prototype JSON-compatible tenant descriptor.
+     */
+    constructor({ configuration, modelClass, tenant }) {
+        this._handle = new TenantHandle({ configuration, tenant });
+        this._modelClass = modelClass;
+        this._databaseIdentifier = modelClass.getDatabaseIdentifier({ tenant });
+        Object.freeze(this);
+    }
+    /**
+     * Runs a general model query/write callback on the captured physical tenant.
+     * The query and every record/association it loads are owned by the operation
+     * and must be used inside the callback.
+     * @template T
+     * @param {(query: import("../database/query/model-class-query.js").default<MC>, operation: import("../database/operation.js").default) => Promise<T>} callback - Bound model callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async databaseOperation(callback) {
+        return await this._handle.databaseOperation({
+            databaseIdentifier: this._databaseIdentifier,
+            name: `usingTenant: ${this._modelClass.getModelName()}`
+        }, async (operation) => {
+            await operation.ensureModelInitialized(this._modelClass);
+            return await callback(operation.forModel(this._modelClass), operation);
+        });
+    }
+    /**
+     * Runs a model callback in a transaction on the captured physical tenant.
+     * @template T
+     * @param {(query: import("../database/query/model-class-query.js").default<MC>, operation: import("../database/operation.js").default) => Promise<T>} callback - Transaction callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async transaction(callback) {
+        return await this._handle.transaction({
+            databaseIdentifier: this._databaseIdentifier,
+            name: `usingTenant transaction: ${this._modelClass.getModelName()}`
+        }, async (operation) => {
+            await operation.ensureModelInitialized(this._modelClass);
+            return await callback(operation.forModel(this._modelClass), operation);
+        });
+    }
+    /**
+     * Creates a record on the captured tenant.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [attributes] - Create attributes.
+     * @returns {Promise<InstanceType<MC>>} - Created record.
+     */
+    async create(attributes = {}) {
+        return await this.databaseOperation(async (query, operation) => {
+            const record = await query.create(attributes);
+            return record.releaseDatabaseOperation(operation);
+        });
+    }
+    /**
+     * Counts records on the captured tenant.
+     * @returns {Promise<number>} - Count on the captured tenant.
+     */
+    async count() {
+        return await this.databaseOperation(async (query) => await query.count());
+    }
+    /**
+     * Finds a record by primary key on the captured tenant.
+     * @param {string | number} recordId - Record identifier.
+     * @returns {Promise<InstanceType<MC> | null>} - Found record.
+     */
+    async find(recordId) {
+        return await this.databaseOperation(async (query, operation) => {
+            const record = await query.find(recordId);
+            return record ? record.releaseDatabaseOperation(operation) : null;
+        });
+    }
+    /**
+     * Finds a record by conditions on the captured tenant.
+     * @param {Record<string, string | number>} conditions - Finder conditions.
+     * @returns {Promise<InstanceType<MC> | null>} - Found record.
+     */
+    async findBy(conditions) {
+        return await this.databaseOperation(async (query, operation) => {
+            const record = await query.findBy(conditions);
+            return record ? record.releaseDatabaseOperation(operation) : null;
+        });
+    }
+    /**
+     * Finds a record by conditions or raises on the captured tenant.
+     * @param {Record<string, string | number>} conditions - Finder conditions.
+     * @returns {Promise<InstanceType<MC>>} - Found record.
+     */
+    async findByOrFail(conditions) {
+        return await this.databaseOperation(async (query, operation) => {
+            const record = await query.findByOrFail(conditions);
+            return record.releaseDatabaseOperation(operation);
+        });
+    }
+    /**
+     * Loads all records on the captured tenant.
+     * @returns {Promise<InstanceType<MC>[]>} - All records on the captured tenant.
+     */
+    async toArray() {
+        return await this.databaseOperation(async (query, operation) => {
+            const records = await query.toArray();
+            return records.map((record) => record.releaseDatabaseOperation(operation));
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-model-scope.js","sourceRoot":"","sources":["../../../src/tenants/tenant-model-scope.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport TenantHandle from \"./tenant-handle.js\"\n\n/**\n * Model query/create scope bound to one immutable tenant handle.\n * @template {typeof import(\"../database/record/index.js\").default} MC\n */\nexport default class TenantModelScope {\n  /**\n   * Runs constructor.\n   * @param {object} args - Scope arguments.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {MC} args.modelClass - Model class to bind.\n   * @param {object} args.tenant - Ordinary or null-prototype JSON-compatible tenant descriptor.\n   */\n  constructor({configuration, modelClass, tenant}) {\n    this._handle = new TenantHandle({configuration, tenant})\n    this._modelClass = modelClass\n    this._databaseIdentifier = modelClass.getDatabaseIdentifier({tenant})\n\n    Object.freeze(this)\n  }\n\n  /**\n   * Runs a general model query/write callback on the captured physical tenant.\n   * The query and every record/association it loads are owned by the operation\n   * and must be used inside the callback.\n   * @template T\n   * @param {(query: import(\"../database/query/model-class-query.js\").default<MC>, operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Bound model callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async databaseOperation(callback) {\n    return await this._handle.databaseOperation({\n      databaseIdentifier: this._databaseIdentifier,\n      name: `usingTenant: ${this._modelClass.getModelName()}`\n    }, async (operation) => {\n      await operation.ensureModelInitialized(this._modelClass)\n\n      return await callback(operation.forModel(this._modelClass), operation)\n    })\n  }\n\n  /**\n   * Runs a model callback in a transaction on the captured physical tenant.\n   * @template T\n   * @param {(query: import(\"../database/query/model-class-query.js\").default<MC>, operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    return await this._handle.transaction({\n      databaseIdentifier: this._databaseIdentifier,\n      name: `usingTenant transaction: ${this._modelClass.getModelName()}`\n    }, async (operation) => {\n      await operation.ensureModelInitialized(this._modelClass)\n\n      return await callback(operation.forModel(this._modelClass), operation)\n    })\n  }\n\n  /**\n   * Creates a record on the captured tenant.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} [attributes] - Create attributes.\n   * @returns {Promise<InstanceType<MC>>} - Created record.\n   */\n  async create(attributes = {}) {\n    return await this.databaseOperation(async (query, operation) => {\n      const record = await query.create(attributes)\n\n      return record.releaseDatabaseOperation(operation)\n    })\n  }\n\n  /**\n   * Counts records on the captured tenant.\n   * @returns {Promise<number>} - Count on the captured tenant.\n   */\n  async count() {\n    return await this.databaseOperation(async (query) => await query.count())\n  }\n\n  /**\n   * Finds a record by primary key on the captured tenant.\n   * @param {string | number} recordId - Record identifier.\n   * @returns {Promise<InstanceType<MC> | null>} - Found record.\n   */\n  async find(recordId) {\n    return await this.databaseOperation(async (query, operation) => {\n      const record = await query.find(recordId)\n\n      return record ? record.releaseDatabaseOperation(operation) : null\n    })\n  }\n\n  /**\n   * Finds a record by conditions on the captured tenant.\n   * @param {Record<string, string | number>} conditions - Finder conditions.\n   * @returns {Promise<InstanceType<MC> | null>} - Found record.\n   */\n  async findBy(conditions) {\n    return await this.databaseOperation(async (query, operation) => {\n      const record = await query.findBy(conditions)\n\n      return record ? record.releaseDatabaseOperation(operation) : null\n    })\n  }\n\n  /**\n   * Finds a record by conditions or raises on the captured tenant.\n   * @param {Record<string, string | number>} conditions - Finder conditions.\n   * @returns {Promise<InstanceType<MC>>} - Found record.\n   */\n  async findByOrFail(conditions) {\n    return await this.databaseOperation(async (query, operation) => {\n      const record = await query.findByOrFail(conditions)\n\n      return record.releaseDatabaseOperation(operation)\n    })\n  }\n\n  /**\n   * Loads all records on the captured tenant.\n   * @returns {Promise<InstanceType<MC>[]>} - All records on the captured tenant.\n   */\n  async toArray() {\n    return await this.databaseOperation(async (query, operation) => {\n      const records = await query.toArray()\n\n      return records.map((record) => record.releaseDatabaseOperation(operation))\n    })\n  }\n}\n"]}

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

@@ -1,3 +1,4 @@
+import TenantHandle from "./tenant-handle.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
@@ -11,6 +12,15 @@
  * app's tenant database provider hooks.
  */
 export default class Tenant {
+    /**
+     * Captures an immutable tenant/database handle for explicit browser/native
+     * ORM operations. Physical database configurations are resolved now and are
+     * never recomputed from later ambient tenant changes.
+     * @param {object} tenant - Ordinary or null-prototype JSON-compatible descriptor understood by the app's tenant database resolver.
+     * @param {import("../configuration.js").default} [configuration] - Owning configuration.
+     * @returns {TenantHandle} - Immutable captured handle.
+     */
+    static handle(tenant: object, configuration?: import("../configuration.js").default): TenantHandle;
     /**
      * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.
      * The callback runs inside `ensureConnections`, so every database identifier the tenant
@@ -46,17 +56,17 @@ export default class Tenant {
      * 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.
+     * @param {{identifier: string, callback: (args: {databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ReturnType<typeof JSON.parse>}) => Promise<void>, parallel?: number, filter?: (tenant: ReturnType<typeof JSON.parse>) => boolean, configuration?: import("../configuration.js").default}} args - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.
      * @returns {Promise<number>} - Number of processed tenants.
      */
     static each({ identifier, callback, parallel, filter, configuration }: {
         identifier: string;
-        callback: (arg0: {
+        callback: (args: {
             databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
-            tenant: unknown;
+            tenant: ReturnType<typeof JSON.parse>;
         }) => Promise<void>;
         parallel?: number;
-        filter?: (tenant: unknown) => boolean;
+        filter?: (tenant: ReturnType<typeof JSON.parse>) => boolean;
         configuration?: import("../configuration.js").default;
     }): Promise<number>;
     /**
@@ -69,9 +79,9 @@ export default class Tenant {
      * per-tenant subquery and declares the key columns and aggregates; see
      * {@link import("./tenant-aggregator.js").TenantAggregateOptions}.
      * @param {import("./tenant-aggregator.js").TenantAggregateOptions} options - Aggregate configuration.
-     * @returns {Promise<Array<Record<string, ?>>>} - One merged row per distinct key-column combination.
+     * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} - One merged row per distinct key-column combination.
      */
-    static aggregateAcross(options: import("./tenant-aggregator.js").TenantAggregateOptions): Promise<Array<Record<string, unknown>>>;
+    static aggregateAcross(options: import("./tenant-aggregator.js").TenantAggregateOptions): Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>;
     /**
      * Drops one tenant's database/schema through the provider's `dropDatabase` hook.
      * @param {{identifier: string, tenant: object, configuration?: import("../configuration.js").default}} args - Tenant descriptor and database identifier to drop.

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;;;;;;;;;;;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"}
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAKA,OAAO,YAAY,MAAM,oBAAoB,CAAA;AAG7C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAJT,MAIS,EAAE,aAAa,AAHhC,CACA,EADQ,OAAO,qBAAqB,EAAE,OAGoB,GAFhD,YAAY,CAIxB;IAED;;;;;;;;;;;;;OAaG;IACH,OAAa,IAAI,CALJ,CAAC,EAKI,MAAM,EAJb,MAIa,EAAE,QAAQ,EAHvB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAGlE,GAFrB,OAAO,CAAC,CAAC,CAAC,CAUtB;IAED;;;;;;OAMG;IACH,OAAa,qCAAqC,CAAC,aAAa,EAHrD,OAAO,qBAAqB,EAAE,OAGuB,GAFnD,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,IAFD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;;;;;;;OASG;IACH,OAAa,IAAI,CAAC,EAAC,UAAU,EAAE,QAAQ,EAAE,QAAY,EAAE,MAAM,EAAE,aAAuC,EAAC,EAH5F;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,CAAC,IAAI,EAAE;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;SAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAGhO,GAF1F,OAAO,CAAC,MAAM,CAAC,CAyB3B;IAED;;;;;;;;;;;OAWG;IACH,OAAa,eAAe,CAAC,OAAO,EAHzB,OAAO,wBAAwB,EAAE,sBAGR,GAFvB,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAIzE;IAED;;;;OAIG;IACH,OAAa,IAAI,CAAC,EAAC,UAAU,EAAE,MAAM,EAAE,aAAuC,EAAC,EAHpE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAGtB,GAFlE,OAAO,CAAC,IAAI,CAAC,CAwBzB;CACF"}

package/build/src/tenants/tenant.js

@@ -2,6 +2,7 @@
 import Current from "../current.js";
 import { dropTenantDatabase } from "./default-tenant-database-provisioning.js";
 import TenantAggregator from "./tenant-aggregator.js";
+import TenantHandle from "./tenant-handle.js";
 import TenantIterator from "./tenant-iterator.js";
 /**
  * Apartment-style runtime façade for multi-tenant apps. A "tenant" is whatever descriptor
@@ -16,6 +17,17 @@ import TenantIterator from "./tenant-iterator.js";
  * app's tenant database provider hooks.
  */
 export default class Tenant {
+    /**
+     * Captures an immutable tenant/database handle for explicit browser/native
+     * ORM operations. Physical database configurations are resolved now and are
+     * never recomputed from later ambient tenant changes.
+     * @param {object} tenant - Ordinary or null-prototype JSON-compatible descriptor understood by the app's tenant database resolver.
+     * @param {import("../configuration.js").default} [configuration] - Owning configuration.
+     * @returns {TenantHandle} - Immutable captured handle.
+     */
+    static handle(tenant, configuration = Current.configuration()) {
+        return new TenantHandle({ configuration, 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
@@ -77,7 +89,7 @@ export default class Tenant {
      * 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.
+     * @param {{identifier: string, callback: (args: {databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ReturnType<typeof JSON.parse>}) => Promise<void>, parallel?: number, filter?: (tenant: ReturnType<typeof JSON.parse>) => boolean, configuration?: import("../configuration.js").default}} args - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.
      * @returns {Promise<number>} - Number of processed tenants.
      */
     static async each({ identifier, callback, parallel = 1, filter, configuration = Current.configuration() }) {
@@ -111,7 +123,7 @@ export default class Tenant {
      * per-tenant subquery and declares the key columns and aggregates; see
      * {@link import("./tenant-aggregator.js").TenantAggregateOptions}.
      * @param {import("./tenant-aggregator.js").TenantAggregateOptions} options - Aggregate configuration.
-     * @returns {Promise<Array<Record<string, ?>>>} - One merged row per distinct key-column combination.
+     * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} - One merged row per distinct key-column combination.
      */
     static async aggregateAcross(options) {
         return await new TenantAggregator(options).run();
@@ -143,4 +155,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`, 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"]}
+//# 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,EAAC,kBAAkB,EAAC,MAAM,2CAA2C,CAAA;AAC5E,OAAO,gBAAgB,MAAM,wBAAwB,CAAA;AACrD,OAAO,YAAY,MAAM,oBAAoB,CAAA;AAC7C,OAAO,cAAc,MAAM,sBAAsB,CAAA;AAEjD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE;QAC3D,OAAO,IAAI,YAAY,CAAC,EAAC,aAAa,EAAE,MAAM,EAAC,CAAC,CAAA;IAClD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ;QAChC,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE,CAAA;QAE7C,OAAO,MAAM,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,aAAa,CAAC,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE;YAC9G,MAAM,IAAI,CAAC,qCAAqC,CAAC,aAAa,CAAC,CAAA;YAE/D,OAAO,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAA;QACpC,CAAC,CAAC,CAAC,CAAA;IACL,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,aAAa;QAC9D,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC,EAAE,CAAC;YACxE,IAAI,UAAU,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,mCAAmC,EAAE;gBAAE,SAAQ;YAE7F,MAAM,kBAAkB,GAAG,UAAU,CAAC,2BAA2B,EAAE,CAAA;YAEnE,IAAI,CAAC,kBAAkB,IAAI,CAAC,aAAa,CAAC,0BAA0B,CAAC,kBAAkB,CAAC;gBAAE,SAAQ;YAElG,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,EAAE,CAAA;YAC1C,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,EAAE,EAAE,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;YAE1F,IAAI,CAAC,KAAK;gBAAE,SAAQ;YAEpB,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5D,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,wBAAwB,EAAE,EAAE,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;gBAErH,IAAI,CAAC,iBAAiB;oBAAE,SAAQ;YAClC,CAAC;YAED,MAAM,UAAU,CAAC,iBAAiB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;QACrD,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,OAAO,CAAC,MAAM,EAAE,CAAA;IACzB,CAAC;IAED;;;;;;;;;OASG;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,4EAA4E;QAC5E,uFAAuF;QACvF,oFAAoF;QACpF,0FAA0F;QAC1F,OAAO,MAAM,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE;YACxD,MAAM,aAAa,CAAC,iBAAiB,CAAC,EAAC,IAAI,EAAE,gBAAgB,UAAU,EAAE,EAAC,EAAE,KAAK,IAAI,EAAE;gBACrF,MAAM,IAAI,CAAC,qCAAqC,CAAC,aAAa,CAAC,CAAA;gBAC/D,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAA;YAC9B,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,OAAO;QAClC,OAAO,MAAM,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAA;IAClD,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;QACpE,MAAM,YAAY,GAAG,OAAO,QAAQ,CAAC,YAAY,KAAK,UAAU;YAC9D,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC;YACtC,CAAC,CAAC,kBAAkB,CAAA;QAEtB,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,YAAY,CAAC;gBACjB,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 {dropTenantDatabase} from \"./default-tenant-database-provisioning.js\"\nimport TenantAggregator from \"./tenant-aggregator.js\"\nimport TenantHandle from \"./tenant-handle.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   * Captures an immutable tenant/database handle for explicit browser/native\n   * ORM operations. Physical database configurations are resolved now and are\n   * never recomputed from later ambient tenant changes.\n   * @param {object} tenant - Ordinary or null-prototype JSON-compatible descriptor understood by the app's tenant database resolver.\n   * @param {import(\"../configuration.js\").default} [configuration] - Owning configuration.\n   * @returns {TenantHandle} - Immutable captured handle.\n   */\n  static handle(tenant, configuration = Current.configuration()) {\n    return new TenantHandle({configuration, tenant})\n  }\n\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: (args: {databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ReturnType<typeof JSON.parse>}) => Promise<void>, parallel?: number, filter?: (tenant: ReturnType<typeof JSON.parse>) => 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, ReturnType<typeof JSON.parse>>>>} - 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/base-expect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-expect.d.ts","sourceRoot":"","sources":["../../../src/testing/base-expect.js"],"names":[],"mappings":"AAEA;IACE;;;;OAIG;IACH,aAFa,OAAO,CAAC,IAAI,CAAC,CAEY;IAEtC;;;;OAIG;IACH,YAFa,OAAO,CAAC,IAAI,CAAC,CAEW;CACtC"}
+{"version":3,"file":"base-expect.d.ts","sourceRoot":"","sources":["../../../src/testing/base-expect.js"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B;;;;OAIG;IACG,SAAS,IAFF,OAAO,CAAC,IAAI,CAAC,CAEY;IAEtC;;;;OAIG;IACG,QAAQ,IAFD,OAAO,CAAC,IAAI,CAAC,CAEW;CACtC"}

package/build/src/testing/browser-frontend-model-event-hook-scenarios.d.ts

@@ -1,29 +1,12 @@
-/**
- * Runs run frontend model event hook scenario.
- * @param {keyof typeof scenarios} scenarioName - Scenario name.
- * @returns {Promise<Record<string, number>>} - Scenario result.
- */
-export default function runFrontendModelEventHookScenario(scenarioName: keyof typeof scenarios): Promise<Record<string, number>>;
-/**
- * FrontendModelResourceConfig type.
- */
+import FrontendModelBase from "../frontend-models/base.js";
 export type FrontendModelResourceConfig = import("../frontend-models/base.js").FrontendModelResourceConfig;
-/**
- * Defines this typedef.
- */
 export type FrontendModelHookTestCreateUpdatePayload = {
     id: string;
     model: FrontendModelBase;
 };
-/**
- * Defines this typedef.
- */
 export type FrontendModelHookTestDestroyPayload = {
     id: string;
 };
-/**
- * FakeSubscriptions type.
- */
 export type FakeSubscriptions = {
     /**
      * - Create callbacks.
@@ -46,24 +29,11 @@ export type FakeSubscriptions = {
      */
     update: Set<(payload: FrontendModelHookTestCreateUpdatePayload) => void>;
 };
-declare namespace scenarios {
-    export { classLifecycleScenario as classLifecycle };
-    export { debounceUnmountScenario as debounceUnmount };
-    export { instanceLifecycleScenario as instanceLifecycle };
-    export { projectionOptionsScenario as projectionOptions };
-    export { resubscribeInstanceScenario as resubscribeInstance };
-}
-import FrontendModelBase from "../frontend-models/base.js";
 /**
  * Runs class lifecycle scenario.
  * @returns {Promise<Record<string, number>>} - Scenario result.
  */
 declare function classLifecycleScenario(): Promise<Record<string, number>>;
-/**
- * Runs debounce unmount scenario.
- * @returns {Promise<Record<string, number>>} - Scenario result.
- */
-declare function debounceUnmountScenario(): Promise<Record<string, number>>;
 /**
  * Runs instance lifecycle scenario.
  * @returns {Promise<Record<string, number>>} - Scenario result.
@@ -74,10 +44,28 @@ declare function instanceLifecycleScenario(): Promise<Record<string, number>>;
  * @returns {Promise<Record<string, number>>} - Scenario result.
  */
 declare function projectionOptionsScenario(): Promise<Record<string, number>>;
+/**
+ * Runs debounce unmount scenario.
+ * @returns {Promise<Record<string, number>>} - Scenario result.
+ */
+declare function debounceUnmountScenario(): Promise<Record<string, number>>;
 /**
  * Runs resubscribe instance scenario.
  * @returns {Promise<Record<string, number>>} - Scenario result.
  */
 declare function resubscribeInstanceScenario(): Promise<Record<string, number>>;
+declare const scenarios: {
+    classLifecycle: typeof classLifecycleScenario;
+    debounceUnmount: typeof debounceUnmountScenario;
+    instanceLifecycle: typeof instanceLifecycleScenario;
+    projectionOptions: typeof projectionOptionsScenario;
+    resubscribeInstance: typeof resubscribeInstanceScenario;
+};
+/**
+ * Runs run frontend model event hook scenario.
+ * @param {keyof typeof scenarios} scenarioName - Scenario name.
+ * @returns {Promise<Record<string, number>>} - Scenario result.
+ */
+export default function runFrontendModelEventHookScenario(scenarioName: keyof typeof scenarios): Promise<Record<string, number>>;
 export {};
 //# sourceMappingURL=browser-frontend-model-event-hook-scenarios.d.ts.map

package/build/src/testing/browser-frontend-model-event-hook-scenarios.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-frontend-model-event-hook-scenarios.d.ts","sourceRoot":"","sources":["../../../src/testing/browser-frontend-model-event-hook-scenarios.js"],"names":[],"mappings":"AA4fA;;;;GAIG;AACH,wEAHW,MAAM,OAAO,SAAS,GACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ3C;;;;0CAzfY,OAAO,4BAA4B,EAAE,2BAA2B;;;;uDAGhE;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAC;;;;kDAGtC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC;;;;;;;;YAIX,GAAG,CAAC,CAAC,OAAO,EAAE,wCAAwC,KAAK,IAAI,CAAC;;;;aAChE,GAAG,CAAC,CAAC,OAAO,EAAE,mCAAmC,KAAK,IAAI,CAAC;;;;aAC3D;QAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,+BAA+B,EAAE,CAAC;QAAC,OAAO,EAAE,OAAO,6BAA6B,EAAE,+BAA+B,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,+BAA+B,EAAE,CAAA;KAAC;;;;YACpP,GAAG,CAAC,CAAC,OAAO,EAAE,wCAAwC,KAAK,IAAI,CAAC;;;;;;;;;8BApBhD,4BAA4B;AA6O1D;;;GAGG;AACH,2CAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiD3C;AA4GD;;;GAGG;AACH,4CAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkC3C;AA9ID;;;GAGG;AACH,8CAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgD3C;AAED;;;GAGG;AACH,8CAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkD3C;AAwCD;;;GAGG;AACH,gDAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAuD3C"}
+{"version":3,"file":"browser-frontend-model-event-hook-scenarios.d.ts","sourceRoot":"","sources":["../../../src/testing/browser-frontend-model-event-hook-scenarios.js"],"names":[],"mappings":"AAOA,OAAO,iBAAiB,MAAM,4BAA4B,CAAA;AAOvD,YAA4E,2BAA2B,GAA7F,OAAO,4BAA4B,EAAE,2BAA2B,CAA6B;AAGvG,YAAkD,wCAAwC,GAAhF;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAC,CAA0C;AAG1F,YAAwB,mCAAmC,GAAjD;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAAqC;AAG3D,YAAkB,iBAAiB,GACnC;;;;IAA6E,MAAM,EAAxE,GAAG,CAAC,CAAC,OAAO,EAAE,wCAAwC,KAAK,IAAI,CAAC,CAC3E;;;;IAAwE,OAAO,EAApE,GAAG,CAAC,CAAC,OAAO,EAAE,mCAAmC,KAAK,IAAI,CAAC,CACtE;;;;IAAiQ,OAAO,EAA7P;QAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,+BAA+B,EAAE,CAAC;QAAC,OAAO,EAAE,OAAO,6BAA6B,EAAE,+BAA+B,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,+BAA+B,EAAE,CAAA;KAAC,CAC/P;;;;IAA6E,MAAM,EAAxE,GAAG,CAAC,CAAC,OAAO,EAAE,wCAAwC,KAAK,IAAI,CAAC,CAC7E;CAAA,CAAA;AAwND;;;GAGG;AACH,iBAAe,sBAAsB,IAFxB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiD3C;AAED;;;GAGG;AACH,iBAAe,yBAAyB,IAF3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgD3C;AAED;;;GAGG;AACH,iBAAe,yBAAyB,IAF3B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkD3C;AAED;;;GAGG;AACH,iBAAe,uBAAuB,IAFzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkC3C;AAED;;;GAGG;AACH,iBAAe,2BAA2B,IAF7B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAuD3C;AAED,QAAA,MAAM,SAAS;IACb,cAAc;IACd,eAAe;IACf,iBAAiB;IACjB,iBAAiB;IACjB,mBAAmB;CACpB,CAAA;AAED;;;;GAIG;AACH,wBAA8B,iCAAiC,CAAC,YAAY,EAHjE,MAAM,OAAO,SAGoD,GAF/D,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ3C"}

package/build/src/testing/browser-test-app.js

@@ -18,9 +18,9 @@ systemTestingComponent.appendChild(blankText);
 root.appendChild(systemTestingComponent);
 const systemTestBrowserHelper = new SystemTestBrowserHelper();
 systemTestBrowserHelper.enableOnBrowser();
-globalThis.velociousBrowserTest = {
-    BrowserEnvironmentHandler,
-    runFrontendModelEventHookScenario,
-    systemTestBrowserHelper
-};
-//# sourceMappingURL=data:application/json;base64,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
+Object.assign(globalThis, { velociousBrowserTest: {
+        BrowserEnvironmentHandler,
+        runFrontendModelEventHookScenario,
+        systemTestBrowserHelper
+    } });
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/expect-to-change.d.ts

@@ -1,30 +1,32 @@
+import BaseExpect from "./base-expect.js";
 export default class ExpectToChange extends BaseExpect {
+    expect: import("./expect.js").default;
+    changeCallback: () => Promise<number>;
+    count: number | undefined;
+    oldCount: number | undefined;
+    newCount: number | undefined;
     /**
      * Runs constructor.
      * @param {object} args - Options object.
-     * @param {function(): Promise<number>} args.changeCallback - Change callback.
+     * @param {() => Promise<number>} args.changeCallback - Change callback.
      * @param {import("./expect.js").default} args.expect - Expect.
      */
     constructor({ changeCallback, expect, ...restArgs }: {
         changeCallback: () => Promise<number>;
         expect: import("./expect.js").default;
     });
-    expect: import("./expect.js").default;
-    changeCallback: () => Promise<number>;
     /**
      * Runs by.
      * @param {number} count - Count value.
      * @returns {import("./expect.js").default} - The by.
      */
     by(count: number): import("./expect.js").default;
-    count: number | undefined;
-    oldCount: number | undefined;
-    newCount: number | undefined;
+    runBefore(): Promise<void>;
+    runAfter(): Promise<void>;
     /**
      * Runs execute.
      * @returns {Promise<void>} - Resolves when complete.
      */
     execute(): Promise<void>;
 }
-import BaseExpect from "./base-expect.js";
 //# sourceMappingURL=expect-to-change.d.ts.map

package/build/src/testing/expect-to-change.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expect-to-change.d.ts","sourceRoot":"","sources":["../../../src/testing/expect-to-change.js"],"names":[],"mappings":"AAKA;IACE;;;;;OAKG;IACH,qDAHG;QAA0C,cAAc,EAAhD,MAAY,OAAO,CAAC,MAAM,CAAC;QACS,MAAM,EAA1C,OAAO,aAAa,EAAE,OAAO;KACvC,EAOA;IAFC,sCAAoB;IACpB,sBARqB,OAAO,CAAC,MAAM,CAAC,CAQA;IAGtC;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,aAAa,EAAE,OAAO,CAMzC;IAHC,0BAAkB;IAMlB,6BAA2C;IAI3C,6BAA2C;IAG7C;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;CACF;uBApDsB,kBAAkB"}
+{"version":3,"file":"expect-to-change.d.ts","sourceRoot":"","sources":["../../../src/testing/expect-to-change.js"],"names":[],"mappings":"AAEA,OAAO,UAAU,MAAM,kBAAkB,CAAA;AAGzC,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU;IAW7C,MAAM;IACN,cAAc,QARJ,OAAO,CAAC,MAAM,CAAC;IAiBzB,KAAK;IAML,QAAQ;IAIR,QAAQ;IA9Bf;;;;;OAKG;IACH,YAAY,EAAC,cAAc,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAC,EAH9C;QAAoC,cAAc,EAA1C,MAAM,OAAO,CAAC,MAAM,CAAC,CAC7B;QAA4C,MAAM,EAA1C,OAAO,aAAa,EAAE,OAAO,CACvC;KACgD,EAMhD;IAED;;;;OAIG;IACH,EAAE,CAAC,KAAK,EAHG,MAGH,GAFK,OAAO,aAAa,EAAE,OAAO,CAMzC;IAEK,SAAS,kBAEd;IAEK,QAAQ,kBAEb;IAED;;;OAGG;IACG,OAAO,IAFA,OAAO,CAAC,IAAI,CAAC,CAYzB;CACF"}

package/build/src/testing/expect-to-change.js

@@ -5,7 +5,7 @@ export default class ExpectToChange extends BaseExpect {
     /**
      * Runs constructor.
      * @param {object} args - Options object.
-     * @param {function(): Promise<number>} args.changeCallback - Change callback.
+     * @param {() => Promise<number>} args.changeCallback - Change callback.
      * @param {import("./expect.js").default} args.expect - Expect.
      */
     constructor({ changeCallback, expect, ...restArgs }) {
@@ -43,4 +43,4 @@ export default class ExpectToChange extends BaseExpect {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/expect-utils.d.ts

@@ -1,51 +1,52 @@
+/**
+ * Runs object containing.
+ * @param {ReturnType<typeof JSON.parse>} value - Value.
+ * @returns {{__velociousMatcher: string, value: ReturnType<typeof JSON.parse>}} - Matcher wrapper.
+ */
+declare function objectContaining(value: ReturnType<typeof JSON.parse>): {
+    __velociousMatcher: string;
+    value: ReturnType<typeof JSON.parse>;
+};
 /**
  * Runs array containing.
- * @param {?} value - Value.
- * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
+ * @param {ReturnType<typeof JSON.parse>} value - Value.
+ * @returns {{__velociousMatcher: string, value: ReturnType<typeof JSON.parse>}} - Matcher wrapper.
  */
-export function arrayContaining(value: unknown): {
+declare function arrayContaining(value: ReturnType<typeof JSON.parse>): {
     __velociousMatcher: string;
-    value: unknown;
+    value: ReturnType<typeof JSON.parse>;
 };
 /**
  * Runs is array containing.
- * @param {?} value - Value.
+ * @param {ReturnType<typeof JSON.parse>} value - Value.
  * @returns {boolean} - Whether arrayContaining matcher.
  */
-export function isArrayContaining(value: unknown): boolean;
+declare function isArrayContaining(value: ReturnType<typeof JSON.parse>): boolean;
 /**
  * Runs is object containing.
- * @param {?} value - Value.
+ * @param {ReturnType<typeof JSON.parse>} value - Value.
  * @returns {boolean} - Whether objectContaining matcher.
  */
-export function isObjectContaining(value: unknown): boolean;
-/**
- * Runs match array containing.
- * @param {?} actual - Actual value.
- * @param {Array<?>} expected - Expected values.
- * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
- */
-export function matchArrayContaining(actual: unknown, expected: Array<unknown>): {
-    matches: boolean;
-    differences: Record<string, Array<unknown>>;
-};
+declare function isObjectContaining(value: ReturnType<typeof JSON.parse>): boolean;
 /**
  * Runs match object.
- * @param {?} actual - Actual value.
- * @param {Record<string, ?> | Array<?>} expected - Expected value.
- * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
+ * @param {ReturnType<typeof JSON.parse>} actual - Actual value.
+ * @param {Record<string, ReturnType<typeof JSON.parse>> | Array<ReturnType<typeof JSON.parse>>} expected - Expected value.
+ * @returns {{matches: boolean, differences: Record<string, Array<ReturnType<typeof JSON.parse>>>}} - Match result.
  */
-export function matchObject(actual: unknown, expected: Record<string, unknown> | Array<unknown>): {
+declare function matchObject(actual: ReturnType<typeof JSON.parse>, expected: Record<string, ReturnType<typeof JSON.parse>> | Array<ReturnType<typeof JSON.parse>>): {
     matches: boolean;
-    differences: Record<string, Array<unknown>>;
+    differences: Record<string, Array<ReturnType<typeof JSON.parse>>>;
 };
 /**
- * Runs object containing.
- * @param {?} value - Value.
- * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
+ * Runs match array containing.
+ * @param {ReturnType<typeof JSON.parse>} actual - Actual value.
+ * @param {Array<ReturnType<typeof JSON.parse>>} expected - Expected values.
+ * @returns {{matches: boolean, differences: Record<string, Array<ReturnType<typeof JSON.parse>>>}} - Match result.
  */
-export function objectContaining(value: unknown): {
-    __velociousMatcher: string;
-    value: unknown;
+declare function matchArrayContaining(actual: ReturnType<typeof JSON.parse>, expected: Array<ReturnType<typeof JSON.parse>>): {
+    matches: boolean;
+    differences: Record<string, Array<ReturnType<typeof JSON.parse>>>;
 };
+export { arrayContaining, isArrayContaining, isObjectContaining, matchArrayContaining, matchObject, objectContaining };
 //# sourceMappingURL=expect-utils.d.ts.map