velocious 1.0.488 → 1.0.492

package/build/src/sync/sync-scope-store.js

@@ -0,0 +1,282 @@
+// @ts-check
+import TableData from "../database/table-data/index.js";
+import UUID from "pure-uuid";
+import { scopeKey } from "./query-scope.js";
+import stableJsonStringify from "./stable-json.js";
+const TABLE_NAME = "velocious_sync_scopes";
+const SCOPE_DIGEST_PREFIX = "velocious-sync-scope:";
+/**
+ * Digests a serialized scope into a fixed-size deterministic key, so scope
+ * identities with long condition values fit an indexed string column.
+ * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
+ * @returns {string} Deterministic UUIDv5 digest of the canonical scope key.
+ */
+function scopeDigestForScope(scope) {
+    return new UUID(5, "ns:URL", `${SCOPE_DIGEST_PREFIX}${scopeKey(scope)}`).format();
+}
+/**
+ * @typedef {object} SyncScopeRow
+ * @property {Record<string, ?>} conditions - Scope attribute conditions.
+ * @property {string | null} cursorPayload - Persisted cursor JSON payload.
+ * @property {string} id - Scope row id.
+ * @property {string} resourceType - Scope resource/model name.
+ * @property {string} scopeDigest - Fixed-size deterministic digest of the canonical scope key.
+ * @property {string} state - Scope state ("active" or "removed").
+ */
+/**
+ * Framework-owned local persistence for declared sync scopes and their cursors.
+ *
+ * Backed by an auto-created `velocious_sync_scopes` table on the configured
+ * database, with a process-local memory fallback when no database is
+ * configured (mirroring the server change-feed store).
+ */
+export default class SyncScopeStore {
+    /**
+     * Creates a sync scope store.
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration owning the database.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     */
+    constructor({ configuration, databaseIdentifier = "default" }) {
+        this.configuration = configuration;
+        this.databaseIdentifier = databaseIdentifier;
+        /** @type {Map<string, SyncScopeRow>} */
+        this._memoryScopes = new Map();
+        this._isReady = false;
+        /** @type {Promise<void> | null} */
+        this._readyPromise = null;
+    }
+    /**
+     * Ensures the backing table exists.
+     * @returns {Promise<void>} Resolves when ready.
+     */
+    async ensureReady() {
+        if (this._isReady)
+            return;
+        if (this._usesMemoryStorage()) {
+            this._isReady = true;
+            return;
+        }
+        if (this._readyPromise)
+            return await this._readyPromise;
+        this._readyPromise = this._withDb(async (db) => {
+            await this._ensureScopesTable(db);
+            this._isReady = true;
+        });
+        try {
+            await this._readyPromise;
+        }
+        finally {
+            if (!this._isReady)
+                this._readyPromise = null;
+        }
+    }
+    /**
+     * Finds or creates the scope row for a serialized scope, reactivating removed scopes.
+     * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
+     * @returns {Promise<SyncScopeRow>} Persisted scope row.
+     */
+    async findOrCreateScope(scope) {
+        await this.ensureReady();
+        const digest = scopeDigestForScope(scope);
+        if (this._usesMemoryStorage()) {
+            const existingScope = this._memoryScopes.get(digest);
+            if (existingScope) {
+                if (existingScope.state !== "active")
+                    existingScope.state = "active";
+                return existingScope;
+            }
+            const newScope = {
+                conditions: scope.conditions,
+                cursorPayload: null,
+                id: new UUID(4).format(),
+                resourceType: scope.resourceType,
+                scopeDigest: digest,
+                state: "active"
+            };
+            this._memoryScopes.set(digest, newScope);
+            return newScope;
+        }
+        return await this._withDb(async (db) => {
+            const existingRow = await this._rowByScopeDigest(db, digest);
+            if (existingRow) {
+                if (existingRow.state !== "active") {
+                    await db.update({ conditions: { id: existingRow.id }, data: { state: "active", updated_at: new Date() }, tableName: TABLE_NAME });
+                    existingRow.state = "active";
+                }
+                return existingRow;
+            }
+            await db.insert({
+                tableName: TABLE_NAME,
+                data: {
+                    conditions_json: stableJsonStringify(scope.conditions),
+                    created_at: new Date(),
+                    cursor_json: null,
+                    id: new UUID(4).format(),
+                    resource_type: scope.resourceType,
+                    scope_digest: digest,
+                    state: "active",
+                    updated_at: new Date()
+                }
+            });
+            const createdRow = await this._rowByScopeDigest(db, digest);
+            if (!createdRow)
+                throw new Error("Failed to persist sync scope");
+            return createdRow;
+        });
+    }
+    /**
+     * Returns all active scope rows.
+     * @returns {Promise<SyncScopeRow[]>} Active scope rows.
+     */
+    async activeScopes() {
+        await this.ensureReady();
+        if (this._usesMemoryStorage()) {
+            return [...this._memoryScopes.values()].filter((scope) => scope.state === "active");
+        }
+        return await this._withDb(async (db) => {
+            const rows = /** @type {Array<Record<string, ?>>} */ (await db
+                .newQuery()
+                .from(TABLE_NAME)
+                .where({ state: "active" })
+                .order("created_at ASC")
+                .results());
+            return rows.map((row) => this._normalizeScopeRow(row));
+        });
+    }
+    /**
+     * Loads the persisted cursor payload for a scope row.
+     * @param {SyncScopeRow} scopeRow - Scope row.
+     * @returns {Promise<string | null>} Cursor JSON payload.
+     */
+    async loadCursor(scopeRow) {
+        await this.ensureReady();
+        if (this._usesMemoryStorage()) {
+            return this._memoryScopes.get(scopeRow.scopeDigest)?.cursorPayload ?? null;
+        }
+        return await this._withDb(async (db) => {
+            const row = await this._rowByScopeDigest(db, scopeRow.scopeDigest);
+            return row ? row.cursorPayload : null;
+        });
+    }
+    /**
+     * Persists the acknowledged cursor for a scope row.
+     * @param {SyncScopeRow} scopeRow - Scope row.
+     * @param {import("./sync-api-client-types.js").SyncCursor} cursor - Acknowledged cursor.
+     * @returns {Promise<void>}
+     */
+    async saveCursor(scopeRow, cursor) {
+        if (!cursor)
+            return;
+        await this.ensureReady();
+        const cursorPayload = JSON.stringify(cursor);
+        if (this._usesMemoryStorage()) {
+            const memoryScope = this._memoryScopes.get(scopeRow.scopeDigest);
+            if (!memoryScope)
+                throw new Error(`No sync scope found for: ${scopeRow.scopeDigest}`);
+            memoryScope.cursorPayload = cursorPayload;
+            return;
+        }
+        await this._withDb(async (db) => {
+            await db.update({
+                conditions: { scope_digest: scopeRow.scopeDigest },
+                data: { cursor_json: cursorPayload, updated_at: new Date() },
+                tableName: TABLE_NAME
+            });
+        });
+    }
+    /**
+     * Deactivates the scope row for a serialized scope.
+     * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
+     * @returns {Promise<void>}
+     */
+    async deactivate(scope) {
+        await this.ensureReady();
+        const digest = scopeDigestForScope(scope);
+        if (this._usesMemoryStorage()) {
+            const memoryScope = this._memoryScopes.get(digest);
+            if (memoryScope)
+                memoryScope.state = "removed";
+            return;
+        }
+        await this._withDb(async (db) => {
+            await db.update({ conditions: { scope_digest: digest }, data: { state: "removed", updated_at: new Date() }, tableName: TABLE_NAME });
+        });
+    }
+    /**
+     * Whether the store runs without a configured database.
+     * @returns {boolean} Whether memory storage is used.
+     */
+    _usesMemoryStorage() {
+        try {
+            return !this.configuration.getDatabaseConfiguration()[this.databaseIdentifier];
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Runs a callback with a database connection.
+     * @template Result
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<Result>} callback - Database callback.
+     * @returns {Promise<Result>} Callback result.
+     */
+    async _withDb(callback) {
+        return await this.configuration.ensureConnections({ name: "Sync scope store" }, async (dbs) => {
+            const db = dbs[this.databaseIdentifier];
+            if (!db)
+                throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`);
+            return await callback(db);
+        });
+    }
+    /**
+     * Ensures the scopes table exists.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>}
+     */
+    async _ensureScopesTable(db) {
+        if (await db.tableExists(TABLE_NAME))
+            return;
+        const table = new TableData(TABLE_NAME, { ifNotExists: true });
+        table.string("id", { null: false, primaryKey: true });
+        table.string("scope_digest", { index: true, null: false });
+        table.string("resource_type", { index: true, null: false });
+        table.text("conditions_json", { null: false });
+        table.text("cursor_json", { null: true });
+        table.string("state", { index: true, null: false });
+        table.datetime("created_at", { null: false });
+        table.datetime("updated_at", { null: false });
+        await db.createTable(table);
+    }
+    /**
+     * Resolves a scope row by its digest.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} digest - Fixed-size scope digest.
+     * @returns {Promise<SyncScopeRow | null>} Scope row or null.
+     */
+    async _rowByScopeDigest(db, digest) {
+        const rows = /** @type {Array<Record<string, ?>>} */ (await db
+            .newQuery()
+            .from(TABLE_NAME)
+            .where({ scope_digest: digest })
+            .limit(1)
+            .results());
+        return rows[0] ? this._normalizeScopeRow(rows[0]) : null;
+    }
+    /**
+     * Normalizes a raw scope table row.
+     * @param {Record<string, ?>} row - Raw table row.
+     * @returns {SyncScopeRow} Normalized scope row.
+     */
+    _normalizeScopeRow(row) {
+        return {
+            conditions: /** @type {Record<string, ?>} */ (JSON.parse(String(row.conditions_json))),
+            cursorPayload: row.cursor_json === null || row.cursor_json === undefined ? null : String(row.cursor_json),
+            id: String(row.id),
+            resourceType: String(row.resource_type),
+            scopeDigest: String(row.scope_digest),
+            state: String(row.state)
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-scope-store.js","sourceRoot":"","sources":["../../../src/sync/sync-scope-store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport TableData from \"../database/table-data/index.js\"\nimport UUID from \"pure-uuid\"\n\nimport {scopeKey} from \"./query-scope.js\"\nimport stableJsonStringify from \"./stable-json.js\"\n\nconst TABLE_NAME = \"velocious_sync_scopes\"\nconst SCOPE_DIGEST_PREFIX = \"velocious-sync-scope:\"\n\n/**\n * Digests a serialized scope into a fixed-size deterministic key, so scope\n * identities with long condition values fit an indexed string column.\n * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n * @returns {string} Deterministic UUIDv5 digest of the canonical scope key.\n */\nfunction scopeDigestForScope(scope) {\n  return new UUID(5, \"ns:URL\", `${SCOPE_DIGEST_PREFIX}${scopeKey(scope)}`).format()\n}\n\n/**\n * @typedef {object} SyncScopeRow\n * @property {Record<string, ?>} conditions - Scope attribute conditions.\n * @property {string | null} cursorPayload - Persisted cursor JSON payload.\n * @property {string} id - Scope row id.\n * @property {string} resourceType - Scope resource/model name.\n * @property {string} scopeDigest - Fixed-size deterministic digest of the canonical scope key.\n * @property {string} state - Scope state (\"active\" or \"removed\").\n */\n\n/**\n * Framework-owned local persistence for declared sync scopes and their cursors.\n *\n * Backed by an auto-created `velocious_sync_scopes` table on the configured\n * database, with a process-local memory fallback when no database is\n * configured (mirroring the server change-feed store).\n */\nexport default class SyncScopeStore {\n  /**\n   * Creates a sync scope store.\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration owning the database.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   */\n  constructor({configuration, databaseIdentifier = \"default\"}) {\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    /** @type {Map<string, SyncScopeRow>} */\n    this._memoryScopes = new Map()\n    this._isReady = false\n    /** @type {Promise<void> | null} */\n    this._readyPromise = null\n  }\n\n  /**\n   * Ensures the backing table exists.\n   * @returns {Promise<void>} Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._isReady) return\n\n    if (this._usesMemoryStorage()) {\n      this._isReady = true\n      return\n    }\n\n    if (this._readyPromise) return await this._readyPromise\n\n    this._readyPromise = this._withDb(async (db) => {\n      await this._ensureScopesTable(db)\n      this._isReady = true\n    })\n\n    try {\n      await this._readyPromise\n    } finally {\n      if (!this._isReady) this._readyPromise = null\n    }\n  }\n\n  /**\n   * Finds or creates the scope row for a serialized scope, reactivating removed scopes.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n   * @returns {Promise<SyncScopeRow>} Persisted scope row.\n   */\n  async findOrCreateScope(scope) {\n    await this.ensureReady()\n\n    const digest = scopeDigestForScope(scope)\n\n    if (this._usesMemoryStorage()) {\n      const existingScope = this._memoryScopes.get(digest)\n\n      if (existingScope) {\n        if (existingScope.state !== \"active\") existingScope.state = \"active\"\n\n        return existingScope\n      }\n\n      const newScope = {\n        conditions: scope.conditions,\n        cursorPayload: null,\n        id: new UUID(4).format(),\n        resourceType: scope.resourceType,\n        scopeDigest: digest,\n        state: \"active\"\n      }\n\n      this._memoryScopes.set(digest, newScope)\n\n      return newScope\n    }\n\n    return await this._withDb(async (db) => {\n      const existingRow = await this._rowByScopeDigest(db, digest)\n\n      if (existingRow) {\n        if (existingRow.state !== \"active\") {\n          await db.update({conditions: {id: existingRow.id}, data: {state: \"active\", updated_at: new Date()}, tableName: TABLE_NAME})\n          existingRow.state = \"active\"\n        }\n\n        return existingRow\n      }\n\n      await db.insert({\n        tableName: TABLE_NAME,\n        data: {\n          conditions_json: stableJsonStringify(scope.conditions),\n          created_at: new Date(),\n          cursor_json: null,\n          id: new UUID(4).format(),\n          resource_type: scope.resourceType,\n          scope_digest: digest,\n          state: \"active\",\n          updated_at: new Date()\n        }\n      })\n\n      const createdRow = await this._rowByScopeDigest(db, digest)\n\n      if (!createdRow) throw new Error(\"Failed to persist sync scope\")\n\n      return createdRow\n    })\n  }\n\n  /**\n   * Returns all active scope rows.\n   * @returns {Promise<SyncScopeRow[]>} Active scope rows.\n   */\n  async activeScopes() {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      return [...this._memoryScopes.values()].filter((scope) => scope.state === \"active\")\n    }\n\n    return await this._withDb(async (db) => {\n      const rows = /** @type {Array<Record<string, ?>>} */ (await db\n        .newQuery()\n        .from(TABLE_NAME)\n        .where({state: \"active\"})\n        .order(\"created_at ASC\")\n        .results())\n\n      return rows.map((row) => this._normalizeScopeRow(row))\n    })\n  }\n\n  /**\n   * Loads the persisted cursor payload for a scope row.\n   * @param {SyncScopeRow} scopeRow - Scope row.\n   * @returns {Promise<string | null>} Cursor JSON payload.\n   */\n  async loadCursor(scopeRow) {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      return this._memoryScopes.get(scopeRow.scopeDigest)?.cursorPayload ?? null\n    }\n\n    return await this._withDb(async (db) => {\n      const row = await this._rowByScopeDigest(db, scopeRow.scopeDigest)\n\n      return row ? row.cursorPayload : null\n    })\n  }\n\n  /**\n   * Persists the acknowledged cursor for a scope row.\n   * @param {SyncScopeRow} scopeRow - Scope row.\n   * @param {import(\"./sync-api-client-types.js\").SyncCursor} cursor - Acknowledged cursor.\n   * @returns {Promise<void>}\n   */\n  async saveCursor(scopeRow, cursor) {\n    if (!cursor) return\n\n    await this.ensureReady()\n\n    const cursorPayload = JSON.stringify(cursor)\n\n    if (this._usesMemoryStorage()) {\n      const memoryScope = this._memoryScopes.get(scopeRow.scopeDigest)\n\n      if (!memoryScope) throw new Error(`No sync scope found for: ${scopeRow.scopeDigest}`)\n\n      memoryScope.cursorPayload = cursorPayload\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.update({\n        conditions: {scope_digest: scopeRow.scopeDigest},\n        data: {cursor_json: cursorPayload, updated_at: new Date()},\n        tableName: TABLE_NAME\n      })\n    })\n  }\n\n  /**\n   * Deactivates the scope row for a serialized scope.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n   * @returns {Promise<void>}\n   */\n  async deactivate(scope) {\n    await this.ensureReady()\n\n    const digest = scopeDigestForScope(scope)\n\n    if (this._usesMemoryStorage()) {\n      const memoryScope = this._memoryScopes.get(digest)\n\n      if (memoryScope) memoryScope.state = \"removed\"\n\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.update({conditions: {scope_digest: digest}, data: {state: \"removed\", updated_at: new Date()}, tableName: TABLE_NAME})\n    })\n  }\n\n  /**\n   * Whether the store runs without a configured database.\n   * @returns {boolean} Whether memory storage is used.\n   */\n  _usesMemoryStorage() {\n    try {\n      return !this.configuration.getDatabaseConfiguration()[this.databaseIdentifier]\n    } catch {\n      return true\n    }\n  }\n\n  /**\n   * Runs a callback with a database connection.\n   * @template Result\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<Result>} callback - Database callback.\n   * @returns {Promise<Result>} Callback result.\n   */\n  async _withDb(callback) {\n    return await this.configuration.ensureConnections({name: \"Sync scope store\"}, async (dbs) => {\n      const db = dbs[this.databaseIdentifier]\n\n      if (!db) throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`)\n\n      return await callback(db)\n    })\n  }\n\n  /**\n   * Ensures the scopes table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>}\n   */\n  async _ensureScopesTable(db) {\n    if (await db.tableExists(TABLE_NAME)) return\n\n    const table = new TableData(TABLE_NAME, {ifNotExists: true})\n\n    table.string(\"id\", {null: false, primaryKey: true})\n    table.string(\"scope_digest\", {index: true, null: false})\n    table.string(\"resource_type\", {index: true, null: false})\n    table.text(\"conditions_json\", {null: false})\n    table.text(\"cursor_json\", {null: true})\n    table.string(\"state\", {index: true, null: false})\n    table.datetime(\"created_at\", {null: false})\n    table.datetime(\"updated_at\", {null: false})\n\n    await db.createTable(table)\n  }\n\n  /**\n   * Resolves a scope row by its digest.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} digest - Fixed-size scope digest.\n   * @returns {Promise<SyncScopeRow | null>} Scope row or null.\n   */\n  async _rowByScopeDigest(db, digest) {\n    const rows = /** @type {Array<Record<string, ?>>} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .where({scope_digest: digest})\n      .limit(1)\n      .results())\n\n    return rows[0] ? this._normalizeScopeRow(rows[0]) : null\n  }\n\n  /**\n   * Normalizes a raw scope table row.\n   * @param {Record<string, ?>} row - Raw table row.\n   * @returns {SyncScopeRow} Normalized scope row.\n   */\n  _normalizeScopeRow(row) {\n    return {\n      conditions: /** @type {Record<string, ?>} */ (JSON.parse(String(row.conditions_json))),\n      cursorPayload: row.cursor_json === null || row.cursor_json === undefined ? null : String(row.cursor_json),\n      id: String(row.id),\n      resourceType: String(row.resource_type),\n      scopeDigest: String(row.scope_digest),\n      state: String(row.state)\n    }\n  }\n}\n"]}

package/build/src/tenants/default-tenant-database-provisioning.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates the tenant database for one tenant.
+ * @param {{configuration: import("../configuration.js").default, databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}} args - Provisioning arguments.
+ * @returns {Promise<void>} - Resolves once the tenant database exists.
+ */
+export function createTenantDatabase({ configuration, databaseConfiguration, tenant }: {
+    configuration: import("../configuration.js").default;
+    databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
+    tenant: unknown;
+}): Promise<void>;
+/**
+ * Drops the tenant database for one tenant. Uses `DROP DATABASE IF EXISTS`, so it
+ * is a safe no-op for a tenant that was never fully provisioned.
+ * @param {{configuration: import("../configuration.js").default, databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType}} args - Provisioning arguments.
+ * @returns {Promise<void>} - Resolves once the tenant database is gone.
+ */
+export function dropTenantDatabase({ configuration, databaseConfiguration }: {
+    configuration: import("../configuration.js").default;
+    databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType;
+}): Promise<void>;
+//# sourceMappingURL=default-tenant-database-provisioning.d.ts.map

package/build/src/tenants/default-tenant-database-provisioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-tenant-database-provisioning.d.ts","sourceRoot":"","sources":["../../../src/tenants/default-tenant-database-provisioning.js"],"names":[],"mappings":"AAgEA;;;;GAIG;AACH,uFAHW;IAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;IAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;IAAC,MAAM,EAAE,OAAC,CAAA;CAAC,GACrJ,OAAO,CAAC,IAAI,CAAC,CA6BzB;AAED;;;;;GAKG;AACH,6EAHW;IAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;IAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAA;CAAC,GAC1I,OAAO,CAAC,IAAI,CAAC,CAqBzB"}

package/build/src/tenants/default-tenant-database-provisioning.js

@@ -0,0 +1,106 @@
+// @ts-check
+/**
+ * Default tenant-database provisioning used by `db:tenants:create`,
+ * `db:tenants:drop`, and `Tenant.drop` when a tenant-database provider does not
+ * define its own `createDatabase`/`dropDatabase`. This is the generic,
+ * driver-agnostic lifecycle every app on the tenant framework needs, so it lives
+ * in the framework instead of being reimplemented in each consuming project.
+ *
+ * File-backed drivers (sqlite) have no server-side CREATE/DROP DATABASE — the file
+ * is created on connect and left in place on drop — so creating just ensures the
+ * tenant's connection and dropping is a no-op. Server drivers (mysql, pgsql, …)
+ * connect to the configured maintenance database (`useDatabase`) and run the
+ * driver's own `createDatabaseSql`/`dropDatabaseSql`.
+ */
+const SAFE_TENANT_DATABASE_NAME = /^[a-z0-9_]+$/;
+/**
+ * Whether the driver stores each database as a local file instead of on a server.
+ * @param {import("../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Resolved tenant database configuration.
+ * @returns {boolean} - True for file-backed drivers such as sqlite.
+ */
+function fileBackedDriver(databaseConfiguration) {
+    return databaseConfiguration.type === "sqlite";
+}
+/**
+ * Validates the tenant database name against a strict allowlist before it is
+ * interpolated into DDL.
+ * @param {import("../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Resolved tenant database configuration.
+ * @returns {string} - The validated tenant database name.
+ */
+function guardedDatabaseName(databaseConfiguration) {
+    const databaseName = databaseConfiguration.database;
+    if (!databaseName || !SAFE_TENANT_DATABASE_NAME.test(databaseName)) {
+        throw new Error(`Unsafe tenant database name: ${databaseName}`);
+    }
+    return databaseName;
+}
+/**
+ * Opens a driver connected to the server's maintenance database (`useDatabase`),
+ * from which `CREATE DATABASE` / `DROP DATABASE` for the tenant can be issued.
+ * @param {import("../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Resolved tenant database configuration.
+ * @param {import("../configuration.js").default} configuration - The Velocious configuration.
+ * @returns {import("../database/drivers/base.js").default} - A driver bound to the maintenance database.
+ */
+function maintenanceConnection(databaseConfiguration, configuration) {
+    const DriverClass = databaseConfiguration.driver;
+    if (!DriverClass) {
+        throw new Error("Tenant database configuration is missing a driver.");
+    }
+    if (!databaseConfiguration.useDatabase) {
+        throw new Error("Tenant database configuration is missing a maintenance database in useDatabase.");
+    }
+    return new DriverClass({ ...databaseConfiguration, database: databaseConfiguration.useDatabase }, configuration);
+}
+/**
+ * Creates the tenant database for one tenant.
+ * @param {{configuration: import("../configuration.js").default, databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}} args - Provisioning arguments.
+ * @returns {Promise<void>} - Resolves once the tenant database exists.
+ */
+export async function createTenantDatabase({ configuration, databaseConfiguration, tenant }) {
+    if (fileBackedDriver(databaseConfiguration)) {
+        await configuration.runWithTenant(tenant, async () => {
+            await configuration.ensureConnections(async () => { });
+        });
+        return;
+    }
+    const databaseName = guardedDatabaseName(databaseConfiguration);
+    const connection = maintenanceConnection(databaseConfiguration, configuration);
+    await connection.connect();
+    try {
+        const sqls = connection.createDatabaseSql(databaseName, {
+            databaseCharset: databaseConfiguration.databaseCharset,
+            databaseCollation: databaseConfiguration.databaseCollation,
+            ifNotExists: true
+        });
+        for (const sql of sqls) {
+            await connection.query(sql);
+        }
+    }
+    finally {
+        await connection.close();
+    }
+}
+/**
+ * Drops the tenant database for one tenant. Uses `DROP DATABASE IF EXISTS`, so it
+ * is a safe no-op for a tenant that was never fully provisioned.
+ * @param {{configuration: import("../configuration.js").default, databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType}} args - Provisioning arguments.
+ * @returns {Promise<void>} - Resolves once the tenant database is gone.
+ */
+export async function dropTenantDatabase({ configuration, databaseConfiguration }) {
+    if (fileBackedDriver(databaseConfiguration)) {
+        return;
+    }
+    const databaseName = guardedDatabaseName(databaseConfiguration);
+    const connection = maintenanceConnection(databaseConfiguration, configuration);
+    await connection.connect();
+    try {
+        const sqls = connection.dropDatabaseSql(databaseName, { ifExists: true });
+        for (const sql of sqls) {
+            await connection.query(sql);
+        }
+    }
+    finally {
+        await connection.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-tenant-database-provisioning.js","sourceRoot":"","sources":["../../../src/tenants/default-tenant-database-provisioning.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Default tenant-database provisioning used by `db:tenants:create`,\n * `db:tenants:drop`, and `Tenant.drop` when a tenant-database provider does not\n * define its own `createDatabase`/`dropDatabase`. This is the generic,\n * driver-agnostic lifecycle every app on the tenant framework needs, so it lives\n * in the framework instead of being reimplemented in each consuming project.\n *\n * File-backed drivers (sqlite) have no server-side CREATE/DROP DATABASE — the file\n * is created on connect and left in place on drop — so creating just ensures the\n * tenant's connection and dropping is a no-op. Server drivers (mysql, pgsql, …)\n * connect to the configured maintenance database (`useDatabase`) and run the\n * driver's own `createDatabaseSql`/`dropDatabaseSql`.\n */\n\nconst SAFE_TENANT_DATABASE_NAME = /^[a-z0-9_]+$/\n\n/**\n * Whether the driver stores each database as a local file instead of on a server.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved tenant database configuration.\n * @returns {boolean} - True for file-backed drivers such as sqlite.\n */\nfunction fileBackedDriver(databaseConfiguration) {\n  return databaseConfiguration.type === \"sqlite\"\n}\n\n/**\n * Validates the tenant database name against a strict allowlist before it is\n * interpolated into DDL.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved tenant database configuration.\n * @returns {string} - The validated tenant database name.\n */\nfunction guardedDatabaseName(databaseConfiguration) {\n  const databaseName = databaseConfiguration.database\n\n  if (!databaseName || !SAFE_TENANT_DATABASE_NAME.test(databaseName)) {\n    throw new Error(`Unsafe tenant database name: ${databaseName}`)\n  }\n\n  return databaseName\n}\n\n/**\n * Opens a driver connected to the server's maintenance database (`useDatabase`),\n * from which `CREATE DATABASE` / `DROP DATABASE` for the tenant can be issued.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved tenant database configuration.\n * @param {import(\"../configuration.js\").default} configuration - The Velocious configuration.\n * @returns {import(\"../database/drivers/base.js\").default} - A driver bound to the maintenance database.\n */\nfunction maintenanceConnection(databaseConfiguration, configuration) {\n  const DriverClass = databaseConfiguration.driver\n\n  if (!DriverClass) {\n    throw new Error(\"Tenant database configuration is missing a driver.\")\n  }\n\n  if (!databaseConfiguration.useDatabase) {\n    throw new Error(\"Tenant database configuration is missing a maintenance database in useDatabase.\")\n  }\n\n  return new DriverClass({...databaseConfiguration, database: databaseConfiguration.useDatabase}, configuration)\n}\n\n/**\n * Creates the tenant database for one tenant.\n * @param {{configuration: import(\"../configuration.js\").default, databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}} args - Provisioning arguments.\n * @returns {Promise<void>} - Resolves once the tenant database exists.\n */\nexport async function createTenantDatabase({configuration, databaseConfiguration, tenant}) {\n  if (fileBackedDriver(databaseConfiguration)) {\n    await configuration.runWithTenant(tenant, async () => {\n      await configuration.ensureConnections(async () => {})\n    })\n\n    return\n  }\n\n  const databaseName = guardedDatabaseName(databaseConfiguration)\n  const connection = maintenanceConnection(databaseConfiguration, configuration)\n\n  await connection.connect()\n\n  try {\n    const sqls = connection.createDatabaseSql(databaseName, {\n      databaseCharset: databaseConfiguration.databaseCharset,\n      databaseCollation: databaseConfiguration.databaseCollation,\n      ifNotExists: true\n    })\n\n    for (const sql of sqls) {\n      await connection.query(sql)\n    }\n  } finally {\n    await connection.close()\n  }\n}\n\n/**\n * Drops the tenant database for one tenant. Uses `DROP DATABASE IF EXISTS`, so it\n * is a safe no-op for a tenant that was never fully provisioned.\n * @param {{configuration: import(\"../configuration.js\").default, databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType}} args - Provisioning arguments.\n * @returns {Promise<void>} - Resolves once the tenant database is gone.\n */\nexport async function dropTenantDatabase({configuration, databaseConfiguration}) {\n  if (fileBackedDriver(databaseConfiguration)) {\n    return\n  }\n\n  const databaseName = guardedDatabaseName(databaseConfiguration)\n  const connection = maintenanceConnection(databaseConfiguration, configuration)\n\n  await connection.connect()\n\n  try {\n    const sqls = connection.dropDatabaseSql(databaseName, {ifExists: true})\n\n    for (const sql of sqls) {\n      await connection.query(sql)\n    }\n  } finally {\n    await connection.close()\n  }\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;;;;;OAYG;IACH,YALa,CAAC,UACH,MAAM,YACN,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,uEAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,CAAS,IAAiG,EAAjG;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,OAAC,KAAK,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,GACpQ,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;;OAIG;IACH,mDAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,GACzF,OAAO,CAAC,IAAI,CAAC,CAyBzB;CACF"}
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;;;;;OAYG;IACH,YALa,CAAC,UACH,MAAM,YACN,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,uEAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,CAAS,IAAiG,EAAjG;YAAC,qBAAqB,EAAE,OAAO,2BAA2B,EAAE,yBAAyB,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,OAAC,KAAK,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,GACpQ,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;;OAIG;IACH,mDAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,GACzF,OAAO,CAAC,IAAI,CAAC,CAwBzB;CACF"}

package/build/src/tenants/tenant.js

@@ -1,5 +1,6 @@
 // @ts-check
 import Current from "../current.js";
+import { dropTenantDatabase } from "./default-tenant-database-provisioning.js";
 import TenantIterator from "./tenant-iterator.js";
 /**
  * Apartment-style runtime façade for multi-tenant apps. A "tenant" is whatever descriptor
@@ -71,9 +72,9 @@ export default class Tenant {
      */
     static async drop({ identifier, tenant, configuration = Current.configuration() }) {
         const provider = configuration.getTenantDatabaseProvider(identifier);
-        if (typeof provider.dropDatabase !== "function") {
-            throw new Error(`Tenant database provider for ${identifier} must define dropDatabase to drop a tenant`);
-        }
+        const dropDatabase = typeof provider.dropDatabase === "function"
+            ? provider.dropDatabase.bind(provider)
+            : dropTenantDatabase;
         await configuration.runWithTenant(tenant, async () => {
             // Guard against an unresolved tenant. resolveDatabaseConfiguration falls back to the
             // base (template/default) tenant database when the resolver returns nothing for this
@@ -82,7 +83,7 @@ export default class Tenant {
             if (!configuration.isDatabaseIdentifierActive(identifier)) {
                 throw new Error(`Tenant database identifier ${identifier} is inactive for tenant: ${TenantIterator.tenantLabel(tenant)}`);
             }
-            await provider.dropDatabase?.({
+            await dropDatabase({
                 configuration,
                 databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),
                 identifier,
@@ -91,4 +92,4 @@ export default class Tenant {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant.js","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Current from \"../current.js\"\nimport TenantIterator from \"./tenant-iterator.js\"\n\n/**\n * Apartment-style runtime façade for multi-tenant apps. A \"tenant\" is whatever descriptor\n * object the app's `tenantDatabaseResolver` understands (an account, a project, …); this\n * class is the single discoverable home for switching into a tenant's context, reading the\n * current one, iterating every tenant of a database identifier, and dropping a tenant's\n * database. Switching delegates to {@link Current} (which owns the async-context tenant\n * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant\n * makes its database immediately queryable — the apartment-style \"switch\" semantics — without\n * the caller establishing connections itself; iteration and drop drive the app's tenant\n * database provider hooks.\n */\nexport default class Tenant {\n  /**\n   * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.\n   * The callback runs inside `ensureConnections`, so every database identifier the tenant\n   * activates (the global database plus the tenant's database) has a checked-out connection\n   * available for the callback's duration: switching into a tenant makes it queryable without\n   * the caller wiring up connections. Already-checked-out connections are reused, so nesting\n   * `Tenant.with` calls does not open redundant connections. The callback receives the active\n   * connections keyed by identifier, the same as `ensureConnections`.\n   * @template T\n   * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.\n   * @param {(connections: Record<string, import(\"../database/drivers/base.js\").default>) => Promise<T>} callback\n   * @returns {Promise<T>}\n   */\n  static async with(tenant, callback) {\n    const configuration = Current.configuration()\n\n    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))\n  }\n\n  /**\n   * The current tenant descriptor, or undefined when running outside any tenant context.\n   * @returns {Record<string, unknown> | undefined}\n   */\n  static current() {\n    return Current.tenant()\n  }\n\n  /**\n   * Lists the tenants for a database identifier through the provider and runs `callback`\n   * within each tenant's context, optionally filtered and several at a time. Like\n   * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's\n   * database is queryable without the caller wiring up connections. Returns how many tenants\n   * the callback ran for (after filtering).\n   * @param {{identifier: string, callback: function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import(\"../configuration.js\").default}} args\n   * @returns {Promise<number>}\n   */\n  static async each({identifier, callback, parallel = 1, filter, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n    const listedTenants = await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => {\n      return await provider.listTenants({configuration, identifier})\n    })\n\n    if (!Array.isArray(listedTenants)) {\n      throw new Error(`Tenant database provider for ${identifier} must return an array from listTenants`)\n    }\n\n    const tenants = filter ? listedTenants.filter(filter) : listedTenants\n    const iterator = new TenantIterator({configuration, identifier, parallelCount: parallel})\n\n    // Run each tenant's callback inside ensureConnections so the iterator stays\n    // connection-agnostic (the db:tenants:* CLI commands share TenantIterator and must run\n    // their callbacks, such as create, before the tenant database exists) while runtime\n    // iteration here gets the tenant's connections established the same way Tenant.with does.\n    return await iterator.run(tenants, async (callbackArgs) => {\n      await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => await callback(callbackArgs))\n    })\n  }\n\n  /**\n   * Drops one tenant's database/schema through the provider's `dropDatabase` hook.\n   * @param {{identifier: string, tenant: object, configuration?: import(\"../configuration.js\").default}} args\n   * @returns {Promise<void>}\n   */\n  static async drop({identifier, tenant, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n\n    if (typeof provider.dropDatabase !== \"function\") {\n      throw new Error(`Tenant database provider for ${identifier} must define dropDatabase to drop a tenant`)\n    }\n\n    await configuration.runWithTenant(tenant, async () => {\n      // Guard against an unresolved tenant. resolveDatabaseConfiguration falls back to the\n      // base (template/default) tenant database when the resolver returns nothing for this\n      // descriptor, so without this check a provider that drops by databaseConfiguration.name\n      // would drop the template database instead of rejecting the bad tenant.\n      if (!configuration.isDatabaseIdentifierActive(identifier)) {\n        throw new Error(`Tenant database identifier ${identifier} is inactive for tenant: ${TenantIterator.tenantLabel(tenant)}`)\n      }\n\n      await provider.dropDatabase?.({\n        configuration,\n        databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),\n        identifier,\n        tenant\n      })\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant.js","sourceRoot":"","sources":["../../../src/tenants/tenant.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Current from \"../current.js\"\nimport {dropTenantDatabase} from \"./default-tenant-database-provisioning.js\"\nimport TenantIterator from \"./tenant-iterator.js\"\n\n/**\n * Apartment-style runtime façade for multi-tenant apps. A \"tenant\" is whatever descriptor\n * object the app's `tenantDatabaseResolver` understands (an account, a project, …); this\n * class is the single discoverable home for switching into a tenant's context, reading the\n * current one, iterating every tenant of a database identifier, and dropping a tenant's\n * database. Switching delegates to {@link Current} (which owns the async-context tenant\n * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant\n * makes its database immediately queryable — the apartment-style \"switch\" semantics — without\n * the caller establishing connections itself; iteration and drop drive the app's tenant\n * database provider hooks.\n */\nexport default class Tenant {\n  /**\n   * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.\n   * The callback runs inside `ensureConnections`, so every database identifier the tenant\n   * activates (the global database plus the tenant's database) has a checked-out connection\n   * available for the callback's duration: switching into a tenant makes it queryable without\n   * the caller wiring up connections. Already-checked-out connections are reused, so nesting\n   * `Tenant.with` calls does not open redundant connections. The callback receives the active\n   * connections keyed by identifier, the same as `ensureConnections`.\n   * @template T\n   * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.\n   * @param {(connections: Record<string, import(\"../database/drivers/base.js\").default>) => Promise<T>} callback\n   * @returns {Promise<T>}\n   */\n  static async with(tenant, callback) {\n    const configuration = Current.configuration()\n\n    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))\n  }\n\n  /**\n   * The current tenant descriptor, or undefined when running outside any tenant context.\n   * @returns {Record<string, unknown> | undefined}\n   */\n  static current() {\n    return Current.tenant()\n  }\n\n  /**\n   * Lists the tenants for a database identifier through the provider and runs `callback`\n   * within each tenant's context, optionally filtered and several at a time. Like\n   * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's\n   * database is queryable without the caller wiring up connections. Returns how many tenants\n   * the callback ran for (after filtering).\n   * @param {{identifier: string, callback: function({databaseConfiguration: import(\"../configuration-types.js\").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import(\"../configuration.js\").default}} args\n   * @returns {Promise<number>}\n   */\n  static async each({identifier, callback, parallel = 1, filter, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n    const listedTenants = await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => {\n      return await provider.listTenants({configuration, identifier})\n    })\n\n    if (!Array.isArray(listedTenants)) {\n      throw new Error(`Tenant database provider for ${identifier} must return an array from listTenants`)\n    }\n\n    const tenants = filter ? listedTenants.filter(filter) : listedTenants\n    const iterator = new TenantIterator({configuration, identifier, parallelCount: parallel})\n\n    // Run each tenant's callback inside ensureConnections so the iterator stays\n    // connection-agnostic (the db:tenants:* CLI commands share TenantIterator and must run\n    // their callbacks, such as create, before the tenant database exists) while runtime\n    // iteration here gets the tenant's connections established the same way Tenant.with does.\n    return await iterator.run(tenants, async (callbackArgs) => {\n      await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => await callback(callbackArgs))\n    })\n  }\n\n  /**\n   * Drops one tenant's database/schema through the provider's `dropDatabase` hook.\n   * @param {{identifier: string, tenant: object, configuration?: import(\"../configuration.js\").default}} args\n   * @returns {Promise<void>}\n   */\n  static async drop({identifier, tenant, configuration = Current.configuration()}) {\n    const provider = configuration.getTenantDatabaseProvider(identifier)\n    const dropDatabase = typeof provider.dropDatabase === \"function\"\n      ? provider.dropDatabase.bind(provider)\n      : dropTenantDatabase\n\n    await configuration.runWithTenant(tenant, async () => {\n      // Guard against an unresolved tenant. resolveDatabaseConfiguration falls back to the\n      // base (template/default) tenant database when the resolver returns nothing for this\n      // descriptor, so without this check a provider that drops by databaseConfiguration.name\n      // would drop the template database instead of rejecting the bad tenant.\n      if (!configuration.isDatabaseIdentifierActive(identifier)) {\n        throw new Error(`Tenant database identifier ${identifier} is inactive for tenant: ${TenantIterator.tenantLabel(tenant)}`)\n      }\n\n      await dropDatabase({\n        configuration,\n        databaseConfiguration: configuration.resolveDatabaseConfiguration(identifier),\n        identifier,\n        tenant\n      })\n    })\n  }\n}\n"]}