Add an asset resolver override (#917)

Author: vicb

.changeset/late-dodos-attack.md

@@ -0,0 +1,5 @@
+---
+"@opennextjs/aws": minor
+---
+
+Add an asset resolver

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/createMainHandler.ts

@@ -4,6 +4,7 @@ import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
 import { openNextHandler } from "./requestHandler";
 import {
+  resolveAssetResolver,
   resolveCdnInvalidation,
   resolveConverter,
   resolveIncrementalCache,
@@ -38,6 +39,12 @@ export async function createMainHandler() {
 
   globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
 
+  if (config.middleware?.external !== true) {
+    globalThis.assetResolver = await resolveAssetResolver(
+      globalThis.openNextConfig.middleware?.assetResolver,
+    );
+  }
+
   globalThis.proxyExternalRequest = await resolveProxyRequest(
     thisFunction.override?.proxyExternalRequest,
   );

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

@@ -80,7 +80,9 @@ export async function openNextHandler(
       };
 
       //#override withRouting
-      routingResult = await routingHandler(internalEvent);
+      routingResult = await routingHandler(internalEvent, {
+        assetResolver: globalThis.assetResolver,
+      });
       //#endOverride
 
       const headers =

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/routing/matcher.ts

@@ -170,6 +170,11 @@ export function getNextConfigHeaders(
   return requestHeaders;
 }
 
+/**
+ * TODO: This method currently only check for the first match.
+ *       It should check for all matches for `beforeFiles` and `afterFiles` rewrite
+ *       See https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites
+ */
 export function handleRewrites<T extends RewriteDefinition>(
   event: InternalEvent,
   rewrites: T[],

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";
@@ -47,23 +48,31 @@ const geoHeaderToNextHeader = {
   "x-open-next-longitude": "x-vercel-ip-longitude",
 };
 
+/**
+ * Adds the middleware headers to an event or result.
+ *
+ * @param eventOrResult
+ * @param middlewareHeaders
+ */
 function applyMiddlewareHeaders(
-  eventHeaders: Record<string, string | string[]>,
+  eventOrResult: InternalEvent | InternalResult,
   middlewareHeaders: Record<string, string | string[] | undefined>,
-  setPrefix = true,
 ) {
-  const keyPrefix = setPrefix ? MIDDLEWARE_HEADER_PREFIX : "";
+  // Use the `MIDDLEWARE_HEADER_PREFIX` prefix for events, they will be processed by the request handler later.
+  // Results do not go through the request handler and should not be prefixed.
+  const isResult = isInternalResult(eventOrResult);
+  const headers = eventOrResult.headers;
+  const keyPrefix = isResult ? "" : MIDDLEWARE_HEADER_PREFIX;
   Object.entries(middlewareHeaders).forEach(([key, value]) => {
     if (value) {
-      eventHeaders[keyPrefix + key] = Array.isArray(value)
-        ? value.join(",")
-        : value;
+      headers[keyPrefix + key] = Array.isArray(value) ? value.join(",") : value;
     }
   });
 }
 
 export default async function routingHandler(
   event: InternalEvent,
+  { assetResolver }: { assetResolver?: AssetResolver },
 ): Promise<InternalResult | RoutingResult> {
   try {
     // Add Next geo headers
@@ -87,14 +96,17 @@ export default async function routingHandler(
       }
     }
 
-    const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
+    // Headers from the Next config and middleware (the later are applied further down).
+    let headers: Record<string, string | string[] | undefined> =
+      getNextConfigHeaders(event, ConfigHeaders);
 
-    let internalEvent = fixDataPage(event, BuildId);
-    if ("statusCode" in internalEvent) {
-      return internalEvent;
+    let eventOrResult = fixDataPage(event, BuildId);
+
+    if (isInternalResult(eventOrResult)) {
+      return eventOrResult;
     }
 
-    const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
+    const redirect = handleRedirects(eventOrResult, RoutesManifest.redirects);
     if (redirect) {
       // We need to encode the value in the Location header to make sure it is valid according to RFC
       // https://stackoverflow.com/a/7654605/16587222
@@ -105,70 +117,84 @@ export default async function routingHandler(
       return redirect;
     }
 
-    const eventOrResult = await handleMiddleware(
-      internalEvent,
+    const middlewareEventOrResult = await handleMiddleware(
+      eventOrResult,
       // 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 (isInternalResult(middlewareEventOrResult)) {
+      return middlewareEventOrResult;
     }
-    const middlewareResponseHeaders = eventOrResult.responseHeaders;
-    let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
-    // internalEvent is `InternalEvent | MiddlewareEvent`
-    internalEvent = eventOrResult;
+
+    headers = {
+      ...middlewareEventOrResult.responseHeaders,
+      ...headers,
+    };
+    let isExternalRewrite = middlewareEventOrResult.isExternalRewrite ?? false;
+    eventOrResult = middlewareEventOrResult;
 
     if (!isExternalRewrite) {
       // First rewrite to be applied
-      const beforeRewrites = handleRewrites(
-        internalEvent,
+      const beforeRewrite = handleRewrites(
+        eventOrResult,
         RoutesManifest.rewrites.beforeFiles,
       );
-      internalEvent = beforeRewrites.internalEvent;
-      isExternalRewrite = beforeRewrites.isExternalRewrite;
+      eventOrResult = beforeRewrite.internalEvent;
+      isExternalRewrite = beforeRewrite.isExternalRewrite;
+      // Check for matching public files after `beforeFiles` rewrites
+      // See:
+      // - https://nextjs.org/docs/app/api-reference/file-conventions/middleware#execution-order
+      // - https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites
+      if (!isExternalRewrite) {
+        const assetResult =
+          await assetResolver?.maybeGetAssetResult?.(eventOrResult);
+        if (assetResult) {
+          applyMiddlewareHeaders(assetResult, headers);
+          return assetResult;
+        }
+      }
     }
-    const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
+    const foundStaticRoute = staticRouteMatcher(eventOrResult.rawPath);
     const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
 
     if (!(isStaticRoute || isExternalRewrite)) {
       // Second rewrite to be applied
-      const afterRewrites = handleRewrites(
-        internalEvent,
+      const afterRewrite = handleRewrites(
+        eventOrResult,
         RoutesManifest.rewrites.afterFiles,
       );
-      internalEvent = afterRewrites.internalEvent;
-      isExternalRewrite = afterRewrites.isExternalRewrite;
+      eventOrResult = afterRewrite.internalEvent;
+      isExternalRewrite = afterRewrite.isExternalRewrite;
     }
 
     let isISR = false;
     // We want to run this just before the dynamic route check
     // We can skip it if its an external rewrite
     if (!isExternalRewrite) {
       const fallbackResult = handleFallbackFalse(
-        internalEvent,
+        eventOrResult,
         PrerenderManifest,
       );
-      internalEvent = fallbackResult.event;
+      eventOrResult = fallbackResult.event;
       isISR = fallbackResult.isISR;
     }
 
-    const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
+    const foundDynamicRoute = dynamicRouteMatcher(eventOrResult.rawPath);
     const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
 
     if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
       // Fallback rewrite to be applied
       const fallbackRewrites = handleRewrites(
-        internalEvent,
+        eventOrResult,
         RoutesManifest.rewrites.fallback,
       );
-      internalEvent = fallbackRewrites.internalEvent;
+      eventOrResult = fallbackRewrites.internalEvent;
       isExternalRewrite = fallbackRewrites.isExternalRewrite;
     }
 
-    const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
+    const isNextImageRoute = eventOrResult.rawPath.startsWith("/_next/image");
 
     const isRouteFoundBeforeAllRewrites =
       isStaticRoute || isDynamicRoute || isExternalRewrite;
@@ -180,16 +206,16 @@ export default async function routingHandler(
         isRouteFoundBeforeAllRewrites ||
         isNextImageRoute ||
         // We need to check again once all rewrites have been applied
-        staticRouteMatcher(internalEvent.rawPath).length > 0 ||
-        dynamicRouteMatcher(internalEvent.rawPath).length > 0
+        staticRouteMatcher(eventOrResult.rawPath).length > 0 ||
+        dynamicRouteMatcher(eventOrResult.rawPath).length > 0
       )
     ) {
-      internalEvent = {
-        ...internalEvent,
+      eventOrResult = {
+        ...eventOrResult,
         rawPath: "/404",
-        url: constructNextUrl(internalEvent.url, "/404"),
+        url: constructNextUrl(eventOrResult.url, "/404"),
         headers: {
-          ...internalEvent.headers,
+          ...eventOrResult.headers,
           "x-middleware-response-cache-control":
             "private, no-cache, no-store, max-age=0, must-revalidate",
         },
@@ -198,28 +224,18 @@ export default async function routingHandler(
 
     if (
       globalThis.openNextConfig.dangerous?.enableCacheInterception &&
-      !("statusCode" in internalEvent)
+      !isInternalResult(eventOrResult)
     ) {
       debug("Cache interception enabled");
-      internalEvent = await cacheInterceptor(internalEvent);
-      if ("statusCode" in internalEvent) {
-        applyMiddlewareHeaders(
-          internalEvent.headers,
-          {
-            ...middlewareResponseHeaders,
-            ...nextHeaders,
-          },
-          false,
-        );
-        return internalEvent;
+      eventOrResult = await cacheInterceptor(eventOrResult);
+      if (isInternalResult(eventOrResult)) {
+        applyMiddlewareHeaders(eventOrResult, headers);
+        return eventOrResult;
       }
     }
 
     // We apply the headers from the middleware response last
-    applyMiddlewareHeaders(internalEvent.headers, {
-      ...middlewareResponseHeaders,
-      ...nextHeaders,
-    });
+    applyMiddlewareHeaders(eventOrResult, headers);
 
     const resolvedRoutes: ResolvedRoute[] = [
       ...foundStaticRoute,
@@ -229,14 +245,14 @@ export default async function routingHandler(
     debug("resolvedRoutes", resolvedRoutes);
 
     return {
-      internalEvent,
+      internalEvent: eventOrResult,
       isExternalRewrite,
       origin: false,
       isISR,
       resolvedRoutes,
       initialURL: event.url,
       locale: NextConfig.i18n
-        ? detectLocale(internalEvent, NextConfig.i18n)
+        ? detectLocale(eventOrResult, NextConfig.i18n)
         : undefined,
     };
   } catch (e) {
@@ -266,3 +282,13 @@ export default async function routingHandler(
     };
   }
 }
+
+/**
+ * @param eventOrResult
+ * @returns Whether the event is an instance of `InternalResult`
+ */
+function isInternalResult(
+  eventOrResult: InternalEvent | InternalResult,
+): eventOrResult is InternalResult {
+  return eventOrResult != null && "statusCode" in eventOrResult;
+}