velocious 1.0.698 → 1.0.700

package/build/src/testing/test-tenant-database-pool.js

@@ -0,0 +1,388 @@
+// @ts-check
+import MigrationsLedger from "../database/migrations-ledger.js";
+import SchemaCloner from "../database/tenants/schema-cloner.js";
+import StructureSqlLoader from "../database/structure-sql-loader.js";
+import { createTenantDatabase, dropTenantDatabase } from "../tenants/default-tenant-database-provisioning.js";
+import TenantIterator from "../tenants/tenant-iterator.js";
+/**
+ * @typedef {import("../configuration-types.js").TestTenantPoolConfiguration} TestTenantPoolConfiguration
+ */
+/**
+ * A leased pool member. Leases are handed out by {@link TestTenantDatabasePool#acquire}
+ * and returned by {@link TestTenantDatabasePool#release}.
+ * @typedef {object} TestTenantPoolLease
+ * @property {string} databaseIdentifier - Tenant database identifier the lease belongs to.
+ * @property {ReturnType<typeof JSON.parse>} tenant - The pool member's tenant descriptor.
+ * @property {TestTenantPoolMember} member - Internal pool member backing the lease.
+ */
+/**
+ * One pre-provisioned pool slot.
+ * @typedef {object} TestTenantPoolMember
+ * @property {boolean} leased - Whether the member is currently held by a lease.
+ * @property {ReturnType<typeof JSON.parse>} tenant - Tenant descriptor resolved by the app's tenantDatabaseResolver.
+ */
+/**
+ * Key-stable JSON key for a tenant descriptor.
+ * @param {ReturnType<typeof JSON.parse>} value - Value to key-stably stringify.
+ * @returns {string} - Deterministic JSON with sorted object keys.
+ */
+function stableTenantKey(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableTenantKey(entry)).join(",")}]`;
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableTenantKey(value[key])}`).join(",")}}`;
+}
+/**
+ * Reusable pool of pre-provisioned test tenant databases (STC-135 "keep a couple for
+ * re-use"). Instead of create + full structure load + drop per test, the pool provisions
+ * N tenant databases once per suite and resets each one between tests with
+ * truncate + migration-ledger baseline — the framework generalization of the
+ * captured-structure fast path consuming apps had to hand-roll.
+ *
+ * Provisioning runs the tenant provider's `createDatabase` hook (or the framework
+ * default provisioning), then loads the default database's captured structure SQL in
+ * one pass via {@link StructureSqlLoader} and baselines the tenant's
+ * `schema_migrations` ledger from the default database. Apps whose tenant schema
+ * differs from the default database (subset tables, FK-free clones) override
+ * `provisionTenant`/`resetTenant` in the pool configuration.
+ *
+ * Leases are deterministic: acquisition takes the first free member in configured
+ * order, so a suite that acquires and releases one lease per test reuses the same
+ * members in the same order. Acquisition is synchronous after provisioning, so
+ * concurrent acquires can never double-lease one member; exhaustion throws instead
+ * of queueing, because a test that holds a lease while waiting would deadlock the
+ * single-threaded runner.
+ */
+export default class TestTenantDatabasePool {
+    /**
+     * Creates a pool for one tenant database identifier.
+     * @param {object} args - Pool arguments.
+     * @param {import("../configuration.js").default} args.configuration - Configuration owning the tenant resolver.
+     * @param {string} args.databaseIdentifier - Tenant-only database identifier to pool.
+     * @param {TestTenantPoolConfiguration} args.poolConfiguration - Pool size (via `tenants`) and optional provisioning overrides.
+     */
+    constructor({ configuration, databaseIdentifier, poolConfiguration }) {
+        if (!configuration)
+            throw new Error("TestTenantDatabasePool requires a configuration");
+        if (!databaseIdentifier)
+            throw new Error("TestTenantDatabasePool requires a databaseIdentifier");
+        if (!Array.isArray(poolConfiguration.tenants) || poolConfiguration.tenants.length === 0) {
+            throw new Error(`Test tenant pool for ${databaseIdentifier} requires a non-empty tenants array`);
+        }
+        this.configuration = configuration;
+        this.databaseIdentifier = databaseIdentifier;
+        this.poolConfiguration = poolConfiguration;
+        /** @type {TestTenantPoolMember[]} */
+        this.members = poolConfiguration.tenants.map((tenant) => ({ leased: false, tenant }));
+        /** @type {Map<string, TestTenantPoolMember>} */
+        this.membersByTenantKey = new Map();
+        for (const member of this.members) {
+            this.membersByTenantKey.set(stableTenantKey(member.tenant), member);
+        }
+        /** @type {Promise<void> | undefined} */
+        this.provisioningPromise = undefined;
+        /** @type {Promise<string | null> | undefined} */
+        this.structureSqlPromise = undefined;
+        this.dropped = false;
+    }
+    /**
+     * Number of pool members.
+     * @returns {number} - Pool size.
+     */
+    size() {
+        return this.members.length;
+    }
+    /**
+     * Acquires one pool member as a lease. The first free member in configured order is
+     * taken; when every member is leased the acquisition fails loudly instead of queueing.
+     * @param {{tenant?: ReturnType<typeof JSON.parse>}} [args] - Optional explicit pool tenant to pin.
+     * @returns {Promise<TestTenantPoolLease>} - Held lease; pass it to {@link release}.
+     */
+    async acquire({ tenant } = {}) {
+        if (this.dropped) {
+            throw new Error(`Test tenant database pool for ${this.databaseIdentifier} was already torn down`);
+        }
+        await this.ensureProvisioned();
+        /** @type {TestTenantPoolMember | undefined} */
+        let member;
+        if (tenant !== undefined) {
+            member = this.membersByTenantKey.get(stableTenantKey(tenant));
+            if (!member) {
+                throw new Error(`Tenant ${TenantIterator.tenantLabel(tenant)} is not a member of the test tenant pool for ${this.databaseIdentifier}`);
+            }
+            if (member.leased) {
+                throw new Error(`Test tenant pool member ${TenantIterator.tenantLabel(tenant)} for ${this.databaseIdentifier} is already leased`);
+            }
+        }
+        else {
+            member = this.members.find((candidate) => !candidate.leased);
+            if (!member) {
+                throw new Error(`Test tenant database pool exhausted for ${this.databaseIdentifier} (size ${this.members.length}, all leased). Release a lease before acquiring another tenant.`);
+            }
+        }
+        member.leased = true;
+        return { databaseIdentifier: this.databaseIdentifier, member, tenant: member.tenant };
+    }
+    /**
+     * Resets a leased member (truncate + ledger baseline, or the configured `resetTenant`
+     * override) and returns it to the free pool. Idempotent for an already-free member.
+     * A failed reset is followed by a full re-provision so a corrupted member cannot be
+     * handed to the next test; if re-provisioning also fails the member stays leased and
+     * the aggregated error is thrown.
+     * @param {TestTenantPoolLease} lease - Lease returned by {@link acquire}.
+     * @returns {Promise<void>} - Resolves once the member is clean and free again.
+     */
+    async release(lease) {
+        if (lease.databaseIdentifier !== this.databaseIdentifier) {
+            throw new Error(`Lease belongs to pool ${lease.databaseIdentifier}, not ${this.databaseIdentifier}`);
+        }
+        const member = lease.member;
+        if (!member.leased)
+            return;
+        try {
+            await this.resetMember(member);
+        }
+        catch (resetError) {
+            try {
+                await this.provisionMember(member);
+            }
+            catch (provisionError) {
+                throw new AggregateError([resetError, provisionError], `Failed to reset and re-provision test tenant pool member ${TenantIterator.tenantLabel(member.tenant)} for ${this.databaseIdentifier}`, { cause: provisionError });
+            }
+        }
+        member.leased = false;
+    }
+    /**
+     * Drops every pool member's tenant database through the provider's `dropDatabase`
+     * hook (or the framework default) and closes the pool. Idempotent.
+     * @returns {Promise<void>} - Resolves after all members were dropped.
+     */
+    async teardown() {
+        if (this.dropped)
+            return;
+        this.dropped = true;
+        const errors = [];
+        for (const member of this.members) {
+            try {
+                await this.dropMember(member);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 0)
+            throw new AggregateError(errors, `Failed to tear down the test tenant database pool for ${this.databaseIdentifier}`);
+    }
+    /**
+     * Provisions every member exactly once (concurrent acquisitions share one
+     * provisioning pass).
+     * @returns {Promise<void>} - Resolves when all members are provisioned.
+     */
+    async ensureProvisioned() {
+        this.provisioningPromise ??= (async () => {
+            for (const member of this.members) {
+                await this.provisionMember(member);
+            }
+        })();
+        await this.provisioningPromise;
+    }
+    /**
+     * Provisions one member: creates the physical tenant database, then loads or clones
+     * the default database's structure and baselines the ledger.
+     * @param {TestTenantPoolMember} member - Pool member to provision.
+     * @returns {Promise<void>} - Resolves when the member's tenant database is ready.
+     */
+    async provisionMember(member) {
+        if (typeof this.poolConfiguration.provisionTenant === "function") {
+            await this.poolConfiguration.provisionTenant({
+                configuration: this.configuration,
+                databaseIdentifier: this.databaseIdentifier,
+                tenant: member.tenant
+            });
+            return;
+        }
+        await this.createTenantDatabaseForMember(member);
+        // The tenantDatabaseResolver rewrites every identifier inside a tenant context
+        // (including `default`), so the structure/ledger source must be read outside the
+        // tenant scope while the member is reached through a dedicated pool checkout.
+        await this.withMemberConnection(member.tenant, async (tenantDb) => {
+            await this.configuration.ensureConnections({ databaseIdentifiers: ["default"], name: `Test tenant pool provision: ${this.databaseIdentifier}` }, async (dbs) => {
+                await this.applyDefaultStructure({ ...dbs, [this.databaseIdentifier]: tenantDb });
+            });
+        });
+    }
+    /**
+     * Creates the physical tenant database via the provider's `createDatabase` hook or
+     * the framework default provisioning.
+     * @param {TestTenantPoolMember} member - Pool member whose database must exist.
+     * @returns {Promise<void>} - Resolves when the tenant database exists.
+     */
+    async createTenantDatabaseForMember(member) {
+        const provider = this.configuration.getTenantDatabaseProviders()[this.databaseIdentifier];
+        const createDatabase = provider && typeof provider.createDatabase === "function"
+            ? provider.createDatabase.bind(provider)
+            : createTenantDatabase;
+        await this.configuration.runWithTenant(member.tenant, async () => {
+            if (!this.configuration.isDatabaseIdentifierActive(this.databaseIdentifier)) {
+                throw new Error(`Tenant database identifier ${this.databaseIdentifier} is inactive for tenant: ${TenantIterator.tenantLabel(member.tenant)}`);
+            }
+            await createDatabase({
+                configuration: this.configuration,
+                databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.databaseIdentifier),
+                identifier: this.databaseIdentifier,
+                tenant: member.tenant
+            });
+        });
+    }
+    /**
+     * Loads the captured default-database structure into the current tenant connection
+     * and baselines its ledger. Drivers without a structure-SQL generator fall back to
+     * {@link SchemaCloner} over every default table.
+     * @param {Record<string, import("../database/drivers/base.js").default>} dbs - Active connections (must include `default` and the pool identifier).
+     * @returns {Promise<void>} - Resolves when the tenant schema and ledger are baselined.
+     */
+    async applyDefaultStructure(dbs) {
+        const tenantDb = this.tenantConnection(dbs);
+        const defaultDb = this.defaultConnection(dbs);
+        const structureSql = await this.capturedStructureSql();
+        if (structureSql !== null) {
+            await new StructureSqlLoader().load({ db: tenantDb, structureSql });
+        }
+        else {
+            const cloner = new SchemaCloner({ sourceDb: defaultDb, targetDb: tenantDb });
+            const tableNames = (await defaultDb.getTables())
+                .map((table) => table.getName())
+                .filter((tableName) => tableName !== MigrationsLedger.tableName());
+            // syncTable (not syncTables) so the ledger is never reconciled against a
+            // default database that has no ledger table yet; baselineLedger owns the
+            // ledger step and skips when there is nothing to baseline from.
+            for (const tableName of tableNames) {
+                await cloner.syncTable(tableName);
+            }
+        }
+        await this.baselineLedger(tenantDb);
+    }
+    /**
+     * Resets one member between tests: truncate every tenant table (the ledger table is
+     * preserved by `truncateAllTables`) and re-baseline the ledger from the default
+     * database, so the next test starts from the same schema state without a structure load.
+     * @param {TestTenantPoolMember} member - Leased member to clean.
+     * @returns {Promise<void>} - Resolves when the member is empty and ledger-current.
+     */
+    async resetMember(member) {
+        if (typeof this.poolConfiguration.resetTenant === "function") {
+            await this.poolConfiguration.resetTenant({
+                configuration: this.configuration,
+                databaseIdentifier: this.databaseIdentifier,
+                tenant: member.tenant
+            });
+            return;
+        }
+        await this.withMemberConnection(member.tenant, async (tenantDb) => {
+            await tenantDb.truncateAllTables();
+            await this.baselineLedger(tenantDb);
+        });
+    }
+    /**
+     * Baselines a tenant connection's ledger from the default database. Skips when the
+     * default database has no ledger yet (nothing to baseline from).
+     * @param {import("../database/drivers/base.js").default} tenantDb - Tenant connection whose ledger is refreshed.
+     * @returns {Promise<void>} - Resolves when the ledger matches the default database.
+     */
+    async baselineLedger(tenantDb) {
+        await this.configuration.ensureConnections({ databaseIdentifiers: ["default"], name: `Test tenant pool ledger: ${this.databaseIdentifier}` }, async (dbs) => {
+            const defaultDb = this.defaultConnection(dbs);
+            if (!await MigrationsLedger.tableExists(defaultDb))
+                return;
+            await MigrationsLedger.baselineFromDatabase({ sourceDb: defaultDb, targetDb: tenantDb });
+        });
+    }
+    /**
+     * Drops one member's tenant database through the provider's `dropDatabase` hook or
+     * the framework default.
+     * @param {TestTenantPoolMember} member - Pool member to drop.
+     * @returns {Promise<void>} - Resolves when the tenant database is gone.
+     */
+    async dropMember(member) {
+        const provider = this.configuration.getTenantDatabaseProviders()[this.databaseIdentifier];
+        const dropDatabase = provider && typeof provider.dropDatabase === "function"
+            ? provider.dropDatabase.bind(provider)
+            : dropTenantDatabase;
+        await this.configuration.runWithTenant(member.tenant, async () => {
+            if (!this.configuration.isDatabaseIdentifierActive(this.databaseIdentifier)) {
+                throw new Error(`Tenant database identifier ${this.databaseIdentifier} is inactive for tenant: ${TenantIterator.tenantLabel(member.tenant)}`);
+            }
+            await dropDatabase({
+                configuration: this.configuration,
+                databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.databaseIdentifier),
+                identifier: this.databaseIdentifier,
+                tenant: member.tenant
+            });
+        });
+    }
+    /**
+     * Captures the default database's structure SQL once per pool (the framework
+     * generalization of the consuming apps' captured-structure fast path). Returns null
+     * for drivers without a structure generator, which selects the SchemaCloner fallback.
+     * @returns {Promise<string | null>} - Captured structure SQL or null.
+     */
+    capturedStructureSql() {
+        this.structureSqlPromise ??= (async () => {
+            return await this.configuration.ensureConnections({ databaseIdentifiers: ["default"], name: "Test tenant pool structure capture" }, async (dbs) => {
+                return await dbs.default.structureSql();
+            });
+        })();
+        return this.structureSqlPromise;
+    }
+    /**
+     * Runs tenant connection.
+     * @param {Record<string, import("../database/drivers/base.js").default>} dbs - Active connections.
+     * @returns {import("../database/drivers/base.js").default} - The pool identifier's connection.
+     */
+    tenantConnection(dbs) {
+        const tenantDb = dbs[this.databaseIdentifier];
+        if (!tenantDb)
+            throw new Error(`Expected a ${this.databaseIdentifier} connection for the test tenant pool`);
+        return tenantDb;
+    }
+    /**
+     * Runs default connection.
+     * @param {Record<string, import("../database/drivers/base.js").default>} dbs - Active connections.
+     * @returns {import("../database/drivers/base.js").default} - The default connection (ledger baseline source).
+     */
+    defaultConnection(dbs) {
+        const defaultDb = dbs.default;
+        if (!defaultDb)
+            throw new Error(`Expected a default connection for the test tenant pool on ${this.databaseIdentifier}`);
+        return defaultDb;
+    }
+    /**
+     * Runs with a dedicated physical connection for one member. The reset path truncates
+     * committed data, so it must not reuse a test-pinned or async-context connection that
+     * a later rollback would undo — it checks out through the pool exactly like
+     * `registerTransactionalTenant` does and releases the connection back to the pool.
+     * @param {ReturnType<typeof JSON.parse>} tenant - Pool member tenant descriptor.
+     * @template T
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<T>} callback - Operation on the dedicated connection.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async withMemberConnection(tenant, callback) {
+        const pool = this.configuration.getDatabasePool(this.databaseIdentifier);
+        const databaseConfiguration = this.configuration.resolveDatabaseConfiguration(this.databaseIdentifier, tenant);
+        if (!databaseConfiguration.tenantOnly) {
+            throw new Error(`Test tenant pool requires a tenantOnly database: ${this.databaseIdentifier}`);
+        }
+        const connection = await pool.checkoutForConfiguration(databaseConfiguration, { name: `Test tenant pool member: ${this.databaseIdentifier}` });
+        try {
+            return await callback(connection);
+        }
+        finally {
+            await pool.checkin(connection);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-tenant-database-pool.js","sourceRoot":"","sources":["../../../src/testing/test-tenant-database-pool.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,gBAAgB,MAAM,kCAAkC,CAAA;AAC/D,OAAO,YAAY,MAAM,sCAAsC,CAAA;AAC/D,OAAO,kBAAkB,MAAM,qCAAqC,CAAA;AACpE,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,oDAAoD,CAAA;AAC3G,OAAO,cAAc,MAAM,+BAA+B,CAAA;AAE1D;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AACH,SAAS,eAAe,CAAC,KAAK;IAC5B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,MAAM,CAAA;IACvF,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;IAE9F,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAA;IAEtC,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;AACpG,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAsB;IACzC;;;;;;OAMG;IACH,YAAY,EAAC,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAC;QAChE,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAA;QACtF,IAAI,CAAC,kBAAkB;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;QAChG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,iBAAiB,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxF,MAAM,IAAI,KAAK,CAAC,wBAAwB,kBAAkB,qCAAqC,CAAC,CAAA;QAClG,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAA;QAC5C,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QAC1C,qCAAqC;QACrC,IAAI,CAAC,OAAO,GAAG,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAC,CAAC,CAAC,CAAA;QACnF,gDAAgD;QAChD,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAA;QAEnC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAA;QACrE,CAAC;QAED,wCAAwC;QACxC,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAA;QACpC,iDAAiD;QACjD,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAA;QACpC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;IACtB,CAAC;IAED;;;OAGG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAA;IAC5B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,CAAC,EAAC,MAAM,EAAC,GAAG,EAAE;QACzB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,kBAAkB,wBAAwB,CAAC,CAAA;QACnG,CAAC;QAED,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAA;QAE9B,+CAA+C;QAC/C,IAAI,MAAM,CAAA;QAEV,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAA;YAE7D,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,KAAK,CAAC,UAAU,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,gDAAgD,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAA;YACxI,CAAC;YACD,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CAAC,2BAA2B,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,kBAAkB,oBAAoB,CAAC,CAAA;YACnI,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;YAE5D,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,KAAK,CAAC,2CAA2C,IAAI,CAAC,kBAAkB,UAAU,IAAI,CAAC,OAAO,CAAC,MAAM,iEAAiE,CAAC,CAAA;YACnL,CAAC;QACH,CAAC;QAED,MAAM,CAAC,MAAM,GAAG,IAAI,CAAA;QAEpB,OAAO,EAAC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAC,CAAA;IACrF,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,CAAC,KAAK;QACjB,IAAI,KAAK,CAAC,kBAAkB,KAAK,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACzD,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,CAAC,kBAAkB,SAAS,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAA;QACtG,CAAC;QAED,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAA;QAE3B,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,OAAM;QAE1B,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;QAChC,CAAC;QAAC,OAAO,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAA;YACpC,CAAC;YAAC,OAAO,cAAc,EAAE,CAAC;gBACxB,MAAM,IAAI,cAAc,CACtB,CAAC,UAAU,EAAE,cAAc,CAAC,EAC5B,4DAA4D,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,kBAAkB,EAAE,EACtI,EAAC,KAAK,EAAE,cAAc,EAAC,CACxB,CAAA;YACH,CAAC;QACH,CAAC;QAED,MAAM,CAAC,MAAM,GAAG,KAAK,CAAA;IACvB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,IAAI,CAAC,OAAO;YAAE,OAAM;QAExB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QAEnB,MAAM,MAAM,GAAG,EAAE,CAAA;QAEjB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;YAC/B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACpB,CAAC;QACH,CAAC;QAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM,MAAM,CAAC,CAAC,CAAC,CAAA;QACxC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,yDAAyD,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAA;IAC7I,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB;QACrB,IAAI,CAAC,mBAAmB,KAAK,CAAC,KAAK,IAAI,EAAE;YACvC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAA;YACpC,CAAC;QACH,CAAC,CAAC,EAAE,CAAA;QAEJ,MAAM,IAAI,CAAC,mBAAmB,CAAA;IAChC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe,CAAC,MAAM;QAC1B,IAAI,OAAO,IAAI,CAAC,iBAAiB,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;YACjE,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC;gBAC3C,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;gBAC3C,MAAM,EAAE,MAAM,CAAC,MAAM;aACtB,CAAC,CAAA;YAEF,OAAM;QACR,CAAC;QAED,MAAM,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAA;QAEhD,+EAA+E;QAC/E,iFAAiF;QACjF,8EAA8E;QAC9E,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE;YAChE,MAAM,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAC,mBAAmB,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,+BAA+B,IAAI,CAAC,kBAAkB,EAAE,EAAC,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;gBAC3J,MAAM,IAAI,CAAC,qBAAqB,CAAC,EAAC,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,QAAQ,EAAC,CAAC,CAAA;YACjF,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,6BAA6B,CAAC,MAAM;QACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,0BAA0B,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAA;QACzF,MAAM,cAAc,GAAG,QAAQ,IAAI,OAAO,QAAQ,CAAC,cAAc,KAAK,UAAU;YAC9E,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;YACxC,CAAC,CAAC,oBAAoB,CAAA;QAExB,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE;YAC/D,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,0BAA0B,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC;gBAC5E,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,CAAC,kBAAkB,4BAA4B,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;YAC/I,CAAC;YAED,MAAM,cAAc,CAAC;gBACnB,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,qBAAqB,EAAE,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,IAAI,CAAC,kBAAkB,CAAC;gBAC/F,UAAU,EAAE,IAAI,CAAC,kBAAkB;gBACnC,MAAM,EAAE,MAAM,CAAC,MAAM;aACtB,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,qBAAqB,CAAC,GAAG;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAA;QAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAA;QAC7C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAA;QAEtD,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,IAAI,kBAAkB,EAAE,CAAC,IAAI,CAAC,EAAC,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAC,CAAC,CAAA;QACnE,CAAC;aAAM,CAAC;YACN,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,EAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAA;YAC1E,MAAM,UAAU,GAAG,CAAC,MAAM,SAAS,CAAC,SAAS,EAAE,CAAC;iBAC7C,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;iBAC/B,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,gBAAgB,CAAC,SAAS,EAAE,CAAC,CAAA;YAEpE,yEAAyE;YACzE,yEAAyE;YACzE,gEAAgE;YAChE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACnC,MAAM,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;YACnC,CAAC;QACH,CAAC;QAED,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;IACrC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,WAAW,CAAC,MAAM;QACtB,IAAI,OAAO,IAAI,CAAC,iBAAiB,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;YAC7D,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC;gBACvC,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;gBAC3C,MAAM,EAAE,MAAM,CAAC,MAAM;aACtB,CAAC,CAAA;YAEF,OAAM;QACR,CAAC;QAED,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE;YAChE,MAAM,QAAQ,CAAC,iBAAiB,EAAE,CAAA;YAClC,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;QACrC,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAAC,QAAQ;QAC3B,MAAM,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAC,mBAAmB,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,4BAA4B,IAAI,CAAC,kBAAkB,EAAE,EAAC,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;YACxJ,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAA;YAE7C,IAAI,CAAC,MAAM,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;gBAAE,OAAM;YAE1D,MAAM,gBAAgB,CAAC,oBAAoB,CAAC,EAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAA;QACxF,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,UAAU,CAAC,MAAM;QACrB,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,0BAA0B,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAA;QACzF,MAAM,YAAY,GAAG,QAAQ,IAAI,OAAO,QAAQ,CAAC,YAAY,KAAK,UAAU;YAC1E,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC;YACtC,CAAC,CAAC,kBAAkB,CAAA;QAEtB,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE;YAC/D,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,0BAA0B,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC;gBAC5E,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,CAAC,kBAAkB,4BAA4B,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;YAC/I,CAAC;YAED,MAAM,YAAY,CAAC;gBACjB,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,qBAAqB,EAAE,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,IAAI,CAAC,kBAAkB,CAAC;gBAC/F,UAAU,EAAE,IAAI,CAAC,kBAAkB;gBACnC,MAAM,EAAE,MAAM,CAAC,MAAM;aACtB,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,oBAAoB;QAClB,IAAI,CAAC,mBAAmB,KAAK,CAAC,KAAK,IAAI,EAAE;YACvC,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAC,mBAAmB,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,oCAAoC,EAAC,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;gBAC9I,OAAO,MAAM,GAAG,CAAC,OAAO,CAAC,YAAY,EAAE,CAAA;YACzC,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,EAAE,CAAA;QAEJ,OAAO,IAAI,CAAC,mBAAmB,CAAA;IACjC,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,GAAG;QAClB,MAAM,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAA;QAE7C,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,cAAc,IAAI,CAAC,kBAAkB,sCAAsC,CAAC,CAAA;QAE3G,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,GAAG;QACnB,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAA;QAE7B,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,6DAA6D,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAA;QAEvH,OAAO,SAAS,CAAA;IAClB,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,oBAAoB,CAAC,MAAM,EAAE,QAAQ;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAA;QACxE,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAA;QAE9G,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,oDAAoD,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAA;QAChG,CAAC;QAED,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC,qBAAqB,EAAE,EAAC,IAAI,EAAE,4BAA4B,IAAI,CAAC,kBAAkB,EAAE,EAAC,CAAC,CAAA;QAE5I,IAAI,CAAC;YACH,OAAO,MAAM,QAAQ,CAAC,UAAU,CAAC,CAAA;QACnC,CAAC;gBAAS,CAAC;YACT,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QAChC,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport MigrationsLedger from \"../database/migrations-ledger.js\"\nimport SchemaCloner from \"../database/tenants/schema-cloner.js\"\nimport StructureSqlLoader from \"../database/structure-sql-loader.js\"\nimport {createTenantDatabase, dropTenantDatabase} from \"../tenants/default-tenant-database-provisioning.js\"\nimport TenantIterator from \"../tenants/tenant-iterator.js\"\n\n/**\n * @typedef {import(\"../configuration-types.js\").TestTenantPoolConfiguration} TestTenantPoolConfiguration\n */\n\n/**\n * A leased pool member. Leases are handed out by {@link TestTenantDatabasePool#acquire}\n * and returned by {@link TestTenantDatabasePool#release}.\n * @typedef {object} TestTenantPoolLease\n * @property {string} databaseIdentifier - Tenant database identifier the lease belongs to.\n * @property {ReturnType<typeof JSON.parse>} tenant - The pool member's tenant descriptor.\n * @property {TestTenantPoolMember} member - Internal pool member backing the lease.\n */\n\n/**\n * One pre-provisioned pool slot.\n * @typedef {object} TestTenantPoolMember\n * @property {boolean} leased - Whether the member is currently held by a lease.\n * @property {ReturnType<typeof JSON.parse>} tenant - Tenant descriptor resolved by the app's tenantDatabaseResolver.\n */\n\n/**\n * Key-stable JSON key for a tenant descriptor.\n * @param {ReturnType<typeof JSON.parse>} value - Value to key-stably stringify.\n * @returns {string} - Deterministic JSON with sorted object keys.\n */\nfunction stableTenantKey(value) {\n  if (value === null || typeof value !== \"object\") return JSON.stringify(value) ?? \"null\"\n  if (Array.isArray(value)) return `[${value.map((entry) => stableTenantKey(entry)).join(\",\")}]`\n\n  const keys = Object.keys(value).sort()\n\n  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableTenantKey(value[key])}`).join(\",\")}}`\n}\n\n/**\n * Reusable pool of pre-provisioned test tenant databases (STC-135 \"keep a couple for\n * re-use\"). Instead of create + full structure load + drop per test, the pool provisions\n * N tenant databases once per suite and resets each one between tests with\n * truncate + migration-ledger baseline — the framework generalization of the\n * captured-structure fast path consuming apps had to hand-roll.\n *\n * Provisioning runs the tenant provider's `createDatabase` hook (or the framework\n * default provisioning), then loads the default database's captured structure SQL in\n * one pass via {@link StructureSqlLoader} and baselines the tenant's\n * `schema_migrations` ledger from the default database. Apps whose tenant schema\n * differs from the default database (subset tables, FK-free clones) override\n * `provisionTenant`/`resetTenant` in the pool configuration.\n *\n * Leases are deterministic: acquisition takes the first free member in configured\n * order, so a suite that acquires and releases one lease per test reuses the same\n * members in the same order. Acquisition is synchronous after provisioning, so\n * concurrent acquires can never double-lease one member; exhaustion throws instead\n * of queueing, because a test that holds a lease while waiting would deadlock the\n * single-threaded runner.\n */\nexport default class TestTenantDatabasePool {\n  /**\n   * Creates a pool for one tenant database identifier.\n   * @param {object} args - Pool arguments.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration owning the tenant resolver.\n   * @param {string} args.databaseIdentifier - Tenant-only database identifier to pool.\n   * @param {TestTenantPoolConfiguration} args.poolConfiguration - Pool size (via `tenants`) and optional provisioning overrides.\n   */\n  constructor({configuration, databaseIdentifier, poolConfiguration}) {\n    if (!configuration) throw new Error(\"TestTenantDatabasePool requires a configuration\")\n    if (!databaseIdentifier) throw new Error(\"TestTenantDatabasePool requires a databaseIdentifier\")\n    if (!Array.isArray(poolConfiguration.tenants) || poolConfiguration.tenants.length === 0) {\n      throw new Error(`Test tenant pool for ${databaseIdentifier} requires a non-empty tenants array`)\n    }\n\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.poolConfiguration = poolConfiguration\n    /** @type {TestTenantPoolMember[]} */\n    this.members = poolConfiguration.tenants.map((tenant) => ({leased: false, tenant}))\n    /** @type {Map<string, TestTenantPoolMember>} */\n    this.membersByTenantKey = new Map()\n\n    for (const member of this.members) {\n      this.membersByTenantKey.set(stableTenantKey(member.tenant), member)\n    }\n\n    /** @type {Promise<void> | undefined} */\n    this.provisioningPromise = undefined\n    /** @type {Promise<string | null> | undefined} */\n    this.structureSqlPromise = undefined\n    this.dropped = false\n  }\n\n  /**\n   * Number of pool members.\n   * @returns {number} - Pool size.\n   */\n  size() {\n    return this.members.length\n  }\n\n  /**\n   * Acquires one pool member as a lease. The first free member in configured order is\n   * taken; when every member is leased the acquisition fails loudly instead of queueing.\n   * @param {{tenant?: ReturnType<typeof JSON.parse>}} [args] - Optional explicit pool tenant to pin.\n   * @returns {Promise<TestTenantPoolLease>} - Held lease; pass it to {@link release}.\n   */\n  async acquire({tenant} = {}) {\n    if (this.dropped) {\n      throw new Error(`Test tenant database pool for ${this.databaseIdentifier} was already torn down`)\n    }\n\n    await this.ensureProvisioned()\n\n    /** @type {TestTenantPoolMember | undefined} */\n    let member\n\n    if (tenant !== undefined) {\n      member = this.membersByTenantKey.get(stableTenantKey(tenant))\n\n      if (!member) {\n        throw new Error(`Tenant ${TenantIterator.tenantLabel(tenant)} is not a member of the test tenant pool for ${this.databaseIdentifier}`)\n      }\n      if (member.leased) {\n        throw new Error(`Test tenant pool member ${TenantIterator.tenantLabel(tenant)} for ${this.databaseIdentifier} is already leased`)\n      }\n    } else {\n      member = this.members.find((candidate) => !candidate.leased)\n\n      if (!member) {\n        throw new Error(`Test tenant database pool exhausted for ${this.databaseIdentifier} (size ${this.members.length}, all leased). Release a lease before acquiring another tenant.`)\n      }\n    }\n\n    member.leased = true\n\n    return {databaseIdentifier: this.databaseIdentifier, member, tenant: member.tenant}\n  }\n\n  /**\n   * Resets a leased member (truncate + ledger baseline, or the configured `resetTenant`\n   * override) and returns it to the free pool. Idempotent for an already-free member.\n   * A failed reset is followed by a full re-provision so a corrupted member cannot be\n   * handed to the next test; if re-provisioning also fails the member stays leased and\n   * the aggregated error is thrown.\n   * @param {TestTenantPoolLease} lease - Lease returned by {@link acquire}.\n   * @returns {Promise<void>} - Resolves once the member is clean and free again.\n   */\n  async release(lease) {\n    if (lease.databaseIdentifier !== this.databaseIdentifier) {\n      throw new Error(`Lease belongs to pool ${lease.databaseIdentifier}, not ${this.databaseIdentifier}`)\n    }\n\n    const member = lease.member\n\n    if (!member.leased) return\n\n    try {\n      await this.resetMember(member)\n    } catch (resetError) {\n      try {\n        await this.provisionMember(member)\n      } catch (provisionError) {\n        throw new AggregateError(\n          [resetError, provisionError],\n          `Failed to reset and re-provision test tenant pool member ${TenantIterator.tenantLabel(member.tenant)} for ${this.databaseIdentifier}`,\n          {cause: provisionError}\n        )\n      }\n    }\n\n    member.leased = false\n  }\n\n  /**\n   * Drops every pool member's tenant database through the provider's `dropDatabase`\n   * hook (or the framework default) and closes the pool. Idempotent.\n   * @returns {Promise<void>} - Resolves after all members were dropped.\n   */\n  async teardown() {\n    if (this.dropped) return\n\n    this.dropped = true\n\n    const errors = []\n\n    for (const member of this.members) {\n      try {\n        await this.dropMember(member)\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 0) throw new AggregateError(errors, `Failed to tear down the test tenant database pool for ${this.databaseIdentifier}`)\n  }\n\n  /**\n   * Provisions every member exactly once (concurrent acquisitions share one\n   * provisioning pass).\n   * @returns {Promise<void>} - Resolves when all members are provisioned.\n   */\n  async ensureProvisioned() {\n    this.provisioningPromise ??= (async () => {\n      for (const member of this.members) {\n        await this.provisionMember(member)\n      }\n    })()\n\n    await this.provisioningPromise\n  }\n\n  /**\n   * Provisions one member: creates the physical tenant database, then loads or clones\n   * the default database's structure and baselines the ledger.\n   * @param {TestTenantPoolMember} member - Pool member to provision.\n   * @returns {Promise<void>} - Resolves when the member's tenant database is ready.\n   */\n  async provisionMember(member) {\n    if (typeof this.poolConfiguration.provisionTenant === \"function\") {\n      await this.poolConfiguration.provisionTenant({\n        configuration: this.configuration,\n        databaseIdentifier: this.databaseIdentifier,\n        tenant: member.tenant\n      })\n\n      return\n    }\n\n    await this.createTenantDatabaseForMember(member)\n\n    // The tenantDatabaseResolver rewrites every identifier inside a tenant context\n    // (including `default`), so the structure/ledger source must be read outside the\n    // tenant scope while the member is reached through a dedicated pool checkout.\n    await this.withMemberConnection(member.tenant, async (tenantDb) => {\n      await this.configuration.ensureConnections({databaseIdentifiers: [\"default\"], name: `Test tenant pool provision: ${this.databaseIdentifier}`}, async (dbs) => {\n        await this.applyDefaultStructure({...dbs, [this.databaseIdentifier]: tenantDb})\n      })\n    })\n  }\n\n  /**\n   * Creates the physical tenant database via the provider's `createDatabase` hook or\n   * the framework default provisioning.\n   * @param {TestTenantPoolMember} member - Pool member whose database must exist.\n   * @returns {Promise<void>} - Resolves when the tenant database exists.\n   */\n  async createTenantDatabaseForMember(member) {\n    const provider = this.configuration.getTenantDatabaseProviders()[this.databaseIdentifier]\n    const createDatabase = provider && typeof provider.createDatabase === \"function\"\n      ? provider.createDatabase.bind(provider)\n      : createTenantDatabase\n\n    await this.configuration.runWithTenant(member.tenant, async () => {\n      if (!this.configuration.isDatabaseIdentifierActive(this.databaseIdentifier)) {\n        throw new Error(`Tenant database identifier ${this.databaseIdentifier} is inactive for tenant: ${TenantIterator.tenantLabel(member.tenant)}`)\n      }\n\n      await createDatabase({\n        configuration: this.configuration,\n        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.databaseIdentifier),\n        identifier: this.databaseIdentifier,\n        tenant: member.tenant\n      })\n    })\n  }\n\n  /**\n   * Loads the captured default-database structure into the current tenant connection\n   * and baselines its ledger. Drivers without a structure-SQL generator fall back to\n   * {@link SchemaCloner} over every default table.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} dbs - Active connections (must include `default` and the pool identifier).\n   * @returns {Promise<void>} - Resolves when the tenant schema and ledger are baselined.\n   */\n  async applyDefaultStructure(dbs) {\n    const tenantDb = this.tenantConnection(dbs)\n    const defaultDb = this.defaultConnection(dbs)\n    const structureSql = await this.capturedStructureSql()\n\n    if (structureSql !== null) {\n      await new StructureSqlLoader().load({db: tenantDb, structureSql})\n    } else {\n      const cloner = new SchemaCloner({sourceDb: defaultDb, targetDb: tenantDb})\n      const tableNames = (await defaultDb.getTables())\n        .map((table) => table.getName())\n        .filter((tableName) => tableName !== MigrationsLedger.tableName())\n\n      // syncTable (not syncTables) so the ledger is never reconciled against a\n      // default database that has no ledger table yet; baselineLedger owns the\n      // ledger step and skips when there is nothing to baseline from.\n      for (const tableName of tableNames) {\n        await cloner.syncTable(tableName)\n      }\n    }\n\n    await this.baselineLedger(tenantDb)\n  }\n\n  /**\n   * Resets one member between tests: truncate every tenant table (the ledger table is\n   * preserved by `truncateAllTables`) and re-baseline the ledger from the default\n   * database, so the next test starts from the same schema state without a structure load.\n   * @param {TestTenantPoolMember} member - Leased member to clean.\n   * @returns {Promise<void>} - Resolves when the member is empty and ledger-current.\n   */\n  async resetMember(member) {\n    if (typeof this.poolConfiguration.resetTenant === \"function\") {\n      await this.poolConfiguration.resetTenant({\n        configuration: this.configuration,\n        databaseIdentifier: this.databaseIdentifier,\n        tenant: member.tenant\n      })\n\n      return\n    }\n\n    await this.withMemberConnection(member.tenant, async (tenantDb) => {\n      await tenantDb.truncateAllTables()\n      await this.baselineLedger(tenantDb)\n    })\n  }\n\n  /**\n   * Baselines a tenant connection's ledger from the default database. Skips when the\n   * default database has no ledger yet (nothing to baseline from).\n   * @param {import(\"../database/drivers/base.js\").default} tenantDb - Tenant connection whose ledger is refreshed.\n   * @returns {Promise<void>} - Resolves when the ledger matches the default database.\n   */\n  async baselineLedger(tenantDb) {\n    await this.configuration.ensureConnections({databaseIdentifiers: [\"default\"], name: `Test tenant pool ledger: ${this.databaseIdentifier}`}, async (dbs) => {\n      const defaultDb = this.defaultConnection(dbs)\n\n      if (!await MigrationsLedger.tableExists(defaultDb)) return\n\n      await MigrationsLedger.baselineFromDatabase({sourceDb: defaultDb, targetDb: tenantDb})\n    })\n  }\n\n  /**\n   * Drops one member's tenant database through the provider's `dropDatabase` hook or\n   * the framework default.\n   * @param {TestTenantPoolMember} member - Pool member to drop.\n   * @returns {Promise<void>} - Resolves when the tenant database is gone.\n   */\n  async dropMember(member) {\n    const provider = this.configuration.getTenantDatabaseProviders()[this.databaseIdentifier]\n    const dropDatabase = provider && typeof provider.dropDatabase === \"function\"\n      ? provider.dropDatabase.bind(provider)\n      : dropTenantDatabase\n\n    await this.configuration.runWithTenant(member.tenant, async () => {\n      if (!this.configuration.isDatabaseIdentifierActive(this.databaseIdentifier)) {\n        throw new Error(`Tenant database identifier ${this.databaseIdentifier} is inactive for tenant: ${TenantIterator.tenantLabel(member.tenant)}`)\n      }\n\n      await dropDatabase({\n        configuration: this.configuration,\n        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.databaseIdentifier),\n        identifier: this.databaseIdentifier,\n        tenant: member.tenant\n      })\n    })\n  }\n\n  /**\n   * Captures the default database's structure SQL once per pool (the framework\n   * generalization of the consuming apps' captured-structure fast path). Returns null\n   * for drivers without a structure generator, which selects the SchemaCloner fallback.\n   * @returns {Promise<string | null>} - Captured structure SQL or null.\n   */\n  capturedStructureSql() {\n    this.structureSqlPromise ??= (async () => {\n      return await this.configuration.ensureConnections({databaseIdentifiers: [\"default\"], name: \"Test tenant pool structure capture\"}, async (dbs) => {\n        return await dbs.default.structureSql()\n      })\n    })()\n\n    return this.structureSqlPromise\n  }\n\n  /**\n   * Runs tenant connection.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} dbs - Active connections.\n   * @returns {import(\"../database/drivers/base.js\").default} - The pool identifier's connection.\n   */\n  tenantConnection(dbs) {\n    const tenantDb = dbs[this.databaseIdentifier]\n\n    if (!tenantDb) throw new Error(`Expected a ${this.databaseIdentifier} connection for the test tenant pool`)\n\n    return tenantDb\n  }\n\n  /**\n   * Runs default connection.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} dbs - Active connections.\n   * @returns {import(\"../database/drivers/base.js\").default} - The default connection (ledger baseline source).\n   */\n  defaultConnection(dbs) {\n    const defaultDb = dbs.default\n\n    if (!defaultDb) throw new Error(`Expected a default connection for the test tenant pool on ${this.databaseIdentifier}`)\n\n    return defaultDb\n  }\n\n  /**\n   * Runs with a dedicated physical connection for one member. The reset path truncates\n   * committed data, so it must not reuse a test-pinned or async-context connection that\n   * a later rollback would undo — it checks out through the pool exactly like\n   * `registerTransactionalTenant` does and releases the connection back to the pool.\n   * @param {ReturnType<typeof JSON.parse>} tenant - Pool member tenant descriptor.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Operation on the dedicated connection.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async withMemberConnection(tenant, callback) {\n    const pool = this.configuration.getDatabasePool(this.databaseIdentifier)\n    const databaseConfiguration = this.configuration.resolveDatabaseConfiguration(this.databaseIdentifier, tenant)\n\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`Test tenant pool requires a tenantOnly database: ${this.databaseIdentifier}`)\n    }\n\n    const connection = await pool.checkoutForConfiguration(databaseConfiguration, {name: `Test tenant pool member: ${this.databaseIdentifier}`})\n\n    try {\n      return await callback(connection)\n    } finally {\n      await pool.checkin(connection)\n    }\n  }\n}\n"]}

package/build/src/testing/velocious-attempt-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"velocious-attempt-executor.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-attempt-executor.js"],"names":[],"mappings":"AAOI,YAA0F,sBAAsB,GAAtG,OAAO,2BAA2B,EAAE,oBAAoB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAwB;AAIjH,YAAiD,gBAAgB,GAAvD,KAAK,GAAG;IAAC,oBAAoB,CAAC,EAAE,IAAI,CAAA;CAAC,CAAkB;AA8EpE,MAAM,CAAC,OAAO,OAAO,wBAAwB;IAQpC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAHjB,MAAM,GAAG,SAGQ,GAFf,MAAM,GAAG,SAAS,CAI9B;IAED;;;;OAIG;IACG,OAAO,CAAC,EAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAC,EAHvH,OAAO,2BAA2B,EAAE,oBAGmF,GAFrH,OAAO,CAAC,IAAI,CAAC,CAmRzB;IAED;;;;;;;OAOG;IACG,eAAe,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAC,EALrD;QAAuC,YAAY,EAA3C,sBAAsB,EAAE,CAChC;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;KAEqD,GAF3C,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;OAOG;IACG,cAAc,CAAC,EAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAC,EALnD;QAAuC,WAAW,EAA1C,sBAAsB,EAAE,CAChC;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;KAEmD,GAFzC,OAAO,CAAC,IAAI,CAAC,CA2BzB;CACF"}
+{"version":3,"file":"velocious-attempt-executor.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-attempt-executor.js"],"names":[],"mappings":"AAOI,YAA0F,sBAAsB,GAAtG,OAAO,2BAA2B,EAAE,oBAAoB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAwB;AAIjH,YAAiD,gBAAgB,GAAvD,KAAK,GAAG;IAAC,oBAAoB,CAAC,EAAE,IAAI,CAAA;CAAC,CAAkB;AA8EpE,MAAM,CAAC,OAAO,OAAO,wBAAwB;IAQpC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAHjB,MAAM,GAAG,SAGQ,GAFf,MAAM,GAAG,SAAS,CAI9B;IAED;;;;OAIG;IACG,OAAO,CAAC,EAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAC,EAHvH,OAAO,2BAA2B,EAAE,oBAGmF,GAFrH,OAAO,CAAC,IAAI,CAAC,CA+TzB;IAED;;;;;;;OAOG;IACG,eAAe,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAC,EALrD;QAAuC,YAAY,EAA3C,sBAAsB,EAAE,CAChC;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;KAEqD,GAF3C,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;OAOG;IACG,cAAc,CAAC,EAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAC,EALnD;QAAuC,WAAW,EAA1C,sBAAsB,EAAE,CAChC;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;KAEmD,GAFzC,OAAO,CAAC,IAAI,CAAC,CA2BzB;CACF"}