velocious 1.0.430 → 1.0.431

package/build/src/routes/resolver.js

@@ -1,30 +1,35 @@
 // @ts-check
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-import fs from "fs/promises";
-import * as inflection from "inflection";
-import Logger from "../logger.js";
-import UploadedFile from "../http-server/client/uploaded-file/uploaded-file.js";
-import ensureError from "../utils/ensure-error.js";
-import toImportSpecifier from "../utils/to-import-specifier.js";
+
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+import fs from "fs/promises"
+import * as inflection from "inflection"
+import Logger from "../logger.js"
+import UploadedFile from "../http-server/client/uploaded-file/uploaded-file.js"
+import ensureError from "../utils/ensure-error.js"
+import toImportSpecifier from "../utils/to-import-specifier.js"
+
 /**
  * Runs normalize action name.
  * @param {string} actionName - Raw action name from route params or route hook.
  * @returns {string} - Normalized controller method name.
  */
 function normalizeActionName(actionName) {
-    return inflection.camelize(actionName.replaceAll("-", "_").replaceAll("/", "_"), true);
+  return inflection.camelize(actionName.replaceAll("-", "_").replaceAll("/", "_"), true)
 }
+
 /**
  * Runs missing module specifier from error.
  * @param {Error} error - Import error.
  * @returns {string | undefined} - Missing module specifier from an ERR_MODULE_NOT_FOUND message.
  */
 function missingModuleSpecifierFromError(error) {
-    const firstLine = error.message.split("\n")[0] || "";
-    const match = firstLine.match(/^Cannot find (?:module|package) ['"](.+?)['"] imported from /);
-    return match?.[1];
+  const firstLine = error.message.split("\n")[0] || ""
+  const match = firstLine.match(/^Cannot find (?:module|package) ['"](.+?)['"] imported from /)
+
+  return match?.[1]
 }
+
 /**
  * Runs is missing target module error.
  * @param {object} args - Arguments.
@@ -33,431 +38,498 @@ function missingModuleSpecifierFromError(error) {
  * @param {string} args.targetImportSpecifier - Target controller import specifier.
  * @returns {boolean} - True when the missing module is the target controller file.
  */
-function isMissingTargetModuleError({ error, targetPath, targetImportSpecifier }) {
-    const ensuredError = ensureError(error);
-    const isModuleNotFoundError = "code" in ensuredError && ensuredError.code === "ERR_MODULE_NOT_FOUND";
-    if (!isModuleNotFoundError)
-        return false;
-    const missingSpecifier = missingModuleSpecifierFromError(ensuredError);
-    if (!missingSpecifier)
-        return false;
-    return missingSpecifier === targetPath || missingSpecifier === targetImportSpecifier;
+function isMissingTargetModuleError({error, targetPath, targetImportSpecifier}) {
+  const ensuredError = ensureError(error)
+  const isModuleNotFoundError = "code" in ensuredError && ensuredError.code === "ERR_MODULE_NOT_FOUND"
+
+  if (!isModuleNotFoundError) return false
+
+  const missingSpecifier = missingModuleSpecifierFromError(ensuredError)
+
+  if (!missingSpecifier) return false
+
+  return missingSpecifier === targetPath || missingSpecifier === targetImportSpecifier
 }
+
 export default class VelociousRoutesResolver {
+  /**
+   * Narrows the runtime value to the documented type.
+    @type {Logger | undefined} */
+  logger
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+   * @param {import("../http-server/client/request.js").default | import("../http-server/client/websocket-request.js").default} args.request - Request object.
+   * @param {import("../http-server/client/response.js").default} args.response - Response object.
+   */
+  constructor({configuration, request, response}) {
+    if (!configuration) throw new Error("No configuration given")
+    if (!request) throw new Error("No request given")
+    if (!response) throw new Error("No response given")
+
+    this.configuration = configuration
+    this.logger = new Logger("RoutesResolver", {configuration})
+    const requestParams = request.params() || {}
+    this.params = {...requestParams}
+    delete this.params.action
+    delete this.params.controller
+    this.request = request
+    this.response = response
+  }
+
+  /**
+   * Runs query parameters.
+   * @returns {Record<string, string>} - Flat query params for tenant/ability resolution.
+   */
+  queryParameters() {
+    const query = this.request.path().split("?")[1]
+
+    if (!query) return {}
+
     /**
-     * Narrows the runtime value to the documented type.
-      @type {Logger | undefined} */
-    logger;
-    /**
-     * Runs constructor.
-     * @param {object} args - Options object.
-     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
-     * @param {import("../http-server/client/request.js").default | import("../http-server/client/websocket-request.js").default} args.request - Request object.
-     * @param {import("../http-server/client/response.js").default} args.response - Response object.
-     */
-    constructor({ configuration, request, response }) {
-        if (!configuration)
-            throw new Error("No configuration given");
-        if (!request)
-            throw new Error("No request given");
-        if (!response)
-            throw new Error("No response given");
-        this.configuration = configuration;
-        this.logger = new Logger("RoutesResolver", { configuration });
-        const requestParams = request.params() || {};
-        this.params = { ...requestParams };
-        delete this.params.action;
-        delete this.params.controller;
-        this.request = request;
-        this.response = response;
+     * Params.
+      @type {Record<string, string>} */
+    const params = {}
+    const searchParams = new URLSearchParams(query)
+
+    for (const [key, value] of searchParams.entries()) {
+      if (params[key] === undefined) {
+        params[key] = value
+      }
     }
-    /**
-     * Runs query parameters.
-     * @returns {Record<string, string>} - Flat query params for tenant/ability resolution.
-     */
-    queryParameters() {
-        const query = this.request.path().split("?")[1];
-        if (!query)
-            return {};
-        /**
-         * Params.
-          @type {Record<string, string>} */
-        const params = {};
-        const searchParams = new URLSearchParams(query);
-        for (const [key, value] of searchParams.entries()) {
-            if (params[key] === undefined) {
-                params[key] = value;
-            }
-        }
-        return params;
+
+    return params
+  }
+
+  async resolve() {
+    this.routeHookControllerClass = undefined
+    let controllerPath
+    const configurationRoutes = this.configuration.getRoutes()
+    const currentRoute = configurationRoutes?.rootRoute
+    const rawPath = this.request.path()
+    const currentPath = rawPath.split("?")[0]
+    let viewPath
+
+    const preCheckParams = {...this.params}
+    const hasMatchingCustomRoute = currentRoute ? !!this.matchPathWithRoutes(currentRoute, currentPath) : false
+
+    if (hasMatchingCustomRoute) {
+      this.params = preCheckParams
     }
-    async resolve() {
-        this.routeHookControllerClass = undefined;
-        let controllerPath;
-        const configurationRoutes = this.configuration.getRoutes();
-        const currentRoute = configurationRoutes?.rootRoute;
-        const rawPath = this.request.path();
-        const currentPath = rawPath.split("?")[0];
-        let viewPath;
-        const preCheckParams = { ...this.params };
-        const hasMatchingCustomRoute = currentRoute ? !!this.matchPathWithRoutes(currentRoute, currentPath) : false;
-        if (hasMatchingCustomRoute) {
-            this.params = preCheckParams;
-        }
-        const routeResolverHookMatch = await this.resolveRouteResolverHooks(currentPath, { hasMatchingCustomRoute });
-        const skipControllerConnections = routeResolverHookMatch?.skipControllerConnections === true;
-        const skipAbilityResolution = routeResolverHookMatch?.skipAbilityResolution === true;
-        const skipTenantResolution = routeResolverHookMatch?.skipTenantResolution === true;
-        const matchResult = routeResolverHookMatch || !currentRoute ? undefined : this.matchPathWithRoutes(currentRoute, currentPath);
-        const actionParam = this.params.action;
-        const controllerParam = this.params.controller;
-        const actionValue = typeof actionParam == "string" ? actionParam : (Array.isArray(actionParam) ? actionParam[0] : undefined);
-        let action = typeof actionValue == "string" ? normalizeActionName(actionValue) : undefined;
-        let controller = typeof controllerParam == "string" ? controllerParam : (Array.isArray(controllerParam) ? controllerParam[0] : undefined);
-        if (routeResolverHookMatch) {
-            const routeHookControllerClass = routeResolverHookMatch.controllerClass;
-            let routeHookControllerPath;
-            let routeHookViewPath;
-            if (typeof routeResolverHookMatch.controllerPath === "string") {
-                routeHookControllerPath = routeResolverHookMatch.controllerPath;
-            }
-            if (typeof routeResolverHookMatch.viewPath === "string") {
-                routeHookViewPath = routeResolverHookMatch.viewPath;
-            }
-            controller = routeResolverHookMatch.controller;
-            action = normalizeActionName(routeResolverHookMatch.action);
-            this.params.controller = controller;
-            this.params.action = routeResolverHookMatch.action;
-            controllerPath = routeHookControllerPath || `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`;
-            viewPath = routeHookViewPath || `${this.configuration.getDirectory()}/src/routes/${controller}`;
-            this.routeHookControllerClass = routeHookControllerClass;
-        }
-        else if (!matchResult) {
-            const __filename = fileURLToPath(import.meta.url);
-            const __dirname = dirname(__filename);
-            const requestedPath = currentPath.replace(/^\//, "") || "_root";
-            const attemptedControllerPath = `${this.configuration.getDirectory()}/src/routes/${requestedPath}/controller.js`;
-            const logger = this.logger;
-            if (!logger)
-                throw new Error("Logger not initialized");
-            await logger.warn(`No route matched for ${rawPath}. Tried controller at ${attemptedControllerPath}`);
-            controller = "errors";
-            controllerPath = "./built-in/errors/controller.js";
-            action = "notFound";
-            viewPath = await fs.realpath(`${__dirname}/built-in/errors`);
-        }
-        else if (action) {
-            if (!controller)
-                controller = "_root";
-            controllerPath = `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`;
-            viewPath = `${this.configuration.getDirectory()}/src/routes/${controller}`;
-        }
-        else {
-            throw new Error(`Matched the route but didn't know what to do with it: ${rawPath} (action: ${action}, controller: ${controller}, params: ${JSON.stringify(this.params)})`);
-        }
-        const controllerClass = await this.resolveControllerClass({ controllerPath });
-        const controllerRequest = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../http-server/client/request.js").default} */ (this.request);
-        const controllerInstance = new controllerClass({
-            action,
-            configuration: this.configuration,
-            controller,
-            params: this.params,
-            request: controllerRequest,
-            response: this.response,
-            viewPath
-        });
-        if (!(action in controllerInstance)) {
-            throw new Error(`Missing action on controller: ${controller}#${action}`);
-        }
-        const actionHandlers = /**
-                                * Narrows the runtime value to the documented type.
-                                 @type {Record<string, () => void | Promise<void>>} */ ( /**
-                                                                * Narrows the runtime value to the documented type.
-                                                                 @type {?} */(controllerInstance));
-        const logMethod = this._logMethod();
-        this._setCompletedLogMetadata({ controllerClass, logMethod });
-        await this._logActionStart({ action, controllerClass, logMethod });
-        try {
-            const tenant = skipTenantResolution
-                ? undefined
-                : await this.configuration.resolveTenant({
-                    params: { ...this.queryParameters(), ...this.params },
-                    request: this.request,
-                    response: this.response
-                });
-            const runAction = async () => {
-                await this.configuration.runWithTenant(tenant, async () => {
-                    const runControllerAction = async () => {
-                        const ability = skipAbilityResolution
-                            ? undefined
-                            : await this.configuration.resolveAbility({
-                                params: this.params,
-                                request: this.request,
-                                response: this.response
-                            });
-                        await this.configuration.runWithAbility(ability, async () => {
-                            await this._measureController(async () => {
-                                await controllerInstance._runBeforeCallbacks();
-                                await actionHandlers[action]();
-                            });
-                        });
-                    };
-                    if (skipControllerConnections) {
-                        await runControllerAction();
-                    }
-                    else {
-                        await this.configuration.ensureConnections({ name: `${controllerClass.name}.${action}` }, runControllerAction);
-                    }
-                });
-            };
-            const aroundAction = this.configuration.getAroundAction?.();
-            if (aroundAction) {
-                await aroundAction({ request: this.request, response: this.response, next: runAction });
-            }
-            else {
-                await runAction();
-            }
-        }
-        catch (error) {
-            const ensuredError = ensureError(error);
-            const errorContext = {
-                action,
-                controller,
-                httpMethod: this.request.httpMethod(),
-                path: this.request.path(),
-                stage: "controller-action"
-            };
-            const errorWithContext = /**
-                                      * Narrows the runtime value to the documented type.
-                                       @type {{velociousContext?: object}} */ (ensuredError);
-            errorWithContext.velociousContext = {
-                ...(errorWithContext.velociousContext || {}),
-                controllerAction: errorContext
-            };
-            throw ensuredError;
-        }
+
+    const routeResolverHookMatch = await this.resolveRouteResolverHooks(currentPath, {hasMatchingCustomRoute})
+    const skipControllerConnections = routeResolverHookMatch?.skipControllerConnections === true
+    const skipAbilityResolution = routeResolverHookMatch?.skipAbilityResolution === true
+    const skipTenantResolution = routeResolverHookMatch?.skipTenantResolution === true
+    const matchResult = routeResolverHookMatch || !currentRoute ? undefined : this.matchPathWithRoutes(currentRoute, currentPath)
+    const actionParam = this.params.action
+    const controllerParam = this.params.controller
+    const actionValue = typeof actionParam == "string" ? actionParam : (Array.isArray(actionParam) ? actionParam[0] : undefined)
+    let action = typeof actionValue == "string" ? normalizeActionName(actionValue) : undefined
+    let controller = typeof controllerParam == "string" ? controllerParam : (Array.isArray(controllerParam) ? controllerParam[0] : undefined)
+
+    if (routeResolverHookMatch) {
+      const routeHookControllerClass = routeResolverHookMatch.controllerClass
+      let routeHookControllerPath
+      let routeHookViewPath
+
+      if (typeof routeResolverHookMatch.controllerPath === "string") {
+        routeHookControllerPath = routeResolverHookMatch.controllerPath
+      }
+
+      if (typeof routeResolverHookMatch.viewPath === "string") {
+        routeHookViewPath = routeResolverHookMatch.viewPath
+      }
+
+      controller = routeResolverHookMatch.controller
+      action = normalizeActionName(routeResolverHookMatch.action)
+      this.params.controller = controller
+      this.params.action = routeResolverHookMatch.action
+      controllerPath = routeHookControllerPath || `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`
+      viewPath = routeHookViewPath || `${this.configuration.getDirectory()}/src/routes/${controller}`
+      this.routeHookControllerClass = routeHookControllerClass
+    } else if (!matchResult) {
+        const __filename = fileURLToPath(import.meta.url)
+        const __dirname = dirname(__filename)
+        const requestedPath = currentPath.replace(/^\//, "") || "_root"
+        const attemptedControllerPath = `${this.configuration.getDirectory()}/src/routes/${requestedPath}/controller.js`
+
+        const logger = this.logger
+
+        if (!logger) throw new Error("Logger not initialized")
+
+        await logger.warn(`No route matched for ${rawPath}. Tried controller at ${attemptedControllerPath}`)
+
+        controller = "errors"
+        controllerPath = "./built-in/errors/controller.js"
+        action = "notFound"
+        viewPath = await fs.realpath(`${__dirname}/built-in/errors`)
+    } else if (action) {
+      if (!controller) controller = "_root"
+
+      controllerPath = `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`
+      viewPath = `${this.configuration.getDirectory()}/src/routes/${controller}`
+    } else {
+      throw new Error(`Matched the route but didn't know what to do with it: ${rawPath} (action: ${action}, controller: ${controller}, params: ${JSON.stringify(this.params)})`)
     }
-    /**
-     * Runs resolve controller class.
-     * @param {object} args - Args.
-     * @param {string} args.controllerPath - Controller import path.
-     * @returns {Promise<typeof import("../controller.js").default>} - The resolved controller class.
-     */
-    async resolveControllerClass({ controllerPath }) {
-        const controllerImportSpecifier = toImportSpecifier(controllerPath);
-        if (!this.routeHookControllerClass) {
-            return /** Narrows the runtime value to the documented type. @type {typeof import("../controller.js").default} */ ((await import(controllerImportSpecifier)).default);
-        }
-        try {
-            return /** Narrows the runtime value to the documented type. @type {typeof import("../controller.js").default} */ ((await import(controllerImportSpecifier)).default);
-        }
-        catch (error) {
-            const isMissingControllerFileError = isMissingTargetModuleError({
-                error: ensureError(error),
-                targetImportSpecifier: controllerImportSpecifier,
-                targetPath: controllerPath
-            });
-            if (!isMissingControllerFileError)
-                throw ensureError(error);
-            return /** Narrows the runtime value to the documented type. @type {typeof import("../controller.js").default} */ (this.routeHookControllerClass);
-        }
+
+    const controllerClass = await this.resolveControllerClass({controllerPath})
+    const controllerRequest = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("../http-server/client/request.js").default} */ (this.request)
+    const controllerInstance = new controllerClass({
+      action,
+      configuration: this.configuration,
+      controller,
+      params: this.params,
+      request: controllerRequest,
+      response: this.response,
+      viewPath
+    })
+
+    if (!(action in controllerInstance)) {
+      throw new Error(`Missing action on controller: ${controller}#${action}`)
     }
-    /**
-     * Runs match path with routes.
-     * @param {import("./base-route.js").default} route - Route.
-     * @param {string} path - Path.
-     * @returns {{restPath: string} | undefined} - REST path metadata for this route.
-     */
-    matchPathWithRoutes(route, path) {
-        const pathWithoutSlash = path.replace(/^\//, "").split("?")[0];
-        for (const subRoute of route.routes) {
-            const paramsSnapshot = { ...this.params };
-            const matchResult = subRoute.matchWithPath({
-                params: this.params,
-                path: pathWithoutSlash,
-                request: this.request
-            });
-            if (!matchResult) {
-                this.params = paramsSnapshot;
-                continue;
-            }
-            const { restPath } = matchResult;
-            if (restPath) {
-                const recursiveMatch = this.matchPathWithRoutes(subRoute, restPath);
-                if (recursiveMatch) {
-                    return recursiveMatch;
-                }
-                this.params = paramsSnapshot;
-                continue;
-            }
-            return matchResult;
-        }
+
+    const actionHandlers = /**
+                            * Narrows the runtime value to the documented type.
+                             @type {Record<string, () => void | Promise<void>>} */ (/**
+                                                                                     * Narrows the runtime value to the documented type.
+                                                                                      @type {?} */ (controllerInstance))
+
+    const logMethod = this._logMethod()
+
+    this._setCompletedLogMetadata({controllerClass, logMethod})
+    await this._logActionStart({action, controllerClass, logMethod})
+
+    try {
+      const tenant = skipTenantResolution
+        ? undefined
+        : await this.configuration.resolveTenant({
+            params: {...this.queryParameters(), ...this.params},
+            request: this.request,
+            response: this.response
+          })
+
+      const runAction = async () => {
+        await this.configuration.runWithTenant(tenant, async () => {
+          const runControllerAction = async () => {
+            const ability = skipAbilityResolution
+              ? undefined
+              : await this.configuration.resolveAbility({
+                  params: this.params,
+                  request: this.request,
+                  response: this.response
+                })
+
+            await this.configuration.runWithAbility(ability, async () => {
+              await this._measureController(async () => {
+                await controllerInstance._runBeforeCallbacks()
+                await actionHandlers[action]()
+              })
+            })
+          }
+
+          if (skipControllerConnections) {
+            await runControllerAction()
+          } else {
+            await this.configuration.ensureConnections({name: `${controllerClass.name}.${action}`}, runControllerAction)
+          }
+        })
+      }
+
+      const aroundAction = this.configuration.getAroundAction?.()
+
+      if (aroundAction) {
+        await aroundAction({request: this.request, response: this.response, next: runAction})
+      } else {
+        await runAction()
+      }
+    } catch (error) {
+      const ensuredError = ensureError(error)
+      const errorContext = {
+        action,
+        controller,
+        httpMethod: this.request.httpMethod(),
+        path: this.request.path(),
+        stage: "controller-action"
+      }
+
+      const errorWithContext = /**
+                                * Narrows the runtime value to the documented type.
+                                 @type {{velociousContext?: object}} */ (ensuredError)
+
+      errorWithContext.velociousContext = {
+        ...(errorWithContext.velociousContext || {}),
+        controllerAction: errorContext
+      }
+
+      throw ensuredError
     }
-    /**
-     * Runs resolve route resolver hooks.
-     * @param {string} currentPath - Request path without query string.
-     * @param {object} options - Resolver hook options.
-     * @param {boolean} [options.hasMatchingCustomRoute] - True when the path matched an explicit custom route.
-     * @returns {Promise<import("../configuration-types.js").RouteResolverHookResult | null>} - Matched action/controller from hooks.
-     */
-    async resolveRouteResolverHooks(currentPath, options = {}) {
-        const { hasMatchingCustomRoute = false } = options;
-        const hooks = this.configuration.getRouteResolverHooks?.() || [];
-        for (const hook of hooks) {
-            const hookResult = await hook({
-                configuration: this.configuration,
-                currentPath,
-                hasMatchingCustomRoute,
-                params: this.params,
-                request: this.request,
-                resolver: this,
-                response: this.response
-            });
-            if (!hookResult)
-                continue;
-            if (typeof hookResult.action !== "string" || hookResult.action.length < 1) {
-                throw new Error(`Expected route resolver hook action to be a string, got: ${hookResult.action}`);
-            }
-            if (typeof hookResult.controller !== "string" || hookResult.controller.length < 1) {
-                throw new Error(`Expected route resolver hook controller to be a string, got: ${hookResult.controller}`);
-            }
-            if (hookResult.params && typeof hookResult.params !== "object") {
-                throw new Error(`Expected route resolver hook params to be an object, got: ${hookResult.params}`);
-            }
-            if (hookResult.controllerClass !== undefined && typeof hookResult.controllerClass !== "function") {
-                throw new Error(`Expected route resolver hook controllerClass to be a class/function when provided, got: ${hookResult.controllerClass}`);
-            }
-            if (hookResult.controllerPath !== undefined && typeof hookResult.controllerPath !== "string") {
-                throw new Error(`Expected route resolver hook controllerPath to be a string when provided, got: ${hookResult.controllerPath}`);
-            }
-            if (hookResult.skipControllerConnections !== undefined && typeof hookResult.skipControllerConnections !== "boolean") {
-                throw new Error(`Expected route resolver hook skipControllerConnections to be a boolean when provided, got: ${hookResult.skipControllerConnections}`);
-            }
-            if (hookResult.skipAbilityResolution !== undefined && typeof hookResult.skipAbilityResolution !== "boolean") {
-                throw new Error(`Expected route resolver hook skipAbilityResolution to be a boolean when provided, got: ${hookResult.skipAbilityResolution}`);
-            }
-            if (hookResult.skipTenantResolution !== undefined && typeof hookResult.skipTenantResolution !== "boolean") {
-                throw new Error(`Expected route resolver hook skipTenantResolution to be a boolean when provided, got: ${hookResult.skipTenantResolution}`);
-            }
-            if (hookResult.viewPath !== undefined && typeof hookResult.viewPath !== "string") {
-                throw new Error(`Expected route resolver hook viewPath to be a string when provided, got: ${hookResult.viewPath}`);
-            }
-            if (hookResult.params) {
-                Object.assign(this.params, hookResult.params);
-            }
-            return hookResult;
-        }
-        return null;
+  }
+
+  /**
+   * Runs resolve controller class.
+   * @param {object} args - Args.
+   * @param {string} args.controllerPath - Controller import path.
+   * @returns {Promise<typeof import("../controller.js").default>} - The resolved controller class.
+   */
+  async resolveControllerClass({controllerPath}) {
+    const controllerImportSpecifier = toImportSpecifier(controllerPath)
+
+    if (!this.routeHookControllerClass) {
+      return /** Narrows the runtime value to the documented type. @type {typeof import("../controller.js").default} */ ((await import(controllerImportSpecifier)).default)
     }
-    /**
-     * Runs log action start.
-     * @param {object} args - Options object.
-     * @param {string} args.action - Action.
-     * @param {typeof import("../controller.js").default} args.controllerClass - Controller class.
-     * @param {"debug" | "info"} args.logMethod - Logger method.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async _logActionStart({ action, controllerClass, logMethod }) {
-        const request = this.request;
-        const timestamp = this._formatTimestamp(new Date());
-        const remoteAddress = request.remoteAddress() || "unknown";
-        const loggedParams = /**
-                              * Narrows the runtime value to the documented type.
-                               @type {Record<string, ?>} */ (this._sanitizeParamsForLogging(this.params));
-        delete loggedParams.action;
-        delete loggedParams.controller;
-        const controllerLogger = new Logger(controllerClass.name, { configuration: this.configuration });
-        await controllerLogger[logMethod](() => `Started ${request.httpMethod()} "${request.path()}" for ${remoteAddress} at ${timestamp}`);
-        await controllerLogger[logMethod](() => `Processing by ${controllerClass.name}#${action}`);
-        await controllerLogger[logMethod](() => [`  Parameters:`, loggedParams]);
+
+    try {
+      return /** Narrows the runtime value to the documented type. @type {typeof import("../controller.js").default} */ ((await import(controllerImportSpecifier)).default)
+    } catch (error) {
+      const isMissingControllerFileError = isMissingTargetModuleError({
+        error: ensureError(error),
+        targetImportSpecifier: controllerImportSpecifier,
+        targetPath: controllerPath
+      })
+
+      if (!isMissingControllerFileError) throw ensureError(error)
+
+      return /** Narrows the runtime value to the documented type. @type {typeof import("../controller.js").default} */ (this.routeHookControllerClass)
     }
-    /**
-     * Runs log method.
-     * @returns {"debug" | "info"} - Request log method.
-     */
-    _logMethod() {
-        return this.configuration.getEnvironment() === "test" ? "debug" : "info";
+  }
+
+  /**
+   * Runs match path with routes.
+   * @param {import("./base-route.js").default} route - Route.
+   * @param {string} path - Path.
+   * @returns {{restPath: string} | undefined} - REST path metadata for this route.
+   */
+  matchPathWithRoutes(route, path) {
+    const pathWithoutSlash = path.replace(/^\//, "").split("?")[0]
+
+    for (const subRoute of route.routes) {
+      const paramsSnapshot = {...this.params}
+      const matchResult = subRoute.matchWithPath({
+        params: this.params,
+        path: pathWithoutSlash,
+        request: this.request
+      })
+
+      if (!matchResult) {
+        this.params = paramsSnapshot
+        continue
+      }
+
+      const {restPath} = matchResult
+
+      if (restPath) {
+        const recursiveMatch = this.matchPathWithRoutes(subRoute, restPath)
+
+        if (recursiveMatch) {
+          return recursiveMatch
+        }
+
+        this.params = paramsSnapshot
+        continue
+      }
+
+      return matchResult
     }
-    /**
-     * Runs measure controller.
-     * @template T
-     * @param {() => Promise<T>} callback - Callback to measure.
-     * @returns {Promise<T>} - Callback result.
-     */
-    async _measureController(callback) {
-        const requestTiming = this.configuration.getCurrentRequestTiming();
-        return requestTiming
-            ? await requestTiming.measure("controller", callback)
-            : await callback();
+  }
+
+  /**
+   * Runs resolve route resolver hooks.
+   * @param {string} currentPath - Request path without query string.
+   * @param {object} options - Resolver hook options.
+   * @param {boolean} [options.hasMatchingCustomRoute] - True when the path matched an explicit custom route.
+   * @returns {Promise<import("../configuration-types.js").RouteResolverHookResult | null>} - Matched action/controller from hooks.
+   */
+  async resolveRouteResolverHooks(currentPath, options = {}) {
+    const {hasMatchingCustomRoute = false} = options
+
+    const hooks = this.configuration.getRouteResolverHooks?.() || []
+
+    for (const hook of hooks) {
+      const hookResult = await hook({
+        configuration: this.configuration,
+        currentPath,
+        hasMatchingCustomRoute,
+        params: this.params,
+        request: this.request,
+        resolver: this,
+        response: this.response
+      })
+
+      if (!hookResult) continue
+
+      if (typeof hookResult.action !== "string" || hookResult.action.length < 1) {
+        throw new Error(`Expected route resolver hook action to be a string, got: ${hookResult.action}`)
+      }
+
+      if (typeof hookResult.controller !== "string" || hookResult.controller.length < 1) {
+        throw new Error(`Expected route resolver hook controller to be a string, got: ${hookResult.controller}`)
+      }
+
+      if (hookResult.params && typeof hookResult.params !== "object") {
+        throw new Error(`Expected route resolver hook params to be an object, got: ${hookResult.params}`)
+      }
+
+      if (hookResult.controllerClass !== undefined && typeof hookResult.controllerClass !== "function") {
+        throw new Error(`Expected route resolver hook controllerClass to be a class/function when provided, got: ${hookResult.controllerClass}`)
+      }
+
+      if (hookResult.controllerPath !== undefined && typeof hookResult.controllerPath !== "string") {
+        throw new Error(`Expected route resolver hook controllerPath to be a string when provided, got: ${hookResult.controllerPath}`)
+      }
+
+      if (hookResult.skipControllerConnections !== undefined && typeof hookResult.skipControllerConnections !== "boolean") {
+        throw new Error(`Expected route resolver hook skipControllerConnections to be a boolean when provided, got: ${hookResult.skipControllerConnections}`)
+      }
+
+      if (hookResult.skipAbilityResolution !== undefined && typeof hookResult.skipAbilityResolution !== "boolean") {
+        throw new Error(`Expected route resolver hook skipAbilityResolution to be a boolean when provided, got: ${hookResult.skipAbilityResolution}`)
+      }
+
+      if (hookResult.skipTenantResolution !== undefined && typeof hookResult.skipTenantResolution !== "boolean") {
+        throw new Error(`Expected route resolver hook skipTenantResolution to be a boolean when provided, got: ${hookResult.skipTenantResolution}`)
+      }
+
+      if (hookResult.viewPath !== undefined && typeof hookResult.viewPath !== "string") {
+        throw new Error(`Expected route resolver hook viewPath to be a string when provided, got: ${hookResult.viewPath}`)
+      }
+
+      if (hookResult.params) {
+        Object.assign(this.params, hookResult.params)
+      }
+
+      return hookResult
     }
+
+    return null
+  }
+
+  /**
+   * Runs log action start.
+   * @param {object} args - Options object.
+   * @param {string} args.action - Action.
+   * @param {typeof import("../controller.js").default} args.controllerClass - Controller class.
+   * @param {"debug" | "info"} args.logMethod - Logger method.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async _logActionStart({action, controllerClass, logMethod}) {
+    const request = this.request
+    const timestamp = this._formatTimestamp(new Date())
+    const remoteAddress = request.remoteAddress() || "unknown"
+    const loggedParams = /**
+                          * Narrows the runtime value to the documented type.
+                           @type {Record<string, ?>} */ (this._sanitizeParamsForLogging(this.params))
+
+    delete loggedParams.action
+    delete loggedParams.controller
+
+    const controllerLogger = new Logger(controllerClass.name, {configuration: this.configuration})
+
+    await controllerLogger[logMethod](() => `Started ${request.httpMethod()} "${request.path()}" for ${remoteAddress} at ${timestamp}`)
+    await controllerLogger[logMethod](() => `Processing by ${controllerClass.name}#${action}`)
+    await controllerLogger[logMethod](() => [`  Parameters:`, loggedParams])
+  }
+
+  /**
+   * Runs log method.
+   * @returns {"debug" | "info"} - Request log method.
+   */
+  _logMethod() {
+    return this.configuration.getEnvironment() === "test" ? "debug" : "info"
+  }
+
+  /**
+   * Runs measure controller.
+   * @template T
+   * @param {() => Promise<T>} callback - Callback to measure.
+   * @returns {Promise<T>} - Callback result.
+   */
+  async _measureController(callback) {
+    const requestTiming = this.configuration.getCurrentRequestTiming()
+
+    return requestTiming
+      ? await requestTiming.measure("controller", callback)
+      : await callback()
+  }
+
+  /**
+   * Runs set completed log metadata.
+   * @param {object} args - Options object.
+   * @param {typeof import("../controller.js").default} args.controllerClass - Controller class.
+   * @param {"debug" | "info"} args.logMethod - Logger method.
+   * @returns {void} - No return value.
+   */
+  _setCompletedLogMetadata({controllerClass, logMethod}) {
+    const requestTiming = this.configuration.getCurrentRequestTiming()
+
+    if (!requestTiming) return
+
+    requestTiming.completedLogSubject = controllerClass.name
+    requestTiming.completedLogMethod = logMethod
+  }
+
+  /**
+   * Runs format timestamp.
+   * @param {Date} date - Date value.
+   * @returns {string} - The timestamp.
+   */
+  _formatTimestamp(date) {
     /**
-     * Runs set completed log metadata.
-     * @param {object} args - Options object.
-     * @param {typeof import("../controller.js").default} args.controllerClass - Controller class.
-     * @param {"debug" | "info"} args.logMethod - Logger method.
-     * @returns {void} - No return value.
+     * Pad.
+     * @param {number} num - Num.
+     * @returns {string} - The pad.
      */
-    _setCompletedLogMetadata({ controllerClass, logMethod }) {
-        const requestTiming = this.configuration.getCurrentRequestTiming();
-        if (!requestTiming)
-            return;
-        requestTiming.completedLogSubject = controllerClass.name;
-        requestTiming.completedLogMethod = logMethod;
+    const pad = (num) => String(num).padStart(2, "0")
+    const year = date.getFullYear()
+    const month = pad(date.getMonth() + 1)
+    const day = pad(date.getDate())
+    const hours = pad(date.getHours())
+    const minutes = pad(date.getMinutes())
+    const seconds = pad(date.getSeconds())
+    const offsetMinutes = date.getTimezoneOffset()
+    const offsetSign = offsetMinutes > 0 ? "-" : "+"
+    const offsetTotalMinutes = Math.abs(offsetMinutes)
+    const offsetHours = pad(Math.floor(offsetTotalMinutes / 60))
+    const offsetRemainingMinutes = pad(offsetTotalMinutes % 60)
+
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds} ${offsetSign}${offsetHours}${offsetRemainingMinutes}`
+  }
+
+  /**
+   * Runs sanitize params for logging.
+   * @param {?} value - Value to use.
+   * @returns {?} - The sanitize params for logging.
+   */
+  _sanitizeParamsForLogging(value) {
+    if (value instanceof UploadedFile) {
+      return {
+        className: value.constructor.name,
+        filename: value.filename(),
+        size: value.size()
+      }
     }
-    /**
-     * Runs format timestamp.
-     * @param {Date} date - Date value.
-     * @returns {string} - The timestamp.
-     */
-    _formatTimestamp(date) {
-        /**
-         * Pad.
-         * @param {number} num - Num.
-         * @returns {string} - The pad.
-         */
-        const pad = (num) => String(num).padStart(2, "0");
-        const year = date.getFullYear();
-        const month = pad(date.getMonth() + 1);
-        const day = pad(date.getDate());
-        const hours = pad(date.getHours());
-        const minutes = pad(date.getMinutes());
-        const seconds = pad(date.getSeconds());
-        const offsetMinutes = date.getTimezoneOffset();
-        const offsetSign = offsetMinutes > 0 ? "-" : "+";
-        const offsetTotalMinutes = Math.abs(offsetMinutes);
-        const offsetHours = pad(Math.floor(offsetTotalMinutes / 60));
-        const offsetRemainingMinutes = pad(offsetTotalMinutes % 60);
-        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds} ${offsetSign}${offsetHours}${offsetRemainingMinutes}`;
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this._sanitizeParamsForLogging(item))
     }
-    /**
-     * Runs sanitize params for logging.
-     * @param {?} value - Value to use.
-     * @returns {?} - The sanitize params for logging.
-     */
-    _sanitizeParamsForLogging(value) {
-        if (value instanceof UploadedFile) {
-            return {
-                className: value.constructor.name,
-                filename: value.filename(),
-                size: value.size()
-            };
-        }
-        if (Array.isArray(value)) {
-            return value.map((item) => this._sanitizeParamsForLogging(item));
-        }
-        if (value && typeof value === "object") {
-            /**
-             * Result.
-              @type {Record<string, ?>} */
-            const result = {};
-            for (const key of Object.keys(value)) {
-                result[key] = this._sanitizeParamsForLogging(value[key]);
-            }
-            return result;
-        }
-        return value;
+
+    if (value && typeof value === "object") {
+      /**
+       * Result.
+        @type {Record<string, ?>} */
+      const result = {}
+
+      for (const key of Object.keys(value)) {
+        result[key] = this._sanitizeParamsForLogging(value[key])
+      }
+
+      return result
     }
+
+    return value
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../../src/routes/resolver.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {dirname} from \"path\"\nimport {fileURLToPath} from \"url\"\nimport fs from \"fs/promises\"\nimport * as inflection from \"inflection\"\nimport Logger from \"../logger.js\"\nimport UploadedFile from \"../http-server/client/uploaded-file/uploaded-file.js\"\nimport ensureError from \"../utils/ensure-error.js\"\nimport toImportSpecifier from \"../utils/to-import-specifier.js\"\n\n/**\n * Runs normalize action name.\n * @param {string} actionName - Raw action name from route params or route hook.\n * @returns {string} - Normalized controller method name.\n */\nfunction normalizeActionName(actionName) {\n  return inflection.camelize(actionName.replaceAll(\"-\", \"_\").replaceAll(\"/\", \"_\"), true)\n}\n\n/**\n * Runs missing module specifier from error.\n * @param {Error} error - Import error.\n * @returns {string | undefined} - Missing module specifier from an ERR_MODULE_NOT_FOUND message.\n */\nfunction missingModuleSpecifierFromError(error) {\n  const firstLine = error.message.split(\"\\n\")[0] || \"\"\n  const match = firstLine.match(/^Cannot find (?:module|package) ['\"](.+?)['\"] imported from /)\n\n  return match?.[1]\n}\n\n/**\n * Runs is missing target module error.\n * @param {object} args - Arguments.\n * @param {Error} args.error - Import error.\n * @param {string} args.targetPath - Target controller path.\n * @param {string} args.targetImportSpecifier - Target controller import specifier.\n * @returns {boolean} - True when the missing module is the target controller file.\n */\nfunction isMissingTargetModuleError({error, targetPath, targetImportSpecifier}) {\n  const ensuredError = ensureError(error)\n  const isModuleNotFoundError = \"code\" in ensuredError && ensuredError.code === \"ERR_MODULE_NOT_FOUND\"\n\n  if (!isModuleNotFoundError) return false\n\n  const missingSpecifier = missingModuleSpecifierFromError(ensuredError)\n\n  if (!missingSpecifier) return false\n\n  return missingSpecifier === targetPath || missingSpecifier === targetImportSpecifier\n}\n\nexport default class VelociousRoutesResolver {\n  /**\n   * Narrows the runtime value to the documented type.\n    @type {Logger | undefined} */\n  logger\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\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   */\n  constructor({configuration, request, response}) {\n    if (!configuration) throw new Error(\"No configuration given\")\n    if (!request) throw new Error(\"No request given\")\n    if (!response) throw new Error(\"No response given\")\n\n    this.configuration = configuration\n    this.logger = new Logger(\"RoutesResolver\", {configuration})\n    const requestParams = request.params() || {}\n    this.params = {...requestParams}\n    delete this.params.action\n    delete this.params.controller\n    this.request = request\n    this.response = response\n  }\n\n  /**\n   * Runs query parameters.\n   * @returns {Record<string, string>} - Flat query params for tenant/ability resolution.\n   */\n  queryParameters() {\n    const query = this.request.path().split(\"?\")[1]\n\n    if (!query) return {}\n\n    /**\n     * Params.\n      @type {Record<string, string>} */\n    const params = {}\n    const searchParams = new URLSearchParams(query)\n\n    for (const [key, value] of searchParams.entries()) {\n      if (params[key] === undefined) {\n        params[key] = value\n      }\n    }\n\n    return params\n  }\n\n  async resolve() {\n    this.routeHookControllerClass = undefined\n    let controllerPath\n    const configurationRoutes = this.configuration.getRoutes()\n    const currentRoute = configurationRoutes?.rootRoute\n    const rawPath = this.request.path()\n    const currentPath = rawPath.split(\"?\")[0]\n    let viewPath\n\n    const preCheckParams = {...this.params}\n    const hasMatchingCustomRoute = currentRoute ? !!this.matchPathWithRoutes(currentRoute, currentPath) : false\n\n    if (hasMatchingCustomRoute) {\n      this.params = preCheckParams\n    }\n\n    const routeResolverHookMatch = await this.resolveRouteResolverHooks(currentPath, {hasMatchingCustomRoute})\n    const skipControllerConnections = routeResolverHookMatch?.skipControllerConnections === true\n    const skipAbilityResolution = routeResolverHookMatch?.skipAbilityResolution === true\n    const skipTenantResolution = routeResolverHookMatch?.skipTenantResolution === true\n    const matchResult = routeResolverHookMatch || !currentRoute ? undefined : this.matchPathWithRoutes(currentRoute, currentPath)\n    const actionParam = this.params.action\n    const controllerParam = this.params.controller\n    const actionValue = typeof actionParam == \"string\" ? actionParam : (Array.isArray(actionParam) ? actionParam[0] : undefined)\n    let action = typeof actionValue == \"string\" ? normalizeActionName(actionValue) : undefined\n    let controller = typeof controllerParam == \"string\" ? controllerParam : (Array.isArray(controllerParam) ? controllerParam[0] : undefined)\n\n    if (routeResolverHookMatch) {\n      const routeHookControllerClass = routeResolverHookMatch.controllerClass\n      let routeHookControllerPath\n      let routeHookViewPath\n\n      if (typeof routeResolverHookMatch.controllerPath === \"string\") {\n        routeHookControllerPath = routeResolverHookMatch.controllerPath\n      }\n\n      if (typeof routeResolverHookMatch.viewPath === \"string\") {\n        routeHookViewPath = routeResolverHookMatch.viewPath\n      }\n\n      controller = routeResolverHookMatch.controller\n      action = normalizeActionName(routeResolverHookMatch.action)\n      this.params.controller = controller\n      this.params.action = routeResolverHookMatch.action\n      controllerPath = routeHookControllerPath || `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`\n      viewPath = routeHookViewPath || `${this.configuration.getDirectory()}/src/routes/${controller}`\n      this.routeHookControllerClass = routeHookControllerClass\n    } else if (!matchResult) {\n        const __filename = fileURLToPath(import.meta.url)\n        const __dirname = dirname(__filename)\n        const requestedPath = currentPath.replace(/^\\//, \"\") || \"_root\"\n        const attemptedControllerPath = `${this.configuration.getDirectory()}/src/routes/${requestedPath}/controller.js`\n\n        const logger = this.logger\n\n        if (!logger) throw new Error(\"Logger not initialized\")\n\n        await logger.warn(`No route matched for ${rawPath}. Tried controller at ${attemptedControllerPath}`)\n\n        controller = \"errors\"\n        controllerPath = \"./built-in/errors/controller.js\"\n        action = \"notFound\"\n        viewPath = await fs.realpath(`${__dirname}/built-in/errors`)\n    } else if (action) {\n      if (!controller) controller = \"_root\"\n\n      controllerPath = `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`\n      viewPath = `${this.configuration.getDirectory()}/src/routes/${controller}`\n    } else {\n      throw new Error(`Matched the route but didn't know what to do with it: ${rawPath} (action: ${action}, controller: ${controller}, params: ${JSON.stringify(this.params)})`)\n    }\n\n    const controllerClass = await this.resolveControllerClass({controllerPath})\n    const controllerRequest = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"../http-server/client/request.js\").default} */ (this.request)\n    const controllerInstance = new controllerClass({\n      action,\n      configuration: this.configuration,\n      controller,\n      params: this.params,\n      request: controllerRequest,\n      response: this.response,\n      viewPath\n    })\n\n    if (!(action in controllerInstance)) {\n      throw new Error(`Missing action on controller: ${controller}#${action}`)\n    }\n\n    const actionHandlers = /**\n                            * Narrows the runtime value to the documented type.\n                             @type {Record<string, () => void | Promise<void>>} */ (/**\n                                                                                     * Narrows the runtime value to the documented type.\n                                                                                      @type {?} */ (controllerInstance))\n\n    const logMethod = this._logMethod()\n\n    this._setCompletedLogMetadata({controllerClass, logMethod})\n    await this._logActionStart({action, controllerClass, logMethod})\n\n    try {\n      const tenant = skipTenantResolution\n        ? undefined\n        : await this.configuration.resolveTenant({\n            params: {...this.queryParameters(), ...this.params},\n            request: this.request,\n            response: this.response\n          })\n\n      const runAction = async () => {\n        await this.configuration.runWithTenant(tenant, async () => {\n          const runControllerAction = async () => {\n            const ability = skipAbilityResolution\n              ? undefined\n              : await this.configuration.resolveAbility({\n                  params: this.params,\n                  request: this.request,\n                  response: this.response\n                })\n\n            await this.configuration.runWithAbility(ability, async () => {\n              await this._measureController(async () => {\n                await controllerInstance._runBeforeCallbacks()\n                await actionHandlers[action]()\n              })\n            })\n          }\n\n          if (skipControllerConnections) {\n            await runControllerAction()\n          } else {\n            await this.configuration.ensureConnections({name: `${controllerClass.name}.${action}`}, runControllerAction)\n          }\n        })\n      }\n\n      const aroundAction = this.configuration.getAroundAction?.()\n\n      if (aroundAction) {\n        await aroundAction({request: this.request, response: this.response, next: runAction})\n      } else {\n        await runAction()\n      }\n    } catch (error) {\n      const ensuredError = ensureError(error)\n      const errorContext = {\n        action,\n        controller,\n        httpMethod: this.request.httpMethod(),\n        path: this.request.path(),\n        stage: \"controller-action\"\n      }\n\n      const errorWithContext = /**\n                                * Narrows the runtime value to the documented type.\n                                 @type {{velociousContext?: object}} */ (ensuredError)\n\n      errorWithContext.velociousContext = {\n        ...(errorWithContext.velociousContext || {}),\n        controllerAction: errorContext\n      }\n\n      throw ensuredError\n    }\n  }\n\n  /**\n   * Runs resolve controller class.\n   * @param {object} args - Args.\n   * @param {string} args.controllerPath - Controller import path.\n   * @returns {Promise<typeof import(\"../controller.js\").default>} - The resolved controller class.\n   */\n  async resolveControllerClass({controllerPath}) {\n    const controllerImportSpecifier = toImportSpecifier(controllerPath)\n\n    if (!this.routeHookControllerClass) {\n      return /** Narrows the runtime value to the documented type. @type {typeof import(\"../controller.js\").default} */ ((await import(controllerImportSpecifier)).default)\n    }\n\n    try {\n      return /** Narrows the runtime value to the documented type. @type {typeof import(\"../controller.js\").default} */ ((await import(controllerImportSpecifier)).default)\n    } catch (error) {\n      const isMissingControllerFileError = isMissingTargetModuleError({\n        error: ensureError(error),\n        targetImportSpecifier: controllerImportSpecifier,\n        targetPath: controllerPath\n      })\n\n      if (!isMissingControllerFileError) throw ensureError(error)\n\n      return /** Narrows the runtime value to the documented type. @type {typeof import(\"../controller.js\").default} */ (this.routeHookControllerClass)\n    }\n  }\n\n  /**\n   * Runs match path with routes.\n   * @param {import(\"./base-route.js\").default} route - Route.\n   * @param {string} path - Path.\n   * @returns {{restPath: string} | undefined} - REST path metadata for this route.\n   */\n  matchPathWithRoutes(route, path) {\n    const pathWithoutSlash = path.replace(/^\\//, \"\").split(\"?\")[0]\n\n    for (const subRoute of route.routes) {\n      const paramsSnapshot = {...this.params}\n      const matchResult = subRoute.matchWithPath({\n        params: this.params,\n        path: pathWithoutSlash,\n        request: this.request\n      })\n\n      if (!matchResult) {\n        this.params = paramsSnapshot\n        continue\n      }\n\n      const {restPath} = matchResult\n\n      if (restPath) {\n        const recursiveMatch = this.matchPathWithRoutes(subRoute, restPath)\n\n        if (recursiveMatch) {\n          return recursiveMatch\n        }\n\n        this.params = paramsSnapshot\n        continue\n      }\n\n      return matchResult\n    }\n  }\n\n  /**\n   * Runs resolve route resolver hooks.\n   * @param {string} currentPath - Request path without query string.\n   * @param {object} options - Resolver hook options.\n   * @param {boolean} [options.hasMatchingCustomRoute] - True when the path matched an explicit custom route.\n   * @returns {Promise<import(\"../configuration-types.js\").RouteResolverHookResult | null>} - Matched action/controller from hooks.\n   */\n  async resolveRouteResolverHooks(currentPath, options = {}) {\n    const {hasMatchingCustomRoute = false} = options\n\n    const hooks = this.configuration.getRouteResolverHooks?.() || []\n\n    for (const hook of hooks) {\n      const hookResult = await hook({\n        configuration: this.configuration,\n        currentPath,\n        hasMatchingCustomRoute,\n        params: this.params,\n        request: this.request,\n        resolver: this,\n        response: this.response\n      })\n\n      if (!hookResult) continue\n\n      if (typeof hookResult.action !== \"string\" || hookResult.action.length < 1) {\n        throw new Error(`Expected route resolver hook action to be a string, got: ${hookResult.action}`)\n      }\n\n      if (typeof hookResult.controller !== \"string\" || hookResult.controller.length < 1) {\n        throw new Error(`Expected route resolver hook controller to be a string, got: ${hookResult.controller}`)\n      }\n\n      if (hookResult.params && typeof hookResult.params !== \"object\") {\n        throw new Error(`Expected route resolver hook params to be an object, got: ${hookResult.params}`)\n      }\n\n      if (hookResult.controllerClass !== undefined && typeof hookResult.controllerClass !== \"function\") {\n        throw new Error(`Expected route resolver hook controllerClass to be a class/function when provided, got: ${hookResult.controllerClass}`)\n      }\n\n      if (hookResult.controllerPath !== undefined && typeof hookResult.controllerPath !== \"string\") {\n        throw new Error(`Expected route resolver hook controllerPath to be a string when provided, got: ${hookResult.controllerPath}`)\n      }\n\n      if (hookResult.skipControllerConnections !== undefined && typeof hookResult.skipControllerConnections !== \"boolean\") {\n        throw new Error(`Expected route resolver hook skipControllerConnections to be a boolean when provided, got: ${hookResult.skipControllerConnections}`)\n      }\n\n      if (hookResult.skipAbilityResolution !== undefined && typeof hookResult.skipAbilityResolution !== \"boolean\") {\n        throw new Error(`Expected route resolver hook skipAbilityResolution to be a boolean when provided, got: ${hookResult.skipAbilityResolution}`)\n      }\n\n      if (hookResult.skipTenantResolution !== undefined && typeof hookResult.skipTenantResolution !== \"boolean\") {\n        throw new Error(`Expected route resolver hook skipTenantResolution to be a boolean when provided, got: ${hookResult.skipTenantResolution}`)\n      }\n\n      if (hookResult.viewPath !== undefined && typeof hookResult.viewPath !== \"string\") {\n        throw new Error(`Expected route resolver hook viewPath to be a string when provided, got: ${hookResult.viewPath}`)\n      }\n\n      if (hookResult.params) {\n        Object.assign(this.params, hookResult.params)\n      }\n\n      return hookResult\n    }\n\n    return null\n  }\n\n  /**\n   * Runs log action start.\n   * @param {object} args - Options object.\n   * @param {string} args.action - Action.\n   * @param {typeof import(\"../controller.js\").default} args.controllerClass - Controller class.\n   * @param {\"debug\" | \"info\"} args.logMethod - Logger method.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _logActionStart({action, controllerClass, logMethod}) {\n    const request = this.request\n    const timestamp = this._formatTimestamp(new Date())\n    const remoteAddress = request.remoteAddress() || \"unknown\"\n    const loggedParams = /**\n                          * Narrows the runtime value to the documented type.\n                           @type {Record<string, ?>} */ (this._sanitizeParamsForLogging(this.params))\n\n    delete loggedParams.action\n    delete loggedParams.controller\n\n    const controllerLogger = new Logger(controllerClass.name, {configuration: this.configuration})\n\n    await controllerLogger[logMethod](() => `Started ${request.httpMethod()} \"${request.path()}\" for ${remoteAddress} at ${timestamp}`)\n    await controllerLogger[logMethod](() => `Processing by ${controllerClass.name}#${action}`)\n    await controllerLogger[logMethod](() => [`  Parameters:`, loggedParams])\n  }\n\n  /**\n   * Runs log method.\n   * @returns {\"debug\" | \"info\"} - Request log method.\n   */\n  _logMethod() {\n    return this.configuration.getEnvironment() === \"test\" ? \"debug\" : \"info\"\n  }\n\n  /**\n   * Runs measure controller.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback to measure.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _measureController(callback) {\n    const requestTiming = this.configuration.getCurrentRequestTiming()\n\n    return requestTiming\n      ? await requestTiming.measure(\"controller\", callback)\n      : await callback()\n  }\n\n  /**\n   * Runs set completed log metadata.\n   * @param {object} args - Options object.\n   * @param {typeof import(\"../controller.js\").default} args.controllerClass - Controller class.\n   * @param {\"debug\" | \"info\"} args.logMethod - Logger method.\n   * @returns {void} - No return value.\n   */\n  _setCompletedLogMetadata({controllerClass, logMethod}) {\n    const requestTiming = this.configuration.getCurrentRequestTiming()\n\n    if (!requestTiming) return\n\n    requestTiming.completedLogSubject = controllerClass.name\n    requestTiming.completedLogMethod = logMethod\n  }\n\n  /**\n   * Runs format timestamp.\n   * @param {Date} date - Date value.\n   * @returns {string} - The timestamp.\n   */\n  _formatTimestamp(date) {\n    /**\n     * Pad.\n     * @param {number} num - Num.\n     * @returns {string} - The pad.\n     */\n    const pad = (num) => String(num).padStart(2, \"0\")\n    const year = date.getFullYear()\n    const month = pad(date.getMonth() + 1)\n    const day = pad(date.getDate())\n    const hours = pad(date.getHours())\n    const minutes = pad(date.getMinutes())\n    const seconds = pad(date.getSeconds())\n    const offsetMinutes = date.getTimezoneOffset()\n    const offsetSign = offsetMinutes > 0 ? \"-\" : \"+\"\n    const offsetTotalMinutes = Math.abs(offsetMinutes)\n    const offsetHours = pad(Math.floor(offsetTotalMinutes / 60))\n    const offsetRemainingMinutes = pad(offsetTotalMinutes % 60)\n\n    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds} ${offsetSign}${offsetHours}${offsetRemainingMinutes}`\n  }\n\n  /**\n   * Runs sanitize params for logging.\n   * @param {?} value - Value to use.\n   * @returns {?} - The sanitize params for logging.\n   */\n  _sanitizeParamsForLogging(value) {\n    if (value instanceof UploadedFile) {\n      return {\n        className: value.constructor.name,\n        filename: value.filename(),\n        size: value.size()\n      }\n    }\n\n    if (Array.isArray(value)) {\n      return value.map((item) => this._sanitizeParamsForLogging(item))\n    }\n\n    if (value && typeof value === \"object\") {\n      /**\n       * Result.\n        @type {Record<string, ?>} */\n      const result = {}\n\n      for (const key of Object.keys(value)) {\n        result[key] = this._sanitizeParamsForLogging(value[key])\n      }\n\n      return result\n    }\n\n    return value\n  }\n}\n"]}