@opennextjs/aws 3.5.8 → 3.6.1

package/dist/adapters/cache.d.ts

@@ -12,4 +12,5 @@ export default class Cache {
     set(key: string, data?: IncrementalCacheValue, ctx?: IncrementalCacheContext): Promise<void>;
     revalidateTag(tags: string | string[]): Promise<void>;
     private updateTagsOnSet;
+    private extractRevalidateForSet;
 }

package/dist/adapters/cache.js

@@ -29,7 +29,7 @@ export default class Cache {
     async getFetchCache(key, softTags, tags) {
         debug("get fetch cache", { key, softTags, tags });
         try {
-            const cachedEntry = await globalThis.incrementalCache.get(key, true);
+            const cachedEntry = await globalThis.incrementalCache.get(key, "fetch");
             if (cachedEntry?.value === undefined)
                 return null;
             const _tags = [...(tags ?? []), ...(softTags ?? [])];
@@ -65,7 +65,7 @@ export default class Cache {
     }
     async getIncrementalCache(key) {
         try {
-            const cachedEntry = await globalThis.incrementalCache.get(key, false);
+            const cachedEntry = await globalThis.incrementalCache.get(key, "cache");
             if (!cachedEntry?.value) {
                 return null;
             }
@@ -150,6 +150,7 @@ export default class Cache {
                 await globalThis.incrementalCache.delete(key);
             }
             else {
+                const revalidate = this.extractRevalidateForSet(ctx);
                 switch (data.kind) {
                     case "ROUTE":
                     case "APP_ROUTE": {
@@ -163,7 +164,8 @@ export default class Cache {
                                 status,
                                 headers,
                             },
-                        }, false);
+                            revalidate,
+                        }, "cache");
                         break;
                     }
                     case "PAGE":
@@ -179,14 +181,16 @@ export default class Cache {
                                     status,
                                     headers,
                                 },
-                            }, false);
+                                revalidate,
+                            }, "cache");
                         }
                         else {
                             await globalThis.incrementalCache.set(key, {
                                 type: "page",
                                 html,
                                 json: pageData,
-                            }, false);
+                                revalidate,
+                            }, "cache");
                         }
                         break;
                     }
@@ -200,17 +204,19 @@ export default class Cache {
                                 status,
                                 headers,
                             },
-                        }, false);
+                            revalidate,
+                        }, "cache");
                         break;
                     }
                     case "FETCH":
-                        await globalThis.incrementalCache.set(key, data, true);
+                        await globalThis.incrementalCache.set(key, data, "fetch");
                         break;
                     case "REDIRECT":
                         await globalThis.incrementalCache.set(key, {
                             type: "redirect",
                             props: data.props,
-                        }, false);
+                            revalidate,
+                        }, "cache");
                         break;
                     case "IMAGE":
                         // Not implemented
@@ -323,7 +329,8 @@ export default class Cache {
         // Write derivedTags to the tag cache
         // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
         const derivedTags = data?.kind === "FETCH"
-            ? (ctx?.tags ?? data?.data?.tags ?? []) // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
+            ? //@ts-expect-error - On older versions of next, ctx was a number, but for these cases we use data?.data?.tags
+                (ctx?.tags ?? data?.data?.tags ?? []) // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
             : data?.kind === "PAGE"
                 ? (data.headers?.["x-next-cache-tags"]?.split(",") ?? [])
                 : [];
@@ -342,4 +349,19 @@ export default class Cache {
             })));
         }
     }
+    extractRevalidateForSet(ctx) {
+        if (ctx === undefined) {
+            return undefined;
+        }
+        if (typeof ctx === "number" || ctx === false) {
+            return ctx;
+        }
+        if ("revalidate" in ctx) {
+            return ctx.revalidate;
+        }
+        if ("cacheControl" in ctx) {
+            return ctx.cacheControl?.revalidate;
+        }
+        return undefined;
+    }
 }

package/dist/adapters/composable-cache.d.ts

@@ -0,0 +1,17 @@
+import type { ComposableCacheEntry } from "../types/cache";
+declare const _default: {
+    get(cacheKey: string): Promise<{
+        value: import("stream/web").ReadableStream<any>;
+        tags: string[];
+        stale: number;
+        timestamp: number;
+        expire: number;
+        revalidate: number;
+    } | undefined>;
+    set(cacheKey: string, pendingEntry: Promise<ComposableCacheEntry>): Promise<void>;
+    refreshTags(): Promise<void>;
+    getExpiration(...tags: string[]): Promise<number>;
+    expireTags(...tags: string[]): Promise<void>;
+    receiveExpiredTags(...tags: string[]): Promise<void>;
+};
+export default _default;

package/dist/adapters/composable-cache.js

@@ -0,0 +1,89 @@
+import { fromReadableStream, toReadableStream } from "../utils/stream";
+import { debug } from "./logger";
+export default {
+    async get(cacheKey) {
+        try {
+            const result = await globalThis.incrementalCache.get(cacheKey, "composable");
+            if (!result?.value?.value) {
+                return undefined;
+            }
+            debug("composable cache result", result);
+            // We need to check if the tags associated with this entry has been revalidated
+            if (globalThis.tagCache.mode === "nextMode" &&
+                result.value.tags.length > 0) {
+                const hasBeenRevalidated = await globalThis.tagCache.hasBeenRevalidated(result.value.tags, result.lastModified);
+                if (hasBeenRevalidated)
+                    return undefined;
+            }
+            else if (globalThis.tagCache.mode === "original" ||
+                globalThis.tagCache.mode === undefined) {
+                const hasBeenRevalidated = (await globalThis.tagCache.getLastModified(cacheKey, result.lastModified)) === -1;
+                if (hasBeenRevalidated)
+                    return undefined;
+            }
+            return {
+                ...result.value,
+                value: toReadableStream(result.value.value),
+            };
+        }
+        catch (e) {
+            debug("Cannot read composable cache entry");
+            return undefined;
+        }
+    },
+    async set(cacheKey, pendingEntry) {
+        const entry = await pendingEntry;
+        const valueToStore = await fromReadableStream(entry.value);
+        await globalThis.incrementalCache.set(cacheKey, {
+            ...entry,
+            value: valueToStore,
+        }, "composable");
+        if (globalThis.tagCache.mode === "original") {
+            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 })));
+            }
+        }
+    },
+    async refreshTags() {
+        // We don't do anything for now, do we want to do something here ???
+        return;
+    },
+    async getExpiration(...tags) {
+        if (globalThis.tagCache.mode === "nextMode") {
+            return globalThis.tagCache.getLastRevalidated(tags);
+        }
+        // We always return 0 here, original tag cache are handled directly in the get part
+        // TODO: We need to test this more, i'm not entirely sure that this is working as expected
+        return 0;
+    },
+    async expireTags(...tags) {
+        if (globalThis.tagCache.mode === "nextMode") {
+            return globalThis.tagCache.writeTags(tags);
+        }
+        const tagCache = globalThis.tagCache;
+        const revalidatedAt = Date.now();
+        // For the original mode, we have more work to do here.
+        // We need to find all paths linked to to these tags
+        const pathsToUpdate = await Promise.all(tags.map(async (tag) => {
+            const paths = await tagCache.getByTag(tag);
+            return paths.map((path) => ({
+                path,
+                tag,
+                revalidatedAt,
+            }));
+        }));
+        // We need to deduplicate paths, we use a set for that
+        const setToWrite = new Set();
+        for (const entry of pathsToUpdate.flat()) {
+            setToWrite.add(entry);
+        }
+        await globalThis.tagCache.writeTags(Array.from(setToWrite));
+    },
+    // This one is necessary for older versions of next
+    async receiveExpiredTags(...tags) {
+        // This function does absolutely nothing
+        return;
+    },
+};

package/dist/build/compileCache.d.ts

@@ -4,6 +4,9 @@ import * as buildHelper from "./helper.js";
  *
  * @param options Build options.
  * @param format Output format.
- * @returns The path to the compiled file.
+ * @returns An object containing the paths to the compiled cache and composable cache files.
  */
-export declare function compileCache(options: buildHelper.BuildOptions, format?: "cjs" | "esm"): string;
+export declare function compileCache(options: buildHelper.BuildOptions, format?: "cjs" | "esm"): {
+    cache: string;
+    composableCache: string;
+};

package/dist/build/compileCache.js

@@ -5,17 +5,18 @@ import * as buildHelper from "./helper.js";
  *
  * @param options Build options.
  * @param format Output format.
- * @returns The path to the compiled file.
+ * @returns An object containing the paths to the compiled cache and composable cache files.
  */
 export function compileCache(options, format = "cjs") {
     const { config } = options;
     const ext = format === "cjs" ? "cjs" : "mjs";
-    const outFile = path.join(options.buildDir, `cache.${ext}`);
+    const compiledCacheFile = path.join(options.buildDir, `cache.${ext}`);
     const isAfter15 = buildHelper.compareSemver(options.nextVersion, ">=", "15.0.0");
+    // Normal cache
     buildHelper.esbuildSync({
         external: ["next", "styled-jsx", "react", "@aws-sdk/*"],
         entryPoints: [path.join(options.openNextDistDir, "adapters", "cache.js")],
-        outfile: outFile,
+        outfile: compiledCacheFile,
         target: ["node18"],
         format,
         banner: {
@@ -26,5 +27,26 @@ export function compileCache(options, format = "cjs") {
             ].join(""),
         },
     }, options);
-    return outFile;
+    const compiledComposableCacheFile = path.join(options.buildDir, `composable-cache.${ext}`);
+    // Composable cache
+    buildHelper.esbuildSync({
+        external: ["next", "styled-jsx", "react", "@aws-sdk/*"],
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "composable-cache.js"),
+        ],
+        outfile: compiledComposableCacheFile,
+        target: ["node18"],
+        format,
+        banner: {
+            js: [
+                `globalThis.disableIncrementalCache = ${config.dangerous?.disableIncrementalCache ?? false};`,
+                `globalThis.disableDynamoDBCache = ${config.dangerous?.disableTagCache ?? false};`,
+                `globalThis.isNextAfter15 = ${isAfter15};`,
+            ].join(""),
+        },
+    }, options);
+    return {
+        cache: compiledCacheFile,
+        composableCache: compiledComposableCacheFile,
+    };
 }

package/dist/build/createServerBundle.js

@@ -14,7 +14,7 @@ import { copyMiddlewareResources, generateEdgeBundle, } from "./edge/createEdgeB
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 import { applyCodePatches } from "./patch/codePatcher.js";
-import { patchBackgroundRevalidation, patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "./patch/patches/index.js";
+import { patchBackgroundRevalidation, patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patch/patches/index.js";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -85,7 +85,10 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const outPackagePath = path.join(outputPath, packagePath);
     fs.mkdirSync(outPackagePath, { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
+    // Normal cache
     fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outPackagePath, "cache.cjs"));
+    // Composable cache
+    fs.copyFileSync(path.join(options.buildDir, `composable-cache.${ext}`), path.join(outPackagePath, "composable-cache.cjs"));
     if (fnOptions.runtime === "deno") {
         addDenoJson(outputPath, packagePath);
     }
@@ -122,6 +125,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchNextServer,
         patchEnvVars,
         patchBackgroundRevalidation,
+        patchUseCacheForISR,
         ...additionalCodePatches,
     ]);
     // Build Lambda code
@@ -134,6 +138,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "<=", "13.4.13");
     const isAfter141 = buildHelper.compareSemver(options.nextVersion, ">=", "14.1");
     const isAfter142 = buildHelper.compareSemver(options.nextVersion, ">=", "14.2");
+    const isAfter152 = buildHelper.compareSemver(options.nextVersion, ">=", "15.2.0");
     const disableRouting = isBefore13413 || config.middleware?.external;
     const updater = new ContentUpdater(options);
     const additionalPlugins = codeCustomization?.additionalPlugins
@@ -159,6 +164,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(isAfter141
                     ? ["experimentalIncrementalCacheHandler"]
                     : ["stableIncrementalCache"]),
+                ...(isAfter152 ? [] : ["composableCache"]),
             ],
         }),
         openNextResolvePlugin({

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

@@ -1,5 +1,5 @@
 export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
 export { patchNextServer } from "./patchNextServer.js";
-export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
+export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";

package/dist/build/patch/patches/index.js

@@ -1,5 +1,5 @@
 export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
 export { patchNextServer } from "./patchNextServer.js";
-export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
+export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";

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

@@ -1,5 +1,7 @@
 import type { CodePatcher } from "../codePatcher.js";
 export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
 export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const useCacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: binary_expression\n    has: \n      kind: member_expression\n      pattern: $STORE_OR_CACHE.isDraftMode\n    inside:\n      kind: if_statement\n      stopBy: end\n      has: \n        kind: return_statement\n        any:\n          - has:\n              kind: 'true'\n          - has:\n              regex: '!0'\n        stopBy: end\nfix:\n  '($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)'";
 export declare const patchFetchCacheForISR: CodePatcher;
 export declare const patchUnstableCacheForISR: CodePatcher;
+export declare const patchUseCacheForISR: CodePatcher;

package/dist/build/patch/patches/patchFetchCacheISR.js

@@ -74,6 +74,28 @@ rule:
 fix:
   ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)
 `;
+export const useCacheRule = `
+rule:
+  kind: member_expression
+  pattern: $STORE_OR_CACHE.isOnDemandRevalidate
+  inside:
+    kind: binary_expression
+    has: 
+      kind: member_expression
+      pattern: $STORE_OR_CACHE.isDraftMode
+    inside:
+      kind: if_statement
+      stopBy: end
+      has: 
+        kind: return_statement
+        any:
+          - has:
+              kind: 'true'
+          - has:
+              regex: '!0'
+        stopBy: end
+fix:
+  '($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)'`;
 export const patchFetchCacheForISR = {
     name: "patch-fetch-cache-for-isr",
     patches: [
@@ -100,3 +122,16 @@ export const patchUnstableCacheForISR = {
         },
     ],
 };
+export const patchUseCacheForISR = {
+    name: "patch-use-cache-for-isr",
+    patches: [
+        {
+            versions: ">=15.3.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|\.runtime\..*\.js|use-cache/use-cache-wrapper\.js)$`, { escape: false }),
+                contentFilter: /\.isOnDemandRevalidate/,
+                patchCode: createPatchCode(useCacheRule, Lang.JavaScript),
+            },
+        },
+    ],
+};

package/dist/core/requestHandler.js

@@ -51,7 +51,11 @@ export async function openNextHandler(internalEvent, options) {
                 continue;
             }
             const key = rawKey.slice(MIDDLEWARE_HEADER_PREFIX_LEN);
-            overwrittenResponseHeaders[key] = value;
+            // We skip this header here since it is used by Next internally and we don't want it on the response headers.
+            // This header needs to be present in the request headers for processRequest, so cookies().get() from Next will work on initial render.
+            if (key !== "x-middleware-set-cookie") {
+                overwrittenResponseHeaders[key] = value;
+            }
             headers[key] = value;
             delete headers[rawKey];
         }
@@ -151,44 +155,68 @@ async function processRequest(req, res, routingResult) {
     // Next.js doesn't parse body if the property exists
     // https://github.com/dougmoscrop/serverless-http/issues/227
     delete req.body;
+    // Here we try to apply as much request metadata as possible
+    // We apply every metadata from `resolve-routes` https://github.com/vercel/next.js/blob/916f105b97211de50f8580f0b39c9e7c60de4886/packages/next/src/server/lib/router-utils/resolve-routes.ts
+    // and `router-server` https://github.com/vercel/next.js/blob/916f105b97211de50f8580f0b39c9e7c60de4886/packages/next/src/server/lib/router-server.ts
+    const initialURL = new URL(routingResult.initialURL);
+    let invokeStatus;
+    if (routingResult.internalEvent.rawPath === "/500") {
+        invokeStatus = 500;
+    }
+    else if (routingResult.internalEvent.rawPath === "/404") {
+        invokeStatus = 404;
+    }
+    const requestMetadata = {
+        isNextDataReq: routingResult.internalEvent.query.__nextDataReq === "1",
+        initURL: routingResult.initialURL,
+        initQuery: convertToQuery(initialURL.search),
+        initProtocol: initialURL.protocol,
+        defaultLocale: NextConfig.i18n?.defaultLocale,
+        locale: routingResult.locale,
+        middlewareInvoke: false,
+        // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
+        invokePath: routingResult.internalEvent.rawPath,
+        invokeQuery: routingResult.internalEvent.query,
+        // invokeStatus is only used for error pages
+        invokeStatus,
+    };
     try {
         //#override applyNextjsPrebundledReact
         setNextjsPrebundledReact(routingResult.internalEvent.rawPath);
         //#endOverride
-        // Here we try to apply as much request metadata as possible
-        // We apply every metadata from `resolve-routes` https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
-        // and `router-server` https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-server.ts
-        const initialURL = new URL(routingResult.initialURL);
-        let invokeStatus;
-        if (routingResult.internalEvent.rawPath === "/500") {
-            invokeStatus = 500;
-        }
-        else if (routingResult.internalEvent.rawPath === "/404") {
-            invokeStatus = 404;
-        }
-        const requestMetadata = {
-            isNextDataReq: routingResult.internalEvent.query.__nextDataReq === "1",
-            initURL: routingResult.initialURL,
-            initQuery: convertToQuery(initialURL.search),
-            initProtocol: initialURL.protocol,
-            defaultLocale: NextConfig.i18n?.defaultLocale,
-            locale: routingResult.locale,
-            middlewareInvoke: false,
-            // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
-            invokePath: routingResult.internalEvent.rawPath,
-            invokeQuery: routingResult.internalEvent.query,
-            // invokeStatus is only used for error pages
-            invokeStatus,
-        };
         // Next Server
         await requestHandler(requestMetadata)(req, res);
     }
     catch (e) {
         // This might fail when using bundled next, importing won't do the trick either
         if (e.constructor.name === "NoFallbackError") {
-            // Do we need to handle _not-found
-            // Ideally this should never get triggered and be intercepted by the routing handler
-            await tryRenderError("404", res, routingResult.internalEvent);
+            await handleNoFallbackError(req, res, routingResult, requestMetadata);
+        }
+        else {
+            error("NextJS request failed.", e);
+            await tryRenderError("500", res, routingResult.internalEvent);
+        }
+    }
+}
+async function handleNoFallbackError(req, res, routingResult, metadata, index = 1) {
+    if (index >= 5) {
+        await tryRenderError("500", res, routingResult.internalEvent);
+        return;
+    }
+    if (index >= routingResult.resolvedRoutes.length) {
+        await tryRenderError("404", res, routingResult.internalEvent);
+        return;
+    }
+    try {
+        await requestHandler({
+            ...routingResult,
+            invokeOutput: routingResult.resolvedRoutes[index].route,
+            ...metadata,
+        })(req, res);
+    }
+    catch (e) {
+        if (e.constructor.name === "NoFallbackError") {
+            await handleNoFallbackError(req, res, routingResult, metadata, index + 1);
         }
         else {
             error("NextJS request failed.", e);

package/dist/core/routing/cacheInterceptor.js

@@ -114,17 +114,13 @@ export async function cacheInterceptor(event) {
     }
     // We also need to remove trailing slash
     localizedPath = localizedPath.replace(/\/$/, "");
-    // If empty path, it means we want index
-    if (localizedPath === "") {
-        localizedPath = "index";
-    }
     debug("Checking cache for", localizedPath, PrerenderManifest);
-    const isISR = Object.keys(PrerenderManifest.routes).includes(localizedPath) ||
+    const isISR = Object.keys(PrerenderManifest.routes).includes(localizedPath ?? "/") ||
         Object.values(PrerenderManifest.dynamicRoutes).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
     debug("isISR", isISR);
     if (isISR) {
         try {
-            const cachedData = await globalThis.incrementalCache.get(localizedPath);
+            const cachedData = await globalThis.incrementalCache.get(localizedPath ?? "/index");
             debug("cached data in interceptor", cachedData);
             if (!cachedData?.value) {
                 return event;

package/dist/core/routing/matcher.js

@@ -3,6 +3,7 @@ import { compile, match } from "path-to-regexp";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { handleLocaleRedirect, localizePath } from "./i18n";
+import { dynamicRouteMatcher, staticRouteMatcher } from "./routeMatcher";
 import { constructNextUrl, convertFromQueryString, convertToQueryString, escapeRegex, getUrlParts, isExternal, unescapeRegex, } from "./util";
 const routeHasMatcher = (headers, cookies, query) => (redirect) => {
     switch (redirect.type) {
@@ -265,9 +266,8 @@ export function fixDataPage(internalEvent, buildId) {
 export function handleFallbackFalse(internalEvent, prerenderManifest) {
     const { rawPath } = internalEvent;
     const { dynamicRoutes, routes } = prerenderManifest;
-    const routeFallback = Object.entries(dynamicRoutes)
-        .filter(([, { fallback }]) => fallback === false)
-        .some(([, { routeRegex }]) => {
+    const prerenderedFallbackRoutes = Object.entries(dynamicRoutes).filter(([, { fallback }]) => fallback === false);
+    const routeFallback = prerenderedFallbackRoutes.some(([, { routeRegex }]) => {
         const routeRegexExp = new RegExp(routeRegex);
         return routeRegexExp.test(rawPath);
     });
@@ -275,11 +275,21 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
     const routesAlreadyHaveLocale = locales?.includes(rawPath.split("/")[1]) ||
         // If we don't use locales, we don't need to add the default locale
         locales === undefined;
-    const localizedPath = routesAlreadyHaveLocale
+    let localizedPath = routesAlreadyHaveLocale
         ? rawPath
         : `/${NextConfig.i18n?.defaultLocale}${rawPath}`;
+    // We need to remove the trailing slash if it exists
+    if (NextConfig.trailingSlash && localizedPath.endsWith("/")) {
+        localizedPath = localizedPath.slice(0, -1);
+    }
+    const matchedStaticRoute = staticRouteMatcher(localizedPath);
+    const prerenderedFallbackRoutesName = prerenderedFallbackRoutes.map(([name]) => name);
+    const matchedDynamicRoute = dynamicRouteMatcher(localizedPath).filter(({ route }) => !prerenderedFallbackRoutesName.includes(route));
     const isPregenerated = Object.keys(routes).includes(localizedPath);
-    if (routeFallback && !isPregenerated) {
+    if (routeFallback &&
+        !isPregenerated &&
+        matchedStaticRoute.length === 0 &&
+        matchedDynamicRoute.length === 0) {
         return {
             event: {
                 ...internalEvent,

package/dist/core/routing/middleware.js

@@ -1,5 +1,6 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
 import { emptyReadableStream } from "../../utils/stream.js";
+import { getQueryFromSearchParams } from "../../overrides/converters/utils.js";
 import { localizePath } from "./i18n/index.js";
 import { convertBodyToReadableStream, getMiddlewareMatch, isExternal, } from "./util.js";
 const middlewareManifest = MiddlewareManifest;
@@ -74,7 +75,6 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     // These are internal headers used by Next.js, we don't want to expose them to the client
     const filteredHeaders = [
         "x-middleware-override-headers",
-        "x-middleware-set-cookie",
         "x-middleware-next",
         "x-middleware-rewrite",
         // We need to drop `content-encoding` because it will be decoded
@@ -103,7 +103,7 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
     let isExternalRewrite = false;
-    let middlewareQueryString = internalEvent.query;
+    let middlewareQuery = internalEvent.query;
     let newUrl = internalEvent.url;
     if (rewriteUrl) {
         newUrl = rewriteUrl;
@@ -113,15 +113,12 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
         }
         else {
             const rewriteUrlObject = new URL(rewriteUrl);
-            // Reset the query params if the middleware is a rewrite
-            middlewareQueryString = middlewareQueryString.__nextDataReq
-                ? {
-                    __nextDataReq: middlewareQueryString.__nextDataReq,
-                }
-                : {};
-            rewriteUrlObject.searchParams.forEach((v, k) => {
-                middlewareQueryString[k] = v;
-            });
+            // Search params from the rewritten URL override the original search params
+            middlewareQuery = getQueryFromSearchParams(rewriteUrlObject.searchParams);
+            // We still need to add internal search params to the query string for pages router on older versions of Next.js
+            if ("__nextDataReq" in internalEvent.query) {
+                middlewareQuery.__nextDataReq = internalEvent.query.__nextDataReq;
+            }
         }
     }
     // If the middleware wants to directly return a response (i.e. not using `NextResponse.next()` or `NextResponse.rewrite()`)
@@ -145,7 +142,7 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
         headers: { ...internalEvent.headers, ...reqHeaders },
         body: internalEvent.body,
         method: internalEvent.method,
-        query: middlewareQueryString,
+        query: middlewareQuery,
         cookies: internalEvent.cookies,
         remoteAddress: internalEvent.remoteAddress,
         isExternalRewrite,

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

@@ -1,10 +1,4 @@
-import type { RouteType } from "../../types/open-next";
+import type { ResolvedRoute } from "../../types/open-next";
 export declare const apiPrefix: string;
-export declare const staticRouteMatcher: (path: string) => {
-    route: string;
-    type: RouteType;
-}[];
-export declare const dynamicRouteMatcher: (path: string) => {
-    route: string;
-    type: RouteType;
-}[];
+export declare const staticRouteMatcher: (path: string) => ResolvedRoute[];
+export declare const dynamicRouteMatcher: (path: string) => ResolvedRoute[];

package/dist/core/util.js

@@ -15,6 +15,7 @@ overrideNextjsRequireHooks(NextConfig);
 applyNextjsRequireHooksOverride();
 //#endOverride
 const cacheHandlerPath = require.resolve("./cache.cjs");
+const composableCacheHandlerPath = require.resolve("./composable-cache.cjs");
 // @ts-ignore
 const nextServer = new NextServer.default({
     //#override requestHandlerHost
@@ -42,6 +43,11 @@ const nextServer = new NextServer.default({
             //#override experimentalIncrementalCacheHandler
             incrementalCacheHandlerPath: cacheHandlerPath,
             //#endOverride
+            //#override composableCache
+            cacheHandlers: {
+                default: composableCacheHandlerPath,
+            },
+            //#endOverride
         },
     },
     customServer: false,

package/dist/overrides/converters/edge.js

@@ -55,7 +55,23 @@ const converter = {
         }
         const headers = new Headers();
         for (const [key, value] of Object.entries(result.headers)) {
-            headers.set(key, Array.isArray(value) ? value.join(",") : value);
+            if (key === "set-cookie" && typeof value === "string") {
+                // If the value is a string, we need to parse it into an array
+                // This is the case for middleware direct result
+                const cookies = parseCookies(value);
+                for (const cookie of cookies) {
+                    headers.append(key, cookie);
+                }
+                continue;
+            }
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    headers.append(key, v);
+                }
+            }
+            else {
+                headers.set(key, value);
+            }
         }
         return new Response(result.body, {
             status: result.statusCode,

package/dist/overrides/imageLoader/fs-dev.js

@@ -1,9 +1,11 @@
 import fs from "node:fs";
+import path from "node:path";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
 export default {
     name: "fs-dev",
     load: async (url) => {
-        const basePath = "../../assets";
-        const body = fs.createReadStream(`${basePath}/${url}`);
+        const imagePath = path.join(getMonorepoRelativePath(), "assets", url);
+        const body = fs.createReadStream(imagePath);
         const contentType = url.endsWith(".png") ? "image/png" : "image/jpeg";
         return {
             body,

package/dist/overrides/incrementalCache/fs-dev.js

@@ -1,7 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const buildId = process.env.NEXT_BUILD_ID;
-const basePath = path.resolve(process.cwd(), `../../cache/${buildId}`);
+const basePath = path.join(getMonorepoRelativePath(), `cache/${buildId}`);
 const getCacheKey = (key) => {
     return path.join(basePath, `${key}.cache`);
 };

package/dist/overrides/incrementalCache/s3-lite.js

@@ -30,8 +30,8 @@ function buildS3Key(key, extension) {
     return path.posix.join(CACHE_BUCKET_KEY_PREFIX ?? "", extension === "fetch" ? "__fetch" : "", NEXT_BUILD_ID ?? "", extension === "fetch" ? key : `${key}.${extension}`);
 }
 const incrementalCache = {
-    async get(key, isFetch) {
-        const result = await awsFetch(buildS3Key(key, isFetch ? "fetch" : "cache"), {
+    async get(key, cacheType) {
+        const result = await awsFetch(buildS3Key(key, cacheType ?? "cache"), {
             method: "GET",
         });
         if (result.status === 404) {
@@ -46,8 +46,8 @@ const incrementalCache = {
             lastModified: new Date(result.headers.get("last-modified") ?? "").getTime(),
         };
     },
-    async set(key, value, isFetch) {
-        const response = await awsFetch(buildS3Key(key, isFetch ? "fetch" : "cache"), {
+    async set(key, value, cacheType) {
+        const response = await awsFetch(buildS3Key(key, cacheType ?? "cache"), {
             method: "PUT",
             body: JSON.stringify(value),
         });

package/dist/overrides/incrementalCache/s3.js

@@ -15,10 +15,10 @@ function buildS3Key(key, extension) {
     return path.posix.join(CACHE_BUCKET_KEY_PREFIX ?? "", extension === "fetch" ? "__fetch" : "", NEXT_BUILD_ID ?? "", extension === "fetch" ? key : `${key}.${extension}`);
 }
 const incrementalCache = {
-    async get(key, isFetch) {
+    async get(key, cacheType) {
         const result = await s3Client.send(new GetObjectCommand({
             Bucket: CACHE_BUCKET_NAME,
-            Key: buildS3Key(key, isFetch ? "fetch" : "cache"),
+            Key: buildS3Key(key, cacheType ?? "cache"),
         }));
         const cacheData = JSON.parse((await result.Body?.transformToString()) ?? "{}");
         return {
@@ -26,10 +26,10 @@ const incrementalCache = {
             lastModified: result.LastModified?.getTime(),
         };
     },
-    async set(key, value, isFetch) {
+    async set(key, value, cacheType) {
         await s3Client.send(new PutObjectCommand({
             Bucket: CACHE_BUCKET_NAME,
-            Key: buildS3Key(key, isFetch ? "fetch" : "cache"),
+            Key: buildS3Key(key, cacheType ?? "cache"),
             Body: JSON.stringify(value),
         }));
     },

package/dist/overrides/tagCache/dynamodb-nextMode.d.ts

@@ -1,6 +1,7 @@
 declare const _default: {
     name: string;
     mode: "nextMode";
+    getLastRevalidated: (tags: string[]) => Promise<number>;
     hasBeenRevalidated: (tags: string[], lastModified?: number) => Promise<boolean>;
     writeTags: (tags: string[]) => Promise<void>;
 };

package/dist/overrides/tagCache/dynamodb-nextMode.js

@@ -52,6 +52,10 @@ function buildDynamoObject(tag, revalidatedAt) {
 export default {
     name: "ddb-nextMode",
     mode: "nextMode",
+    getLastRevalidated: async (tags) => {
+        // Not supported for now
+        return 0;
+    },
     hasBeenRevalidated: async (tags, lastModified) => {
         if (globalThis.openNextConfig.dangerous?.disableTagCache) {
             return false;

package/dist/overrides/tagCache/fs-dev.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
-const tagFile = "../../dynamodb-provider/dynamodb-cache.json";
+import path from "node:path";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
+const tagFile = path.join(getMonorepoRelativePath(), "dynamodb-provider/dynamodb-cache.json");
 const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
 const tagCache = {
@@ -26,7 +28,7 @@ const tagCache = {
         tags = unchangedTags.concat(newTags.map((tag) => ({
             tag: { S: tag.tag },
             path: { S: tag.path },
-            revalidatedAt: { N: String(tag.revalidatedAt) },
+            revalidatedAt: { N: String(tag.revalidatedAt ?? 1) },
         })));
     },
 };

package/dist/overrides/wrappers/express-dev.js

@@ -1,9 +1,11 @@
+import path from "node:path";
 import express from "express";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const wrapper = async (handler, converter) => {
     const app = express();
     // To serve static assets
-    app.use(express.static("../../assets"));
-    const imageHandlerPath = "../../image-optimization-function/index.mjs";
+    app.use(express.static(path.join(getMonorepoRelativePath(), "assets")));
+    const imageHandlerPath = path.join(getMonorepoRelativePath(), "image-optimization-function/index.mjs");
     const imageHandler = await import(imageHandlerPath).then((m) => m.handler);
     app.all("/_next/image", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);

package/dist/plugins/edge.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import chalk from "chalk";
 import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
+import { normalizePath } from "../utils/normalize-path.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
 /**
  * @param opts.nextDir - The path to the .next directory
@@ -11,7 +12,7 @@ import { getCrossPlatformPathRegex } from "../utils/regex.js";
  * @returns
  */
 export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudflare, }) {
-    const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
+    const entryFiles = middlewareInfo?.files.map((file) => normalizePath(path.join(nextDir, file))) ?? [];
     const routes = middlewareInfo
         ? [
             {

package/dist/types/cache.d.ts

@@ -1,3 +1,4 @@
+import type { ReadableStream } from "node:stream/web";
 interface CachedFetchValue {
     kind: "FETCH";
     data: {
@@ -61,7 +62,7 @@ export interface CacheHandlerValue {
     cacheState?: string;
     value: IncrementalCacheValue | null;
 }
-export type Extension = "cache" | "fetch";
+export type Extension = "cache" | "fetch" | "composable";
 type MetaHeaders = {
     "x-next-cache-tags"?: string;
     [k: string]: string | string[] | undefined;
@@ -82,11 +83,54 @@ export type TagCacheMetaFile = {
         N: string;
     };
 };
-export type IncrementalCacheContext = {
-    revalidate?: number | false | undefined;
-    fetchCache?: boolean | undefined;
-    fetchUrl?: string | undefined;
-    fetchIdx?: number | undefined;
-    tags?: string[] | undefined;
+interface SetIncrementalFetchCacheContext {
+    fetchCache: true;
+    fetchUrl?: string;
+    fetchIdx?: number;
+    tags?: string[];
+}
+interface SetIncrementalResponseCacheContext {
+    fetchCache?: false;
+    cacheControl?: {
+        revalidate: number | false;
+        expire?: number;
+    };
+    /**
+     * True if the route is enabled for PPR.
+     */
+    isRoutePPREnabled?: boolean;
+    /**
+     * True if this is a fallback request.
+     */
+    isFallback?: boolean;
+}
+interface SetIncrementalCacheContext {
+    revalidate?: number | false;
+    isRoutePPREnabled?: boolean;
+    isFallback?: boolean;
+}
+type OldSetIncrementalCacheContext = number | false | undefined;
+export type IncrementalCacheContext = OldSetIncrementalCacheContext | SetIncrementalCacheContext | SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext;
+export interface ComposableCacheEntry {
+    value: ReadableStream<Uint8Array>;
+    tags: string[];
+    stale: number;
+    timestamp: number;
+    expire: number;
+    revalidate: number;
+}
+export type StoredComposableCacheEntry = Omit<ComposableCacheEntry, "value"> & {
+    value: string;
 };
+export interface ComposableCacheHandler {
+    get(cacheKey: string): Promise<ComposableCacheEntry | undefined>;
+    set(cacheKey: string, pendingEntry: Promise<ComposableCacheEntry>): Promise<void>;
+    refreshTags(): Promise<void>;
+    getExpiration(...tags: string[]): Promise<number>;
+    expireTags(...tags: string[]): Promise<void>;
+    /**
+     * This function is only there for older versions and do nothing
+     */
+    receiveExpiredTags(...tags: string[]): Promise<void>;
+}
 export {};

package/dist/types/global.d.ts

@@ -185,5 +185,10 @@ declare global {
      * Only available in main functions.
      */
     var __next_route_preloader: (stage: "waitUntil" | "start" | "warmerEvent" | "onDemand") => Promise<void>;
+    /**
+     * This is the relative package path of the monorepo. It will be an empty string "" in normal repos.
+     * ex. `packages/web`
+     */
+    var monorepoPackagePath: string;
 }
 export {};

package/dist/types/overrides.d.ts

@@ -1,5 +1,5 @@
 import type { Readable } from "node:stream";
-import type { Meta } from "./cache";
+import type { Extension, Meta, StoredComposableCacheEntry } from "./cache";
 import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin, ResolvedRoute, StreamCreator, WaitUntil } from "./open-next";
 export interface QueueMessage {
     MessageDeduplicationId: string;
@@ -51,12 +51,16 @@ export type WithLastModified<T> = {
     lastModified?: number;
     value?: T;
 };
-export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? CachedFetchValue : CachedFile) & {
+export type CacheEntryType = Extension;
+export type CacheValue<CacheType extends CacheEntryType> = (CacheType extends "fetch" ? CachedFetchValue : CacheType extends "cache" ? CachedFile : StoredComposableCacheEntry) & {
+    /**
+     * This is available for page cache entry, but only at runtime.
+     */
     revalidate?: number | false;
 };
 export type IncrementalCache = {
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
-    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
+    set<CacheType extends CacheEntryType = "cache">(key: string, value: CacheValue<CacheType>, isFetch?: CacheType): Promise<void>;
     delete(key: string): Promise<void>;
     name: string;
 };
@@ -86,6 +90,7 @@ Cons :
 */
 export type NextModeTagCache = BaseTagCache & {
     mode: "nextMode";
+    getLastRevalidated(tags: string[]): Promise<number>;
     hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
     writeTags(tags: string[]): Promise<void>;
     getPathsByTags?: (tags: string[]) => Promise<string[]>;

package/dist/utils/cache.d.ts

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

package/dist/utils/normalize-path.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizePath(path: string): string;
+export declare function getMonorepoRelativePath(relativePath?: string): string;

package/dist/utils/normalize-path.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+export function normalizePath(path) {
+    return path.replace(/\\/g, "/");
+}
+export function getMonorepoRelativePath(relativePath = "../..") {
+    return path.join(globalThis.monorepoPackagePath
+        .split("/")
+        .filter(Boolean)
+        .map(() => "..")
+        .join("/"), relativePath);
+}

package/package.json

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