@opennextjs/aws 3.6.5 → 3.7.0

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];
@@ -92,13 +102,15 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
-        statusCode: 200,
+        // sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
+        statusCode: cachedValue.meta?.status ?? 200,
         body: toReadableStream(body, false),
         isBase64Encoded: false,
         headers: {
             ...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);
@@ -259,7 +264,8 @@ export function handleRedirects(event, redirects) {
 }
 export function fixDataPage(internalEvent, buildId) {
     const { rawPath, query } = internalEvent;
-    const dataPattern = `${NextConfig.basePath ?? ""}/_next/data/${buildId}`;
+    const basePath = NextConfig.basePath ?? "";
+    const dataPattern = `${basePath}/_next/data/${buildId}`;
     // Return 404 for data requests that don't match the buildId
     if (rawPath.startsWith("/_next/data") && !rawPath.startsWith(dataPattern)) {
         return {
@@ -273,9 +279,9 @@ export function fixDataPage(internalEvent, buildId) {
         };
     }
     if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
-        const newPath = rawPath
+        const newPath = `${basePath}${rawPath
             .slice(dataPattern.length, -".json".length)
-            .replace(/^\/index$/, "/");
+            .replace(/^\/index$/, "/")}`;
         query.__nextDataReq = "1";
         return {
             ...internalEvent,

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/overrides/converters/edge.js

@@ -2,6 +2,8 @@ import { Buffer } from "node:buffer";
 import cookieParser from "cookie";
 import { parseSetCookieHeader } from "../../http/util";
 import { getQueryFromSearchParams } from "./utils.js";
+// https://fetch.spec.whatwg.org/#statuses
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
 const converter = {
     convertFrom: async (event) => {
         const url = new URL(event.url);
@@ -77,7 +79,11 @@ const converter = {
                 headers.set(key, value);
             }
         }
-        return new Response(result.body, {
+        // We should not return a body for statusCode's that doesn't allow bodies
+        const body = NULL_BODY_STATUSES.has(result.statusCode)
+            ? null
+            : result.body;
+        return new Response(body, {
             status: result.statusCode,
             headers,
         });

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/next-types.d.ts

@@ -72,10 +72,12 @@ export interface NextConfig {
     experimental: {
         serverActions?: boolean;
         appDir?: boolean;
+        optimizeCss?: boolean;
     };
     images: ImageConfig;
     poweredByHeader?: boolean;
     serverExternalPackages?: string[];
+    deploymentId?: string;
 }
 export interface RouteDefinition {
     page: string;

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.5",
+  "version": "3.7.0",
   "bin": {
     "open-next": "./dist/index.js"
   },

package/dist/build/patch/patches/dropBabel.d.ts

@@ -1,20 +0,0 @@
-/**
- * Patches to avoid pulling babel (~4MB).
- *
- * Details:
- * - empty `NextServer#runMiddleware` and `NextServer#runEdgeFunction` that are not used
- * - drop `next/dist/server/node-environment-extensions/error-inspect.js`
- */
-import type { CodePatcher } from "../codePatcher.js";
-export declare const patchDropBabel: CodePatcher;
-/**
- * Swaps the body for a throwing implementation
- *
- * @param methodName The name of the method
- * @returns A rule to replace the body with a `throw`
- */
-export declare function createEmptyBodyRule(methodName: string): string;
-/**
- * Drops `require("./node-environment-extensions/error-inspect");`
- */
-export declare const errorInspectRule = "\nrule:\n  pattern: require(\"./node-environment-extensions/error-inspect\");\nfix: |-\n  // Removed by OpenNext\n  // require(\"./node-environment-extensions/error-inspect\");\n";