velocious 1.0.324 → 1.0.326

package/build/src/configuration.js

@@ -84,6 +84,28 @@ export default class VelociousConfiguration {
         this._websocketChannelSubscribers = undefined;
         this._websocketChannelResolver = websocketChannelResolver;
         this._websocketMessageHandlerResolver = websocketMessageHandlerResolver;
+        /** @type {Map<string, typeof import("./http-server/websocket-connection.js").default>} */
+        this._websocketConnectionClasses = new Map();
+        /** @type {Map<string, typeof import("./http-server/websocket-channel.js").default>} */
+        this._websocketChannelClasses = new Map();
+        /** @type {Map<string, Set<import("./http-server/websocket-channel.js").default>>} - channelType → live subscriptions across all sessions. */
+        this._websocketChannelSubscriptions = new Map();
+        /** @type {Map<string, {session: import("./http-server/client/websocket-session.js").default, graceTimer: ReturnType<typeof setTimeout>, pausedAt: number}>} - sessionId → paused session awaiting resume. */
+        this._pausedWebsocketSessions = new Map();
+        /** Grace period for paused WebSocket sessions before permanent teardown. */
+        this._websocketSessionGraceSeconds = 300;
+        /**
+         * Optional wrapper called around every WebSocket-borne request /
+         * connection message / channel dispatch. Apps register it here
+         * to set up per-request context (e.g. AsyncLocalStorage for
+         * locale, tenant, tracing) that downstream handlers read.
+         * @type {((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null}
+         */
+        this._websocketAroundRequest = null;
+        /** @type {((context: {request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default, next: () => Promise<void>}) => Promise<void>) | null} */
+        this._aroundAction = null;
+        /** @type {((session: import("./http-server/client/websocket-session.js").default) => any | Promise<any>) | null} */
+        this._websocketSessionIdentityResolver = null;
         this._logging = logging;
         this._mailerBackend = mailerBackend;
         this._routeResolverHooks = [...(routeResolverHooks || [])];
@@ -669,6 +691,318 @@ export default class VelociousConfiguration {
     getWebsocketChannelResolver() {
         return this._websocketChannelResolver;
     }
+    /**
+     * Registers a `VelociousWebsocketConnection` subclass under a name.
+     * Clients that send `{type: "connection-open", connectionType: name}`
+     * will have this class instantiated for their connection.
+     *
+     * @param {string} name
+     * @param {typeof import("./http-server/websocket-connection.js").default} ConnectionClass
+     * @returns {void}
+     */
+    registerWebsocketConnection(name, ConnectionClass) {
+        if (!name)
+            throw new Error("Connection name is required");
+        if (!ConnectionClass)
+            throw new Error("ConnectionClass is required");
+        this._websocketConnectionClasses.set(name, ConnectionClass);
+    }
+    /**
+     * @param {string} name
+     * @returns {typeof import("./http-server/websocket-connection.js").default | undefined}
+     */
+    getWebsocketConnectionClass(name) {
+        return this._websocketConnectionClasses.get(name);
+    }
+    /**
+     * Registers a `VelociousWebsocketChannel` subclass under a name.
+     * Clients subscribe via `{type: "channel-subscribe", channelType: name, ...}`.
+     *
+     * @param {string} name
+     * @param {typeof import("./http-server/websocket-channel.js").default} ChannelClass
+     * @returns {void}
+     */
+    registerWebsocketChannel(name, ChannelClass) {
+        if (!name)
+            throw new Error("Channel name is required");
+        if (!ChannelClass)
+            throw new Error("ChannelClass is required");
+        this._websocketChannelClasses.set(name, ChannelClass);
+    }
+    /**
+     * @param {string} name
+     * @returns {typeof import("./http-server/websocket-channel.js").default | undefined}
+     */
+    getWebsocketChannelClass(name) {
+        return this._websocketChannelClasses.get(name);
+    }
+    /**
+     * Tracks a live channel subscription in the global routing registry.
+     * Called by the session when `canSubscribe()` resolves truthy; the
+     * session calls `_unregisterWebsocketChannelSubscription` on unsubscribe.
+     *
+     * @param {string} name
+     * @param {import("./http-server/websocket-channel.js").default} subscription
+     * @returns {void}
+     */
+    _registerWebsocketChannelSubscription(name, subscription) {
+        let bucket = this._websocketChannelSubscriptions.get(name);
+        if (!bucket) {
+            bucket = new Set();
+            this._websocketChannelSubscriptions.set(name, bucket);
+        }
+        bucket.add(subscription);
+    }
+    /**
+     * @param {string} name
+     * @param {import("./http-server/websocket-channel.js").default} subscription
+     * @returns {void}
+     */
+    _unregisterWebsocketChannelSubscription(name, subscription) {
+        const bucket = this._websocketChannelSubscriptions.get(name);
+        if (!bucket)
+            return;
+        bucket.delete(subscription);
+        if (bucket.size === 0) {
+            this._websocketChannelSubscriptions.delete(name);
+        }
+    }
+    /**
+     * Delivers `body` to every live subscriber of `name` whose
+     * `matches(broadcastParams)` returns true. Pure routing — no auth
+     * re-check, no persistence. Subscribers who were admitted by
+     * `canSubscribe()` continue to receive broadcasts until they
+     * unsubscribe or the session ends.
+     *
+     * @param {string} name
+     * @param {Record<string, any>} broadcastParams
+     * @param {any} body
+     * @returns {void}
+     */
+    /**
+     * @returns {number} - Grace period (seconds) before a paused WS session is torn down.
+     */
+    getWebsocketSessionGraceSeconds() { return this._websocketSessionGraceSeconds; }
+    /**
+     * Registers a wrapper invoked around every WS-borne request /
+     * connection message / channel dispatch. The wrapper receives the
+     * session and a `next` callback; it must call `next()` to run the
+     * handler. Use it to set up AsyncLocalStorage per request.
+     *
+     * @param {((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null} wrapper
+     * @returns {void}
+     */
+    setWebsocketAroundRequest(wrapper) {
+        this._websocketAroundRequest = wrapper;
+    }
+    /**
+     * @returns {((session: import("./http-server/client/websocket-session.js").default, next: () => Promise<void>) => Promise<void>) | null}
+     */
+    getWebsocketAroundRequest() {
+        return this._websocketAroundRequest;
+    }
+    /**
+     * Registers a wrapper invoked around every controller action — both
+     * HTTP and WS-borne. Receives `{request, response, next}` and must
+     * call `next()` to run the action. Use it for per-request context
+     * like AsyncLocalStorage-scoped locale or tracing.
+     *
+     * @param {((context: {request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default, next: () => Promise<void>}) => Promise<void>) | null} wrapper
+     * @returns {void}
+     */
+    setAroundAction(wrapper) {
+        this._aroundAction = wrapper;
+    }
+    /**
+     * @returns {((context: {request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, response: import("./http-server/client/response.js").default, next: () => Promise<void>}) => Promise<void>) | null}
+     */
+    getAroundAction() {
+        return this._aroundAction;
+    }
+    /**
+     * Registers an identity resolver called once at pause time and once
+     * at resume time. The resolver receives the session and returns any
+     * value that identifies the authenticated caller — typically a
+     * `userId` read from the session's upgrade-request cookie. Velocious
+     * captures the pause-time value on the paused session and compares
+     * it via `===` (or deep-equality for plain objects) to the fresh
+     * resume-time value. If they differ, the resume is rejected with
+     * `session-gone` and the paused session is destroyed so a signed-out
+     * or re-authenticated client cannot reclaim another user's state.
+     *
+     * Return `null`/`undefined` to mean "no identity" — resumes still
+     * succeed if pause and resume both resolve to a nullish value.
+     *
+     * @param {((session: import("./http-server/client/websocket-session.js").default) => any | Promise<any>) | null} resolver
+     * @returns {void}
+     */
+    setWebsocketSessionIdentityResolver(resolver) {
+        this._websocketSessionIdentityResolver = resolver;
+    }
+    /** @returns {((session: import("./http-server/client/websocket-session.js").default) => any | Promise<any>) | null} */
+    getWebsocketSessionIdentityResolver() {
+        return this._websocketSessionIdentityResolver;
+    }
+    /**
+     * @param {number} seconds
+     * @returns {void}
+     */
+    setWebsocketSessionGraceSeconds(seconds) {
+        if (!Number.isFinite(seconds) || seconds < 0)
+            throw new Error(`Invalid grace seconds: ${seconds}`);
+        this._websocketSessionGraceSeconds = seconds;
+    }
+    /**
+     * Moves a session into the paused registry and starts the grace
+     * timer. When the timer fires, the session's permanent teardown
+     * hook is invoked. Called by the session itself from `_handleClose`
+     * when there is resumable state (live Connections / Channel subs).
+     *
+     * @param {import("./http-server/client/websocket-session.js").default} session
+     * @returns {void}
+     */
+    _pauseWebsocketSession(session) {
+        const sessionId = session.sessionId;
+        if (!sessionId)
+            throw new Error("Session must have a sessionId to be paused");
+        if (this._pausedWebsocketSessions.has(sessionId))
+            return;
+        const graceMs = this._websocketSessionGraceSeconds * 1000;
+        const graceTimer = setTimeout(() => {
+            this._expireWebsocketSession(sessionId);
+        }, graceMs);
+        // Don't keep the process alive purely for a paused session timer.
+        if (typeof graceTimer.unref === "function")
+            graceTimer.unref();
+        this._pausedWebsocketSessions.set(sessionId, { session, graceTimer, pausedAt: Date.now() });
+    }
+    /**
+     * Looks up a paused session by id (does NOT remove it — caller is
+     * expected to call `_resumeWebsocketSession` to complete the handoff).
+     *
+     * @param {string} sessionId
+     * @returns {import("./http-server/client/websocket-session.js").default | null}
+     */
+    _findPausedWebsocketSession(sessionId) {
+        return this._pausedWebsocketSessions.get(sessionId)?.session || null;
+    }
+    /**
+     * Removes a paused session from the registry and cancels its grace
+     * timer. Called on successful resume handoff and on explicit
+     * expiry.
+     *
+     * @param {string} sessionId
+     * @returns {void}
+     */
+    _clearPausedWebsocketSession(sessionId) {
+        const entry = this._pausedWebsocketSessions.get(sessionId);
+        if (!entry)
+            return;
+        clearTimeout(entry.graceTimer);
+        this._pausedWebsocketSessions.delete(sessionId);
+    }
+    /**
+     * Grace-timer callback. Calls the session's permanent-teardown
+     * hook and drops it from the registry.
+     *
+     * @param {string} sessionId
+     * @returns {void}
+     */
+    _expireWebsocketSession(sessionId) {
+        const entry = this._pausedWebsocketSessions.get(sessionId);
+        if (!entry)
+            return;
+        this._pausedWebsocketSessions.delete(sessionId);
+        try {
+            entry.session._finalizeGraceExpiry();
+        }
+        catch (error) {
+            console.error(`Failed to finalize expired WS session ${sessionId}`, error);
+        }
+    }
+    /**
+     * @param {string} name
+     * @param {Record<string, any>} broadcastParams
+     * @param {any} body
+     * @returns {void}
+     */
+    broadcastToChannel(name, broadcastParams, body) {
+        // V2 subscriptions live per worker-thread. When running in
+        // worker-thread mode, the publisher runs either in the main
+        // process (host) or in one of the workers:
+        //
+        //  - Main process: `_websocketEvents` is the host singleton and
+        //    `broadcastV2` fans out to every worker directly.
+        //  - Worker: `_websocketEvents` has `publishV2Broadcast` that
+        //    posts to main, which then fans out to every worker.
+        //
+        // In-process mode doesn't install a websocket-events transport,
+        // so fall through to the local dispatch.
+        /** @type {any} */
+        const websocketEvents = this._websocketEvents;
+        if (websocketEvents && typeof websocketEvents.broadcastV2 === "function") {
+            websocketEvents.broadcastV2({ channel: name, broadcastParams, body });
+            return;
+        }
+        if (websocketEvents && typeof websocketEvents.publishV2Broadcast === "function" && websocketEvents.parentPort) {
+            websocketEvents.publishV2Broadcast({ channel: name, broadcastParams, body });
+            return;
+        }
+        this._broadcastToChannelLocal(name, broadcastParams, body);
+    }
+    /**
+     * Awaits all pending broadcast operations (including event-log
+     * persistence). Call this after `broadcastToChannel` when you need
+     * the event to be persisted before continuing (e.g. before
+     * responding to an HTTP request).
+     *
+     * @returns {Promise<void>}
+     */
+    async awaitPendingBroadcasts() {
+        /** @type {any} */
+        const websocketEvents = this._websocketEvents;
+        if (websocketEvents && typeof websocketEvents.awaitPendingBroadcasts === "function") {
+            await websocketEvents.awaitPendingBroadcasts();
+        }
+    }
+    /**
+     * Local (per-worker) channel broadcast dispatch. Called either
+     * directly (in-process mode) or by the worker thread after the
+     * main-process fan-out.
+     *
+     * @param {string} name - Channel name.
+     * @param {Record<string, any>} broadcastParams - Params passed to each subscription's `matches()`.
+     * @param {any} body - Message body delivered via `sendMessage()`.
+     * @param {{eventId?: string}} [meta] - Optional event metadata for replay tracking.
+     * @returns {void}
+     */
+    _broadcastToChannelLocal(name, broadcastParams, body, meta) {
+        const bucket = this._websocketChannelSubscriptions.get(name);
+        if (!bucket)
+            return;
+        for (const subscription of bucket) {
+            if (subscription.isClosed())
+                continue;
+            let matches;
+            try {
+                matches = subscription.matches(broadcastParams || {});
+            }
+            catch (error) {
+                // A broken `matches()` on one subscriber must not poison the
+                // broadcast to other subscribers. Skip and continue.
+                console.error(`broadcastToChannel: ${name} subscription ${subscription.subscriptionId} matches() threw`, error);
+                continue;
+            }
+            if (!matches)
+                continue;
+            try {
+                subscription.sendMessage(body, { eventId: meta?.eventId });
+            }
+            catch (error) {
+                console.error(`broadcastToChannel: ${name} subscription ${subscription.subscriptionId} sendMessage threw`, error);
+            }
+        }
+    }
     /** @returns {import("./configuration-types.js").WebsocketMessageHandlerResolverType | undefined} - The websocket message handler resolver. */
     getWebsocketMessageHandlerResolver() {
         return this._websocketMessageHandlerResolver;
@@ -868,4 +1202,4 @@ export default class VelociousConfiguration {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../src/configuration.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * @template T\n * @typedef {function(Record<string, import(\"./database/drivers/base.js\").default>) : Promise<T>} WithConnectionsCallbackType\n */\n\nimport {digg} from \"diggerize\"\nimport gettextConfig from \"gettext-universal/build/src/config.js\"\nimport translate from \"gettext-universal/build/src/translate.js\"\nimport Ability from \"./authorization/ability.js\"\nimport EventEmitter from \"./utils/event-emitter.js\"\nimport VelociousWebsocketChannelSubscribers from \"./http-server/websocket-channel-subscribers.js\"\nimport {ensureFrontendModelWebsocketPublishersRegistered} from \"./frontend-models/websocket-publishers.js\"\nimport {frontendModelResourceConfigurationFromDefinition, frontendModelResourcesForBackendProject} from \"./frontend-models/resource-definition.js\"\nimport PluginRoutes from \"./routes/plugin-routes.js\"\nimport restArgsError from \"./utils/rest-args-error.js\"\nimport {withTrackedStack} from \"./utils/with-tracked-stack.js\"\n\n/** @type {{currentConfiguration: VelociousConfiguration | null}} */\nconst shared = {\n  currentConfiguration: null\n}\n\nclass CurrentConfigurationNotSetError extends Error {}\n\nexport {CurrentConfigurationNotSetError}\n\n/**\n * @param {import(\"./configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Base database configuration.\n * @param {import(\"./configuration-types.js\").DatabaseConfigurationType | Partial<import(\"./configuration-types.js\").DatabaseConfigurationType> | void} overrideConfiguration - Tenant override configuration.\n * @returns {import(\"./configuration-types.js\").DatabaseConfigurationType} - Merged database configuration.\n */\nfunction mergeDatabaseConfiguration(databaseConfiguration, overrideConfiguration) {\n  if (!overrideConfiguration) return databaseConfiguration\n\n  return {\n    ...databaseConfiguration,\n    ...overrideConfiguration,\n    record: {\n      ...(databaseConfiguration.record || {}),\n      ...(overrideConfiguration.record || {})\n    },\n    sqlConfig: {\n      ...(databaseConfiguration.sqlConfig || {}),\n      ...(overrideConfiguration.sqlConfig || {})\n    }\n  }\n}\n\nexport default class VelociousConfiguration {\n  /** @type {Promise<void> | null} */\n  _closeDatabaseConnectionsPromise = null\n  /** @returns {VelociousConfiguration} - The current.  */\n  static current() {\n    if (!shared.currentConfiguration) throw new CurrentConfigurationNotSetError(\"A current configuration hasn't been set\")\n\n    return shared.currentConfiguration\n  }\n\n  /** @param {import(\"./configuration-types.js\").ConfigurationArgsType} args - Configuration arguments. */\n  constructor({abilityResolver, abilityResources, attachments, backgroundJobs, backendProjects, cookieSecret, cors, database, debug = false, directory, environment, environmentHandler, initializeModels, initializers, locale, localeFallbacks, locales, logging, mailerBackend, requestTimeoutMs, routeResolverHooks, scheduledBackgroundJobs, structureSql, tenantDatabaseResolver, tenantResolver, testing, timezoneOffsetMinutes, websocketChannelResolver, websocketMessageHandlerResolver, ...restArgs}) {\n    restArgsError(restArgs)\n\n    this._abilityResolver = abilityResolver\n    this._abilityResources = abilityResources || []\n    this._backgroundJobs = backgroundJobs\n    this._scheduledBackgroundJobs = scheduledBackgroundJobs\n    this._attachments = attachments || {}\n    this._backendProjects = backendProjects || []\n    this.cors = cors\n    this._cookieSecret = cookieSecret\n    this.database = database\n    this.debug = debug\n    this._environment = environment || process.env.VELOCIOUS_ENV || process.env.NODE_ENV || \"development\"\n    this._environmentHandler = environmentHandler\n    this._directory = directory\n    this._initializeModels = initializeModels\n    this._isInitialized = false\n    this.locale = locale\n    this.localeFallbacks = localeFallbacks\n    this.locales = locales\n    this._initializers = initializers\n    this._testing = testing\n    this._timezoneOffsetMinutes = timezoneOffsetMinutes\n    this._requestTimeoutMs = requestTimeoutMs\n    this._structureSql = structureSql\n    this._tenantDatabaseResolver = tenantDatabaseResolver\n    this._tenantResolver = tenantResolver\n    this._websocketEvents = undefined\n    /** @type {VelociousWebsocketChannelSubscribers | undefined} */\n    this._websocketChannelSubscribers = undefined\n    this._websocketChannelResolver = websocketChannelResolver\n    this._websocketMessageHandlerResolver = websocketMessageHandlerResolver\n    this._logging = logging\n    this._mailerBackend = mailerBackend\n    this._routeResolverHooks = [...(routeResolverHooks || [])]\n    this._errorEvents = new EventEmitter()\n\n    /** @type {{[key: string]: import(\"./database/pool/base.js\").default}} */\n    this.databasePools = {}\n\n    /** @type {{[key: string]: typeof import(\"./database/record/index.js\").default}} */\n    this.modelClasses = {}\n\n    this.getEnvironmentHandler().setConfiguration(this)\n  }\n\n  /** @returns {import(\"./configuration-types.js\").CorsType | undefined} - The cors.  */\n  getCors() {\n    return this.cors\n  }\n\n  /** @returns {string | undefined} - Cookie secret. */\n  getCookieSecret() {\n    return this._cookieSecret\n  }\n\n  /** @returns {Record<string, import(\"./configuration-types.js\").DatabaseConfigurationType>} - The database configuration.  */\n  getDatabaseConfiguration() {\n    if (!this.database) throw new Error(\"No database configuration\")\n\n    if (!this.database[this.getEnvironment()]) {\n      throw new Error(`No database configuration for environment: ${this.getEnvironment()} - ${Object.keys(this.database).join(\", \")}`)\n    }\n\n    return digg(this, \"database\", this.getEnvironment())\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @param {unknown} [tenant] - Tenant override.\n   * @returns {import(\"./configuration-types.js\").DatabaseConfigurationType} - Resolved database configuration for the identifier.\n   */\n  resolveDatabaseConfiguration(identifier, tenant = this.getCurrentTenant()) {\n    const databaseConfiguration = this.getDatabaseConfiguration()[identifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`No such database identifier configured: ${identifier}`)\n    }\n\n    if (tenant === undefined || !this._tenantDatabaseResolver) {\n      return databaseConfiguration\n    }\n\n    const overrideConfiguration = this._tenantDatabaseResolver({\n      configuration: this,\n      databaseConfiguration,\n      identifier,\n      tenant\n    })\n\n    return mergeDatabaseConfiguration(databaseConfiguration, overrideConfiguration)\n  }\n\n  /** @returns {Array<string>} - The database identifiers.  */\n  getDatabaseIdentifiers() {\n    const identifiers = Object.keys(this.getDatabaseConfiguration())\n    const disabledIdentifiers = new Set()\n    const disabledIdentifiersRaw = process.env.VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS\n\n    if (disabledIdentifiersRaw) {\n      for (const identifier of disabledIdentifiersRaw.split(\",\")) {\n        const trimmed = identifier.trim()\n\n        if (trimmed) disabledIdentifiers.add(trimmed)\n      }\n    }\n\n    if (process.env.VELOCIOUS_DISABLE_MSSQL === \"1\") {\n      disabledIdentifiers.add(\"mssql\")\n    }\n\n    if (disabledIdentifiers.size === 0) return identifiers\n\n    return identifiers.filter((identifier) => !disabledIdentifiers.has(identifier))\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @returns {import(\"./database/pool/base.js\").default} - The database pool.\n   */\n  getDatabasePool(identifier = \"default\") {\n    if (!this.isDatabasePoolInitialized(identifier)) {\n      this.initializeDatabasePool(identifier)\n    }\n\n    return digg(this, \"databasePools\", identifier)\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @returns {import(\"./configuration-types.js\").DatabaseConfigurationType})\n   */\n  getDatabaseIdentifier(identifier) {\n    return this.resolveDatabaseConfiguration(identifier)\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @returns {typeof import(\"./database/pool/base.js\").default} - The database pool type.\n   */\n  getDatabasePoolType(identifier = \"default\") {\n    const poolTypeClass = digg(this.getDatabaseIdentifier(identifier), \"poolType\")\n\n    if (!poolTypeClass) {\n      throw new Error(\"No poolType given in database configuration\")\n    }\n\n    return poolTypeClass\n  }\n\n  getDatabaseType(identifier = \"default\") {\n    const databaseType = this.getDatabaseIdentifier(identifier).type\n\n    if (!databaseType) throw new Error(\"No database type given in database configuration\")\n\n    return databaseType\n  }\n\n  /**\n   * @returns {string} - The directory.\n   */\n  getDirectory() {\n    if (!this._directory) {\n      this._directory = process.cwd()\n    }\n\n    return this._directory\n  }\n\n  /**\n   * @returns {import(\"./configuration-types.js\").BackendProjectConfiguration[]} - Backend projects.\n   */\n  getBackendProjects() { return this._backendProjects }\n\n  /** @returns {import(\"./configuration-types.js\").AbilityResourceClassType[]} - Ability resource classes. */\n  getAbilityResources() { return this._abilityResources }\n\n  /**\n   * @param {import(\"./configuration-types.js\").AbilityResourceClassType[]} resources - Ability resource classes.\n   * @returns {void} - No return value.\n   */\n  setAbilityResources(resources) { this._abilityResources = resources }\n\n  /** @returns {import(\"./configuration-types.js\").AbilityResolverType | undefined} - Ability resolver. */\n  getAbilityResolver() { return this._abilityResolver }\n\n  /** @returns {import(\"./configuration-types.js\").TenantResolverType | undefined} - Tenant resolver. */\n  getTenantResolver() { return this._tenantResolver }\n\n  /** @returns {import(\"./configuration-types.js\").TenantDatabaseResolverType | undefined} - Tenant database resolver. */\n  getTenantDatabaseResolver() { return this._tenantDatabaseResolver }\n\n  /** @returns {import(\"./configuration-types.js\").AttachmentsConfiguration} - Attachments configuration. */\n  getAttachmentsConfiguration() { return this._attachments || {} }\n\n  /** @returns {import(\"./configuration-types.js\").RouteResolverHookType[]} - Route resolver hooks. */\n  getRouteResolverHooks() { return this._routeResolverHooks }\n\n  /**\n   * @param {import(\"./configuration-types.js\").RouteResolverHookType} hook - Route resolver hook.\n   * @returns {void} - No return value.\n   */\n  addRouteResolverHook(hook) {\n    this._routeResolverHooks.push(hook)\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").AbilityResolverType | undefined} resolver - Ability resolver.\n   * @returns {void} - No return value.\n   */\n  setAbilityResolver(resolver) { this._abilityResolver = resolver }\n\n  /**\n   * @param {import(\"./configuration-types.js\").TenantResolverType | undefined} resolver - Tenant resolver.\n   * @returns {void} - No return value.\n   */\n  setTenantResolver(resolver) { this._tenantResolver = resolver }\n\n  /**\n   * @param {import(\"./configuration-types.js\").TenantDatabaseResolverType | undefined} resolver - Tenant database resolver.\n   * @returns {void} - No return value.\n   */\n  setTenantDatabaseResolver(resolver) { this._tenantDatabaseResolver = resolver }\n\n  /**\n   * @returns {string} - The environment.\n   */\n  getEnvironment() { return digg(this, \"_environment\") }\n\n  /**\n   * @returns {number} - Request timeout in seconds.\n   */\n  getRequestTimeoutMs() {\n    const envTimeout = this._parseRequestTimeoutSeconds(process.env.VELOCIOUS_REQUEST_TIMEOUT_MS)\n    const value = typeof this._requestTimeoutMs === \"function\"\n      ? this._requestTimeoutMs()\n      : this._requestTimeoutMs\n\n    if (typeof value === \"number\") return value\n    if (typeof envTimeout === \"number\" && Number.isFinite(envTimeout)) return envTimeout\n\n    return 60\n  }\n\n  /**\n   * @param {string | undefined} rawValue - Env value.\n   * @returns {number | undefined} - Timeout in seconds.\n   */\n  _parseRequestTimeoutSeconds(rawValue) {\n    if (rawValue === undefined) return undefined\n\n    const trimmed = rawValue.trim().toLowerCase()\n\n    if (!trimmed) return undefined\n\n    const match = trimmed.match(/^(\\d+(?:\\.\\d+)?)(ms|s)?$/)\n\n    if (!match) return undefined\n\n    const numeric = Number(match[1])\n\n    if (!Number.isFinite(numeric)) return undefined\n\n    const unit = match[2]\n\n    if (unit === \"ms\") return numeric / 1000\n    if (unit === \"s\") return numeric\n\n    if (trimmed.includes(\".\")) return numeric\n    if (numeric >= 1000) return numeric / 1000\n\n    return numeric\n  }\n\n  /**\n   * @param {string} newEnvironment - New environment.\n   * @returns {void} - No return value.\n   */\n  setEnvironment(newEnvironment) { this._environment = newEnvironment }\n\n  /**\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.defaultConsole] - Whether default console.\n   * @returns {Required<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"console\" | \"file\" | \"levels\">> & Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"directory\" | \"filePath\"> & Partial<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"outputs\" | \"loggers\">>} - The logging configuration.\n   */\n  getLoggingConfiguration({defaultConsole} = {}) {\n    const environment = this.getEnvironment()\n    const environmentHandler = this.getEnvironmentHandler()\n    const directory = this._logging?.directory || environmentHandler.getDefaultLogDirectory({configuration: this})\n    const filePath = this._logging?.filePath || environmentHandler.getLogFilePath({configuration: this, directory, environment})\n    const consoleOverride = this._logging?.console\n    const hasLoggingConfig = Boolean(this._logging)\n    const fileLogging = hasLoggingConfig ? (this._logging?.file ?? Boolean(filePath)) : false\n    const configuredLevels = this._logging?.levels\n    const includeLowLevelDebug = this._logging?.debugLowLevel === true\n    const loggers = this._logging?.loggers\n\n    const consoleDefault = defaultConsole !== undefined ? defaultConsole : true\n    const consoleLogging = consoleOverride !== undefined ? consoleOverride : consoleDefault\n\n    /** @type {Array<\"debug-low-level\" | \"debug\" | \"info\" | \"warn\" | \"error\">} */\n    const defaultLevels = [\"info\", \"warn\", \"error\"]\n\n    if (includeLowLevelDebug) defaultLevels.unshift(\"debug-low-level\")\n\n    const levels = configuredLevels || defaultLevels\n\n    return {\n      console: consoleLogging,\n      directory,\n      file: fileLogging ?? false,\n      filePath,\n      loggers,\n      levels,\n      outputs: this._logging?.outputs\n    }\n  }\n\n  /**\n   * @returns {Required<import(\"./configuration-types.js\").BackgroundJobsConfiguration>} - Background jobs configuration.\n   */\n  getBackgroundJobsConfig() {\n    const envHost = process.env.VELOCIOUS_BACKGROUND_JOBS_HOST\n    const envPortRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_PORT\n    const envDatabaseIdentifier = process.env.VELOCIOUS_BACKGROUND_JOBS_DATABASE_IDENTIFIER\n    const envPort = envPortRaw ? Number(envPortRaw) : undefined\n    const configured = this._backgroundJobs || {}\n    const host = configured.host || envHost || \"127.0.0.1\"\n    const port = typeof configured.port === \"number\"\n      ? configured.port\n      : (typeof envPort === \"number\" && Number.isFinite(envPort) ? envPort : 7331)\n    const databaseIdentifier = configured.databaseIdentifier || envDatabaseIdentifier || \"default\"\n\n    return {host, port, databaseIdentifier}\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").BackgroundJobsConfiguration} backgroundJobs - Background jobs config.\n   * @returns {void}\n   */\n  setBackgroundJobsConfig(backgroundJobs) {\n    this._backgroundJobs = Object.assign({}, this._backgroundJobs, backgroundJobs)\n  }\n\n  /**\n   * @returns {Promise<import(\"./configuration-types.js\").ScheduledBackgroundJobsConfiguration | undefined>} - Scheduled background jobs configuration.\n   */\n  async getScheduledBackgroundJobsConfig() {\n    if (!this._scheduledBackgroundJobs) {\n      return undefined\n    }\n\n    if (typeof this._scheduledBackgroundJobs === \"function\") {\n      return await this._scheduledBackgroundJobs({configuration: this})\n    }\n\n    return this._scheduledBackgroundJobs\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").ScheduledBackgroundJobsConfiguration | import(\"./configuration-types.js\").ScheduledBackgroundJobsLoaderType | undefined} scheduledBackgroundJobs - Scheduled background jobs configuration.\n   * @returns {void}\n   */\n  setScheduledBackgroundJobsConfig(scheduledBackgroundJobs) {\n    this._scheduledBackgroundJobs = scheduledBackgroundJobs\n  }\n\n  /**\n   * @returns {import(\"./configuration-types.js\").MailerBackend | undefined} - Mailer backend.\n   */\n  getMailerBackend() {\n    return this._mailerBackend\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").MailerBackend} mailerBackend - Mailer backend.\n   * @returns {void} - No return value.\n   */\n  setMailerBackend(mailerBackend) {\n    this._mailerBackend = mailerBackend\n  }\n\n  /**\n   * Logging configuration tailored for HTTP request logging. Defaults console logging to true and applies the user `logging.console` flag only for request logging.\n   * @returns {Required<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"console\" | \"file\" | \"levels\">> & Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"directory\" | \"filePath\"> & Partial<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"outputs\" | \"loggers\">>} - The http logging configuration.\n   */\n  getHttpLoggingConfiguration() {\n    return this.getLoggingConfiguration({defaultConsole: true})\n  }\n\n  /**\n   * @returns {import(\"./environment-handlers/base.js\").default} - The environment handler.\n   */\n  getEnvironmentHandler() {\n    if (!this._environmentHandler) throw new Error(\"No environment handler set\")\n\n    return this._environmentHandler\n  }\n\n  /**\n   * @returns {import(\"./configuration-types.js\").LocaleFallbacksType | undefined} - The locale fallbacks.\n   */\n  getLocaleFallbacks() { return this.localeFallbacks }\n\n  /**\n   * @param {import(\"./configuration-types.js\").LocaleFallbacksType} newLocaleFallbacks - New locale fallbacks.\n   * @returns {void} - No return value.\n   */\n  setLocaleFallbacks(newLocaleFallbacks) { this.localeFallbacks = newLocaleFallbacks }\n\n  /** @returns {import(\"./configuration-types.js\").StructureSqlConfiguration | undefined} - Structure SQL config. */\n  getStructureSqlConfig() { return this._structureSql }\n\n  /**\n   * @returns {boolean} - Whether structure SQL files should be generated for the current environment.\n   */\n  shouldWriteStructureSql() {\n    const config = this.getStructureSqlConfig()\n    const disabledEnvironments = config?.disabledEnvironments\n\n    if (Array.isArray(disabledEnvironments) && disabledEnvironments.includes(this.getEnvironment())) {\n      return false\n    }\n\n    return true\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").StructureSqlConfiguration} structureSql - Structure SQL config.\n   * @returns {void} - No return value.\n   */\n  setStructureSqlConfig(structureSql) {\n    this._structureSql = structureSql\n  }\n\n  /**\n   * @returns {string} - The locale.\n   */\n  getLocale() {\n    if (typeof this.locale == \"function\") {\n      return this.locale()\n    } else if (this.locale) {\n      return this.locale\n    } else {\n      return this.getLocales()[0]\n    }\n  }\n\n  /** @returns {Array<string>} - The locales.  */\n  getLocales() { return digg(this, \"locales\") }\n\n  /**\n   * @param {string} name - Name.\n   * @returns {typeof import(\"./database/record/index.js\").default} - The model class.\n   */\n  getModelClass(name) {\n    const modelClass = this.modelClasses[name]\n\n    if (!modelClass) throw new Error(`No such model class ${name} in ${Object.keys(this.modelClasses).join(\", \")}}`)\n\n    return modelClass\n  }\n\n  /**\n   * @returns {Record<string, typeof import(\"./database/record/index.js\").default>} A hash of all model classes, keyed by model name, as they were defined in the configuration. This is a direct reference to the model classes, not a copy.\n   */\n  getModelClasses() {\n    return this.modelClasses\n  }\n\n  /** @returns {string | undefined} The path to a config file that should be used for testing. */\n  getTesting() { return this._testing }\n\n  /**\n   * @param {string} [identifier] - Database identifier to initialize.\n   * @returns {void} - No return value.\n   */\n  initializeDatabasePool(identifier = \"default\") {\n    if (!this.database) throw new Error(\"No 'database' was given\")\n    if (this.databasePools[identifier]) throw new Error(\"DatabasePool has already been initialized\")\n\n    const PoolType = this.getDatabasePoolType(identifier)\n\n    this.databasePools[identifier] = new PoolType({configuration: this, identifier})\n    this.databasePools[identifier].setCurrent()\n  }\n\n  /**\n   * @param {string} [identifier] - Database identifier to check.\n   * @returns {boolean} - Whether database pool initialized.\n   */\n  isDatabasePoolInitialized(identifier = \"default\") { return Boolean(this.databasePools[identifier]) }\n\n  /** @returns {boolean} - Whether initialized.  */\n  isInitialized() { return this._isInitialized }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.type - Type identifier.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeModels(args = {type: \"server\"}) {\n    if (!this._modelsInitialized) {\n      this._modelsInitialized = true\n\n      const shouldSkipDummyModelInitialization = process.env.VELOCIOUS_SKIP_DUMMY_MODEL_INITIALIZATION === \"1\"\n        && process.env.VELOCIOUS_BROWSER_TESTS === \"true\"\n        && this.getEnvironment() === \"test\"\n\n      if (shouldSkipDummyModelInitialization) {\n        return\n      }\n\n      if (this._initializeModels) {\n        await this._initializeModels({configuration: this, type: args.type})\n      }\n\n      await ensureFrontendModelWebsocketPublishersRegistered(this)\n    }\n  }\n\n  /**\n   * Ensures each configured database pool has a global connection available.\n   * Useful when `getCurrentConnection` might be called without an async context.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async ensureGlobalConnections() {\n    for (const identifier of this.getDatabaseIdentifiers()) {\n      const pool = this.getDatabasePool(identifier)\n\n      await pool.ensureGlobalConnection()\n    }\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.type - Type identifier.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize({type} = {type: \"undefined\"}) {\n    if (!this.isInitialized()) {\n      this._isInitialized = true\n\n      await this.initializeModels({type})\n      await this.getEnvironmentHandler().autoDiscoverResources(this)\n      this._validateResourceRelationshipsOnModels()\n\n      if (this._initializers) {\n        const initializers = await this._initializers({configuration: this})\n        const {requireContext, ...restArgs} = initializers\n\n        restArgsError(restArgs)\n\n        if (requireContext) {\n          for (const initializerKey of requireContext.keys()) {\n            const InitializerClass = requireContext(initializerKey).default\n            const initializerInstance = new InitializerClass({configuration: this, type})\n\n            await initializerInstance.run()\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Validates that resource-defined relationships are also defined on the corresponding model classes.\n   * Throws an error if a relationship is defined on a resource but missing from the model.\n   *\n   * @returns {void}\n   */\n  _validateResourceRelationshipsOnModels() {\n    for (const backendProject of this._backendProjects) {\n      const resources = frontendModelResourcesForBackendProject(backendProject)\n\n      for (const [modelName, resourceDefinition] of Object.entries(resources)) {\n        const resourceConfig = frontendModelResourceConfigurationFromDefinition(resourceDefinition)\n\n        if (!resourceConfig?.relationships) continue\n\n        if (!Array.isArray(resourceConfig.relationships)) {\n          throw new Error(`Resource for ${modelName} defines relationships as an object. Use an array instead: static relationships = ${JSON.stringify(Object.keys(resourceConfig.relationships))}`)\n        }\n\n        const modelClass = /** @type {typeof import(\"./database/record/index.js\").default | undefined} */ (this.modelClasses[modelName])\n\n        if (!modelClass) continue\n\n        const existingRelationships = modelClass.getRelationshipsMap()\n\n        for (const relationshipName of resourceConfig.relationships) {\n          if (!(relationshipName in existingRelationships)) {\n            throw new Error(\n              `Resource for ${modelName} defines relationship \"${relationshipName}\" but ${modelName} model does not. ` +\n              `Add ${modelName}.belongsTo(\"${relationshipName}\", ...) or the appropriate relationship call on the model class.`\n            )\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {typeof import(\"./database/record/index.js\").default} modelClass - Model class.\n   * @returns {void} - No return value.\n   */\n  registerModelClass(modelClass) {\n    this.modelClasses[modelClass.getModelName()] = modelClass\n  }\n\n  /** @returns {void} - No return value.  */\n  setCurrent() {\n    shared.currentConfiguration = this\n  }\n\n  /** @returns {import(\"./routes/index.js\").default | undefined} - The routes.  */\n  getRoutes() { return this._routes }\n\n  /**\n   * @param {import(\"./routes/index.js\").default} newRoutes - New routes.\n   * @returns {void} - No return value.\n   */\n  setRoutes(newRoutes) { this._routes = newRoutes }\n\n  /**\n   * Adds plugin/library routes using a lightweight route DSL backed by route resolver hooks.\n   * @param {(routes: import(\"./routes/plugin-routes.js\").default) => void} callback - Routes callback.\n   * @returns {void} - No return value.\n   */\n  routes(callback) {\n    const pluginRoutes = new PluginRoutes({configuration: this})\n\n    callback(pluginRoutes)\n  }\n\n  /**\n   * @param {function(string, Record<string, any> | undefined) : string} callback - Translator callback.\n   * @returns {void} - No return value.\n   */\n  setTranslator(callback) { this._translator = callback }\n\n  /**\n   * @param {string} msgID - Msg id.\n   * @param {Record<string, any>} [args] - Translator options and variables.\n   * @returns {string} - The default translator.\n   */\n  _defaultTranslator(msgID, args) {\n    this._configureDefaultTranslator()\n\n    const translateArgs = args ? {...args} : undefined\n    const defaultValue = translateArgs?.defaultValue\n    const locales = translateArgs?.locales\n\n    if (translateArgs) {\n      delete translateArgs.defaultValue\n      delete translateArgs.locales\n    }\n\n    const variables = translateArgs && Object.keys(translateArgs).length > 0 ? translateArgs : undefined\n\n    const locale = this.getLocale()\n    const preferredLocales = locales || (locale ? undefined : [])\n    const message = translate(msgID, variables, preferredLocales)\n\n    if (message === msgID && defaultValue) return translate(defaultValue, variables, [])\n\n    return message\n  }\n\n  /** @returns {(msgID: string, args?: Record<string, any>) => string} */\n  getTranslator() {\n    if (this._translator) return this._translator\n\n    if (!this._defaultTranslatorBound) {\n      this._defaultTranslatorBound = this._defaultTranslator.bind(this)\n    }\n\n    return this._defaultTranslatorBound\n  }\n\n  /** @returns {void} - Configure gettext defaults for this configuration. */\n  _configureDefaultTranslator() {\n    const locale = this.getLocale()\n\n    gettextConfig.setLocale(locale || \"\")\n\n    const fallbacks = locale ? this.getLocaleFallbacks()?.[locale] : []\n\n    gettextConfig.setFallbacks(fallbacks || [])\n  }\n\n  /**\n   * @returns {number | undefined} - The timezone offset in minutes.\n   */\n  getTimezoneOffsetMinutes() {\n    if (typeof this._timezoneOffsetMinutes === \"function\") {\n      const configuredOffset = this._timezoneOffsetMinutes()\n\n      if (typeof configuredOffset === \"number\") return configuredOffset\n    }\n\n    if (typeof this._timezoneOffsetMinutes === \"number\") {\n      return this._timezoneOffsetMinutes\n    }\n\n    return new Date().getTimezoneOffset()\n  }\n\n  /** @returns {import(\"./http-server/websocket-events.js\").default | undefined} - The websocket events.  */\n  getWebsocketEvents() {\n    return this._websocketEvents\n  }\n\n  /**\n   * @param {import(\"./http-server/websocket-events.js\").default} websocketEvents - Websocket events.\n   * @returns {void} - No return value.\n   */\n  setWebsocketEvents(websocketEvents) {\n    this._websocketEvents = websocketEvents\n  }\n\n  /**\n   * Per-process registry of channel subscribers used by worker code that\n   * needs to react to events broadcast via `websocketEventsHost.publish(...)`\n   * without holding an actual websocket session.\n   * @returns {import(\"./http-server/websocket-channel-subscribers.js\").default} - The channel subscribers registry.\n   */\n  getWebsocketChannelSubscribers() {\n    if (!this._websocketChannelSubscribers) {\n      this._websocketChannelSubscribers = new VelociousWebsocketChannelSubscribers()\n    }\n\n    return this._websocketChannelSubscribers\n  }\n\n  /** @returns {import(\"./configuration-types.js\").WebsocketChannelResolverType | undefined} - The websocket channel resolver. */\n  getWebsocketChannelResolver() {\n    return this._websocketChannelResolver\n  }\n\n  /** @returns {import(\"./configuration-types.js\").WebsocketMessageHandlerResolverType | undefined} - The websocket message handler resolver. */\n  getWebsocketMessageHandlerResolver() {\n    return this._websocketMessageHandlerResolver\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").WebsocketChannelResolverType} resolver - Resolver.\n   * @returns {void} - No return value.\n   */\n  setWebsocketChannelResolver(resolver) {\n    this._websocketChannelResolver = resolver\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").WebsocketMessageHandlerResolverType} resolver - Resolver.\n   * @returns {void} - No return value.\n   */\n  setWebsocketMessageHandlerResolver(resolver) {\n    this._websocketMessageHandlerResolver = resolver\n  }\n\n  /**\n   * @param {object} args - Ability resolver args.\n   * @param {Record<string, any>} args.params - Request params.\n   * @param {import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default} args.request - Request object.\n   * @param {import(\"./http-server/client/response.js\").default} args.response - Response object.\n   * @returns {Promise<import(\"./authorization/ability.js\").default | undefined>} - Resolved ability.\n   */\n  async resolveAbility({params, request, response}) {\n    const resolver = this.getAbilityResolver()\n\n    if (resolver) {\n      const resolved = await resolver({configuration: this, params, request, response})\n\n      if (resolved) return resolved\n    }\n\n    const resources = this.getAbilityResources()\n\n    if (resources.length === 0) return\n\n    return new Ability({\n      context: {configuration: this, params, request, response},\n      resources\n    })\n  }\n\n  /**\n   * @param {import(\"./authorization/ability.js\").default | undefined} ability - Ability instance.\n   * @param {() => Promise<any>} callback - Callback.\n   * @returns {Promise<any>} - Callback result.\n   */\n  async runWithAbility(ability, callback) {\n    return await this.getEnvironmentHandler().runWithAbility(ability, callback)\n  }\n\n  /**\n   * @returns {import(\"./authorization/ability.js\").default | undefined} - Current ability from context.\n   */\n  getCurrentAbility() {\n    return this.getEnvironmentHandler().getCurrentAbility()\n  }\n\n  /**\n   * @returns {unknown} - Current tenant from context.\n   */\n  getCurrentTenant() {\n    return this.getEnvironmentHandler().getCurrentTenant()\n  }\n\n  /**\n   * @param {unknown} tenant - Tenant.\n   * @param {() => Promise<any>} callback - Callback.\n   * @returns {Promise<any>} - Callback result.\n   */\n  async runWithTenant(tenant, callback) {\n    return await this.getEnvironmentHandler().runWithTenant(tenant, callback)\n  }\n\n  /**\n   * @param {object} args - Tenant resolver args.\n   * @param {Record<string, any>} args.params - Request params.\n   * @param {import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default | undefined} args.request - Request object.\n   * @param {import(\"./http-server/client/response.js\").default | undefined} args.response - Response object.\n   * @param {{channel: string, params?: Record<string, unknown>}} [args.subscription] - Subscription metadata.\n   * @returns {Promise<unknown>} - Resolved tenant.\n   */\n  async resolveTenant({params, request, response, subscription}) {\n    const resolver = this.getTenantResolver()\n\n    if (!resolver) return\n\n    return await resolver({\n      configuration: this,\n      params,\n      request,\n      response,\n      subscription\n    })\n  }\n\n  /** @returns {import(\"eventemitter3\").EventEmitter} - Framework error events emitter. */\n  getErrorEvents() {\n    return this._errorEvents\n  }\n\n  /**\n   * @template T\n   * @param {WithConnectionsCallbackType<T>} callback - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withConnections(callback) {\n    /** @type {{[key: string]: import(\"./database/drivers/base.js\").default}} */\n    const dbs = {}\n\n    const stack = Error().stack\n    const actualCallback = async () => {\n      return await withTrackedStack(stack || \"withConnections\", async () => {\n        return await callback(dbs)\n      })\n    }\n\n    /** @type {() => Promise<T>} */\n    let runRequest = actualCallback\n\n    for (const identifier of this.getDatabaseIdentifiers()) {\n      let actualRunRequest = runRequest\n\n      const nextRunRequest = async () => {\n        return await this.getDatabasePool(identifier).withConnection(async (db) => {\n          dbs[identifier] = db\n\n          return await actualRunRequest()\n        })\n      }\n\n      runRequest = nextRunRequest\n    }\n\n    return await runRequest()\n  }\n\n  /** @returns {Record<string, import(\"./database/drivers/base.js\").default>} A map of database connections with identifier as key */\n  getCurrentConnections() {\n    /** @type {{[key: string]: import(\"./database/drivers/base.js\").default}} */\n    const dbs = {}\n\n    for (const identifier of this.getDatabaseIdentifiers()) {\n      try {\n        const pool = this.getDatabasePool(identifier)\n        const currentConnection = pool.getCurrentContextConnection ? pool.getCurrentContextConnection() : pool.getCurrentConnection()\n\n        if (currentConnection && (!pool.connectionMatchesCurrentConfiguration || pool.connectionMatchesCurrentConfiguration(currentConnection))) {\n          dbs[identifier] = currentConnection\n        }\n      } catch (error) {\n        if (\n          error instanceof Error &&\n          (\n            error.message == \"ID hasn't been set for this async context\" ||\n            error.message == \"A connection hasn't been made yet\" ||\n            error.message.startsWith(\"No async context set for database connection\") ||\n            error.message.startsWith(\"Connection \") && error.message.includes(\"doesn't exist any more\")\n          )\n        ) {\n          // Ignore\n        } else {\n          throw error\n        }\n      }\n    }\n\n    return dbs\n  }\n\n  /**\n   * @template T\n   * @param {WithConnectionsCallbackType<T>} callback - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async ensureConnections(callback) {\n    const dbs = this.getCurrentConnections()\n    const identifiers = this.getDatabaseIdentifiers()\n    const hasAllConnections = identifiers.every((identifier) => dbs[identifier])\n\n    if (hasAllConnections) {\n      return await callback(dbs)\n    } else {\n      return await this.withConnections(callback)\n    }\n  }\n\n  /**\n   * Closes active database connections and clears global connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeDatabaseConnections() {\n    if (this._closeDatabaseConnectionsPromise) {\n      await this._closeDatabaseConnectionsPromise\n      return\n    }\n\n    const constructors = new Set()\n\n    this._closeDatabaseConnectionsPromise = (async () => {\n      for (const pool of Object.values(this.databasePools)) {\n        if (!pool) continue\n\n        if (typeof pool.closeAll === \"function\") {\n          await pool.closeAll()\n        }\n\n        const poolConstructor = /** @type {{clearGlobalConnections?: (configuration: VelociousConfiguration) => void}} */ (pool.constructor)\n\n        if (typeof poolConstructor?.clearGlobalConnections === \"function\") {\n          constructors.add(poolConstructor)\n        }\n      }\n\n      for (const constructor of constructors) {\n        constructor.clearGlobalConnections?.(this)\n      }\n\n      // Allow models to be re-initialized after connections are closed.\n      this._modelsInitialized = false\n    })()\n\n    try {\n      await this._closeDatabaseConnectionsPromise\n    } finally {\n      this._closeDatabaseConnectionsPromise = null\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../src/configuration.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * @template T\n * @typedef {function(Record<string, import(\"./database/drivers/base.js\").default>) : Promise<T>} WithConnectionsCallbackType\n */\n\nimport {digg} from \"diggerize\"\nimport gettextConfig from \"gettext-universal/build/src/config.js\"\nimport translate from \"gettext-universal/build/src/translate.js\"\nimport Ability from \"./authorization/ability.js\"\nimport EventEmitter from \"./utils/event-emitter.js\"\nimport VelociousWebsocketChannelSubscribers from \"./http-server/websocket-channel-subscribers.js\"\nimport {ensureFrontendModelWebsocketPublishersRegistered} from \"./frontend-models/websocket-publishers.js\"\nimport {frontendModelResourceConfigurationFromDefinition, frontendModelResourcesForBackendProject} from \"./frontend-models/resource-definition.js\"\nimport PluginRoutes from \"./routes/plugin-routes.js\"\nimport restArgsError from \"./utils/rest-args-error.js\"\nimport {withTrackedStack} from \"./utils/with-tracked-stack.js\"\n\n/** @type {{currentConfiguration: VelociousConfiguration | null}} */\nconst shared = {\n  currentConfiguration: null\n}\n\nclass CurrentConfigurationNotSetError extends Error {}\n\nexport {CurrentConfigurationNotSetError}\n\n/**\n * @param {import(\"./configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Base database configuration.\n * @param {import(\"./configuration-types.js\").DatabaseConfigurationType | Partial<import(\"./configuration-types.js\").DatabaseConfigurationType> | void} overrideConfiguration - Tenant override configuration.\n * @returns {import(\"./configuration-types.js\").DatabaseConfigurationType} - Merged database configuration.\n */\nfunction mergeDatabaseConfiguration(databaseConfiguration, overrideConfiguration) {\n  if (!overrideConfiguration) return databaseConfiguration\n\n  return {\n    ...databaseConfiguration,\n    ...overrideConfiguration,\n    record: {\n      ...(databaseConfiguration.record || {}),\n      ...(overrideConfiguration.record || {})\n    },\n    sqlConfig: {\n      ...(databaseConfiguration.sqlConfig || {}),\n      ...(overrideConfiguration.sqlConfig || {})\n    }\n  }\n}\n\nexport default class VelociousConfiguration {\n  /** @type {Promise<void> | null} */\n  _closeDatabaseConnectionsPromise = null\n  /** @returns {VelociousConfiguration} - The current.  */\n  static current() {\n    if (!shared.currentConfiguration) throw new CurrentConfigurationNotSetError(\"A current configuration hasn't been set\")\n\n    return shared.currentConfiguration\n  }\n\n  /** @param {import(\"./configuration-types.js\").ConfigurationArgsType} args - Configuration arguments. */\n  constructor({abilityResolver, abilityResources, attachments, backgroundJobs, backendProjects, cookieSecret, cors, database, debug = false, directory, environment, environmentHandler, initializeModels, initializers, locale, localeFallbacks, locales, logging, mailerBackend, requestTimeoutMs, routeResolverHooks, scheduledBackgroundJobs, structureSql, tenantDatabaseResolver, tenantResolver, testing, timezoneOffsetMinutes, websocketChannelResolver, websocketMessageHandlerResolver, ...restArgs}) {\n    restArgsError(restArgs)\n\n    this._abilityResolver = abilityResolver\n    this._abilityResources = abilityResources || []\n    this._backgroundJobs = backgroundJobs\n    this._scheduledBackgroundJobs = scheduledBackgroundJobs\n    this._attachments = attachments || {}\n    this._backendProjects = backendProjects || []\n    this.cors = cors\n    this._cookieSecret = cookieSecret\n    this.database = database\n    this.debug = debug\n    this._environment = environment || process.env.VELOCIOUS_ENV || process.env.NODE_ENV || \"development\"\n    this._environmentHandler = environmentHandler\n    this._directory = directory\n    this._initializeModels = initializeModels\n    this._isInitialized = false\n    this.locale = locale\n    this.localeFallbacks = localeFallbacks\n    this.locales = locales\n    this._initializers = initializers\n    this._testing = testing\n    this._timezoneOffsetMinutes = timezoneOffsetMinutes\n    this._requestTimeoutMs = requestTimeoutMs\n    this._structureSql = structureSql\n    this._tenantDatabaseResolver = tenantDatabaseResolver\n    this._tenantResolver = tenantResolver\n    this._websocketEvents = undefined\n    /** @type {VelociousWebsocketChannelSubscribers | undefined} */\n    this._websocketChannelSubscribers = undefined\n    this._websocketChannelResolver = websocketChannelResolver\n    this._websocketMessageHandlerResolver = websocketMessageHandlerResolver\n    /** @type {Map<string, typeof import(\"./http-server/websocket-connection.js\").default>} */\n    this._websocketConnectionClasses = new Map()\n\n    /** @type {Map<string, typeof import(\"./http-server/websocket-channel.js\").default>} */\n    this._websocketChannelClasses = new Map()\n\n    /** @type {Map<string, Set<import(\"./http-server/websocket-channel.js\").default>>} - channelType → live subscriptions across all sessions. */\n    this._websocketChannelSubscriptions = new Map()\n\n    /** @type {Map<string, {session: import(\"./http-server/client/websocket-session.js\").default, graceTimer: ReturnType<typeof setTimeout>, pausedAt: number}>} - sessionId → paused session awaiting resume. */\n    this._pausedWebsocketSessions = new Map()\n\n    /** Grace period for paused WebSocket sessions before permanent teardown. */\n    this._websocketSessionGraceSeconds = 300\n\n    /**\n     * Optional wrapper called around every WebSocket-borne request /\n     * connection message / channel dispatch. Apps register it here\n     * to set up per-request context (e.g. AsyncLocalStorage for\n     * locale, tenant, tracing) that downstream handlers read.\n     * @type {((session: import(\"./http-server/client/websocket-session.js\").default, next: () => Promise<void>) => Promise<void>) | null}\n     */\n    this._websocketAroundRequest = null\n\n    /** @type {((context: {request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default, response: import(\"./http-server/client/response.js\").default, next: () => Promise<void>}) => Promise<void>) | null} */\n    this._aroundAction = null\n\n    /** @type {((session: import(\"./http-server/client/websocket-session.js\").default) => any | Promise<any>) | null} */\n    this._websocketSessionIdentityResolver = null\n    this._logging = logging\n    this._mailerBackend = mailerBackend\n    this._routeResolverHooks = [...(routeResolverHooks || [])]\n    this._errorEvents = new EventEmitter()\n\n    /** @type {{[key: string]: import(\"./database/pool/base.js\").default}} */\n    this.databasePools = {}\n\n    /** @type {{[key: string]: typeof import(\"./database/record/index.js\").default}} */\n    this.modelClasses = {}\n\n    this.getEnvironmentHandler().setConfiguration(this)\n  }\n\n  /** @returns {import(\"./configuration-types.js\").CorsType | undefined} - The cors.  */\n  getCors() {\n    return this.cors\n  }\n\n  /** @returns {string | undefined} - Cookie secret. */\n  getCookieSecret() {\n    return this._cookieSecret\n  }\n\n  /** @returns {Record<string, import(\"./configuration-types.js\").DatabaseConfigurationType>} - The database configuration.  */\n  getDatabaseConfiguration() {\n    if (!this.database) throw new Error(\"No database configuration\")\n\n    if (!this.database[this.getEnvironment()]) {\n      throw new Error(`No database configuration for environment: ${this.getEnvironment()} - ${Object.keys(this.database).join(\", \")}`)\n    }\n\n    return digg(this, \"database\", this.getEnvironment())\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @param {unknown} [tenant] - Tenant override.\n   * @returns {import(\"./configuration-types.js\").DatabaseConfigurationType} - Resolved database configuration for the identifier.\n   */\n  resolveDatabaseConfiguration(identifier, tenant = this.getCurrentTenant()) {\n    const databaseConfiguration = this.getDatabaseConfiguration()[identifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`No such database identifier configured: ${identifier}`)\n    }\n\n    if (tenant === undefined || !this._tenantDatabaseResolver) {\n      return databaseConfiguration\n    }\n\n    const overrideConfiguration = this._tenantDatabaseResolver({\n      configuration: this,\n      databaseConfiguration,\n      identifier,\n      tenant\n    })\n\n    return mergeDatabaseConfiguration(databaseConfiguration, overrideConfiguration)\n  }\n\n  /** @returns {Array<string>} - The database identifiers.  */\n  getDatabaseIdentifiers() {\n    const identifiers = Object.keys(this.getDatabaseConfiguration())\n    const disabledIdentifiers = new Set()\n    const disabledIdentifiersRaw = process.env.VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS\n\n    if (disabledIdentifiersRaw) {\n      for (const identifier of disabledIdentifiersRaw.split(\",\")) {\n        const trimmed = identifier.trim()\n\n        if (trimmed) disabledIdentifiers.add(trimmed)\n      }\n    }\n\n    if (process.env.VELOCIOUS_DISABLE_MSSQL === \"1\") {\n      disabledIdentifiers.add(\"mssql\")\n    }\n\n    if (disabledIdentifiers.size === 0) return identifiers\n\n    return identifiers.filter((identifier) => !disabledIdentifiers.has(identifier))\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @returns {import(\"./database/pool/base.js\").default} - The database pool.\n   */\n  getDatabasePool(identifier = \"default\") {\n    if (!this.isDatabasePoolInitialized(identifier)) {\n      this.initializeDatabasePool(identifier)\n    }\n\n    return digg(this, \"databasePools\", identifier)\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @returns {import(\"./configuration-types.js\").DatabaseConfigurationType})\n   */\n  getDatabaseIdentifier(identifier) {\n    return this.resolveDatabaseConfiguration(identifier)\n  }\n\n  /**\n   * @param {string} identifier - Identifier.\n   * @returns {typeof import(\"./database/pool/base.js\").default} - The database pool type.\n   */\n  getDatabasePoolType(identifier = \"default\") {\n    const poolTypeClass = digg(this.getDatabaseIdentifier(identifier), \"poolType\")\n\n    if (!poolTypeClass) {\n      throw new Error(\"No poolType given in database configuration\")\n    }\n\n    return poolTypeClass\n  }\n\n  getDatabaseType(identifier = \"default\") {\n    const databaseType = this.getDatabaseIdentifier(identifier).type\n\n    if (!databaseType) throw new Error(\"No database type given in database configuration\")\n\n    return databaseType\n  }\n\n  /**\n   * @returns {string} - The directory.\n   */\n  getDirectory() {\n    if (!this._directory) {\n      this._directory = process.cwd()\n    }\n\n    return this._directory\n  }\n\n  /**\n   * @returns {import(\"./configuration-types.js\").BackendProjectConfiguration[]} - Backend projects.\n   */\n  getBackendProjects() { return this._backendProjects }\n\n  /** @returns {import(\"./configuration-types.js\").AbilityResourceClassType[]} - Ability resource classes. */\n  getAbilityResources() { return this._abilityResources }\n\n  /**\n   * @param {import(\"./configuration-types.js\").AbilityResourceClassType[]} resources - Ability resource classes.\n   * @returns {void} - No return value.\n   */\n  setAbilityResources(resources) { this._abilityResources = resources }\n\n  /** @returns {import(\"./configuration-types.js\").AbilityResolverType | undefined} - Ability resolver. */\n  getAbilityResolver() { return this._abilityResolver }\n\n  /** @returns {import(\"./configuration-types.js\").TenantResolverType | undefined} - Tenant resolver. */\n  getTenantResolver() { return this._tenantResolver }\n\n  /** @returns {import(\"./configuration-types.js\").TenantDatabaseResolverType | undefined} - Tenant database resolver. */\n  getTenantDatabaseResolver() { return this._tenantDatabaseResolver }\n\n  /** @returns {import(\"./configuration-types.js\").AttachmentsConfiguration} - Attachments configuration. */\n  getAttachmentsConfiguration() { return this._attachments || {} }\n\n  /** @returns {import(\"./configuration-types.js\").RouteResolverHookType[]} - Route resolver hooks. */\n  getRouteResolverHooks() { return this._routeResolverHooks }\n\n  /**\n   * @param {import(\"./configuration-types.js\").RouteResolverHookType} hook - Route resolver hook.\n   * @returns {void} - No return value.\n   */\n  addRouteResolverHook(hook) {\n    this._routeResolverHooks.push(hook)\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").AbilityResolverType | undefined} resolver - Ability resolver.\n   * @returns {void} - No return value.\n   */\n  setAbilityResolver(resolver) { this._abilityResolver = resolver }\n\n  /**\n   * @param {import(\"./configuration-types.js\").TenantResolverType | undefined} resolver - Tenant resolver.\n   * @returns {void} - No return value.\n   */\n  setTenantResolver(resolver) { this._tenantResolver = resolver }\n\n  /**\n   * @param {import(\"./configuration-types.js\").TenantDatabaseResolverType | undefined} resolver - Tenant database resolver.\n   * @returns {void} - No return value.\n   */\n  setTenantDatabaseResolver(resolver) { this._tenantDatabaseResolver = resolver }\n\n  /**\n   * @returns {string} - The environment.\n   */\n  getEnvironment() { return digg(this, \"_environment\") }\n\n  /**\n   * @returns {number} - Request timeout in seconds.\n   */\n  getRequestTimeoutMs() {\n    const envTimeout = this._parseRequestTimeoutSeconds(process.env.VELOCIOUS_REQUEST_TIMEOUT_MS)\n    const value = typeof this._requestTimeoutMs === \"function\"\n      ? this._requestTimeoutMs()\n      : this._requestTimeoutMs\n\n    if (typeof value === \"number\") return value\n    if (typeof envTimeout === \"number\" && Number.isFinite(envTimeout)) return envTimeout\n\n    return 60\n  }\n\n  /**\n   * @param {string | undefined} rawValue - Env value.\n   * @returns {number | undefined} - Timeout in seconds.\n   */\n  _parseRequestTimeoutSeconds(rawValue) {\n    if (rawValue === undefined) return undefined\n\n    const trimmed = rawValue.trim().toLowerCase()\n\n    if (!trimmed) return undefined\n\n    const match = trimmed.match(/^(\\d+(?:\\.\\d+)?)(ms|s)?$/)\n\n    if (!match) return undefined\n\n    const numeric = Number(match[1])\n\n    if (!Number.isFinite(numeric)) return undefined\n\n    const unit = match[2]\n\n    if (unit === \"ms\") return numeric / 1000\n    if (unit === \"s\") return numeric\n\n    if (trimmed.includes(\".\")) return numeric\n    if (numeric >= 1000) return numeric / 1000\n\n    return numeric\n  }\n\n  /**\n   * @param {string} newEnvironment - New environment.\n   * @returns {void} - No return value.\n   */\n  setEnvironment(newEnvironment) { this._environment = newEnvironment }\n\n  /**\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.defaultConsole] - Whether default console.\n   * @returns {Required<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"console\" | \"file\" | \"levels\">> & Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"directory\" | \"filePath\"> & Partial<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"outputs\" | \"loggers\">>} - The logging configuration.\n   */\n  getLoggingConfiguration({defaultConsole} = {}) {\n    const environment = this.getEnvironment()\n    const environmentHandler = this.getEnvironmentHandler()\n    const directory = this._logging?.directory || environmentHandler.getDefaultLogDirectory({configuration: this})\n    const filePath = this._logging?.filePath || environmentHandler.getLogFilePath({configuration: this, directory, environment})\n    const consoleOverride = this._logging?.console\n    const hasLoggingConfig = Boolean(this._logging)\n    const fileLogging = hasLoggingConfig ? (this._logging?.file ?? Boolean(filePath)) : false\n    const configuredLevels = this._logging?.levels\n    const includeLowLevelDebug = this._logging?.debugLowLevel === true\n    const loggers = this._logging?.loggers\n\n    const consoleDefault = defaultConsole !== undefined ? defaultConsole : true\n    const consoleLogging = consoleOverride !== undefined ? consoleOverride : consoleDefault\n\n    /** @type {Array<\"debug-low-level\" | \"debug\" | \"info\" | \"warn\" | \"error\">} */\n    const defaultLevels = [\"info\", \"warn\", \"error\"]\n\n    if (includeLowLevelDebug) defaultLevels.unshift(\"debug-low-level\")\n\n    const levels = configuredLevels || defaultLevels\n\n    return {\n      console: consoleLogging,\n      directory,\n      file: fileLogging ?? false,\n      filePath,\n      loggers,\n      levels,\n      outputs: this._logging?.outputs\n    }\n  }\n\n  /**\n   * @returns {Required<import(\"./configuration-types.js\").BackgroundJobsConfiguration>} - Background jobs configuration.\n   */\n  getBackgroundJobsConfig() {\n    const envHost = process.env.VELOCIOUS_BACKGROUND_JOBS_HOST\n    const envPortRaw = process.env.VELOCIOUS_BACKGROUND_JOBS_PORT\n    const envDatabaseIdentifier = process.env.VELOCIOUS_BACKGROUND_JOBS_DATABASE_IDENTIFIER\n    const envPort = envPortRaw ? Number(envPortRaw) : undefined\n    const configured = this._backgroundJobs || {}\n    const host = configured.host || envHost || \"127.0.0.1\"\n    const port = typeof configured.port === \"number\"\n      ? configured.port\n      : (typeof envPort === \"number\" && Number.isFinite(envPort) ? envPort : 7331)\n    const databaseIdentifier = configured.databaseIdentifier || envDatabaseIdentifier || \"default\"\n\n    return {host, port, databaseIdentifier}\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").BackgroundJobsConfiguration} backgroundJobs - Background jobs config.\n   * @returns {void}\n   */\n  setBackgroundJobsConfig(backgroundJobs) {\n    this._backgroundJobs = Object.assign({}, this._backgroundJobs, backgroundJobs)\n  }\n\n  /**\n   * @returns {Promise<import(\"./configuration-types.js\").ScheduledBackgroundJobsConfiguration | undefined>} - Scheduled background jobs configuration.\n   */\n  async getScheduledBackgroundJobsConfig() {\n    if (!this._scheduledBackgroundJobs) {\n      return undefined\n    }\n\n    if (typeof this._scheduledBackgroundJobs === \"function\") {\n      return await this._scheduledBackgroundJobs({configuration: this})\n    }\n\n    return this._scheduledBackgroundJobs\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").ScheduledBackgroundJobsConfiguration | import(\"./configuration-types.js\").ScheduledBackgroundJobsLoaderType | undefined} scheduledBackgroundJobs - Scheduled background jobs configuration.\n   * @returns {void}\n   */\n  setScheduledBackgroundJobsConfig(scheduledBackgroundJobs) {\n    this._scheduledBackgroundJobs = scheduledBackgroundJobs\n  }\n\n  /**\n   * @returns {import(\"./configuration-types.js\").MailerBackend | undefined} - Mailer backend.\n   */\n  getMailerBackend() {\n    return this._mailerBackend\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").MailerBackend} mailerBackend - Mailer backend.\n   * @returns {void} - No return value.\n   */\n  setMailerBackend(mailerBackend) {\n    this._mailerBackend = mailerBackend\n  }\n\n  /**\n   * Logging configuration tailored for HTTP request logging. Defaults console logging to true and applies the user `logging.console` flag only for request logging.\n   * @returns {Required<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"console\" | \"file\" | \"levels\">> & Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"directory\" | \"filePath\"> & Partial<Pick<import(\"./configuration-types.js\").LoggingConfiguration, \"outputs\" | \"loggers\">>} - The http logging configuration.\n   */\n  getHttpLoggingConfiguration() {\n    return this.getLoggingConfiguration({defaultConsole: true})\n  }\n\n  /**\n   * @returns {import(\"./environment-handlers/base.js\").default} - The environment handler.\n   */\n  getEnvironmentHandler() {\n    if (!this._environmentHandler) throw new Error(\"No environment handler set\")\n\n    return this._environmentHandler\n  }\n\n  /**\n   * @returns {import(\"./configuration-types.js\").LocaleFallbacksType | undefined} - The locale fallbacks.\n   */\n  getLocaleFallbacks() { return this.localeFallbacks }\n\n  /**\n   * @param {import(\"./configuration-types.js\").LocaleFallbacksType} newLocaleFallbacks - New locale fallbacks.\n   * @returns {void} - No return value.\n   */\n  setLocaleFallbacks(newLocaleFallbacks) { this.localeFallbacks = newLocaleFallbacks }\n\n  /** @returns {import(\"./configuration-types.js\").StructureSqlConfiguration | undefined} - Structure SQL config. */\n  getStructureSqlConfig() { return this._structureSql }\n\n  /**\n   * @returns {boolean} - Whether structure SQL files should be generated for the current environment.\n   */\n  shouldWriteStructureSql() {\n    const config = this.getStructureSqlConfig()\n    const disabledEnvironments = config?.disabledEnvironments\n\n    if (Array.isArray(disabledEnvironments) && disabledEnvironments.includes(this.getEnvironment())) {\n      return false\n    }\n\n    return true\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").StructureSqlConfiguration} structureSql - Structure SQL config.\n   * @returns {void} - No return value.\n   */\n  setStructureSqlConfig(structureSql) {\n    this._structureSql = structureSql\n  }\n\n  /**\n   * @returns {string} - The locale.\n   */\n  getLocale() {\n    if (typeof this.locale == \"function\") {\n      return this.locale()\n    } else if (this.locale) {\n      return this.locale\n    } else {\n      return this.getLocales()[0]\n    }\n  }\n\n  /** @returns {Array<string>} - The locales.  */\n  getLocales() { return digg(this, \"locales\") }\n\n  /**\n   * @param {string} name - Name.\n   * @returns {typeof import(\"./database/record/index.js\").default} - The model class.\n   */\n  getModelClass(name) {\n    const modelClass = this.modelClasses[name]\n\n    if (!modelClass) throw new Error(`No such model class ${name} in ${Object.keys(this.modelClasses).join(\", \")}}`)\n\n    return modelClass\n  }\n\n  /**\n   * @returns {Record<string, typeof import(\"./database/record/index.js\").default>} A hash of all model classes, keyed by model name, as they were defined in the configuration. This is a direct reference to the model classes, not a copy.\n   */\n  getModelClasses() {\n    return this.modelClasses\n  }\n\n  /** @returns {string | undefined} The path to a config file that should be used for testing. */\n  getTesting() { return this._testing }\n\n  /**\n   * @param {string} [identifier] - Database identifier to initialize.\n   * @returns {void} - No return value.\n   */\n  initializeDatabasePool(identifier = \"default\") {\n    if (!this.database) throw new Error(\"No 'database' was given\")\n    if (this.databasePools[identifier]) throw new Error(\"DatabasePool has already been initialized\")\n\n    const PoolType = this.getDatabasePoolType(identifier)\n\n    this.databasePools[identifier] = new PoolType({configuration: this, identifier})\n    this.databasePools[identifier].setCurrent()\n  }\n\n  /**\n   * @param {string} [identifier] - Database identifier to check.\n   * @returns {boolean} - Whether database pool initialized.\n   */\n  isDatabasePoolInitialized(identifier = \"default\") { return Boolean(this.databasePools[identifier]) }\n\n  /** @returns {boolean} - Whether initialized.  */\n  isInitialized() { return this._isInitialized }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.type - Type identifier.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeModels(args = {type: \"server\"}) {\n    if (!this._modelsInitialized) {\n      this._modelsInitialized = true\n\n      const shouldSkipDummyModelInitialization = process.env.VELOCIOUS_SKIP_DUMMY_MODEL_INITIALIZATION === \"1\"\n        && process.env.VELOCIOUS_BROWSER_TESTS === \"true\"\n        && this.getEnvironment() === \"test\"\n\n      if (shouldSkipDummyModelInitialization) {\n        return\n      }\n\n      if (this._initializeModels) {\n        await this._initializeModels({configuration: this, type: args.type})\n      }\n\n      await ensureFrontendModelWebsocketPublishersRegistered(this)\n    }\n  }\n\n  /**\n   * Ensures each configured database pool has a global connection available.\n   * Useful when `getCurrentConnection` might be called without an async context.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async ensureGlobalConnections() {\n    for (const identifier of this.getDatabaseIdentifiers()) {\n      const pool = this.getDatabasePool(identifier)\n\n      await pool.ensureGlobalConnection()\n    }\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.type - Type identifier.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize({type} = {type: \"undefined\"}) {\n    if (!this.isInitialized()) {\n      this._isInitialized = true\n\n      await this.initializeModels({type})\n      await this.getEnvironmentHandler().autoDiscoverResources(this)\n      this._validateResourceRelationshipsOnModels()\n\n      if (this._initializers) {\n        const initializers = await this._initializers({configuration: this})\n        const {requireContext, ...restArgs} = initializers\n\n        restArgsError(restArgs)\n\n        if (requireContext) {\n          for (const initializerKey of requireContext.keys()) {\n            const InitializerClass = requireContext(initializerKey).default\n            const initializerInstance = new InitializerClass({configuration: this, type})\n\n            await initializerInstance.run()\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Validates that resource-defined relationships are also defined on the corresponding model classes.\n   * Throws an error if a relationship is defined on a resource but missing from the model.\n   *\n   * @returns {void}\n   */\n  _validateResourceRelationshipsOnModels() {\n    for (const backendProject of this._backendProjects) {\n      const resources = frontendModelResourcesForBackendProject(backendProject)\n\n      for (const [modelName, resourceDefinition] of Object.entries(resources)) {\n        const resourceConfig = frontendModelResourceConfigurationFromDefinition(resourceDefinition)\n\n        if (!resourceConfig?.relationships) continue\n\n        if (!Array.isArray(resourceConfig.relationships)) {\n          throw new Error(`Resource for ${modelName} defines relationships as an object. Use an array instead: static relationships = ${JSON.stringify(Object.keys(resourceConfig.relationships))}`)\n        }\n\n        const modelClass = /** @type {typeof import(\"./database/record/index.js\").default | undefined} */ (this.modelClasses[modelName])\n\n        if (!modelClass) continue\n\n        const existingRelationships = modelClass.getRelationshipsMap()\n\n        for (const relationshipName of resourceConfig.relationships) {\n          if (!(relationshipName in existingRelationships)) {\n            throw new Error(\n              `Resource for ${modelName} defines relationship \"${relationshipName}\" but ${modelName} model does not. ` +\n              `Add ${modelName}.belongsTo(\"${relationshipName}\", ...) or the appropriate relationship call on the model class.`\n            )\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {typeof import(\"./database/record/index.js\").default} modelClass - Model class.\n   * @returns {void} - No return value.\n   */\n  registerModelClass(modelClass) {\n    this.modelClasses[modelClass.getModelName()] = modelClass\n  }\n\n  /** @returns {void} - No return value.  */\n  setCurrent() {\n    shared.currentConfiguration = this\n  }\n\n  /** @returns {import(\"./routes/index.js\").default | undefined} - The routes.  */\n  getRoutes() { return this._routes }\n\n  /**\n   * @param {import(\"./routes/index.js\").default} newRoutes - New routes.\n   * @returns {void} - No return value.\n   */\n  setRoutes(newRoutes) { this._routes = newRoutes }\n\n  /**\n   * Adds plugin/library routes using a lightweight route DSL backed by route resolver hooks.\n   * @param {(routes: import(\"./routes/plugin-routes.js\").default) => void} callback - Routes callback.\n   * @returns {void} - No return value.\n   */\n  routes(callback) {\n    const pluginRoutes = new PluginRoutes({configuration: this})\n\n    callback(pluginRoutes)\n  }\n\n  /**\n   * @param {function(string, Record<string, any> | undefined) : string} callback - Translator callback.\n   * @returns {void} - No return value.\n   */\n  setTranslator(callback) { this._translator = callback }\n\n  /**\n   * @param {string} msgID - Msg id.\n   * @param {Record<string, any>} [args] - Translator options and variables.\n   * @returns {string} - The default translator.\n   */\n  _defaultTranslator(msgID, args) {\n    this._configureDefaultTranslator()\n\n    const translateArgs = args ? {...args} : undefined\n    const defaultValue = translateArgs?.defaultValue\n    const locales = translateArgs?.locales\n\n    if (translateArgs) {\n      delete translateArgs.defaultValue\n      delete translateArgs.locales\n    }\n\n    const variables = translateArgs && Object.keys(translateArgs).length > 0 ? translateArgs : undefined\n\n    const locale = this.getLocale()\n    const preferredLocales = locales || (locale ? undefined : [])\n    const message = translate(msgID, variables, preferredLocales)\n\n    if (message === msgID && defaultValue) return translate(defaultValue, variables, [])\n\n    return message\n  }\n\n  /** @returns {(msgID: string, args?: Record<string, any>) => string} */\n  getTranslator() {\n    if (this._translator) return this._translator\n\n    if (!this._defaultTranslatorBound) {\n      this._defaultTranslatorBound = this._defaultTranslator.bind(this)\n    }\n\n    return this._defaultTranslatorBound\n  }\n\n  /** @returns {void} - Configure gettext defaults for this configuration. */\n  _configureDefaultTranslator() {\n    const locale = this.getLocale()\n\n    gettextConfig.setLocale(locale || \"\")\n\n    const fallbacks = locale ? this.getLocaleFallbacks()?.[locale] : []\n\n    gettextConfig.setFallbacks(fallbacks || [])\n  }\n\n  /**\n   * @returns {number | undefined} - The timezone offset in minutes.\n   */\n  getTimezoneOffsetMinutes() {\n    if (typeof this._timezoneOffsetMinutes === \"function\") {\n      const configuredOffset = this._timezoneOffsetMinutes()\n\n      if (typeof configuredOffset === \"number\") return configuredOffset\n    }\n\n    if (typeof this._timezoneOffsetMinutes === \"number\") {\n      return this._timezoneOffsetMinutes\n    }\n\n    return new Date().getTimezoneOffset()\n  }\n\n  /** @returns {import(\"./http-server/websocket-events.js\").default | undefined} - The websocket events.  */\n  getWebsocketEvents() {\n    return this._websocketEvents\n  }\n\n  /**\n   * @param {import(\"./http-server/websocket-events.js\").default} websocketEvents - Websocket events.\n   * @returns {void} - No return value.\n   */\n  setWebsocketEvents(websocketEvents) {\n    this._websocketEvents = websocketEvents\n  }\n\n  /**\n   * Per-process registry of channel subscribers used by worker code that\n   * needs to react to events broadcast via `websocketEventsHost.publish(...)`\n   * without holding an actual websocket session.\n   * @returns {import(\"./http-server/websocket-channel-subscribers.js\").default} - The channel subscribers registry.\n   */\n  getWebsocketChannelSubscribers() {\n    if (!this._websocketChannelSubscribers) {\n      this._websocketChannelSubscribers = new VelociousWebsocketChannelSubscribers()\n    }\n\n    return this._websocketChannelSubscribers\n  }\n\n  /** @returns {import(\"./configuration-types.js\").WebsocketChannelResolverType | undefined} - The websocket channel resolver. */\n  getWebsocketChannelResolver() {\n    return this._websocketChannelResolver\n  }\n\n  /**\n   * Registers a `VelociousWebsocketConnection` subclass under a name.\n   * Clients that send `{type: \"connection-open\", connectionType: name}`\n   * will have this class instantiated for their connection.\n   *\n   * @param {string} name\n   * @param {typeof import(\"./http-server/websocket-connection.js\").default} ConnectionClass\n   * @returns {void}\n   */\n  registerWebsocketConnection(name, ConnectionClass) {\n    if (!name) throw new Error(\"Connection name is required\")\n    if (!ConnectionClass) throw new Error(\"ConnectionClass is required\")\n    this._websocketConnectionClasses.set(name, ConnectionClass)\n  }\n\n  /**\n   * @param {string} name\n   * @returns {typeof import(\"./http-server/websocket-connection.js\").default | undefined}\n   */\n  getWebsocketConnectionClass(name) {\n    return this._websocketConnectionClasses.get(name)\n  }\n\n  /**\n   * Registers a `VelociousWebsocketChannel` subclass under a name.\n   * Clients subscribe via `{type: \"channel-subscribe\", channelType: name, ...}`.\n   *\n   * @param {string} name\n   * @param {typeof import(\"./http-server/websocket-channel.js\").default} ChannelClass\n   * @returns {void}\n   */\n  registerWebsocketChannel(name, ChannelClass) {\n    if (!name) throw new Error(\"Channel name is required\")\n    if (!ChannelClass) throw new Error(\"ChannelClass is required\")\n    this._websocketChannelClasses.set(name, ChannelClass)\n  }\n\n  /**\n   * @param {string} name\n   * @returns {typeof import(\"./http-server/websocket-channel.js\").default | undefined}\n   */\n  getWebsocketChannelClass(name) {\n    return this._websocketChannelClasses.get(name)\n  }\n\n  /**\n   * Tracks a live channel subscription in the global routing registry.\n   * Called by the session when `canSubscribe()` resolves truthy; the\n   * session calls `_unregisterWebsocketChannelSubscription` on unsubscribe.\n   *\n   * @param {string} name\n   * @param {import(\"./http-server/websocket-channel.js\").default} subscription\n   * @returns {void}\n   */\n  _registerWebsocketChannelSubscription(name, subscription) {\n    let bucket = this._websocketChannelSubscriptions.get(name)\n\n    if (!bucket) {\n      bucket = new Set()\n      this._websocketChannelSubscriptions.set(name, bucket)\n    }\n\n    bucket.add(subscription)\n  }\n\n  /**\n   * @param {string} name\n   * @param {import(\"./http-server/websocket-channel.js\").default} subscription\n   * @returns {void}\n   */\n  _unregisterWebsocketChannelSubscription(name, subscription) {\n    const bucket = this._websocketChannelSubscriptions.get(name)\n\n    if (!bucket) return\n\n    bucket.delete(subscription)\n\n    if (bucket.size === 0) {\n      this._websocketChannelSubscriptions.delete(name)\n    }\n  }\n\n  /**\n   * Delivers `body` to every live subscriber of `name` whose\n   * `matches(broadcastParams)` returns true. Pure routing — no auth\n   * re-check, no persistence. Subscribers who were admitted by\n   * `canSubscribe()` continue to receive broadcasts until they\n   * unsubscribe or the session ends.\n   *\n   * @param {string} name\n   * @param {Record<string, any>} broadcastParams\n   * @param {any} body\n   * @returns {void}\n   */\n  /**\n   * @returns {number} - Grace period (seconds) before a paused WS session is torn down.\n   */\n  getWebsocketSessionGraceSeconds() { return this._websocketSessionGraceSeconds }\n\n  /**\n   * Registers a wrapper invoked around every WS-borne request /\n   * connection message / channel dispatch. The wrapper receives the\n   * session and a `next` callback; it must call `next()` to run the\n   * handler. Use it to set up AsyncLocalStorage per request.\n   *\n   * @param {((session: import(\"./http-server/client/websocket-session.js\").default, next: () => Promise<void>) => Promise<void>) | null} wrapper\n   * @returns {void}\n   */\n  setWebsocketAroundRequest(wrapper) {\n    this._websocketAroundRequest = wrapper\n  }\n\n  /**\n   * @returns {((session: import(\"./http-server/client/websocket-session.js\").default, next: () => Promise<void>) => Promise<void>) | null}\n   */\n  getWebsocketAroundRequest() {\n    return this._websocketAroundRequest\n  }\n\n  /**\n   * Registers a wrapper invoked around every controller action — both\n   * HTTP and WS-borne. Receives `{request, response, next}` and must\n   * call `next()` to run the action. Use it for per-request context\n   * like AsyncLocalStorage-scoped locale or tracing.\n   *\n   * @param {((context: {request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default, response: import(\"./http-server/client/response.js\").default, next: () => Promise<void>}) => Promise<void>) | null} wrapper\n   * @returns {void}\n   */\n  setAroundAction(wrapper) {\n    this._aroundAction = wrapper\n  }\n\n  /**\n   * @returns {((context: {request: import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default, response: import(\"./http-server/client/response.js\").default, next: () => Promise<void>}) => Promise<void>) | null}\n   */\n  getAroundAction() {\n    return this._aroundAction\n  }\n\n  /**\n   * Registers an identity resolver called once at pause time and once\n   * at resume time. The resolver receives the session and returns any\n   * value that identifies the authenticated caller — typically a\n   * `userId` read from the session's upgrade-request cookie. Velocious\n   * captures the pause-time value on the paused session and compares\n   * it via `===` (or deep-equality for plain objects) to the fresh\n   * resume-time value. If they differ, the resume is rejected with\n   * `session-gone` and the paused session is destroyed so a signed-out\n   * or re-authenticated client cannot reclaim another user's state.\n   *\n   * Return `null`/`undefined` to mean \"no identity\" — resumes still\n   * succeed if pause and resume both resolve to a nullish value.\n   *\n   * @param {((session: import(\"./http-server/client/websocket-session.js\").default) => any | Promise<any>) | null} resolver\n   * @returns {void}\n   */\n  setWebsocketSessionIdentityResolver(resolver) {\n    this._websocketSessionIdentityResolver = resolver\n  }\n\n  /** @returns {((session: import(\"./http-server/client/websocket-session.js\").default) => any | Promise<any>) | null} */\n  getWebsocketSessionIdentityResolver() {\n    return this._websocketSessionIdentityResolver\n  }\n\n  /**\n   * @param {number} seconds\n   * @returns {void}\n   */\n  setWebsocketSessionGraceSeconds(seconds) {\n    if (!Number.isFinite(seconds) || seconds < 0) throw new Error(`Invalid grace seconds: ${seconds}`)\n    this._websocketSessionGraceSeconds = seconds\n  }\n\n  /**\n   * Moves a session into the paused registry and starts the grace\n   * timer. When the timer fires, the session's permanent teardown\n   * hook is invoked. Called by the session itself from `_handleClose`\n   * when there is resumable state (live Connections / Channel subs).\n   *\n   * @param {import(\"./http-server/client/websocket-session.js\").default} session\n   * @returns {void}\n   */\n  _pauseWebsocketSession(session) {\n    const sessionId = session.sessionId\n\n    if (!sessionId) throw new Error(\"Session must have a sessionId to be paused\")\n    if (this._pausedWebsocketSessions.has(sessionId)) return\n\n    const graceMs = this._websocketSessionGraceSeconds * 1000\n    const graceTimer = setTimeout(() => {\n      this._expireWebsocketSession(sessionId)\n    }, graceMs)\n\n    // Don't keep the process alive purely for a paused session timer.\n    if (typeof graceTimer.unref === \"function\") graceTimer.unref()\n\n    this._pausedWebsocketSessions.set(sessionId, {session, graceTimer, pausedAt: Date.now()})\n  }\n\n  /**\n   * Looks up a paused session by id (does NOT remove it — caller is\n   * expected to call `_resumeWebsocketSession` to complete the handoff).\n   *\n   * @param {string} sessionId\n   * @returns {import(\"./http-server/client/websocket-session.js\").default | null}\n   */\n  _findPausedWebsocketSession(sessionId) {\n    return this._pausedWebsocketSessions.get(sessionId)?.session || null\n  }\n\n  /**\n   * Removes a paused session from the registry and cancels its grace\n   * timer. Called on successful resume handoff and on explicit\n   * expiry.\n   *\n   * @param {string} sessionId\n   * @returns {void}\n   */\n  _clearPausedWebsocketSession(sessionId) {\n    const entry = this._pausedWebsocketSessions.get(sessionId)\n\n    if (!entry) return\n\n    clearTimeout(entry.graceTimer)\n    this._pausedWebsocketSessions.delete(sessionId)\n  }\n\n  /**\n   * Grace-timer callback. Calls the session's permanent-teardown\n   * hook and drops it from the registry.\n   *\n   * @param {string} sessionId\n   * @returns {void}\n   */\n  _expireWebsocketSession(sessionId) {\n    const entry = this._pausedWebsocketSessions.get(sessionId)\n\n    if (!entry) return\n\n    this._pausedWebsocketSessions.delete(sessionId)\n    try {\n      entry.session._finalizeGraceExpiry()\n    } catch (error) {\n      console.error(`Failed to finalize expired WS session ${sessionId}`, error)\n    }\n  }\n\n  /**\n   * @param {string} name\n   * @param {Record<string, any>} broadcastParams\n   * @param {any} body\n   * @returns {void}\n   */\n  broadcastToChannel(name, broadcastParams, body) {\n    // V2 subscriptions live per worker-thread. When running in\n    // worker-thread mode, the publisher runs either in the main\n    // process (host) or in one of the workers:\n    //\n    //  - Main process: `_websocketEvents` is the host singleton and\n    //    `broadcastV2` fans out to every worker directly.\n    //  - Worker: `_websocketEvents` has `publishV2Broadcast` that\n    //    posts to main, which then fans out to every worker.\n    //\n    // In-process mode doesn't install a websocket-events transport,\n    // so fall through to the local dispatch.\n    /** @type {any} */\n    const websocketEvents = this._websocketEvents\n\n    if (websocketEvents && typeof websocketEvents.broadcastV2 === \"function\") {\n      websocketEvents.broadcastV2({channel: name, broadcastParams, body})\n      return\n    }\n\n    if (websocketEvents && typeof websocketEvents.publishV2Broadcast === \"function\" && websocketEvents.parentPort) {\n      websocketEvents.publishV2Broadcast({channel: name, broadcastParams, body})\n      return\n    }\n\n    this._broadcastToChannelLocal(name, broadcastParams, body)\n  }\n\n  /**\n   * Awaits all pending broadcast operations (including event-log\n   * persistence). Call this after `broadcastToChannel` when you need\n   * the event to be persisted before continuing (e.g. before\n   * responding to an HTTP request).\n   *\n   * @returns {Promise<void>}\n   */\n  async awaitPendingBroadcasts() {\n    /** @type {any} */\n    const websocketEvents = this._websocketEvents\n\n    if (websocketEvents && typeof websocketEvents.awaitPendingBroadcasts === \"function\") {\n      await websocketEvents.awaitPendingBroadcasts()\n    }\n  }\n\n  /**\n   * Local (per-worker) channel broadcast dispatch. Called either\n   * directly (in-process mode) or by the worker thread after the\n   * main-process fan-out.\n   *\n   * @param {string} name - Channel name.\n   * @param {Record<string, any>} broadcastParams - Params passed to each subscription's `matches()`.\n   * @param {any} body - Message body delivered via `sendMessage()`.\n   * @param {{eventId?: string}} [meta] - Optional event metadata for replay tracking.\n   * @returns {void}\n   */\n  _broadcastToChannelLocal(name, broadcastParams, body, meta) {\n    const bucket = this._websocketChannelSubscriptions.get(name)\n\n    if (!bucket) return\n\n    for (const subscription of bucket) {\n      if (subscription.isClosed()) continue\n\n      let matches\n\n      try {\n        matches = subscription.matches(broadcastParams || {})\n      } catch (error) {\n        // A broken `matches()` on one subscriber must not poison the\n        // broadcast to other subscribers. Skip and continue.\n        console.error(`broadcastToChannel: ${name} subscription ${subscription.subscriptionId} matches() threw`, error)\n        continue\n      }\n\n      if (!matches) continue\n\n      try {\n        subscription.sendMessage(body, {eventId: meta?.eventId})\n      } catch (error) {\n        console.error(`broadcastToChannel: ${name} subscription ${subscription.subscriptionId} sendMessage threw`, error)\n      }\n    }\n  }\n\n  /** @returns {import(\"./configuration-types.js\").WebsocketMessageHandlerResolverType | undefined} - The websocket message handler resolver. */\n  getWebsocketMessageHandlerResolver() {\n    return this._websocketMessageHandlerResolver\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").WebsocketChannelResolverType} resolver - Resolver.\n   * @returns {void} - No return value.\n   */\n  setWebsocketChannelResolver(resolver) {\n    this._websocketChannelResolver = resolver\n  }\n\n  /**\n   * @param {import(\"./configuration-types.js\").WebsocketMessageHandlerResolverType} resolver - Resolver.\n   * @returns {void} - No return value.\n   */\n  setWebsocketMessageHandlerResolver(resolver) {\n    this._websocketMessageHandlerResolver = resolver\n  }\n\n  /**\n   * @param {object} args - Ability resolver args.\n   * @param {Record<string, any>} args.params - Request params.\n   * @param {import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default} args.request - Request object.\n   * @param {import(\"./http-server/client/response.js\").default} args.response - Response object.\n   * @returns {Promise<import(\"./authorization/ability.js\").default | undefined>} - Resolved ability.\n   */\n  async resolveAbility({params, request, response}) {\n    const resolver = this.getAbilityResolver()\n\n    if (resolver) {\n      const resolved = await resolver({configuration: this, params, request, response})\n\n      if (resolved) return resolved\n    }\n\n    const resources = this.getAbilityResources()\n\n    if (resources.length === 0) return\n\n    return new Ability({\n      context: {configuration: this, params, request, response},\n      resources\n    })\n  }\n\n  /**\n   * @param {import(\"./authorization/ability.js\").default | undefined} ability - Ability instance.\n   * @param {() => Promise<any>} callback - Callback.\n   * @returns {Promise<any>} - Callback result.\n   */\n  async runWithAbility(ability, callback) {\n    return await this.getEnvironmentHandler().runWithAbility(ability, callback)\n  }\n\n  /**\n   * @returns {import(\"./authorization/ability.js\").default | undefined} - Current ability from context.\n   */\n  getCurrentAbility() {\n    return this.getEnvironmentHandler().getCurrentAbility()\n  }\n\n  /**\n   * @returns {unknown} - Current tenant from context.\n   */\n  getCurrentTenant() {\n    return this.getEnvironmentHandler().getCurrentTenant()\n  }\n\n  /**\n   * @param {unknown} tenant - Tenant.\n   * @param {() => Promise<any>} callback - Callback.\n   * @returns {Promise<any>} - Callback result.\n   */\n  async runWithTenant(tenant, callback) {\n    return await this.getEnvironmentHandler().runWithTenant(tenant, callback)\n  }\n\n  /**\n   * @param {object} args - Tenant resolver args.\n   * @param {Record<string, any>} args.params - Request params.\n   * @param {import(\"./http-server/client/request.js\").default | import(\"./http-server/client/websocket-request.js\").default | undefined} args.request - Request object.\n   * @param {import(\"./http-server/client/response.js\").default | undefined} args.response - Response object.\n   * @param {{channel: string, params?: Record<string, unknown>}} [args.subscription] - Subscription metadata.\n   * @returns {Promise<unknown>} - Resolved tenant.\n   */\n  async resolveTenant({params, request, response, subscription}) {\n    const resolver = this.getTenantResolver()\n\n    if (!resolver) return\n\n    return await resolver({\n      configuration: this,\n      params,\n      request,\n      response,\n      subscription\n    })\n  }\n\n  /** @returns {import(\"eventemitter3\").EventEmitter} - Framework error events emitter. */\n  getErrorEvents() {\n    return this._errorEvents\n  }\n\n  /**\n   * @template T\n   * @param {WithConnectionsCallbackType<T>} callback - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withConnections(callback) {\n    /** @type {{[key: string]: import(\"./database/drivers/base.js\").default}} */\n    const dbs = {}\n\n    const stack = Error().stack\n    const actualCallback = async () => {\n      return await withTrackedStack(stack || \"withConnections\", async () => {\n        return await callback(dbs)\n      })\n    }\n\n    /** @type {() => Promise<T>} */\n    let runRequest = actualCallback\n\n    for (const identifier of this.getDatabaseIdentifiers()) {\n      let actualRunRequest = runRequest\n\n      const nextRunRequest = async () => {\n        return await this.getDatabasePool(identifier).withConnection(async (db) => {\n          dbs[identifier] = db\n\n          return await actualRunRequest()\n        })\n      }\n\n      runRequest = nextRunRequest\n    }\n\n    return await runRequest()\n  }\n\n  /** @returns {Record<string, import(\"./database/drivers/base.js\").default>} A map of database connections with identifier as key */\n  getCurrentConnections() {\n    /** @type {{[key: string]: import(\"./database/drivers/base.js\").default}} */\n    const dbs = {}\n\n    for (const identifier of this.getDatabaseIdentifiers()) {\n      try {\n        const pool = this.getDatabasePool(identifier)\n        const currentConnection = pool.getCurrentContextConnection ? pool.getCurrentContextConnection() : pool.getCurrentConnection()\n\n        if (currentConnection && (!pool.connectionMatchesCurrentConfiguration || pool.connectionMatchesCurrentConfiguration(currentConnection))) {\n          dbs[identifier] = currentConnection\n        }\n      } catch (error) {\n        if (\n          error instanceof Error &&\n          (\n            error.message == \"ID hasn't been set for this async context\" ||\n            error.message == \"A connection hasn't been made yet\" ||\n            error.message.startsWith(\"No async context set for database connection\") ||\n            error.message.startsWith(\"Connection \") && error.message.includes(\"doesn't exist any more\")\n          )\n        ) {\n          // Ignore\n        } else {\n          throw error\n        }\n      }\n    }\n\n    return dbs\n  }\n\n  /**\n   * @template T\n   * @param {WithConnectionsCallbackType<T>} callback - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async ensureConnections(callback) {\n    const dbs = this.getCurrentConnections()\n    const identifiers = this.getDatabaseIdentifiers()\n    const hasAllConnections = identifiers.every((identifier) => dbs[identifier])\n\n    if (hasAllConnections) {\n      return await callback(dbs)\n    } else {\n      return await this.withConnections(callback)\n    }\n  }\n\n  /**\n   * Closes active database connections and clears global connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeDatabaseConnections() {\n    if (this._closeDatabaseConnectionsPromise) {\n      await this._closeDatabaseConnectionsPromise\n      return\n    }\n\n    const constructors = new Set()\n\n    this._closeDatabaseConnectionsPromise = (async () => {\n      for (const pool of Object.values(this.databasePools)) {\n        if (!pool) continue\n\n        if (typeof pool.closeAll === \"function\") {\n          await pool.closeAll()\n        }\n\n        const poolConstructor = /** @type {{clearGlobalConnections?: (configuration: VelociousConfiguration) => void}} */ (pool.constructor)\n\n        if (typeof poolConstructor?.clearGlobalConnections === \"function\") {\n          constructors.add(poolConstructor)\n        }\n      }\n\n      for (const constructor of constructors) {\n        constructor.clearGlobalConnections?.(this)\n      }\n\n      // Allow models to be re-initialized after connections are closed.\n      this._modelsInitialized = false\n    })()\n\n    try {\n      await this._closeDatabaseConnectionsPromise\n    } finally {\n      this._closeDatabaseConnectionsPromise = null\n    }\n  }\n}\n"]}