@opennextjs/aws 3.6.6 → 3.7.0

package/dist/adapters/cache.js

@@ -1,4 +1,4 @@
-import { getTagsFromValue, hasBeenRevalidated } from "../utils/cache";
+import { getTagsFromValue, hasBeenRevalidated, writeTags } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
 function isFetchCache(options) {
@@ -246,7 +246,7 @@ export default class Cache {
         try {
             if (globalThis.tagCache.mode === "nextMode") {
                 const paths = (await globalThis.tagCache.getPathsByTags?.(_tags)) ?? [];
-                await globalThis.tagCache.writeTags(_tags);
+                await writeTags(_tags);
                 if (paths.length > 0) {
                     // TODO: we should introduce a new method in cdnInvalidationHandler to invalidate paths by tags for cdn that supports it
                     // It also means that we'll need to provide the tags used in every request to the wrapper or converter.
@@ -291,7 +291,7 @@ export default class Cache {
                     }
                 }
                 // Update all keys with the given tag with revalidatedAt set to now
-                await globalThis.tagCache.writeTags(toInsert);
+                await writeTags(toInsert);
                 // We can now invalidate all paths in the CDN
                 // This only applies to `revalidateTag`, not to `res.revalidate()`
                 const uniquePaths = Array.from(new Set(toInsert
@@ -340,7 +340,7 @@ export default class Cache {
         const storedTags = await globalThis.tagCache.getByPath(key);
         const tagsToWrite = derivedTags.filter((tag) => !storedTags.includes(tag));
         if (tagsToWrite.length > 0) {
-            await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({
+            await writeTags(tagsToWrite.map((tag) => ({
                 path: key,
                 tag: tag,
                 // In case the tags are not there we just need to create them

package/dist/adapters/composable-cache.js

@@ -1,8 +1,15 @@
+import { writeTags } from "../utils/cache";
 import { fromReadableStream, toReadableStream } from "../utils/stream";
 import { debug } from "./logger";
+const pendingWritePromiseMap = new Map();
 export default {
     async get(cacheKey) {
         try {
+            // We first check if we have a pending write for this cache key
+            // If we do, we return the pending promise instead of fetching the cache
+            if (pendingWritePromiseMap.has(cacheKey)) {
+                return pendingWritePromiseMap.get(cacheKey);
+            }
             const result = await globalThis.incrementalCache.get(cacheKey, "composable");
             if (!result?.value?.value) {
                 return undefined;
@@ -32,7 +39,10 @@ export default {
         }
     },
     async set(cacheKey, pendingEntry) {
-        const entry = await pendingEntry;
+        pendingWritePromiseMap.set(cacheKey, pendingEntry);
+        const entry = await pendingEntry.finally(() => {
+            pendingWritePromiseMap.delete(cacheKey);
+        });
         const valueToStore = await fromReadableStream(entry.value);
         await globalThis.incrementalCache.set(cacheKey, {
             ...entry,
@@ -42,7 +52,7 @@ export default {
             const storedTags = await globalThis.tagCache.getByPath(cacheKey);
             const tagsToWrite = entry.tags.filter((tag) => !storedTags.includes(tag));
             if (tagsToWrite.length > 0) {
-                await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({ tag, path: cacheKey })));
+                await writeTags(tagsToWrite.map((tag) => ({ tag, path: cacheKey })));
             }
         }
     },
@@ -60,7 +70,7 @@ export default {
     },
     async expireTags(...tags) {
         if (globalThis.tagCache.mode === "nextMode") {
-            return globalThis.tagCache.writeTags(tags);
+            return writeTags(tags);
         }
         const tagCache = globalThis.tagCache;
         const revalidatedAt = Date.now();
@@ -79,7 +89,7 @@ export default {
         for (const entry of pathsToUpdate.flat()) {
             setToWrite.add(entry);
         }
-        await globalThis.tagCache.writeTags(Array.from(setToWrite));
+        await writeTags(Array.from(setToWrite));
     },
     // This one is necessary for older versions of next
     async receiveExpiredTags(...tags) {

package/dist/adapters/edge-adapter.js

@@ -4,11 +4,15 @@ import { emptyReadableStream } from "../utils/stream";
 import { NextConfig } from "../adapters/config";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { convertBodyToReadableStream } from "../core/routing/util";
+import { INTERNAL_EVENT_REQUEST_ID } from "../core/routingHandler";
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent, options) => {
     globalThis.isEdgeRuntime = true;
+    const requestId = globalThis.openNextConfig.middleware?.external
+        ? internalEvent.headers[INTERNAL_EVENT_REQUEST_ID]
+        : Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in edge runtime functions
-    return runWithOpenNextRequestContext({ isISRRevalidation: false, waitUntil: options?.waitUntil }, async () => {
+    return runWithOpenNextRequestContext({ isISRRevalidation: false, waitUntil: options?.waitUntil, requestId }, async () => {
         // @ts-expect-error - This is bundled
         const handler = await import("./middleware.mjs");
         const response = await handler.default({

package/dist/adapters/middleware.js

@@ -1,25 +1,29 @@
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
-import { resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
+import { resolveAssetResolver, resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
 import { constructNextUrl } from "../core/routing/util";
-import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
+import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent, options) => {
-    const originResolver = await resolveOriginResolver(globalThis.openNextConfig.middleware?.originResolver);
-    const externalRequestProxy = await resolveProxyRequest(globalThis.openNextConfig.middleware?.override?.proxyExternalRequest);
+    const config = globalThis.openNextConfig.middleware;
+    const originResolver = await resolveOriginResolver(config?.originResolver);
+    const externalRequestProxy = await resolveProxyRequest(config?.override?.proxyExternalRequest);
+    const assetResolver = await resolveAssetResolver(config?.assetResolver);
     //#override includeCacheInMiddleware
-    globalThis.tagCache = await resolveTagCache(globalThis.openNextConfig.middleware?.override?.tagCache);
-    globalThis.queue = await resolveQueue(globalThis.openNextConfig.middleware?.override?.queue);
-    globalThis.incrementalCache = await resolveIncrementalCache(globalThis.openNextConfig.middleware?.override?.incrementalCache);
+    globalThis.tagCache = await resolveTagCache(config?.override?.tagCache);
+    globalThis.queue = await resolveQueue(config?.override?.queue);
+    globalThis.incrementalCache = await resolveIncrementalCache(config?.override?.incrementalCache);
     //#endOverride
+    const requestId = Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the external middleware
     return runWithOpenNextRequestContext({
         isISRRevalidation: internalEvent.headers["x-isr"] === "1",
         waitUntil: options?.waitUntil,
+        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) {
@@ -32,6 +36,7 @@ const defaultHandler = async (internalEvent, options) => {
                             ...result.internalEvent.headers,
                             [INTERNAL_HEADER_INITIAL_URL]: internalEvent.url,
                             [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes),
+                            [INTERNAL_EVENT_REQUEST_ID]: requestId,
                         },
                     },
                     isExternalRewrite: result.isExternalRewrite,
@@ -50,6 +55,10 @@ const defaultHandler = async (internalEvent, options) => {
                     type: "middleware",
                     internalEvent: {
                         ...result.internalEvent,
+                        headers: {
+                            ...result.internalEvent.headers,
+                            [INTERNAL_EVENT_REQUEST_ID]: requestId,
+                        },
                         rawPath: "/500",
                         url: constructNextUrl(result.internalEvent.url, "/500"),
                         method: "GET",
@@ -63,6 +72,7 @@ const defaultHandler = async (internalEvent, options) => {
                 };
             }
         }
+        result.headers[INTERNAL_EVENT_REQUEST_ID] = requestId;
         debug("Middleware response", result);
         return result;
     });

package/dist/core/createMainHandler.js

@@ -1,7 +1,7 @@
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
 import { openNextHandler } from "./requestHandler";
-import { resolveCdnInvalidation, resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+import { resolveAssetResolver, resolveCdnInvalidation, resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
 export async function createMainHandler() {
     // @ts-expect-error `./open-next.config.mjs` exists only in the build output
     const config = await import("./open-next.config.mjs").then((m) => m.default);
@@ -16,6 +16,9 @@ export async function createMainHandler() {
     globalThis.queue = await resolveQueue(thisFunction.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     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);
     globalThis.cdnInvalidationHandler = await resolveCdnInvalidation(thisFunction.override?.cdnInvalidation);
     // From the config, we create the converter

package/dist/core/requestHandler.js

@@ -5,7 +5,7 @@ import { NextConfig } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
-import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
+import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
@@ -14,10 +14,17 @@ patchAsyncStorage();
 //#endOverride
 export async function openNextHandler(internalEvent, options) {
     const initialHeaders = internalEvent.headers;
+    // We only use the requestId header if we are using an external middleware
+    // This is to ensure that no one can spoof the requestId
+    // When using an external middleware, we always assume that headers cannot be spoofed
+    const requestId = globalThis.openNextConfig.middleware?.external
+        ? internalEvent.headers[INTERNAL_EVENT_REQUEST_ID]
+        : Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
     return runWithOpenNextRequestContext({
         isISRRevalidation: initialHeaders["x-isr"] === "1",
         waitUntil: options?.waitUntil,
+        requestId,
     }, async () => {
         await globalThis.__next_route_preloader("waitUntil");
         if (initialHeaders["x-forwarded-host"]) {
@@ -40,7 +47,9 @@ export async function openNextHandler(internalEvent, options) {
             ...internalHeaders,
         };
         //#override withRouting
-        routingResult = await routingHandler(internalEvent);
+        routingResult = await routingHandler(internalEvent, {
+            assetResolver: globalThis.assetResolver,
+        });
         //#endOverride
         const headers = "type" in routingResult
             ? routingResult.headers

package/dist/core/resolve.d.ts

@@ -35,6 +35,11 @@ export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNext
  * @__PURE__
  */
 export declare function resolveOriginResolver(originResolver: RemoveUndefined<OpenNextConfig["middleware"]>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
+/**
+ * @returns
+ * @__PURE__
+ */
+export declare function resolveAssetResolver(assetResolver: RemoveUndefined<OpenNextConfig["middleware"]>["assetResolver"]): Promise<import("../types/overrides").AssetResolver>;
 /**
  * @__PURE__
  */

package/dist/core/resolve.js

@@ -78,6 +78,17 @@ export async function resolveOriginResolver(originResolver) {
     const m_1 = await import("../overrides/originResolver/pattern-env.js");
     return m_1.default;
 }
+/**
+ * @returns
+ * @__PURE__
+ */
+export async function resolveAssetResolver(assetResolver) {
+    if (typeof assetResolver === "function") {
+        return assetResolver();
+    }
+    const m_1 = await import("../overrides/assetResolver/dummy.js");
+    return m_1.default;
+}
 /**
  * @__PURE__
  */

package/dist/core/routing/cacheInterceptor.js

@@ -7,6 +7,16 @@ import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";
 const CACHE_ONE_YEAR = 60 * 60 * 24 * 365;
 const CACHE_ONE_MONTH = 60 * 60 * 24 * 30;
+/*
+ * We use this header to prevent Firefox (and possibly some CDNs) from incorrectly reusing the RSC responses during caching.
+ * This can especially happen when there's a redirect in the middleware as the `_rsc` query parameter is not visible there.
+ * So it will get dropped during the redirect, which results in the RSC response being cached instead of the actual HTML on the path `/`.
+ * This value can be found in the routes manifest, under `rsc.varyHeader`.
+ * They recompute it here in Next:
+ * https://github.com/vercel/next.js/blob/c5bf5bb4c8b01b1befbbfa7ad97a97476ee9d0d7/packages/next/src/server/base-server.ts#L2011
+ * Also see this PR: https://github.com/vercel/next.js/pull/79426
+ */
+const VARY_HEADER = "RSC, Next-Router-State-Tree, Next-Router-Prefetch, Next-Router-Segment-Prefetch, Next-Url";
 async function computeCacheControl(path, body, host, revalidate, lastModified) {
     let finalRevalidate = CACHE_ONE_YEAR;
     const existingRoute = Object.entries(PrerenderManifest.routes).find((p) => p[0] === path)?.[1];
@@ -100,6 +110,7 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
             ...cacheControl,
             "content-type": type,
             ...cachedValue.meta?.headers,
+            vary: VARY_HEADER,
         },
     };
 }

package/dist/core/routing/matcher.d.ts

@@ -1,6 +1,11 @@
 import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
 import type { InternalEvent, InternalResult } from "../../types/open-next";
 export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
+/**
+ * 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 declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {
         query: Record<string, string | string[]>;

package/dist/core/routing/matcher.js

@@ -97,6 +97,11 @@ export function getNextConfigHeaders(event, configHeaders) {
     }
     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(event, rewrites) {
     const { rawPath, headers, query, cookies, url } = event;
     const localizedRawPath = localizePath(event);

package/dist/core/routing/util.js

@@ -233,6 +233,8 @@ export function addOpenNextHeader(headers) {
     }
     if (globalThis.openNextDebug) {
         headers["X-OpenNext-Version"] = globalThis.openNextVersion;
+    }
+    if (process.env.OPEN_NEXT_REQUEST_ID_HEADER || globalThis.openNextDebug) {
         headers["X-OpenNext-RequestId"] =
             globalThis.__openNextAls.getStore()?.requestId;
     }

package/dist/core/routingHandler.d.ts

@@ -1,8 +1,12 @@
 import type { InternalEvent, InternalResult, RoutingResult } from "../types/open-next";
+import type { AssetResolver } from "../types/overrides";
 export declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export declare const MIDDLEWARE_HEADER_PREFIX_LEN: number;
 export declare const INTERNAL_HEADER_PREFIX = "x-opennext-";
 export declare const INTERNAL_HEADER_INITIAL_URL = "x-opennext-initial-url";
 export declare const INTERNAL_HEADER_LOCALE = "x-opennext-locale";
 export declare const INTERNAL_HEADER_RESOLVED_ROUTES = "x-opennext-resolved-routes";
-export default function routingHandler(event: InternalEvent): Promise<InternalResult | RoutingResult>;
+export declare const INTERNAL_EVENT_REQUEST_ID = "x-opennext-request-id";
+export default function routingHandler(event: InternalEvent, { assetResolver }: {
+    assetResolver?: AssetResolver;
+}): Promise<InternalResult | RoutingResult>;

package/dist/core/routingHandler.js

@@ -12,6 +12,7 @@ export const INTERNAL_HEADER_PREFIX = "x-opennext-";
 export const INTERNAL_HEADER_INITIAL_URL = `${INTERNAL_HEADER_PREFIX}initial-url`;
 export const INTERNAL_HEADER_LOCALE = `${INTERNAL_HEADER_PREFIX}locale`;
 export const INTERNAL_HEADER_RESOLVED_ROUTES = `${INTERNAL_HEADER_PREFIX}resolved-routes`;
+export const INTERNAL_EVENT_REQUEST_ID = `${INTERNAL_HEADER_PREFIX}request-id`;
 // Geolocation headers starting from Nextjs 15
 // See https://github.com/vercel/vercel/blob/7714b1c/packages/functions/src/headers.ts
 const geoHeaderToNextHeader = {
@@ -21,17 +22,25 @@ const geoHeaderToNextHeader = {
     "x-open-next-latitude": "x-vercel-ip-latitude",
     "x-open-next-longitude": "x-vercel-ip-longitude",
 };
-function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = true) {
-    const keyPrefix = setPrefix ? MIDDLEWARE_HEADER_PREFIX : "";
+/**
+ * Adds the middleware headers to an event or result.
+ *
+ * @param eventOrResult
+ * @param middlewareHeaders
+ */
+function applyMiddlewareHeaders(eventOrResult, middlewareHeaders) {
+    // 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) {
+export default async function routingHandler(event, { assetResolver }) {
     try {
         // Add Next geo headers
         for (const [openNextGeoName, nextGeoName] of Object.entries(geoHeaderToNextHeader)) {
@@ -48,12 +57,13 @@ export default async function routingHandler(event) {
                 delete event.headers[key];
             }
         }
-        const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
-        let internalEvent = fixDataPage(event, BuildId);
-        if ("statusCode" in internalEvent) {
-            return internalEvent;
+        // Headers from the Next config and middleware (the later are applied further down).
+        let headers = getNextConfigHeaders(event, ConfigHeaders);
+        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
@@ -61,99 +71,105 @@ export default async function routingHandler(event) {
             debug("redirect", redirect);
             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, RoutesManifest.rewrites.beforeFiles);
-            internalEvent = beforeRewrites.internalEvent;
-            isExternalRewrite = beforeRewrites.isExternalRewrite;
+            const beforeRewrite = handleRewrites(eventOrResult, RoutesManifest.rewrites.beforeFiles);
+            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, RoutesManifest.rewrites.afterFiles);
-            internalEvent = afterRewrites.internalEvent;
-            isExternalRewrite = afterRewrites.isExternalRewrite;
+            const afterRewrite = handleRewrites(eventOrResult, RoutesManifest.rewrites.afterFiles);
+            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, PrerenderManifest);
-            internalEvent = fallbackResult.event;
+            const fallbackResult = handleFallbackFalse(eventOrResult, PrerenderManifest);
+            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, RoutesManifest.rewrites.fallback);
-            internalEvent = fallbackRewrites.internalEvent;
+            const fallbackRewrites = handleRewrites(eventOrResult, RoutesManifest.rewrites.fallback);
+            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;
         // If we still haven't found a route, we show the 404 page
         // We need to ensure that rewrites are applied before showing the 404 page
         if (!(isRouteFoundBeforeAllRewrites ||
             isNextImageRoute ||
             // We need to check again once all rewrites have been applied
-            staticRouteMatcher(internalEvent.rawPath).length > 0 ||
-            dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
-            internalEvent = {
-                ...internalEvent,
+            staticRouteMatcher(eventOrResult.rawPath).length > 0 ||
+            dynamicRouteMatcher(eventOrResult.rawPath).length > 0)) {
+            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",
                 },
             };
         }
         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 = [
             ...foundStaticRoute,
             ...foundDynamicRoute,
         ];
         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,
         };
     }
@@ -184,3 +200,10 @@ export default async function routingHandler(event) {
         };
     }
 }
+/**
+ * @param eventOrResult
+ * @returns Whether the event is an instance of `InternalResult`
+ */
+function isInternalResult(eventOrResult) {
+    return eventOrResult != null && "statusCode" in eventOrResult;
+}

package/dist/overrides/assetResolver/dummy.d.ts

@@ -0,0 +1,8 @@
+import type { AssetResolver } from "../../types/overrides";
+/**
+ * A dummy asset resolver.
+ *
+ * It never overrides the result with an asset.
+ */
+declare const resolver: AssetResolver;
+export default resolver;

package/dist/overrides/assetResolver/dummy.js

@@ -0,0 +1,9 @@
+/**
+ * A dummy asset resolver.
+ *
+ * It never overrides the result with an asset.
+ */
+const resolver = {
+    name: "dummy",
+};
+export default resolver;

package/dist/types/global.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncLocalStorage } from "node:async_hooks";
 import type { OutgoingHttpHeaders } from "node:http";
-import type { CDNInvalidationHandler, IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
+import type { AssetResolver, CDNInvalidationHandler, IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
 import type { DetachedPromiseRunner } from "../utils/promise";
 import type { OpenNextConfig, WaitUntil } from "./open-next";
 export interface RequestData {
@@ -53,6 +53,8 @@ interface OpenNextRequestContext {
     mergeHeadersPriority?: "middleware" | "handler";
     lastModified?: number;
     waitUntil?: WaitUntil;
+    /** We use this to deduplicate write of the tags*/
+    writtenTags: Set<string>;
 }
 declare global {
     /**
@@ -179,6 +181,12 @@ declare global {
      * Defined in `createMainHandler`
      */
     var cdnInvalidationHandler: CDNInvalidationHandler;
+    /**
+     * The function called to resolve assets.
+     * Available in main functions
+     * Defined in `createMainHandler` when the middleware is internal
+     */
+    var assetResolver: AssetResolver | undefined;
     /**
      * A function to preload the routes.
      * This needs to be defined on globalThis because it can be used by custom overrides.

package/dist/types/open-next.d.ts

@@ -1,7 +1,7 @@
 import type { ReadableStream } from "node:stream/web";
 import type { Writable } from "node:stream";
 import type { WarmerEvent, WarmerResponse } from "../adapters/warmer-function";
-import type { CDNInvalidationHandler, Converter, ImageLoader, IncrementalCache, OriginResolver, ProxyExternalRequest, Queue, TagCache, Warmer, Wrapper } from "./overrides";
+import type { AssetResolver, CDNInvalidationHandler, Converter, ImageLoader, IncrementalCache, OriginResolver, ProxyExternalRequest, Queue, TagCache, Warmer, Wrapper } from "./overrides";
 export type BaseEventOrResult<T extends string = string> = {
     type: T;
 };
@@ -103,6 +103,7 @@ export type IncludedOriginResolver = "pattern-env" | "dummy";
 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> {
     /**
      * This is the main entrypoint of your app.
@@ -273,6 +274,12 @@ export interface OpenNextConfig {
          * @default "pattern-env"
          */
         originResolver?: IncludedOriginResolver | LazyLoadedOverride<OriginResolver>;
+        /**
+         * The assetResolver is used to resolve assets in the routing layer.
+         *
+         * @default "dummy"
+         */
+        assetResolver?: IncludedAssetResolver | LazyLoadedOverride<AssetResolver>;
     };
     /**
      * Override the default warmer

package/dist/types/overrides.d.ts

@@ -15,6 +15,19 @@ export interface Queue {
     send(message: QueueMessage): Promise<void>;
     name: string;
 }
+/**
+ * Resolves assets in the routing layer.
+ */
+export interface AssetResolver {
+    name: string;
+    /**
+     * Called by the routing layer to check for a matching static asset.
+     *
+     * @param event
+     * @returns an `InternalResult` when an asset is found a the path from the event, undefined otherwise.
+     */
+    maybeGetAssetResult?: (event: InternalEvent) => Promise<InternalResult | undefined> | undefined;
+}
 export type CachedFile = {
     type: "redirect";
     props?: Object;
@@ -95,6 +108,11 @@ export type NextModeTagCache = BaseTagCache & {
     writeTags(tags: string[]): Promise<void>;
     getPathsByTags?: (tags: string[]) => Promise<string[]>;
 };
+export interface OriginalTagCacheWriteInput {
+    tag: string;
+    path: string;
+    revalidatedAt?: number;
+}
 /**
  * On get :
 We just check for the cache key in the tag cache. If it has been revalidated we just return null, otherwise we continue
@@ -119,11 +137,7 @@ export type OriginalTagCache = BaseTagCache & {
     getByTag(tag: string): Promise<string[]>;
     getByPath(path: string): Promise<string[]>;
     getLastModified(path: string, lastModified?: number): Promise<number>;
-    writeTags(tags: {
-        tag: string;
-        path: string;
-        revalidatedAt?: number;
-    }[]): Promise<void>;
+    writeTags(tags: OriginalTagCacheWriteInput[]): Promise<void>;
 };
 export type TagCache = NextModeTagCache | OriginalTagCache;
 export type WrapperHandler<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = (handler: OpenNextHandler<E, R>, converter: Converter<E, R>) => Promise<(...args: any[]) => any>;

package/dist/utils/cache.d.ts

@@ -1,3 +1,4 @@
-import type { CacheValue, WithLastModified } from "../types/overrides";
+import type { CacheValue, OriginalTagCacheWriteInput, WithLastModified } from "../types/overrides";
 export declare function hasBeenRevalidated(key: string, tags: string[], cacheEntry: WithLastModified<CacheValue<any>>): Promise<boolean>;
 export declare function getTagsFromValue(value?: CacheValue<"cache">): string[];
+export declare function writeTags(tags: (string | OriginalTagCacheWriteInput)[]): Promise<void>;

package/dist/utils/cache.js

@@ -1,3 +1,4 @@
+import { debug } from "../adapters/logger";
 export async function hasBeenRevalidated(key, tags, cacheEntry) {
     if (globalThis.openNextConfig.dangerous?.disableTagCache) {
         return false;
@@ -30,3 +31,34 @@ export function getTagsFromValue(value) {
         return [];
     }
 }
+function getTagKey(tag) {
+    if (typeof tag === "string") {
+        return tag;
+    }
+    return JSON.stringify({
+        tag: tag.tag,
+        path: tag.path,
+    });
+}
+export async function writeTags(tags) {
+    const store = globalThis.__openNextAls.getStore();
+    debug("Writing tags", tags, store);
+    if (!store || globalThis.openNextConfig.dangerous?.disableTagCache) {
+        return;
+    }
+    const tagsToWrite = tags.filter((t) => {
+        const tagKey = getTagKey(t);
+        const shouldWrite = !store.writtenTags.has(tagKey);
+        // We preemptively add the tag to the writtenTags set
+        // to avoid writing the same tag multiple times in the same request
+        if (shouldWrite) {
+            store.writtenTags.add(tagKey);
+        }
+        return shouldWrite;
+    });
+    if (tagsToWrite.length === 0) {
+        return;
+    }
+    // Here we know that we have the correct type
+    await globalThis.tagCache.writeTags(tagsToWrite);
+}

package/dist/utils/promise.d.ts

@@ -17,7 +17,8 @@ export declare class DetachedPromiseRunner {
     add<T>(promise: Promise<T>): void;
     await(): Promise<void>;
 }
-export declare function runWithOpenNextRequestContext<T>({ isISRRevalidation, waitUntil, }: {
+export declare function runWithOpenNextRequestContext<T>({ isISRRevalidation, waitUntil, requestId, }: {
     isISRRevalidation: boolean;
     waitUntil?: WaitUntil;
+    requestId?: string;
 }, fn: () => Promise<T>): Promise<T>;

package/dist/utils/promise.js

@@ -77,12 +77,13 @@ function provideNextAfterProvider() {
         globalThis[VERCEL_REQUEST_CONTEXT_SYMBOL] = nextAfterContext;
     }
 }
-export function runWithOpenNextRequestContext({ isISRRevalidation, waitUntil, }, fn) {
+export function runWithOpenNextRequestContext({ isISRRevalidation, waitUntil, requestId = Math.random().toString(36), }, fn) {
     return globalThis.__openNextAls.run({
-        requestId: Math.random().toString(36),
+        requestId,
         pendingPromiseRunner: new DetachedPromiseRunner(),
         isISRRevalidation,
         waitUntil,
+        writtenTags: new Set(),
     }, async () => {
         provideNextAfterProvider();
         let result;

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.6.6",
+  "version": "3.7.0",
   "bin": {
     "open-next": "./dist/index.js"
   },