Add an asset resolver override

Author: vicb

packages/open-next/src/adapters/middleware.ts

@@ -9,6 +9,7 @@ import type { OpenNextHandlerOptions } from "types/overrides";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import {
+  resolveAssetResolver,
   resolveIncrementalCache,
   resolveOriginResolver,
   resolveProxyRequest,
@@ -29,25 +30,22 @@ const defaultHandler = async (
   internalEvent: InternalEvent,
   options?: OpenNextHandlerOptions,
 ): Promise<InternalResult | MiddlewareResult> => {
-  const originResolver = await resolveOriginResolver(
-    globalThis.openNextConfig.middleware?.originResolver,
-  );
+  const config = globalThis.openNextConfig.middleware;
+  const originResolver = await resolveOriginResolver(config?.originResolver);
 
   const externalRequestProxy = await resolveProxyRequest(
-    globalThis.openNextConfig.middleware?.override?.proxyExternalRequest,
+    config?.override?.proxyExternalRequest,
   );
 
+  const assetResolver = await resolveAssetResolver(config?.assetResolver);
+
   //#override includeCacheInMiddleware
-  globalThis.tagCache = await resolveTagCache(
-    globalThis.openNextConfig.middleware?.override?.tagCache,
-  );
+  globalThis.tagCache = await resolveTagCache(config?.override?.tagCache);
 
-  globalThis.queue = await resolveQueue(
-    globalThis.openNextConfig.middleware?.override?.queue,
-  );
+  globalThis.queue = await resolveQueue(config?.override?.queue);
 
   globalThis.incrementalCache = await resolveIncrementalCache(
-    globalThis.openNextConfig.middleware?.override?.incrementalCache,
+    config?.override?.incrementalCache,
   );
   //#endOverride
 
@@ -61,7 +59,7 @@ const defaultHandler = async (
       requestId,
     },
     async () => {
-      const result = await routingHandler(internalEvent);
+      const result = await routingHandler(internalEvent, { assetResolver });
       if ("internalEvent" in result) {
         debug("Middleware intercepted event", internalEvent);
         if (!result.isExternalRewrite) {

packages/open-next/src/core/resolve.ts

@@ -116,6 +116,20 @@ export async function resolveOriginResolver(
   return m_1.default;
 }
 
+/**
+ * @returns
+ * @__PURE__
+ */
+export async function resolveAssetResolver(
+  assetResolver: RemoveUndefined<OpenNextConfig["middleware"]>["assetResolver"],
+) {
+  if (typeof assetResolver === "function") {
+    return assetResolver();
+  }
+  const m_1 = await import("../overrides/assetResolver/dummy.js");
+  return m_1.default;
+}
+
 /**
  * @__PURE__
  */

packages/open-next/src/core/routingHandler.ts

@@ -12,6 +12,7 @@ import type {
   RoutingResult,
 } from "types/open-next";
 
+import type { AssetResolver } from "types/overrides";
 import { debug, error } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { detectLocale } from "./routing/i18n";
@@ -64,6 +65,7 @@ function applyMiddlewareHeaders(
 
 export default async function routingHandler(
   event: InternalEvent,
+  { assetResolver }: { assetResolver?: AssetResolver } = {},
 ): Promise<InternalResult | RoutingResult> {
   try {
     // Add Next geo headers
@@ -89,11 +91,13 @@ export default async function routingHandler(
 
     const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
 
-    let internalEvent = fixDataPage(event, BuildId);
-    if ("statusCode" in internalEvent) {
-      return internalEvent;
+    const internalEventOrResult = fixDataPage(event, BuildId);
+    if ("statusCode" in internalEventOrResult) {
+      return internalEventOrResult;
     }
 
+    let internalEvent: InternalEvent | InternalResult = internalEventOrResult;
+
     const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
     if (redirect) {
       // We need to encode the value in the Location header to make sure it is valid according to RFC
@@ -105,21 +109,20 @@ export default async function routingHandler(
       return redirect;
     }
 
-    const eventOrResult = await handleMiddleware(
+    const middlewareEventOrResult = await handleMiddleware(
       internalEvent,
       // We need to pass the initial search without any decoding
       // TODO: we'd need to refactor InternalEvent to include the initial querystring directly
       // Should be done in another PR because it is a breaking change
       new URL(event.url).search,
     );
-    const isResult = "statusCode" in eventOrResult;
-    if (isResult) {
-      return eventOrResult;
+    if ("statusCode" in middlewareEventOrResult) {
+      return middlewareEventOrResult;
     }
-    const middlewareResponseHeaders = eventOrResult.responseHeaders;
-    let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
-    // internalEvent is `InternalEvent | MiddlewareEvent`
-    internalEvent = eventOrResult;
+
+    const middlewareResponseHeaders = middlewareEventOrResult.responseHeaders;
+    let isExternalRewrite = middlewareEventOrResult.isExternalRewrite ?? false;
+    internalEvent = middlewareEventOrResult;
 
     if (!isExternalRewrite) {
       // First rewrite to be applied
@@ -184,7 +187,22 @@ export default async function routingHandler(
         dynamicRouteMatcher(internalEvent.rawPath).length > 0
       )
     ) {
-      internalEvent = {
+      const assetEventOrResult =
+        await assetResolver?.onRouteNotFound(internalEvent);
+
+      if (assetEventOrResult && "statusCode" in assetEventOrResult) {
+        applyMiddlewareHeaders(
+          assetEventOrResult.headers,
+          {
+            ...middlewareResponseHeaders,
+            ...nextHeaders,
+          },
+          false,
+        );
+        return assetEventOrResult;
+      }
+
+      internalEvent = assetEventOrResult ?? {
         ...internalEvent,
         rawPath: "/404",
         url: constructNextUrl(internalEvent.url, "/404"),

packages/open-next/src/overrides/assetResolver/dummy.ts

@@ -0,0 +1,10 @@
+import type { InternalEvent } from "types/open-next";
+import type { AssetResolver } from "types/overrides";
+
+const resolver: AssetResolver = {
+  name: "dummy",
+  // @returns `undefined` to preserve the routing layer default behavior (404 page)
+  onRouteNotFound: (_event: InternalEvent) => undefined,
+};
+
+export default resolver;

packages/open-next/src/types/open-next.ts

@@ -3,6 +3,7 @@ import type { ReadableStream } from "node:stream/web";
 import type { Writable } from "node:stream";
 import type { WarmerEvent, WarmerResponse } from "../adapters/warmer-function";
 import type {
+  AssetResolver,
   CDNInvalidationHandler,
   Converter,
   ImageLoader,
@@ -186,6 +187,9 @@ export type IncludedWarmer = "aws-lambda" | "dummy";
 export type IncludedProxyExternalRequest = "node" | "fetch" | "dummy";
 
 export type IncludedCDNInvalidationHandler = "cloudfront" | "dummy";
+
+export type IncludedAssetResolver = "dummy";
+
 export interface DefaultOverrideOptions<
   E extends BaseEventOrResult = InternalEvent,
   R extends BaseEventOrResult = InternalResult,
@@ -396,6 +400,13 @@ export interface OpenNextConfig {
     originResolver?:
       | IncludedOriginResolver
       | LazyLoadedOverride<OriginResolver>;
+
+    /**
+     * The assetResolver is used to resolve assets in the routing layer.
+     *
+     * @default "dummy"
+     */
+    assetResolver?: IncludedAssetResolver | LazyLoadedOverride<AssetResolver>;
   };
 
   /**

packages/open-next/src/types/overrides.ts

@@ -31,6 +31,27 @@ export interface Queue {
   name: string;
 }
 
+/**
+ * Resolves assets in the routing layer.
+ */
+export interface AssetResolver {
+  // TODO: add onCatchAllRoute, called when a catchAllRoute matches as it could potentially match an asset
+  // onCatchAllRoute
+
+  /**
+   * Called when no matching route is found.
+   *
+   * @param event The internal event from the routing layer
+   * @returns - `Promise<InternalEvent>` replaces the internal event in the routing layer
+   *          - `Promise<InternalResult>` will get the routing layer to return the result, i.e. an asset
+   *          - `Promise<undefined> | undefined` does not change the routing default behavior of returning a 404
+   */
+  onRouteNotFound(
+    event: InternalEvent,
+  ): Promise<InternalEvent | InternalResult | undefined> | undefined;
+  name: string;
+}
+
 // Incremental cache
 
 export type CachedFile =