velocious 1.0.488 → 1.0.492

package/README.md

@@ -1661,6 +1661,8 @@ unsubscribe()
 await client.close()
 ```
 
+For long-lived Node clients, the constructor also accepts opt-in liveness options (all default off, so browser/Expo usage is unchanged): `webSocketImplementation` (inject Node's `ws`, since the global/undici WebSocket exposes neither protocol ping nor an unref-able socket), `heartbeatIntervalMs` (a ping heartbeat that drops a socket whose peer stops ponging, so a client notices a vanished server), and `unref` (unref the underlying socket so an idle connection can't keep the process alive on its own). See [docs/websocket-channels.md](docs/websocket-channels.md).
+
 ## Subscribe to events
 
 ```js

package/build/application.js

@@ -4,6 +4,7 @@ import AppRoutes from "./routes/app-routes.js"
 import Logger from "./logger.js"
 import HttpServer from "./http-server/index.js"
 import HttpServerLock from "./http-server/server-lock.js"
+import SyncApiController from "./sync/sync-api-controller.js"
 import websocketEventsHost from "./http-server/websocket-events-host.js"
 import restArgsError from "./utils/rest-args-error.js"
 
@@ -54,6 +55,8 @@ export default class VelociousApplication {
 
     await this.configuration.initialize({type: this.getType()})
 
+    SyncApiController.mountFromConfiguration(this.configuration)
+
     this.configuration.setRoutes(routes)
 
     if (!this.configuration.isDatabasePoolInitialized()) {

package/build/cli/commands/db/tenants/create.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import BaseCommand from "../../../base-command.js"
+import {createTenantDatabase} from "../../../../tenants/default-tenant-database-provisioning.js"
 import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js"
 
 export default class DbTenantsCreate extends BaseCommand {
@@ -14,13 +15,14 @@ export default class DbTenantsCreate extends BaseCommand {
       identifier: this.processArgs?.[1]
     })
     const provider = helper.provider
-
-    if (typeof provider.createDatabase !== "function") {
-      throw new Error(`Tenant database provider for ${helper.identifier} must define createDatabase to use db:tenants:create`)
-    }
+    // Providers may customize creation, but the generic driver-agnostic provisioning
+    // is the framework default so apps do not reimplement it.
+    const createDatabase = typeof provider.createDatabase === "function"
+      ? provider.createDatabase.bind(provider)
+      : createTenantDatabase
 
     const tenantCount = await helper.eachTenant(async ({databaseConfiguration, tenant}) => {
-      await provider.createDatabase?.({
+      await createDatabase({
         configuration: this.getConfiguration(),
         databaseConfiguration,
         identifier: helper.identifier,

package/build/cli/commands/db/tenants/drop.js

@@ -1,12 +1,13 @@
 // @ts-check
 
 import BaseCommand from "../../../base-command.js"
+import {dropTenantDatabase} from "../../../../tenants/default-tenant-database-provisioning.js"
 import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js"
 
 export default class DbTenantsDrop extends BaseCommand {
   /**
    * Drops the tenant database/schema for every listed tenant through the provider's
-   * `dropDatabase` hook.
+   * `dropDatabase` hook, or the framework default when the provider defines none.
    * @returns {Promise<{identifier: string, tenantCount: number} | void>} - Result in test mode.
    */
   async execute() {
@@ -15,13 +16,12 @@ export default class DbTenantsDrop extends BaseCommand {
       identifier: this.processArgs?.[1]
     })
     const provider = helper.provider
-
-    if (typeof provider.dropDatabase !== "function") {
-      throw new Error(`Tenant database provider for ${helper.identifier} must define dropDatabase to use db:tenants:drop`)
-    }
+    const dropDatabase = typeof provider.dropDatabase === "function"
+      ? provider.dropDatabase.bind(provider)
+      : dropTenantDatabase
 
     const tenantCount = await helper.eachTenant(async ({databaseConfiguration, tenant}) => {
-      await provider.dropDatabase?.({
+      await dropDatabase({
         configuration: this.getConfiguration(),
         databaseConfiguration,
         identifier: helper.identifier,

package/build/configuration-types.js

@@ -355,9 +355,17 @@
  * @property {Record<string, FrontendModelSyncJsonValue>} [policy] - Deterministic non-secret policy inputs included in the policy hash only.
  */
 
+/**
+ * Velocious sync API endpoint configuration.
+ * @typedef {object} VelociousSyncApiConfiguration
+ * @property {string} [mountPath] - Mount path for the sync endpoints. Defaults to "/velocious/sync".
+ * @property {FrontendModelResourceClassType} resourceClass - App sync resource class served by the auto-mounted sync endpoints.
+ */
+
 /**
  * Velocious sync configuration.
  * @typedef {object} VelociousSyncConfiguration
+ * @property {VelociousSyncApiConfiguration} [api] - Auto-mounts the Velocious sync changes/replay endpoints for this resource class.
  * @property {import("./sync/device-identity.js").SyncJsonWebKey | null} [deviceCertificateBackendPublicKey] - Public backend key used to verify offline device certificates for sync replay.
  * @property {number} [changeFeedRetentionSize] - Number of accepted server changes retained before clients must refresh from snapshot.
  * @property {Array<import("./sync/offline-grant.js").OfflineGrantSigningKey>} offlineGrantSigningKeys - Signing keys used to issue and verify offline grants. Secrets must never be exposed to clients.
@@ -421,6 +429,7 @@
  * @property {string} [frontendModelsOutputPath] - Optional output project path where `src/frontend-models` should be generated.
  * @property {string} [resourcesPath] - Optional override for the resources directory to auto-discover; defaults to `<path>/src/resources`. Set internally for package entries.
  * @property {Record<string, FrontendModelResourceDefinition>} [frontendModels] - Auto-discovered frontend model definitions keyed by model class name. Set internally by the environment handler — do not set manually.
+ * @property {AbilityResourceClassType[]} [abilityResources] - Auto-discovered ability resource classes (frontend-model and authorization) from this project's resources directory. Set internally by the environment handler — do not set manually.
  */
 
 /**

package/build/configuration.js

@@ -424,6 +424,7 @@ export default class VelociousConfiguration {
    * @returns {import("./configuration-types.js").VelociousSyncConfiguration} - Normalized sync configuration.
    */
   _normalizeSyncConfiguration(sync) {
+    const api = sync?.api
     const deviceCertificateBackendPublicKey = sync?.deviceCertificateBackendPublicKey || null
     const changeFeedRetentionSize = sync?.changeFeedRetentionSize
     const offlineGrantSigningKeys = sync?.offlineGrantSigningKeys || []
@@ -441,6 +442,7 @@ export default class VelociousConfiguration {
     }
 
     return {
+      api: this._normalizeSyncApiConfiguration(api),
       changeFeedRetentionSize: changeFeedRetentionSize || 10000,
       deviceCertificateBackendPublicKey,
       offlineGrantSigningKeys: offlineGrantSigningKeys.map((key) => normalizeOfflineGrantSigningKey(key)),
@@ -448,6 +450,33 @@ export default class VelociousConfiguration {
     }
   }
 
+  /**
+   * Normalizes sync API endpoint configuration.
+   * @param {import("./configuration-types.js").VelociousSyncApiConfiguration | undefined} api - Sync API configuration.
+   * @returns {import("./configuration-types.js").VelociousSyncApiConfiguration | undefined} - Normalized sync API configuration.
+   */
+  _normalizeSyncApiConfiguration(api) {
+    if (api === undefined || api === null) return undefined
+
+    if (typeof api !== "object" || Array.isArray(api)) {
+      throw new Error("sync.api must be an object with a resourceClass")
+    }
+
+    const {mountPath, resourceClass} = api
+
+    if (typeof resourceClass !== "function") {
+      throw new Error(`sync.api.resourceClass must be a resource class, got: ${String(resourceClass)}`)
+    }
+    if (!resourceClass.ModelClass) {
+      throw new Error(`sync.api.resourceClass ${resourceClass.name} must define static ModelClass`)
+    }
+    if (mountPath !== undefined && (typeof mountPath !== "string" || !mountPath.startsWith("/"))) {
+      throw new Error(`sync.api.mountPath must start with '/', got: ${String(mountPath)}`)
+    }
+
+    return {mountPath, resourceClass}
+  }
+
   /**
    * Runs get database configuration.
    * @returns {Record<string, import("./configuration-types.js").DatabaseConfigurationType>} - The database configuration.
@@ -875,6 +904,34 @@ export default class VelociousConfiguration {
    */
   setAbilityResources(resources) { this._abilityResources = resources }
 
+  /**
+   * Merges resource classes discovered from the app and every registered package
+   * into the ability-resources list. `autoDiscoverResources` populates each backend
+   * project's `frontendModels` (including package projects), so this makes a
+   * package-contributed model's abilities reach subscription and per-record
+   * authorization automatically — consuming apps do not have to hand-register
+   * package resources. Already-present classes (e.g. an app's explicitly-set
+   * resources) are left untouched.
+   * @returns {void} - No return value.
+   */
+  _mergeDiscoveredAbilityResources() {
+    const merged = [...this._abilityResources]
+    const seen = new Set(merged)
+
+    for (const backendProject of this._backendProjects) {
+      if (!backendProject.abilityResources) continue
+
+      for (const ResourceClass of backendProject.abilityResources) {
+        if (seen.has(ResourceClass)) continue
+
+        seen.add(ResourceClass)
+        merged.push(ResourceClass)
+      }
+    }
+
+    this._abilityResources = merged
+  }
+
   /**
    * Runs get ability resolver.
    * @returns {import("./configuration-types.js").AbilityResolverType | undefined} - Ability resolver.
@@ -1723,6 +1780,7 @@ export default class VelociousConfiguration {
 
       await this.initializeModels({type})
       await this.getEnvironmentHandler().autoDiscoverResources(this)
+      this._mergeDiscoveredAbilityResources()
       this._validateResourceRelationshipsOnModels()
 
       if (this._initializers) {

package/build/database/query/index.js

@@ -235,18 +235,48 @@ export default class VelociousDatabaseQuery {
     return this._groups
   }
 
+  /**
+   * Runs get joins.
+   * @returns {Array<?>} - The joins.
+   */
+  getJoins() { return this._joins }
+
+  /**
+   * Runs get limit.
+   * @returns {number | null} - The limit.
+   */
+  getLimit() { return this._limit }
+
+  /**
+   * Runs get offset.
+   * @returns {number | null} - The offset.
+   */
+  getOffset() { return this._offset }
+
   /**
    * Runs get options.
    * @returns {import("../query-parser/options.js").default} - The options options.
    */
   getOptions() { return this.driver.options() }
 
+  /**
+   * Runs get orders.
+   * @returns {Array<?>} - The orders.
+   */
+  getOrders() { return this._orders }
+
   /**
    * Runs get selects.
    * @returns {Array<import("./select-base.js").default>} - The selects.
    */
   getSelects() { return this._selects }
 
+  /**
+   * Runs get wheres.
+   * @returns {Array<import("./where-base.js").default>} - The wheres.
+   */
+  getWheres() { return this._wheres }
+
   /**
    * Runs from.
    * @param {string|import("./from-base.js").default} from - From.

package/build/database/query/model-class-query.js

@@ -3,6 +3,7 @@
 import {incorporate} from "incorporator"
 import * as inflection from "inflection"
 import {isPlainObject} from "is-plain-object"
+import {currentSyncClient} from "../../sync/sync-client-registry.js"
 import Logger from "../../logger.js"
 import Preloader from "./preloader.js"
 import {normalizeQueryDataSpec, runQueryData} from "./query-data.js"
@@ -1114,6 +1115,22 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
   queryLogName(operation) {
     return `${this.getModelClass().name} ${operation}`
   }
+
+  /**
+   * Declares this query as a sync scope on the current sync client.
+   * @returns {Promise<?>} - Declared scope and pull result.
+   */
+  async sync() {
+    return await currentSyncClient().sync(this)
+  }
+
+  /**
+   * Deactivates this query's sync scope on the current sync client.
+   * @returns {Promise<void>} - Resolves when the scope is deactivated.
+   */
+  async unsync() {
+    await currentSyncClient().unsync(this)
+  }
 }
 
 /**

package/build/database/record/index.js

@@ -535,6 +535,22 @@ class VelociousDatabaseRecord {
     callbacks[callbackName].push(callback)
   }
 
+  /**
+   * Runs unregister lifecycle callback.
+   * @param {"afterCreate" | "afterDestroy" | "afterSave" | "afterUpdate" | "beforeCreate" | "beforeDestroy" | "beforeSave" | "beforeUpdate" | "beforeValidation"} callbackName - Callback type.
+   * @param {LifecycleCallbackType} callback - Previously registered callback.
+   * @returns {void}
+   */
+  static unregisterLifecycleCallback(callbackName, callback) {
+    const callbacks = this.getLifecycleCallbacksMap()[callbackName]
+
+    if (!callbacks) return
+
+    const callbackIndex = callbacks.indexOf(callback)
+
+    if (callbackIndex >= 0) callbacks.splice(callbackIndex, 1)
+  }
+
   /**
    * Runs before validation.
    * @template R

package/build/environment-handlers/node.js

@@ -100,10 +100,11 @@ export default class VelociousEnvironmentHandlerNode extends Base{
    */
   async autoDiscoverResources(configuration) {
     const {frontendModelResourceDefinitionIsClass} = await import("../frontend-models/resource-definition.js")
+    const {default: AuthorizationBaseResource} = await import("../authorization/base-resource.js")
     const backendProjects = configuration.getBackendProjects()
 
     for (const backendProject of backendProjects) {
-      if (backendProject.frontendModels) continue
+      if (backendProject.abilityResources) continue
 
       const resourcesDir = backendProject.resourcesPath || path.join(backendProject.path, "src", "resources")
       let files
@@ -115,9 +116,13 @@ export default class VelociousEnvironmentHandlerNode extends Base{
       }
 
       /**
-       * Discovered.
+       * Discovered frontend-model resources keyed by model name.
        * @type {Record<string, ?>} */
       const discovered = {}
+      /**
+       * Every discovered ability resource class (frontend-model and authorization).
+       * @type {Array<?>} */
+      const abilityResourceClasses = []
 
       for (const file of files) {
         if (!file.endsWith(".js") && !file.endsWith(".mjs")) continue
@@ -127,10 +132,17 @@ export default class VelociousEnvironmentHandlerNode extends Base{
         const imported = await import(filePath)
         const ResourceClass = imported.default
 
+        // Any authorization resource (frontend-model resources also extend it) that
+        // declares a `ModelClass`; skip abstract/common base resources without one.
+        const isAbilityResource = typeof ResourceClass === "function"
+          && (ResourceClass === AuthorizationBaseResource || ResourceClass.prototype instanceof AuthorizationBaseResource)
+
+        if (!isAbilityResource || !ResourceClass.ModelClass) continue
+
+        abilityResourceClasses.push(ResourceClass)
+
+        // Only frontend-model resources drive routing/generation/publisher discovery.
         if (!frontendModelResourceDefinitionIsClass(ResourceClass)) continue
-        // Skip abstract/common base resources that declare no `ModelClass` — they are
-        // not models, so they must not be recorded as discovered frontend models.
-        if (!ResourceClass.ModelClass) continue
 
         const baseName = file.replace(/\.(js|mjs)$/, "")
         const modelName = baseName.replace(/-resource$/, "")
@@ -141,9 +153,13 @@ export default class VelociousEnvironmentHandlerNode extends Base{
         discovered[modelName] = ResourceClass
       }
 
-      if (Object.keys(discovered).length > 0) {
+      if (!backendProject.frontendModels && Object.keys(discovered).length > 0) {
         backendProject.frontendModels = discovered
       }
+
+      if (abilityResourceClasses.length > 0) {
+        backendProject.abilityResources = abilityResourceClasses
+      }
     }
   }
 

package/build/src/application.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/application.js"],"names":[],"mappings":"AASA;;mGAEmG;AAEnG;IACE;;;;;;OAMG;IACH,8DAJG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACL,UAAU;QAC5B,IAAI,EAAjB,MAAM;KAChB,EAmBA;IAbC,oDAAkC;IAElC;;yCAEqC;IACrC,yBADU,uBAAuB,CACc;IAE/C,eAA8B;IAC9B,cAAiB;IACjB;;4CAEwC;IACxC,gBADU,cAAc,GAAG,SAAS,CACL;IAGjC;;;OAGG;IACH,WAFa,MAAM,CAEY;IAE/B;;;OAGG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,YAFa,OAAO,CAQnB;IAED;;;;OAIG;IACH,cAHW,MAAa,IAAI,GACf,OAAO,CAAC,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,mBAFa,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;;;;;;OAQG;IACH,8EANG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACtB,IAAI;QACM,uBAAuB,EAA/C,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACJ,IAAI,EAAjB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAlBG,mCAOE;IAaN;;;;;;;OAOG;IACH,qDALG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACvB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;;;;OAUG;IACH,gFARG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACtB,IAAI;QACH,SAAS;QACV,UAAU;QACX,IAAI,EAAjB,MAAM;QACQ,OAAO;KAC7B,GAAU,UAAU,CAItB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,yBAFa,OAAO,CAAC,IAAI,CAAC,CAOzB;IAED;;;OAGG;IACH,yBAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAFG,qEAA0B;CAG/B;;;;sCAvNY,OAAO,0BAA0B,EAAE,uBAAuB;mBARpD,aAAa;2BAEL,8BAA8B;uBADlC,wBAAwB"}
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/application.js"],"names":[],"mappings":"AAUA;;mGAEmG;AAEnG;IACE;;;;;;OAMG;IACH,8DAJG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACL,UAAU;QAC5B,IAAI,EAAjB,MAAM;KAChB,EAmBA;IAbC,oDAAkC;IAElC;;yCAEqC;IACrC,yBADU,uBAAuB,CACc;IAE/C,eAA8B;IAC9B,cAAiB;IACjB;;4CAEwC;IACxC,gBADU,cAAc,GAAG,SAAS,CACL;IAGjC;;;OAGG;IACH,WAFa,MAAM,CAEY;IAE/B;;;OAGG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;OAGG;IACH,YAFa,OAAO,CAQnB;IAED;;;;OAIG;IACH,cAHW,MAAa,IAAI,GACf,OAAO,CAAC,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,mBAFa,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;;;;;;OAQG;IACH,8EANG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACtB,IAAI;QACM,uBAAuB,EAA/C,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACJ,IAAI,EAAjB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAlBG,mCAOE;IAaN;;;;;;;OAOG;IACH,qDALG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACvB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;;;;OAUG;IACH,gFARG;QAAmD,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACtB,IAAI;QACH,SAAS;QACV,UAAU;QACX,IAAI,EAAjB,MAAM;QACQ,OAAO;KAC7B,GAAU,UAAU,CAItB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,yBAFa,OAAO,CAAC,IAAI,CAAC,CAOzB;IAED;;;OAGG;IACH,yBAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAFG,qEAA0B;CAG/B;;;;sCAzNY,OAAO,0BAA0B,EAAE,uBAAuB;mBATpD,aAAa;2BAEL,8BAA8B;uBADlC,wBAAwB"}

package/build/src/application.js

@@ -3,6 +3,7 @@ import AppRoutes from "./routes/app-routes.js";
 import Logger from "./logger.js";
 import HttpServer from "./http-server/index.js";
 import HttpServerLock from "./http-server/server-lock.js";
+import SyncApiController from "./sync/sync-api-controller.js";
 import websocketEventsHost from "./http-server/websocket-events-host.js";
 import restArgsError from "./utils/rest-args-error.js";
 /**
@@ -44,6 +45,7 @@ export default class VelociousApplication {
     async initialize() {
         const routes = await AppRoutes.getRoutes(this.configuration);
         await this.configuration.initialize({ type: this.getType() });
+        SyncApiController.mountFromConfiguration(this.configuration);
         this.configuration.setRoutes(routes);
         if (!this.configuration.isDatabasePoolInitialized()) {
             await this.configuration.initializeDatabasePool();
@@ -197,4 +199,4 @@ export default class VelociousApplication {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.js","sourceRoot":"","sources":["../../src/application.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport AppRoutes from \"./routes/app-routes.js\"\nimport Logger from \"./logger.js\"\nimport HttpServer from \"./http-server/index.js\"\nimport HttpServerLock from \"./http-server/server-lock.js\"\nimport websocketEventsHost from \"./http-server/websocket-events-host.js\"\nimport restArgsError from \"./utils/rest-args-error.js\"\n\n/**\n * HttpServerConfiguration type.\n * @typedef {import(\"./configuration-types.js\").HttpServerConfiguration} HttpServerConfiguration */\n\nexport default class VelociousApplication {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {HttpServerConfiguration} [args.httpServer] - Http server.\n   * @param {string} args.type - Type identifier.\n   */\n  constructor({configuration, httpServer, type, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!configuration) throw new Error(\"configuration is required\")\n\n    this.configuration = configuration\n\n    /**\n     * Stores the http server configuration value.\n     * @type {HttpServerConfiguration} */\n    this.httpServerConfiguration = httpServer ?? {}\n\n    this.logger = new Logger(this)\n    this._type = type\n    /**\n     * Stores the http server lock value.\n     * @type {HttpServerLock | undefined} */\n    this.httpServerLock = undefined\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return this._type }\n\n  /**\n   * Runs initialize.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize() {\n    const routes = await AppRoutes.getRoutes(this.configuration)\n\n    await this.configuration.initialize({type: this.getType()})\n\n    this.configuration.setRoutes(routes)\n\n    if (!this.configuration.isDatabasePoolInitialized()) {\n      await this.configuration.initializeDatabasePool()\n    }\n\n  }\n\n  /**\n   * Runs is active.\n   * @returns {boolean} - Whether active.\n   */\n  isActive() {\n    if (this.httpServer) {\n      return this.httpServer?.isActive()\n    }\n\n    return false\n  }\n\n  /**\n   * Runs run.\n   * @param {function() : void} callback - Callback function.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async run(callback) {\n    await this.startHttpServer()\n\n    try {\n      await callback()\n    } finally {\n      await this.stop()\n    }\n  }\n\n  /**\n   * Runs start http server.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async startHttpServer() {\n    const {configuration} = this\n    const httpServerConfiguration = {\n      ...configuration.httpServer,\n      ...this.httpServerConfiguration\n    }\n    const port = httpServerConfiguration.port ?? 3006\n    const host = httpServerConfiguration.host\n\n    await this.logger.debug(`Starting server on port ${port}`)\n    await this.acquireHttpServerLock({configuration, host: host ?? \"0.0.0.0\", port})\n    await this.startLockedHttpServer({configuration, host, httpServerConfiguration, port})\n  }\n\n  /**\n   * Runs start locked http server.\n   * @param {object} args - HTTP server startup arguments.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} [args.host] - HTTP server host.\n   * @param {Record<string, ?>} args.httpServerConfiguration - Merged HTTP server configuration.\n   * @param {number} args.port - HTTP server port.\n   * @returns {Promise<void>} - Resolves after the HTTP server has started.\n   */\n  async startLockedHttpServer({configuration, host, httpServerConfiguration, port}) {\n    try {\n      if (!configuration.getWebsocketEvents()) {\n        configuration.setWebsocketEvents(/** @type {?} */ (websocketEventsHost))\n      }\n\n      await configuration.connectBeacon({peerType: \"server\"})\n\n      this.httpServer = this.createHttpServer({\n        configuration,\n        host,\n        inProcess: httpServerConfiguration.inProcess,\n        maxWorkers: httpServerConfiguration.maxWorkers,\n        port,\n        workers: httpServerConfiguration.workers\n      })\n      this.httpServer.events.on(\"close\", this.onHttpServerClose)\n      configuration._httpServerInstance = this.httpServer\n\n      await this.httpServer.start()\n    } catch (error) {\n      await this.releaseHttpServerLock()\n      configuration._httpServerInstance = undefined\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs acquire http server lock.\n   * @param {object} args - Lock acquisition arguments.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} args.host - HTTP server host.\n   * @param {number} args.port - HTTP server port.\n   * @returns {Promise<void>} - Resolves after acquiring the server lock when needed.\n   */\n  async acquireHttpServerLock({configuration, host, port}) {\n    if (this.getType() === \"test-runner\") return\n\n    const httpServerLock = new HttpServerLock({configuration, host, port})\n    await httpServerLock.acquire()\n    this.httpServerLock = httpServerLock\n  }\n\n  /**\n   * Runs create http server.\n   * @param {object} args - HTTP server arguments.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} [args.host] - Host.\n   * @param {boolean} [args.inProcess] - Run HTTP handlers in the main thread.\n   * @param {number} [args.maxWorkers] - Max workers.\n   * @param {number} args.port - Port.\n   * @param {number} [args.workers] - Worker count.\n   * @returns {HttpServer} - HTTP server instance.\n   */\n  createHttpServer({configuration, host, inProcess, maxWorkers, port, workers}) {\n    return new HttpServer({configuration, host, inProcess, maxWorkers, port, workers})\n  }\n\n  /**\n   * Runs stop.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async stop() {\n    await this.logger.debug(\"Stopping server\")\n\n    try {\n      await this.httpServer?.stop()\n      this.configuration._httpServerInstance = undefined\n      await this.configuration.disconnectBeacon()\n      await this.configuration.closeDatabaseConnections()\n    } finally {\n      await this.releaseHttpServerLock()\n    }\n  }\n\n  /**\n   * Runs release http server lock.\n   * @returns {Promise<void>} - Resolves after the HTTP server lock has been released.\n   */\n  async releaseHttpServerLock() {\n    const {httpServerLock} = this\n\n    this.httpServerLock = undefined\n    if (httpServerLock) await httpServerLock.release()\n  }\n\n  /**\n   * On http server close.\n   * @returns {void} - No return value.\n   */\n  onHttpServerClose = () => {\n    this.logger.debug(\"HTTP server closed\")\n\n    if (this.waitResolve) {\n      this.waitResolve()\n    }\n  }\n\n  /**\n   * Runs wait.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  wait() {\n    return new Promise((resolve) => {\n      this.waitResolve = resolve\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.js","sourceRoot":"","sources":["../../src/application.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport AppRoutes from \"./routes/app-routes.js\"\nimport Logger from \"./logger.js\"\nimport HttpServer from \"./http-server/index.js\"\nimport HttpServerLock from \"./http-server/server-lock.js\"\nimport SyncApiController from \"./sync/sync-api-controller.js\"\nimport websocketEventsHost from \"./http-server/websocket-events-host.js\"\nimport restArgsError from \"./utils/rest-args-error.js\"\n\n/**\n * HttpServerConfiguration type.\n * @typedef {import(\"./configuration-types.js\").HttpServerConfiguration} HttpServerConfiguration */\n\nexport default class VelociousApplication {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {HttpServerConfiguration} [args.httpServer] - Http server.\n   * @param {string} args.type - Type identifier.\n   */\n  constructor({configuration, httpServer, type, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!configuration) throw new Error(\"configuration is required\")\n\n    this.configuration = configuration\n\n    /**\n     * Stores the http server configuration value.\n     * @type {HttpServerConfiguration} */\n    this.httpServerConfiguration = httpServer ?? {}\n\n    this.logger = new Logger(this)\n    this._type = type\n    /**\n     * Stores the http server lock value.\n     * @type {HttpServerLock | undefined} */\n    this.httpServerLock = undefined\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return this._type }\n\n  /**\n   * Runs initialize.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize() {\n    const routes = await AppRoutes.getRoutes(this.configuration)\n\n    await this.configuration.initialize({type: this.getType()})\n\n    SyncApiController.mountFromConfiguration(this.configuration)\n\n    this.configuration.setRoutes(routes)\n\n    if (!this.configuration.isDatabasePoolInitialized()) {\n      await this.configuration.initializeDatabasePool()\n    }\n\n  }\n\n  /**\n   * Runs is active.\n   * @returns {boolean} - Whether active.\n   */\n  isActive() {\n    if (this.httpServer) {\n      return this.httpServer?.isActive()\n    }\n\n    return false\n  }\n\n  /**\n   * Runs run.\n   * @param {function() : void} callback - Callback function.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async run(callback) {\n    await this.startHttpServer()\n\n    try {\n      await callback()\n    } finally {\n      await this.stop()\n    }\n  }\n\n  /**\n   * Runs start http server.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async startHttpServer() {\n    const {configuration} = this\n    const httpServerConfiguration = {\n      ...configuration.httpServer,\n      ...this.httpServerConfiguration\n    }\n    const port = httpServerConfiguration.port ?? 3006\n    const host = httpServerConfiguration.host\n\n    await this.logger.debug(`Starting server on port ${port}`)\n    await this.acquireHttpServerLock({configuration, host: host ?? \"0.0.0.0\", port})\n    await this.startLockedHttpServer({configuration, host, httpServerConfiguration, port})\n  }\n\n  /**\n   * Runs start locked http server.\n   * @param {object} args - HTTP server startup arguments.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} [args.host] - HTTP server host.\n   * @param {Record<string, ?>} args.httpServerConfiguration - Merged HTTP server configuration.\n   * @param {number} args.port - HTTP server port.\n   * @returns {Promise<void>} - Resolves after the HTTP server has started.\n   */\n  async startLockedHttpServer({configuration, host, httpServerConfiguration, port}) {\n    try {\n      if (!configuration.getWebsocketEvents()) {\n        configuration.setWebsocketEvents(/** @type {?} */ (websocketEventsHost))\n      }\n\n      await configuration.connectBeacon({peerType: \"server\"})\n\n      this.httpServer = this.createHttpServer({\n        configuration,\n        host,\n        inProcess: httpServerConfiguration.inProcess,\n        maxWorkers: httpServerConfiguration.maxWorkers,\n        port,\n        workers: httpServerConfiguration.workers\n      })\n      this.httpServer.events.on(\"close\", this.onHttpServerClose)\n      configuration._httpServerInstance = this.httpServer\n\n      await this.httpServer.start()\n    } catch (error) {\n      await this.releaseHttpServerLock()\n      configuration._httpServerInstance = undefined\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs acquire http server lock.\n   * @param {object} args - Lock acquisition arguments.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} args.host - HTTP server host.\n   * @param {number} args.port - HTTP server port.\n   * @returns {Promise<void>} - Resolves after acquiring the server lock when needed.\n   */\n  async acquireHttpServerLock({configuration, host, port}) {\n    if (this.getType() === \"test-runner\") return\n\n    const httpServerLock = new HttpServerLock({configuration, host, port})\n    await httpServerLock.acquire()\n    this.httpServerLock = httpServerLock\n  }\n\n  /**\n   * Runs create http server.\n   * @param {object} args - HTTP server arguments.\n   * @param {import(\"./configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} [args.host] - Host.\n   * @param {boolean} [args.inProcess] - Run HTTP handlers in the main thread.\n   * @param {number} [args.maxWorkers] - Max workers.\n   * @param {number} args.port - Port.\n   * @param {number} [args.workers] - Worker count.\n   * @returns {HttpServer} - HTTP server instance.\n   */\n  createHttpServer({configuration, host, inProcess, maxWorkers, port, workers}) {\n    return new HttpServer({configuration, host, inProcess, maxWorkers, port, workers})\n  }\n\n  /**\n   * Runs stop.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async stop() {\n    await this.logger.debug(\"Stopping server\")\n\n    try {\n      await this.httpServer?.stop()\n      this.configuration._httpServerInstance = undefined\n      await this.configuration.disconnectBeacon()\n      await this.configuration.closeDatabaseConnections()\n    } finally {\n      await this.releaseHttpServerLock()\n    }\n  }\n\n  /**\n   * Runs release http server lock.\n   * @returns {Promise<void>} - Resolves after the HTTP server lock has been released.\n   */\n  async releaseHttpServerLock() {\n    const {httpServerLock} = this\n\n    this.httpServerLock = undefined\n    if (httpServerLock) await httpServerLock.release()\n  }\n\n  /**\n   * On http server close.\n   * @returns {void} - No return value.\n   */\n  onHttpServerClose = () => {\n    this.logger.debug(\"HTTP server closed\")\n\n    if (this.waitResolve) {\n      this.waitResolve()\n    }\n  }\n\n  /**\n   * Runs wait.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  wait() {\n    return new Promise((resolve) => {\n      this.waitResolve = resolve\n    })\n  }\n}\n"]}

package/build/src/cli/commands/db/tenants/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../../src/cli/commands/db/tenants/create.js"],"names":[],"mappings":"AAKA;IACE;;;OAGG;IACH,WAFa,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAuBrE;CACF;wBA9BuB,0BAA0B"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../../src/cli/commands/db/tenants/create.js"],"names":[],"mappings":"AAMA;IACE;;;OAGG;IACH,WAFa,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAwBrE;CACF;wBAhCuB,0BAA0B"}

package/build/src/cli/commands/db/tenants/create.js

@@ -1,5 +1,6 @@
 // @ts-check
 import BaseCommand from "../../../base-command.js";
+import { createTenantDatabase } from "../../../../tenants/default-tenant-database-provisioning.js";
 import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js";
 export default class DbTenantsCreate extends BaseCommand {
     /**
@@ -12,11 +13,13 @@ export default class DbTenantsCreate extends BaseCommand {
             identifier: this.processArgs?.[1]
         });
         const provider = helper.provider;
-        if (typeof provider.createDatabase !== "function") {
-            throw new Error(`Tenant database provider for ${helper.identifier} must define createDatabase to use db:tenants:create`);
-        }
+        // Providers may customize creation, but the generic driver-agnostic provisioning
+        // is the framework default so apps do not reimplement it.
+        const createDatabase = typeof provider.createDatabase === "function"
+            ? provider.createDatabase.bind(provider)
+            : createTenantDatabase;
         const tenantCount = await helper.eachTenant(async ({ databaseConfiguration, tenant }) => {
-            await provider.createDatabase?.({
+            await createDatabase({
                 configuration: this.getConfiguration(),
                 databaseConfiguration,
                 identifier: helper.identifier,
@@ -27,4 +30,4 @@ export default class DbTenantsCreate extends BaseCommand {
             return { identifier: helper.identifier, tenantCount };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NsaS9jb21tYW5kcy9kYi90ZW5hbnRzL2NyZWF0ZS5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosT0FBTyxXQUFXLE1BQU0sMEJBQTBCLENBQUE7QUFDbEQsT0FBTywyQkFBMkIsTUFBTSw0Q0FBNEMsQ0FBQTtBQUVwRixNQUFNLENBQUMsT0FBTyxPQUFPLGVBQWdCLFNBQVEsV0FBVztJQUN0RDs7O09BR0c7SUFDSCxLQUFLLENBQUMsT0FBTztRQUNYLE1BQU0sTUFBTSxHQUFHLElBQUksMkJBQTJCLENBQUM7WUFDN0MsT0FBTyxFQUFFLElBQUk7WUFDYixVQUFVLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUMsQ0FBQztTQUNsQyxDQUFDLENBQUE7UUFDRixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsUUFBUSxDQUFBO1FBRWhDLElBQUksT0FBTyxRQUFRLENBQUMsY0FBYyxLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQ2xELE1BQU0sSUFBSSxLQUFLLENBQUMsZ0NBQWdDLE1BQU0sQ0FBQyxVQUFVLHNEQUFzRCxDQUFDLENBQUE7UUFDMUgsQ0FBQztRQUVELE1BQU0sV0FBVyxHQUFHLE1BQU0sTUFBTSxDQUFDLFVBQVUsQ0FBQyxLQUFLLEVBQUUsRUFBQyxxQkFBcUIsRUFBRSxNQUFNLEVBQUMsRUFBRSxFQUFFO1lBQ3BGLE1BQU0sUUFBUSxDQUFDLGNBQWMsRUFBRSxDQUFDO2dCQUM5QixhQUFhLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixFQUFFO2dCQUN0QyxxQkFBcUI7Z0JBQ3JCLFVBQVUsRUFBRSxNQUFNLENBQUMsVUFBVTtnQkFDN0IsTUFBTTthQUNQLENBQUMsQ0FBQTtRQUNKLENBQUMsQ0FBQyxDQUFBO1FBRUYsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU87WUFBRSxPQUFPLEVBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQyxVQUFVLEVBQUUsV0FBVyxFQUFDLENBQUE7SUFDNUUsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCBCYXNlQ29tbWFuZCBmcm9tIFwiLi4vLi4vLi4vYmFzZS1jb21tYW5kLmpzXCJcbmltcG9ydCBUZW5hbnREYXRhYmFzZUNvbW1hbmRIZWxwZXIgZnJvbSBcIi4uLy4uLy4uL3RlbmFudC1kYXRhYmFzZS1jb21tYW5kLWhlbHBlci5qc1wiXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIERiVGVuYW50c0NyZWF0ZSBleHRlbmRzIEJhc2VDb21tYW5kIHtcbiAgLyoqXG4gICAqIFJ1bnMgZXhlY3V0ZS5cbiAgICogQHJldHVybnMge1Byb21pc2U8e2lkZW50aWZpZXI6IHN0cmluZywgdGVuYW50Q291bnQ6IG51bWJlcn0gfCB2b2lkPn0gLSBSZXN1bHQgaW4gdGVzdCBtb2RlLlxuICAgKi9cbiAgYXN5bmMgZXhlY3V0ZSgpIHtcbiAgICBjb25zdCBoZWxwZXIgPSBuZXcgVGVuYW50RGF0YWJhc2VDb21tYW5kSGVscGVyKHtcbiAgICAgIGNvbW1hbmQ6IHRoaXMsXG4gICAgICBpZGVudGlmaWVyOiB0aGlzLnByb2Nlc3NBcmdzPy5bMV1cbiAgICB9KVxuICAgIGNvbnN0IHByb3ZpZGVyID0gaGVscGVyLnByb3ZpZGVyXG5cbiAgICBpZiAodHlwZW9mIHByb3ZpZGVyLmNyZWF0ZURhdGFiYXNlICE9PSBcImZ1bmN0aW9uXCIpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgVGVuYW50IGRhdGFiYXNlIHByb3ZpZGVyIGZvciAke2hlbHBlci5pZGVudGlmaWVyfSBtdXN0IGRlZmluZSBjcmVhdGVEYXRhYmFzZSB0byB1c2UgZGI6dGVuYW50czpjcmVhdGVgKVxuICAgIH1cblxuICAgIGNvbnN0IHRlbmFudENvdW50ID0gYXdhaXQgaGVscGVyLmVhY2hUZW5hbnQoYXN5bmMgKHtkYXRhYmFzZUNvbmZpZ3VyYXRpb24sIHRlbmFudH0pID0+IHtcbiAgICAgIGF3YWl0IHByb3ZpZGVyLmNyZWF0ZURhdGFiYXNlPy4oe1xuICAgICAgICBjb25maWd1cmF0aW9uOiB0aGlzLmdldENvbmZpZ3VyYXRpb24oKSxcbiAgICAgICAgZGF0YWJhc2VDb25maWd1cmF0aW9uLFxuICAgICAgICBpZGVudGlmaWVyOiBoZWxwZXIuaWRlbnRpZmllcixcbiAgICAgICAgdGVuYW50XG4gICAgICB9KVxuICAgIH0pXG5cbiAgICBpZiAodGhpcy5hcmdzLnRlc3RpbmcpIHJldHVybiB7aWRlbnRpZmllcjogaGVscGVyLmlkZW50aWZpZXIsIHRlbmFudENvdW50fVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/cli/commands/db/tenants/drop.d.ts

@@ -1,7 +1,7 @@
 export default class DbTenantsDrop extends BaseCommand {
     /**
      * Drops the tenant database/schema for every listed tenant through the provider's
-     * `dropDatabase` hook.
+     * `dropDatabase` hook, or the framework default when the provider defines none.
      * @returns {Promise<{identifier: string, tenantCount: number} | void>} - Result in test mode.
      */
     execute(): Promise<{

package/build/src/cli/commands/db/tenants/drop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../../../../src/cli/commands/db/tenants/drop.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,WAFa,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAuBrE;CACF;wBA/BuB,0BAA0B"}
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../../../../src/cli/commands/db/tenants/drop.js"],"names":[],"mappings":"AAMA;IACE;;;;OAIG;IACH,WAFa,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAsBrE;CACF;wBA/BuB,0BAA0B"}

package/build/src/cli/commands/db/tenants/drop.js

@@ -1,10 +1,11 @@
 // @ts-check
 import BaseCommand from "../../../base-command.js";
+import { dropTenantDatabase } from "../../../../tenants/default-tenant-database-provisioning.js";
 import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js";
 export default class DbTenantsDrop extends BaseCommand {
     /**
      * Drops the tenant database/schema for every listed tenant through the provider's
-     * `dropDatabase` hook.
+     * `dropDatabase` hook, or the framework default when the provider defines none.
      * @returns {Promise<{identifier: string, tenantCount: number} | void>} - Result in test mode.
      */
     async execute() {
@@ -13,11 +14,11 @@ export default class DbTenantsDrop extends BaseCommand {
             identifier: this.processArgs?.[1]
         });
         const provider = helper.provider;
-        if (typeof provider.dropDatabase !== "function") {
-            throw new Error(`Tenant database provider for ${helper.identifier} must define dropDatabase to use db:tenants:drop`);
-        }
+        const dropDatabase = typeof provider.dropDatabase === "function"
+            ? provider.dropDatabase.bind(provider)
+            : dropTenantDatabase;
         const tenantCount = await helper.eachTenant(async ({ databaseConfiguration, tenant }) => {
-            await provider.dropDatabase?.({
+            await dropDatabase({
                 configuration: this.getConfiguration(),
                 databaseConfiguration,
                 identifier: helper.identifier,
@@ -28,4 +29,4 @@ export default class DbTenantsDrop extends BaseCommand {
             return { identifier: helper.identifier, tenantCount };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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