velocious 1.0.577 → 1.0.579

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

@@ -0,0 +1,221 @@
+// @ts-check
+/**
+ * TenantDescriptorValue type.
+ * @typedef {null | boolean | number | string | TenantDescriptorValue[] | {[key: string]: TenantDescriptorValue}} TenantDescriptorValue
+ */
+/** @typedef {{[key: string]: TenantDescriptorValue}} TenantDescriptor */
+/**
+ * Returns a readable path for a captured descriptor/configuration value.
+ * @param {string} path - Parent path.
+ * @param {string | number} key - Child key.
+ * @returns {string} - Child path.
+ */
+function childPath(path, key) {
+    if (typeof key === "number")
+        return `${path}[${key}]`;
+    return path ? `${path}.${key}` : key;
+}
+/**
+ * Returns the runtime class label for an unsupported capture value.
+ * @param {object} value - Unsupported value.
+ * @returns {string} - Runtime class label.
+ */
+function valueClassName(value) {
+    return value.constructor?.name || "object";
+}
+/**
+ * Defines one captured key without invoking inherited setters such as
+ * `Object.prototype.__proto__`.
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} target - Captured object.
+ * @param {string} key - Own key to define.
+ * @param {ReturnType<typeof JSON.parse>} value - Captured value.
+ */
+function defineCapturedDataProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+    });
+}
+/**
+ * Deeply copies and freezes a JSON-compatible tenant descriptor value.
+ * @param {ReturnType<typeof JSON.parse>} value - Value to capture.
+ * @param {string} path - Descriptor path.
+ * @param {Set<object>} ancestors - Active ancestor objects used for cycle detection.
+ * @returns {TenantDescriptorValue} - Immutable captured value.
+ */
+function captureTenantValue(value, path, ancestors) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (!value || typeof value !== "object") {
+        throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${typeof value}`);
+    }
+    if (ancestors.has(value))
+        throw new TypeError(`Tenant descriptor contains a cycle at ${path}`);
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const capturedEntries = value.map((entry, index) => captureTenantValue(entry, childPath(path, index), ancestors));
+            Object.freeze(capturedEntries);
+            return capturedEntries;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${valueClassName(value)}`);
+        }
+        /** @type {TenantDescriptor} */
+        const captured = {};
+        for (const [key, entry] of Object.entries(value)) {
+            defineCapturedDataProperty(captured, key, captureTenantValue(entry, childPath(path, key), ancestors));
+        }
+        return Object.freeze(captured);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+/**
+ * Captures a root application tenant descriptor.
+ * @param {object} tenant - Ordinary or null-prototype JSON-compatible tenant descriptor.
+ * @returns {TenantDescriptor} - Immutable descriptor snapshot.
+ */
+function captureTenant(tenant) {
+    return /** @type {TenantDescriptor} */ (captureTenantValue(tenant, "", new Set()));
+}
+/**
+ * Deeply captures configuration values while retaining function/class identities.
+ * Mutable non-plain runtime objects are rejected because retaining them would let
+ * callers redirect a handle after construction.
+ * @param {ReturnType<typeof JSON.parse>} value - Configuration value.
+ * @param {string} path - Configuration path.
+ * @param {Set<object>} ancestors - Active ancestor objects.
+ * @returns {ReturnType<typeof JSON.parse>} - Immutable captured value.
+ */
+function captureConfigurationValue(value, path, ancestors) {
+    if (value === null || value === undefined || typeof value === "string" || typeof value === "boolean" || typeof value === "number" || typeof value === "function") {
+        return value;
+    }
+    if (typeof value !== "object") {
+        throw new TypeError(`Tenant database configuration contains an unsupported value at ${path}: ${typeof value}`);
+    }
+    if (ancestors.has(value))
+        throw new TypeError(`Tenant database configuration contains a cycle at ${path}`);
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+        if (Object.isFrozen(value))
+            return value;
+        throw new TypeError(`Tenant database configuration contains an unsupported mutable value at ${path}: ${valueClassName(value)}`);
+    }
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return Object.freeze(value.map((entry, index) => captureConfigurationValue(entry, childPath(path, index), ancestors)));
+        }
+        /** @type {Record<string, ReturnType<typeof JSON.parse>>} */
+        const captured = {};
+        for (const [key, entry] of Object.entries(value)) {
+            defineCapturedDataProperty(captured, key, captureConfigurationValue(entry, childPath(path, key), ancestors));
+        }
+        return Object.freeze(captured);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+/**
+ * Copies and deeply freezes a resolved physical database configuration.
+ * @param {import("../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Resolved database configuration.
+ * @returns {import("../configuration-types.js").DatabaseConfigurationType} - Captured configuration.
+ */
+function captureDatabaseConfiguration(databaseConfiguration) {
+    return /** @type {import("../configuration-types.js").DatabaseConfigurationType} */ (captureConfigurationValue(databaseConfiguration, "databaseConfiguration", new Set()));
+}
+/**
+ * Immutable tenant/database handle. Physical database configurations are
+ * resolved and captured at construction, so later ambient tenant changes
+ * cannot redirect work performed through this handle.
+ */
+export default class TenantHandle {
+    /**
+     * Runs constructor.
+     * @param {object} args - Handle arguments.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {object} args.tenant - Ordinary or null-prototype JSON-compatible application tenant descriptor.
+     */
+    constructor({ configuration, tenant }) {
+        if (!configuration)
+            throw new Error("TenantHandle requires a configuration");
+        if (!tenant || typeof tenant !== "object" || Array.isArray(tenant)) {
+            throw new TypeError("TenantHandle requires a tenant object");
+        }
+        const capturedTenant = captureTenant(tenant);
+        /** @type {Record<string, import("../configuration-types.js").DatabaseConfigurationType>} */
+        const databaseConfigurations = Object.create(null);
+        const disabledIdentifiers = configuration.getDisabledDatabaseIdentifiers();
+        for (const identifier of Object.keys(configuration.getDatabaseConfiguration())) {
+            if (disabledIdentifiers.has(identifier))
+                continue;
+            if (!configuration.isDatabaseIdentifierActive(identifier, capturedTenant))
+                continue;
+            databaseConfigurations[identifier] = captureDatabaseConfiguration(configuration.resolveDatabaseConfiguration(identifier, capturedTenant));
+        }
+        this._configuration = configuration;
+        this._databaseConfigurations = Object.freeze(databaseConfigurations);
+        this._tenant = capturedTenant;
+        Object.freeze(this);
+    }
+    /**
+     * Returns the captured tenant descriptor. Routing never re-resolves physical
+     * identity from this value after handle construction.
+     * @returns {TenantDescriptor} - Tenant descriptor.
+     */
+    tenant() {
+        return this._tenant;
+    }
+    /**
+     * Returns the captured physical configuration for an active identifier.
+     * @param {string} databaseIdentifier - Logical database identifier.
+     * @returns {import("../configuration-types.js").DatabaseConfigurationType} - Captured resolved configuration.
+     */
+    databaseConfiguration(databaseIdentifier) {
+        const databaseConfiguration = this._databaseConfigurations[databaseIdentifier];
+        if (!databaseConfiguration) {
+            throw new Error(`Unknown or inactive database identifier for tenant handle: ${databaseIdentifier}`);
+        }
+        return databaseConfiguration;
+    }
+    /**
+     * Runs explicit ORM work on one pinned connection for this handle's captured
+     * physical database. Use `operation.forModel(ModelClass)` for queries and
+     * writes; loaded records and association/preload work retain that operation.
+     * @template T
+     * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.
+     * @param {(operation: import("../database/operation.js").default) => Promise<T>} callback - Owned work callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async databaseOperation({ databaseIdentifier, name = "TenantHandle.databaseOperation" }, callback) {
+        return await this._configuration.withDatabaseOperation({
+            databaseConfiguration: this.databaseConfiguration(databaseIdentifier),
+            databaseIdentifier,
+            name,
+            tenant: this._tenant
+        }, callback);
+    }
+    /**
+     * Runs explicit ORM work in a transaction pinned to this handle's captured
+     * physical database.
+     * @template T
+     * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.
+     * @param {(operation: import("../database/operation.js").default) => Promise<T>} callback - Transaction callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async transaction({ databaseIdentifier, name = "TenantHandle.transaction" }, callback) {
+        return await this.databaseOperation({ databaseIdentifier, name }, async (operation) => {
+            return await operation.transaction(async () => await callback(operation));
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant-handle.js","sourceRoot":"","sources":["../../../src/tenants/tenant-handle.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;;GAGG;AACH,yEAAyE;AAEzE;;;;;GAKG;AACH,SAAS,SAAS,CAAC,IAAI,EAAE,GAAG;IAC1B,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,GAAG,IAAI,IAAI,GAAG,GAAG,CAAA;IAErD,OAAO,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA;AACtC,CAAC;AAED;;;;GAIG;AACH,SAAS,cAAc,CAAC,KAAK;IAC3B,OAAO,KAAK,CAAC,WAAW,EAAE,IAAI,IAAI,QAAQ,CAAA;AAC5C,CAAC;AAED;;;;;;GAMG;AACH,SAAS,0BAA0B,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK;IACpD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE;QACjC,YAAY,EAAE,IAAI;QAClB,UAAU,EAAE,IAAI;QAChB,KAAK;QACL,QAAQ,EAAE,IAAI;KACf,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS;IAChD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAA;IAC3F,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IAErE,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACxC,MAAM,IAAI,SAAS,CAAC,sDAAsD,IAAI,KAAK,OAAO,KAAK,EAAE,CAAC,CAAA;IACpG,CAAC;IACD,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,yCAAyC,IAAI,EAAE,CAAC,CAAA;IAE9F,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IAEpB,IAAI,CAAC;QACH,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,eAAe,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,CAAA;YAEjH,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAA;YAE9B,OAAO,eAAe,CAAA;QACxB,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;QAE9C,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACzD,MAAM,IAAI,SAAS,CAAC,sDAAsD,IAAI,KAAK,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;QAC7G,CAAC;QAED,+BAA+B;QAC/B,MAAM,QAAQ,GAAG,EAAE,CAAA;QAEnB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACjD,0BAA0B,CAAC,QAAQ,EAAE,GAAG,EAAE,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC,CAAA;QACvG,CAAC;QAED,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAChC,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,MAAM;IAC3B,OAAO,+BAA+B,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAA;AACpF,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS;IACvD,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;QACjK,OAAO,KAAK,CAAA;IACd,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,IAAI,SAAS,CAAC,kEAAkE,IAAI,KAAK,OAAO,KAAK,EAAE,CAAC,CAAA;IAChH,CAAC;IACD,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,qDAAqD,IAAI,EAAE,CAAC,CAAA;IAE1G,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;IAE9C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QAClF,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAA;QAExC,MAAM,IAAI,SAAS,CAAC,0EAA0E,IAAI,KAAK,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IACjI,CAAC;IAED,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IAEpB,IAAI,CAAC;QACH,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,yBAAyB,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;QACxH,CAAC;QAED,4DAA4D;QAC5D,MAAM,QAAQ,GAAG,EAAE,CAAA;QAEnB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACjD,0BAA0B,CAAC,QAAQ,EAAE,GAAG,EAAE,yBAAyB,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC,CAAA;QAC9G,CAAC;QAED,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAChC,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,4BAA4B,CAAC,qBAAqB;IACzD,OAAO,4EAA4E,CAAC,CAClF,yBAAyB,CAAC,qBAAqB,EAAE,uBAAuB,EAAE,IAAI,GAAG,EAAE,CAAC,CACrF,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B;;;;;OAKG;IACH,YAAY,EAAC,aAAa,EAAE,MAAM,EAAC;QACjC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;QAC5E,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACnE,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC,CAAA;QAC9D,CAAC;QAED,MAAM,cAAc,GAAG,aAAa,CAAC,MAAM,CAAC,CAAA;QAC5C,4FAA4F;QAC5F,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAClD,MAAM,mBAAmB,GAAG,aAAa,CAAC,8BAA8B,EAAE,CAAA;QAE1E,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,wBAAwB,EAAE,CAAC,EAAE,CAAC;YAC/E,IAAI,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC;gBAAE,SAAQ;YACjD,IAAI,CAAC,aAAa,CAAC,0BAA0B,CAAC,UAAU,EAAE,cAAc,CAAC;gBAAE,SAAQ;YAEnF,sBAAsB,CAAC,UAAU,CAAC,GAAG,4BAA4B,CAC/D,aAAa,CAAC,4BAA4B,CAAC,UAAU,EAAE,cAAc,CAAC,CACvE,CAAA;QACH,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,aAAa,CAAA;QACnC,IAAI,CAAC,uBAAuB,GAAG,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAA;QACpE,IAAI,CAAC,OAAO,GAAG,cAAc,CAAA;QAE7B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACrB,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;IAED;;;;OAIG;IACH,qBAAqB,CAAC,kBAAkB;QACtC,MAAM,qBAAqB,GAAG,IAAI,CAAC,uBAAuB,CAAC,kBAAkB,CAAC,CAAA;QAE9E,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,8DAA8D,kBAAkB,EAAE,CAAC,CAAA;QACrG,CAAC;QAED,OAAO,qBAAqB,CAAA;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,iBAAiB,CAAC,EAAC,kBAAkB,EAAE,IAAI,GAAG,gCAAgC,EAAC,EAAE,QAAQ;QAC7F,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC;YACrD,qBAAqB,EAAE,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,CAAC;YACrE,kBAAkB;YAClB,IAAI;YACJ,MAAM,EAAE,IAAI,CAAC,OAAO;SACrB,EAAE,QAAQ,CAAC,CAAA;IACd,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW,CAAC,EAAC,kBAAkB,EAAE,IAAI,GAAG,0BAA0B,EAAC,EAAE,QAAQ;QACjF,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAC,kBAAkB,EAAE,IAAI,EAAC,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE;YAClF,OAAO,MAAM,SAAS,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,CAAC,MAAM,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAA;QAC3E,CAAC,CAAC,CAAA;IACJ,CAAC;CACF","sourcesContent":["// @ts-check\n\n/**\n * TenantDescriptorValue type.\n * @typedef {null | boolean | number | string | TenantDescriptorValue[] | {[key: string]: TenantDescriptorValue}} TenantDescriptorValue\n */\n/** @typedef {{[key: string]: TenantDescriptorValue}} TenantDescriptor */\n\n/**\n * Returns a readable path for a captured descriptor/configuration value.\n * @param {string} path - Parent path.\n * @param {string | number} key - Child key.\n * @returns {string} - Child path.\n */\nfunction childPath(path, key) {\n  if (typeof key === \"number\") return `${path}[${key}]`\n\n  return path ? `${path}.${key}` : key\n}\n\n/**\n * Returns the runtime class label for an unsupported capture value.\n * @param {object} value - Unsupported value.\n * @returns {string} - Runtime class label.\n */\nfunction valueClassName(value) {\n  return value.constructor?.name || \"object\"\n}\n\n/**\n * Defines one captured key without invoking inherited setters such as\n * `Object.prototype.__proto__`.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} target - Captured object.\n * @param {string} key - Own key to define.\n * @param {ReturnType<typeof JSON.parse>} value - Captured value.\n */\nfunction defineCapturedDataProperty(target, key, value) {\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: true,\n    value,\n    writable: true\n  })\n}\n\n/**\n * Deeply copies and freezes a JSON-compatible tenant descriptor value.\n * @param {ReturnType<typeof JSON.parse>} value - Value to capture.\n * @param {string} path - Descriptor path.\n * @param {Set<object>} ancestors - Active ancestor objects used for cycle detection.\n * @returns {TenantDescriptorValue} - Immutable captured value.\n */\nfunction captureTenantValue(value, path, ancestors) {\n  if (value === null || typeof value === \"string\" || typeof value === \"boolean\") return value\n  if (typeof value === \"number\" && Number.isFinite(value)) return value\n\n  if (!value || typeof value !== \"object\") {\n    throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${typeof value}`)\n  }\n  if (ancestors.has(value)) throw new TypeError(`Tenant descriptor contains a cycle at ${path}`)\n\n  ancestors.add(value)\n\n  try {\n    if (Array.isArray(value)) {\n      const capturedEntries = value.map((entry, index) => captureTenantValue(entry, childPath(path, index), ancestors))\n\n      Object.freeze(capturedEntries)\n\n      return capturedEntries\n    }\n\n    const prototype = Object.getPrototypeOf(value)\n\n    if (prototype !== Object.prototype && prototype !== null) {\n      throw new TypeError(`Tenant descriptor contains an unsupported value at ${path}: ${valueClassName(value)}`)\n    }\n\n    /** @type {TenantDescriptor} */\n    const captured = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      defineCapturedDataProperty(captured, key, captureTenantValue(entry, childPath(path, key), ancestors))\n    }\n\n    return Object.freeze(captured)\n  } finally {\n    ancestors.delete(value)\n  }\n}\n\n/**\n * Captures a root application tenant descriptor.\n * @param {object} tenant - Ordinary or null-prototype JSON-compatible tenant descriptor.\n * @returns {TenantDescriptor} - Immutable descriptor snapshot.\n */\nfunction captureTenant(tenant) {\n  return /** @type {TenantDescriptor} */ (captureTenantValue(tenant, \"\", new Set()))\n}\n\n/**\n * Deeply captures configuration values while retaining function/class identities.\n * Mutable non-plain runtime objects are rejected because retaining them would let\n * callers redirect a handle after construction.\n * @param {ReturnType<typeof JSON.parse>} value - Configuration value.\n * @param {string} path - Configuration path.\n * @param {Set<object>} ancestors - Active ancestor objects.\n * @returns {ReturnType<typeof JSON.parse>} - Immutable captured value.\n */\nfunction captureConfigurationValue(value, path, ancestors) {\n  if (value === null || value === undefined || typeof value === \"string\" || typeof value === \"boolean\" || typeof value === \"number\" || typeof value === \"function\") {\n    return value\n  }\n  if (typeof value !== \"object\") {\n    throw new TypeError(`Tenant database configuration contains an unsupported value at ${path}: ${typeof value}`)\n  }\n  if (ancestors.has(value)) throw new TypeError(`Tenant database configuration contains a cycle at ${path}`)\n\n  const prototype = Object.getPrototypeOf(value)\n\n  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {\n    if (Object.isFrozen(value)) return value\n\n    throw new TypeError(`Tenant database configuration contains an unsupported mutable value at ${path}: ${valueClassName(value)}`)\n  }\n\n  ancestors.add(value)\n\n  try {\n    if (Array.isArray(value)) {\n      return Object.freeze(value.map((entry, index) => captureConfigurationValue(entry, childPath(path, index), ancestors)))\n    }\n\n    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const captured = {}\n\n    for (const [key, entry] of Object.entries(value)) {\n      defineCapturedDataProperty(captured, key, captureConfigurationValue(entry, childPath(path, key), ancestors))\n    }\n\n    return Object.freeze(captured)\n  } finally {\n    ancestors.delete(value)\n  }\n}\n\n/**\n * Copies and deeply freezes a resolved physical database configuration.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved database configuration.\n * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured configuration.\n */\nfunction captureDatabaseConfiguration(databaseConfiguration) {\n  return /** @type {import(\"../configuration-types.js\").DatabaseConfigurationType} */ (\n    captureConfigurationValue(databaseConfiguration, \"databaseConfiguration\", new Set())\n  )\n}\n\n/**\n * Immutable tenant/database handle. Physical database configurations are\n * resolved and captured at construction, so later ambient tenant changes\n * cannot redirect work performed through this handle.\n */\nexport default class TenantHandle {\n  /**\n   * Runs constructor.\n   * @param {object} args - Handle arguments.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {object} args.tenant - Ordinary or null-prototype JSON-compatible application tenant descriptor.\n   */\n  constructor({configuration, tenant}) {\n    if (!configuration) throw new Error(\"TenantHandle requires a configuration\")\n    if (!tenant || typeof tenant !== \"object\" || Array.isArray(tenant)) {\n      throw new TypeError(\"TenantHandle requires a tenant object\")\n    }\n\n    const capturedTenant = captureTenant(tenant)\n    /** @type {Record<string, import(\"../configuration-types.js\").DatabaseConfigurationType>} */\n    const databaseConfigurations = Object.create(null)\n    const disabledIdentifiers = configuration.getDisabledDatabaseIdentifiers()\n\n    for (const identifier of Object.keys(configuration.getDatabaseConfiguration())) {\n      if (disabledIdentifiers.has(identifier)) continue\n      if (!configuration.isDatabaseIdentifierActive(identifier, capturedTenant)) continue\n\n      databaseConfigurations[identifier] = captureDatabaseConfiguration(\n        configuration.resolveDatabaseConfiguration(identifier, capturedTenant)\n      )\n    }\n\n    this._configuration = configuration\n    this._databaseConfigurations = Object.freeze(databaseConfigurations)\n    this._tenant = capturedTenant\n\n    Object.freeze(this)\n  }\n\n  /**\n   * Returns the captured tenant descriptor. Routing never re-resolves physical\n   * identity from this value after handle construction.\n   * @returns {TenantDescriptor} - Tenant descriptor.\n   */\n  tenant() {\n    return this._tenant\n  }\n\n  /**\n   * Returns the captured physical configuration for an active identifier.\n   * @param {string} databaseIdentifier - Logical database identifier.\n   * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured resolved configuration.\n   */\n  databaseConfiguration(databaseIdentifier) {\n    const databaseConfiguration = this._databaseConfigurations[databaseIdentifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`Unknown or inactive database identifier for tenant handle: ${databaseIdentifier}`)\n    }\n\n    return databaseConfiguration\n  }\n\n  /**\n   * Runs explicit ORM work on one pinned connection for this handle's captured\n   * physical database. Use `operation.forModel(ModelClass)` for queries and\n   * writes; loaded records and association/preload work retain that operation.\n   * @template T\n   * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Owned work callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async databaseOperation({databaseIdentifier, name = \"TenantHandle.databaseOperation\"}, callback) {\n    return await this._configuration.withDatabaseOperation({\n      databaseConfiguration: this.databaseConfiguration(databaseIdentifier),\n      databaseIdentifier,\n      name,\n      tenant: this._tenant\n    }, callback)\n  }\n\n  /**\n   * Runs explicit ORM work in a transaction pinned to this handle's captured\n   * physical database.\n   * @template T\n   * @param {{databaseIdentifier: string, name?: string}} options - Logical database and checkout name.\n   * @param {(operation: import(\"../database/operation.js\").default) => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction({databaseIdentifier, name = \"TenantHandle.transaction\"}, callback) {\n    return await this.databaseOperation({databaseIdentifier, name}, async (operation) => {\n      return await operation.transaction(async () => await callback(operation))\n    })\n  }\n}\n"]}

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

@@ -8,12 +8,9 @@
  * runtime tenant façade; the caller is responsible for producing the tenant list.
  */
 export default class TenantIterator {
-    /**
-     * Builds a human-readable label for a tenant for use in error messages.
-     * @param {?} tenant - Tenant descriptor to identify in an error.
-     * @returns {string} - Human-readable tenant label.
-     */
-    static tenantLabel(tenant: unknown): string;
+    configuration: import("../configuration.js").default;
+    identifier: string;
+    parallelCount: number;
     /**
      * Creates an iterator bound to a configuration and tenant database identifier.
      * @param {{configuration: import("../configuration.js").default, identifier: string, parallelCount?: number}} args - Tenant configuration, database identifier, and concurrency limit.
@@ -23,30 +20,33 @@ export default class TenantIterator {
         identifier: string;
         parallelCount?: number;
     });
-    configuration: import("../configuration.js").default;
-    identifier: string;
-    parallelCount: number;
     /**
      * Runs `callback` within each tenant's context and returns how many tenants were processed.
-     * @param {Array<?>} tenants - Tenant descriptors to enter and process.
-     * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback - Per-tenant operation receiving the active database configuration.
+     * @param {Array<ReturnType<typeof JSON.parse>>} tenants - Tenant descriptors to enter and process.
+     * @param {(args: {databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ReturnType<typeof JSON.parse>}) => Promise<void>} callback - Per-tenant operation receiving the active database configuration.
      * @returns {Promise<number>} - Number of processed tenants.
      */
-    run(tenants: Array<unknown>, callback: (arg0: {
+    run(tenants: Array<ReturnType<typeof JSON.parse>>, callback: (args: {
         databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
-        tenant: unknown;
+        tenant: ReturnType<typeof JSON.parse>;
     }) => Promise<void>): Promise<number>;
     /**
      * Enters one tenant's context and runs the callback, asserting the database is active first.
-     * @param {{callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, tenant: ?}} args - Tenant descriptor and operation to run in its context.
+     * @param {{callback: (args: {databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ReturnType<typeof JSON.parse>}) => Promise<void>, tenant: ReturnType<typeof JSON.parse>}} args - Tenant descriptor and operation to run in its context.
      * @returns {Promise<void>}
      */
     runTenantCallback({ callback, tenant }: {
-        callback: (arg0: {
+        callback: (args: {
             databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
-            tenant: unknown;
+            tenant: ReturnType<typeof JSON.parse>;
         }) => Promise<void>;
-        tenant: unknown;
+        tenant: ReturnType<typeof JSON.parse>;
     }): Promise<void>;
+    /**
+     * Builds a human-readable label for a tenant for use in error messages.
+     * @param {ReturnType<typeof JSON.parse>} tenant - Tenant descriptor to identify in an error.
+     * @returns {string} - Human-readable tenant label.
+     */
+    static tenantLabel(tenant: ReturnType<typeof JSON.parse>): string;
 }
 //# sourceMappingURL=tenant-iterator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tenant-iterator.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant-iterator.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAmFE;;;;OAIG;IACH,2BAHW,OAAC,GACC,MAAM,CAiBlB;IAtGD;;;OAGG;IACH,0DAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAC,EAM5G;IAHC,qDAAkC;IAClC,mBAA4B;IAC5B,sBAAkC;IAGpC;;;;;OAKG;IACH,aAJW,KAAK,CAAC,OAAC,CAAC,YACR,CAAS,IAAiG,EAAjG;QAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,GACzH,OAAO,CAAC,MAAM,CAAC,CAgD3B;IAED;;;;OAIG;IACH,wCAHW;QAAC,QAAQ,EAAE,CAAS,IAAiG,EAAjG;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,GAChJ,OAAO,CAAC,IAAI,CAAC,CAazB;CAuBF"}
+{"version":3,"file":"tenant-iterator.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant-iterator.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IAM1B,aAAa;IACb,UAAU;IACV,aAAa;IAPpB;;;OAGG;IACH,YAAY,EAAC,aAAa,EAAE,UAAU,EAAE,aAAiB,EAAC,EAF/C;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAElD,EAIzD;IAED;;;;;OAKG;IACG,GAAG,CAAC,OAAO,EAJN,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAI7B,EAAE,QAAQ,EAHhB,CAAC,IAAI,EAAE;QAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;QAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;KAAC,KAAK,OAAO,CAAC,IAAI,CAGrI,GAFd,OAAO,CAAC,MAAM,CAAC,CAgD3B;IAED;;;;OAIG;IACG,iBAAiB,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC,EAH/B;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,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;KAGzK,GAF7B,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,MAAM,EAHd,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGd,GAFZ,MAAM,CAiBlB;CACF"}

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

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

package/build/src/tenants/tenant-model-scope.d.ts

@@ -0,0 +1,73 @@
+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<MC extends typeof import("../database/record/index.js").default> {
+    _handle: TenantHandle;
+    _modelClass: MC;
+    _databaseIdentifier: string;
+    /**
+     * 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 }: {
+        configuration: import("../configuration.js").default;
+        modelClass: MC;
+        tenant: object;
+    });
+    /**
+     * 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.
+     */
+    databaseOperation<T>(callback: (query: import("../database/query/model-class-query.js").default<MC>, operation: import("../database/operation.js").default) => Promise<T>): Promise<T>;
+    /**
+     * 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.
+     */
+    transaction<T>(callback: (query: import("../database/query/model-class-query.js").default<MC>, operation: import("../database/operation.js").default) => Promise<T>): Promise<T>;
+    /**
+     * Creates a record on the captured tenant.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [attributes] - Create attributes.
+     * @returns {Promise<InstanceType<MC>>} - Created record.
+     */
+    create(attributes?: Record<string, ReturnType<typeof JSON.parse>>): Promise<InstanceType<MC>>;
+    /**
+     * Counts records on the captured tenant.
+     * @returns {Promise<number>} - Count on the captured tenant.
+     */
+    count(): Promise<number>;
+    /**
+     * Finds a record by primary key on the captured tenant.
+     * @param {string | number} recordId - Record identifier.
+     * @returns {Promise<InstanceType<MC> | null>} - Found record.
+     */
+    find(recordId: string | number): Promise<InstanceType<MC> | 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.
+     */
+    findBy(conditions: Record<string, string | number>): Promise<InstanceType<MC> | 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.
+     */
+    findByOrFail(conditions: Record<string, string | number>): Promise<InstanceType<MC>>;
+    /**
+     * Loads all records on the captured tenant.
+     * @returns {Promise<InstanceType<MC>[]>} - All records on the captured tenant.
+     */
+    toArray(): Promise<InstanceType<MC>[]>;
+}
+//# sourceMappingURL=tenant-model-scope.d.ts.map

package/build/src/tenants/tenant-model-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-model-scope.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant-model-scope.js"],"names":[],"mappings":"AAEA,OAAO,YAAY,MAAM,oBAAoB,CAAA;AAE7C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB,CAF+B,EAAE,SAAxD,cAAc,6BAA6B,EAAE,OAAW;IAW7D,OAAO;IACP,WAAW;IACX,mBAAmB;IAV1B;;;;;;OAMG;IACH,YAAY,EAAC,aAAa,EAAE,UAAU,EAAE,MAAM,EAAC,EAJ5C;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAiB,UAAU,EAAnB,EAAE,CACV;QAAqB,MAAM,EAAnB,MAAM,CAChB;KAC8C,EAM9C;IAED;;;;;;;OAOG;IACG,iBAAiB,CAJV,CAAC,EAIU,QAAQ,EAHrB,CAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,0BAA0B,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAGpH,GAFnB,OAAO,CAAC,CAAC,CAAC,CAWtB;IAED;;;;;OAKG;IACG,WAAW,CAJJ,CAAC,EAII,QAAQ,EAHf,CAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,0BAA0B,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAG1H,GAFb,OAAO,CAAC,CAAC,CAAC,CAWtB;IAED;;;;OAIG;IACG,MAAM,CAAC,UAAU,AAHpB,CACA,EADQ,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAG3B,GAFf,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAQrC;IAED;;;OAGG;IACG,KAAK,IAFE,OAAO,CAAC,MAAM,CAAC,CAI3B;IAED;;;;OAIG;IACG,IAAI,CAAC,QAAQ,EAHR,MAAM,GAAG,MAGD,GAFN,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAQ5C;IAED;;;;OAIG;IACG,MAAM,CAAC,UAAU,EAHZ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGlB,GAFV,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAQ5C;IAED;;;;OAIG;IACG,YAAY,CAAC,UAAU,EAHlB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGZ,GAFhB,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAQrC;IAED;;;OAGG;IACG,OAAO,IAFA,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC,CAQvC;CACF"}