astro 6.0.0-alpha.0 → 6.0.0-alpha.2

package/dist/core/app/index.js

@@ -1,491 +1,25 @@
+import { App } from "./app.js";
+import { BaseApp } from "./base.js";
+import { fromRoutingStrategy, toRoutingStrategy } from "./common.js";
+import { createConsoleLogger } from "./logging.js";
 import {
-  collapseDuplicateTrailingSlashes,
-  hasFileExtension,
-  isInternalPath
-} from "@astrojs/internal-helpers/path";
-import { matchPattern } from "../../assets/utils/remotePattern.js";
-import { normalizeTheLocale } from "../../i18n/index.js";
-import {
-  clientAddressSymbol,
-  DEFAULT_404_COMPONENT,
-  REROUTABLE_STATUS_CODES,
-  REROUTE_DIRECTIVE_HEADER,
-  responseSentSymbol
-} from "../constants.js";
-import { getSetCookiesFromResponse } from "../cookies/index.js";
-import { AstroError, AstroErrorData } from "../errors/index.js";
-import { consoleLogDestination } from "../logger/console.js";
-import { AstroIntegrationLogger, Logger } from "../logger/core.js";
-import { NOOP_MIDDLEWARE_FN } from "../middleware/noop-middleware.js";
-import {
-  appendForwardSlash,
-  joinPaths,
-  prependForwardSlash,
-  removeTrailingForwardSlash
-} from "../path.js";
-import { createAssetLink } from "../render/ssr-element.js";
-import { RenderContext } from "../render-context.js";
-import { redirectTemplate } from "../routing/3xx.js";
-import { ensure404Route } from "../routing/astro-designed-error-pages.js";
-import { createDefaultRoutes } from "../routing/default.js";
-import { matchRoute } from "../routing/match.js";
-import { PERSIST_SYMBOL } from "../session.js";
+  deserializeManifest,
+  deserializeRouteData,
+  deserializeRouteInfo,
+  serializeRouteData,
+  serializeRouteInfo
+} from "./manifest.js";
 import { AppPipeline } from "./pipeline.js";
-import { deserializeManifest } from "./common.js";
-class App {
-  #manifest;
-  #manifestData;
-  #logger = new Logger({
-    dest: consoleLogDestination,
-    level: "info"
-  });
-  #baseWithoutTrailingSlash;
-  #pipeline;
-  #adapterLogger;
-  constructor(manifest, streaming = true) {
-    this.#manifest = manifest;
-    this.#manifestData = {
-      routes: manifest.routes.map((route) => route.routeData)
-    };
-    ensure404Route(this.#manifestData);
-    this.#baseWithoutTrailingSlash = removeTrailingForwardSlash(this.#manifest.base);
-    this.#pipeline = this.#createPipeline(streaming);
-    this.#adapterLogger = new AstroIntegrationLogger(
-      this.#logger.options,
-      this.#manifest.adapterName
-    );
-  }
-  getAdapterLogger() {
-    return this.#adapterLogger;
-  }
-  getAllowedDomains() {
-    return this.#manifest.allowedDomains;
-  }
-  get manifest() {
-    return this.#manifest;
-  }
-  set manifest(value) {
-    this.#manifest = value;
-  }
-  matchesAllowedDomains(forwardedHost, protocol) {
-    return App.validateForwardedHost(forwardedHost, this.#manifest.allowedDomains, protocol);
-  }
-  static validateForwardedHost(forwardedHost, allowedDomains, protocol) {
-    if (!allowedDomains || allowedDomains.length === 0) {
-      return false;
-    }
-    try {
-      const testUrl = new URL(`${protocol || "https"}://${forwardedHost}`);
-      return allowedDomains.some((pattern) => {
-        return matchPattern(testUrl, pattern);
-      });
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Creates a pipeline by reading the stored manifest
-   *
-   * @param streaming
-   * @private
-   */
-  #createPipeline(streaming = false) {
-    return AppPipeline.create({
-      logger: this.#logger,
-      manifest: this.#manifest,
-      runtimeMode: "production",
-      renderers: this.#manifest.renderers,
-      defaultRoutes: createDefaultRoutes(this.#manifest),
-      resolve: async (specifier) => {
-        if (!(specifier in this.#manifest.entryModules)) {
-          throw new Error(`Unable to resolve [${specifier}]`);
-        }
-        const bundlePath = this.#manifest.entryModules[specifier];
-        if (bundlePath.startsWith("data:") || bundlePath.length === 0) {
-          return bundlePath;
-        } else {
-          return createAssetLink(bundlePath, this.#manifest.base, this.#manifest.assetsPrefix);
-        }
-      },
-      serverLike: true,
-      streaming
-    });
-  }
-  set setManifestData(newManifestData) {
-    this.#manifestData = newManifestData;
-  }
-  removeBase(pathname) {
-    if (pathname.startsWith(this.#manifest.base)) {
-      return pathname.slice(this.#baseWithoutTrailingSlash.length + 1);
-    }
-    return pathname;
-  }
-  /**
-   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
-   *
-   * If the decoding fails, it logs the error and return the pathname as is.
-   * @param request
-   * @private
-   */
-  #getPathnameFromRequest(request) {
-    const url = new URL(request.url);
-    const pathname = prependForwardSlash(this.removeBase(url.pathname));
-    try {
-      return decodeURI(pathname);
-    } catch (e) {
-      this.getAdapterLogger().error(e.toString());
-      return pathname;
-    }
-  }
-  /**
-   * Given a `Request`, it returns the `RouteData` that matches its `pathname`. By default, prerendered
-   * routes aren't returned, even if they are matched.
-   *
-   * When `allowPrerenderedRoutes` is `true`, the function returns matched prerendered routes too.
-   * @param request
-   * @param allowPrerenderedRoutes
-   */
-  match(request, allowPrerenderedRoutes = false) {
-    const url = new URL(request.url);
-    if (this.#manifest.assets.has(url.pathname)) return void 0;
-    let pathname = this.#computePathnameFromDomain(request);
-    if (!pathname) {
-      pathname = prependForwardSlash(this.removeBase(url.pathname));
-    }
-    let routeData = matchRoute(decodeURI(pathname), this.#manifestData);
-    if (!routeData) return void 0;
-    if (allowPrerenderedRoutes) {
-      return routeData;
-    } else if (routeData.prerender) {
-      return void 0;
-    }
-    return routeData;
-  }
-  #computePathnameFromDomain(request) {
-    let pathname = void 0;
-    const url = new URL(request.url);
-    if (this.#manifest.i18n && (this.#manifest.i18n.strategy === "domains-prefix-always" || this.#manifest.i18n.strategy === "domains-prefix-other-locales" || this.#manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
-      let forwardedHost = request.headers.get("X-Forwarded-Host");
-      let protocol = request.headers.get("X-Forwarded-Proto");
-      if (protocol) {
-        protocol = protocol + ":";
-      } else {
-        protocol = url.protocol;
-      }
-      if (forwardedHost && !this.matchesAllowedDomains(forwardedHost, protocol?.replace(":", ""))) {
-        forwardedHost = null;
-      }
-      let host = forwardedHost;
-      if (!host) {
-        host = request.headers.get("Host");
-      }
-      if (host && protocol) {
-        host = host.split(":")[0];
-        try {
-          let locale;
-          const hostAsUrl = new URL(`${protocol}//${host}`);
-          for (const [domainKey, localeValue] of Object.entries(
-            this.#manifest.i18n.domainLookupTable
-          )) {
-            const domainKeyAsUrl = new URL(domainKey);
-            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
-              locale = localeValue;
-              break;
-            }
-          }
-          if (locale) {
-            pathname = prependForwardSlash(
-              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
-            );
-            if (url.pathname.endsWith("/")) {
-              pathname = appendForwardSlash(pathname);
-            }
-          }
-        } catch (e) {
-          this.#logger.error(
-            "router",
-            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
-          );
-          this.#logger.error("router", `Error: ${e}`);
-        }
-      }
-    }
-    return pathname;
-  }
-  #redirectTrailingSlash(pathname) {
-    const { trailingSlash } = this.#manifest;
-    if (pathname === "/" || isInternalPath(pathname)) {
-      return pathname;
-    }
-    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
-    if (path !== pathname) {
-      return path;
-    }
-    if (trailingSlash === "ignore") {
-      return pathname;
-    }
-    if (trailingSlash === "always" && !hasFileExtension(pathname)) {
-      return appendForwardSlash(pathname);
-    }
-    if (trailingSlash === "never") {
-      return removeTrailingForwardSlash(pathname);
-    }
-    return pathname;
-  }
-  async render(request, {
-    addCookieHeader,
-    clientAddress = Reflect.get(request, clientAddressSymbol),
-    locals,
-    prerenderedErrorPageFetch = fetch,
-    routeData
-  } = {}) {
-    const url = new URL(request.url);
-    const redirect = this.#redirectTrailingSlash(url.pathname);
-    if (redirect !== url.pathname) {
-      const status = request.method === "GET" ? 301 : 308;
-      return new Response(
-        redirectTemplate({
-          status,
-          relativeLocation: url.pathname,
-          absoluteLocation: redirect,
-          from: request.url
-        }),
-        {
-          status,
-          headers: {
-            location: redirect + url.search
-          }
-        }
-      );
-    }
-    if (routeData) {
-      this.#logger.debug(
-        "router",
-        "The adapter " + this.#manifest.adapterName + " provided a custom RouteData for ",
-        request.url
-      );
-      this.#logger.debug("router", "RouteData:\n" + routeData);
-    }
-    if (locals) {
-      if (typeof locals !== "object") {
-        const error = new AstroError(AstroErrorData.LocalsNotAnObject);
-        this.#logger.error(null, error.stack);
-        return this.#renderError(request, {
-          status: 500,
-          error,
-          clientAddress,
-          prerenderedErrorPageFetch
-        });
-      }
-    }
-    if (!routeData) {
-      routeData = this.match(request);
-      this.#logger.debug("router", "Astro matched the following route for " + request.url);
-      this.#logger.debug("router", "RouteData:\n" + routeData);
-    }
-    if (!routeData) {
-      routeData = this.#manifestData.routes.find(
-        (route) => route.component === "404.astro" || route.component === DEFAULT_404_COMPONENT
-      );
-    }
-    if (!routeData) {
-      this.#logger.debug("router", "Astro hasn't found routes that match " + request.url);
-      this.#logger.debug("router", "Here's the available routes:\n", this.#manifestData);
-      return this.#renderError(request, {
-        locals,
-        status: 404,
-        clientAddress,
-        prerenderedErrorPageFetch
-      });
-    }
-    const pathname = this.#getPathnameFromRequest(request);
-    const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
-    let response;
-    let session;
-    try {
-      const mod = await this.#pipeline.getModuleForRoute(routeData);
-      const renderContext = await RenderContext.create({
-        pipeline: this.#pipeline,
-        locals,
-        pathname,
-        request,
-        routeData,
-        status: defaultStatus,
-        clientAddress
-      });
-      session = renderContext.session;
-      response = await renderContext.render(await mod.page());
-    } catch (err) {
-      this.#logger.error(null, err.stack || err.message || String(err));
-      return this.#renderError(request, {
-        locals,
-        status: 500,
-        error: err,
-        clientAddress,
-        prerenderedErrorPageFetch
-      });
-    } finally {
-      await session?.[PERSIST_SYMBOL]();
-    }
-    if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
-      return this.#renderError(request, {
-        locals,
-        response,
-        status: response.status,
-        // We don't have an error to report here. Passing null means we pass nothing intentionally
-        // while undefined means there's no error
-        error: response.status === 500 ? null : void 0,
-        clientAddress,
-        prerenderedErrorPageFetch
-      });
-    }
-    if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
-      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
-    }
-    if (addCookieHeader) {
-      for (const setCookieHeaderValue of App.getSetCookieFromResponse(response)) {
-        response.headers.append("set-cookie", setCookieHeaderValue);
-      }
-    }
-    Reflect.set(response, responseSentSymbol, true);
-    return response;
-  }
-  setCookieHeaders(response) {
-    return getSetCookiesFromResponse(response);
-  }
-  /**
-   * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
-   * For example,
-   * ```ts
-   * for (const cookie_ of App.getSetCookieFromResponse(response)) {
-   *     const cookie: string = cookie_
-   * }
-   * ```
-   * @param response The response to read cookies from.
-   * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
-   */
-  static getSetCookieFromResponse = getSetCookiesFromResponse;
-  /**
-   * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
-   * This also handles pre-rendered /404 or /500 routes
-   */
-  async #renderError(request, {
-    locals,
-    status,
-    response: originalResponse,
-    skipMiddleware = false,
-    error,
-    clientAddress,
-    prerenderedErrorPageFetch
-  }) {
-    const errorRoutePath = `/${status}${this.#manifest.trailingSlash === "always" ? "/" : ""}`;
-    const errorRouteData = matchRoute(errorRoutePath, this.#manifestData);
-    const url = new URL(request.url);
-    if (errorRouteData) {
-      if (errorRouteData.prerender) {
-        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
-        const statusURL = new URL(
-          `${this.#baseWithoutTrailingSlash}/${status}${maybeDotHtml}`,
-          url
-        );
-        if (statusURL.toString() !== request.url) {
-          const response2 = await prerenderedErrorPageFetch(statusURL.toString());
-          const override = { status, removeContentEncodingHeaders: true };
-          return this.#mergeResponses(response2, originalResponse, override);
-        }
-      }
-      const mod = await this.#pipeline.getModuleForRoute(errorRouteData);
-      let session;
-      try {
-        const renderContext = await RenderContext.create({
-          locals,
-          pipeline: this.#pipeline,
-          middleware: skipMiddleware ? NOOP_MIDDLEWARE_FN : void 0,
-          pathname: this.#getPathnameFromRequest(request),
-          request,
-          routeData: errorRouteData,
-          status,
-          props: { error },
-          clientAddress
-        });
-        session = renderContext.session;
-        const response2 = await renderContext.render(await mod.page());
-        return this.#mergeResponses(response2, originalResponse);
-      } catch {
-        if (skipMiddleware === false) {
-          return this.#renderError(request, {
-            locals,
-            status,
-            response: originalResponse,
-            skipMiddleware: true,
-            clientAddress,
-            prerenderedErrorPageFetch
-          });
-        }
-      } finally {
-        await session?.[PERSIST_SYMBOL]();
-      }
-    }
-    const response = this.#mergeResponses(new Response(null, { status }), originalResponse);
-    Reflect.set(response, responseSentSymbol, true);
-    return response;
-  }
-  #mergeResponses(newResponse, originalResponse, override) {
-    let newResponseHeaders = newResponse.headers;
-    if (override?.removeContentEncodingHeaders) {
-      newResponseHeaders = new Headers(newResponseHeaders);
-      newResponseHeaders.delete("Content-Encoding");
-      newResponseHeaders.delete("Content-Length");
-    }
-    if (!originalResponse) {
-      if (override !== void 0) {
-        return new Response(newResponse.body, {
-          status: override.status,
-          statusText: newResponse.statusText,
-          headers: newResponseHeaders
-        });
-      }
-      return newResponse;
-    }
-    const status = override?.status ? override.status : originalResponse.status === 200 ? newResponse.status : originalResponse.status;
-    try {
-      originalResponse.headers.delete("Content-type");
-    } catch {
-    }
-    const mergedHeaders = new Map([
-      ...Array.from(newResponseHeaders),
-      ...Array.from(originalResponse.headers)
-    ]);
-    const newHeaders = new Headers();
-    for (const [name, value] of mergedHeaders) {
-      newHeaders.set(name, value);
-    }
-    return new Response(newResponse.body, {
-      status,
-      statusText: status === 200 ? newResponse.statusText : originalResponse.statusText,
-      // If you're looking at here for possible bugs, it means that it's not a bug.
-      // With the middleware, users can meddle with headers, and we should pass to the 404/500.
-      // If users see something weird, it's because they are setting some headers they should not.
-      //
-      // Although, we don't want it to replace the content-type, because the error page must return `text/html`
-      headers: newHeaders
-    });
-  }
-  #getDefaultStatusCode(routeData, pathname) {
-    if (!routeData.pattern.test(pathname)) {
-      for (const fallbackRoute of routeData.fallbackRoutes) {
-        if (fallbackRoute.pattern.test(pathname)) {
-          return 302;
-        }
-      }
-    }
-    const route = removeTrailingForwardSlash(routeData.route);
-    if (route.endsWith("/404")) return 404;
-    if (route.endsWith("/500")) return 500;
-    return 200;
-  }
-}
 export {
   App,
-  deserializeManifest
+  AppPipeline,
+  BaseApp,
+  createConsoleLogger,
+  deserializeManifest,
+  deserializeRouteData,
+  deserializeRouteInfo,
+  fromRoutingStrategy,
+  serializeRouteData,
+  serializeRouteInfo,
+  toRoutingStrategy
 };

package/dist/core/app/logging.d.ts

@@ -0,0 +1,3 @@
+import type { AstroInlineConfig } from '../../types/public/index.js';
+import { Logger } from '../logger/core.js';
+export declare function createConsoleLogger(level: AstroInlineConfig['logLevel']): Logger;

package/dist/core/app/logging.js

@@ -0,0 +1,11 @@
+import { consoleLogDestination } from "../logger/console.js";
+import { Logger } from "../logger/core.js";
+function createConsoleLogger(level) {
+  return new Logger({
+    dest: consoleLogDestination,
+    level: level ?? "info"
+  });
+}
+export {
+  createConsoleLogger
+};

package/dist/core/app/manifest.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedRouteData } from '../../types/astro.js';
+import type { AstroConfig, RouteData } from '../../types/public/index.js';
+import type { RoutesList } from '../../types/astro.js';
+import type { RouteInfo, SerializedSSRManifest, SSRManifest, SerializedRouteInfo } from './types.js';
+export declare function deserializeManifest(serializedManifest: SerializedSSRManifest, routesList?: RoutesList): SSRManifest;
+export declare function serializeRouteData(routeData: RouteData, trailingSlash: AstroConfig['trailingSlash']): SerializedRouteData;
+export declare function deserializeRouteData(rawRouteData: SerializedRouteData): RouteData;
+export declare function serializeRouteInfo(routeInfo: RouteInfo, trailingSlash: AstroConfig['trailingSlash']): SerializedRouteInfo;
+export declare function deserializeRouteInfo(rawRouteInfo: SerializedRouteInfo): RouteInfo;

package/dist/core/app/manifest.js

@@ -0,0 +1,107 @@
+import { decodeKey } from "../encryption.js";
+import { NOOP_MIDDLEWARE_FN } from "../middleware/noop-middleware.js";
+function deserializeManifest(serializedManifest, routesList) {
+  const routes = [];
+  if (serializedManifest.routes) {
+    for (const serializedRoute of serializedManifest.routes) {
+      routes.push({
+        ...serializedRoute,
+        routeData: deserializeRouteData(serializedRoute.routeData)
+      });
+      const route = serializedRoute;
+      route.routeData = deserializeRouteData(serializedRoute.routeData);
+    }
+  }
+  if (routesList) {
+    for (const route of routesList?.routes) {
+      routes.push({
+        file: "",
+        links: [],
+        scripts: [],
+        styles: [],
+        routeData: route
+      });
+    }
+  }
+  const assets = new Set(serializedManifest.assets);
+  const componentMetadata = new Map(serializedManifest.componentMetadata);
+  const inlinedScripts = new Map(serializedManifest.inlinedScripts);
+  const clientDirectives = new Map(serializedManifest.clientDirectives);
+  const key = decodeKey(serializedManifest.key);
+  return {
+    // in case user middleware exists, this no-op middleware will be reassigned (see plugin-ssr.ts)
+    middleware() {
+      return { onRequest: NOOP_MIDDLEWARE_FN };
+    },
+    ...serializedManifest,
+    rootDir: new URL(serializedManifest.rootDir),
+    srcDir: new URL(serializedManifest.srcDir),
+    publicDir: new URL(serializedManifest.publicDir),
+    outDir: new URL(serializedManifest.outDir),
+    cacheDir: new URL(serializedManifest.cacheDir),
+    buildClientDir: new URL(serializedManifest.buildClientDir),
+    buildServerDir: new URL(serializedManifest.buildServerDir),
+    assets,
+    componentMetadata,
+    inlinedScripts,
+    clientDirectives,
+    routes,
+    key
+  };
+}
+function serializeRouteData(routeData, trailingSlash) {
+  return {
+    ...routeData,
+    pattern: routeData.pattern.source,
+    redirectRoute: routeData.redirectRoute ? serializeRouteData(routeData.redirectRoute, trailingSlash) : void 0,
+    fallbackRoutes: routeData.fallbackRoutes.map((fallbackRoute) => {
+      return serializeRouteData(fallbackRoute, trailingSlash);
+    }),
+    _meta: { trailingSlash }
+  };
+}
+function deserializeRouteData(rawRouteData) {
+  return {
+    route: rawRouteData.route,
+    type: rawRouteData.type,
+    pattern: new RegExp(rawRouteData.pattern),
+    params: rawRouteData.params,
+    component: rawRouteData.component,
+    pathname: rawRouteData.pathname || void 0,
+    segments: rawRouteData.segments,
+    prerender: rawRouteData.prerender,
+    redirect: rawRouteData.redirect,
+    redirectRoute: rawRouteData.redirectRoute ? deserializeRouteData(rawRouteData.redirectRoute) : void 0,
+    fallbackRoutes: rawRouteData.fallbackRoutes.map((fallback) => {
+      return deserializeRouteData(fallback);
+    }),
+    isIndex: rawRouteData.isIndex,
+    origin: rawRouteData.origin,
+    distURL: rawRouteData.distURL
+  };
+}
+function serializeRouteInfo(routeInfo, trailingSlash) {
+  return {
+    styles: routeInfo.styles,
+    file: routeInfo.file,
+    links: routeInfo.links,
+    scripts: routeInfo.scripts,
+    routeData: serializeRouteData(routeInfo.routeData, trailingSlash)
+  };
+}
+function deserializeRouteInfo(rawRouteInfo) {
+  return {
+    styles: rawRouteInfo.styles,
+    file: rawRouteInfo.file,
+    links: rawRouteInfo.links,
+    scripts: rawRouteInfo.scripts,
+    routeData: deserializeRouteData(rawRouteInfo.routeData)
+  };
+}
+export {
+  deserializeManifest,
+  deserializeRouteData,
+  deserializeRouteInfo,
+  serializeRouteData,
+  serializeRouteInfo
+};

package/dist/core/app/middlewares.js

@@ -1,4 +1,4 @@
-import { defineMiddleware } from "../middleware/index.js";
+import { defineMiddleware } from "../middleware/defineMiddleware.js";
 const FORM_CONTENT_TYPES = [
   "application/x-www-form-urlencoded",
   "multipart/form-data",

package/dist/core/app/node.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import { Http2ServerResponse } from "node:http2";
 import { clientAddressSymbol, nodeRequestAbortControllerCleanupSymbol } from "../constants.js";
-import { deserializeManifest } from "./common.js";
+import { deserializeManifest } from "./manifest.js";
 import { createOutgoingHttpHeaders } from "./createOutgoingHttpHeaders.js";
 import { App } from "./index.js";
+import { sanitizeHost, validateForwardedHeaders } from "./validate-forwarded-headers.js";
 class NodeApp extends App {
   headersMap = void 0;
   setHeadersMap(headers) {
@@ -48,20 +49,20 @@ class NodeApp extends App {
     const getFirstForwardedValue = (multiValueHeader) => {
       return multiValueHeader?.toString()?.split(",").map((e) => e.trim())?.[0];
     };
-    const forwardedProtocol = getFirstForwardedValue(req.headers["x-forwarded-proto"]);
     const providedProtocol = isEncrypted ? "https" : "http";
-    const protocol = forwardedProtocol ?? providedProtocol;
-    let forwardedHostname = getFirstForwardedValue(req.headers["x-forwarded-host"]);
     const providedHostname = req.headers.host ?? req.headers[":authority"];
-    if (forwardedHostname && !App.validateForwardedHost(
-      forwardedHostname,
-      allowedDomains,
-      forwardedProtocol ?? providedProtocol
-    )) {
-      forwardedHostname = void 0;
-    }
-    const hostname = forwardedHostname ?? providedHostname;
-    const port = getFirstForwardedValue(req.headers["x-forwarded-port"]);
+    const validated = validateForwardedHeaders(
+      getFirstForwardedValue(req.headers["x-forwarded-proto"]),
+      getFirstForwardedValue(req.headers["x-forwarded-host"]),
+      getFirstForwardedValue(req.headers["x-forwarded-port"]),
+      allowedDomains
+    );
+    const protocol = validated.protocol ?? providedProtocol;
+    const sanitizedProvidedHostname = sanitizeHost(
+      typeof providedHostname === "string" ? providedHostname : void 0
+    );
+    const hostname = validated.host ?? sanitizedProvidedHostname;
+    const port = validated.port;
     let url;
     try {
       const hostnamePort = getHostnamePort(hostname, port);