@opennextjs/aws 3.5.7 → 3.6.0

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
@@ -233,8 +239,11 @@ export default class Cache {
         if (config?.disableTagCache || config?.disableIncrementalCache) {
             return;
         }
+        const _tags = Array.isArray(tags) ? tags : [tags];
+        if (_tags.length === 0) {
+            return;
+        }
         try {
-            const _tags = Array.isArray(tags) ? tags : [tags];
             if (globalThis.tagCache.mode === "nextMode") {
                 const paths = (await globalThis.tagCache.getPathsByTags?.(_tags)) ?? [];
                 await globalThis.tagCache.writeTags(_tags);
@@ -320,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(",") ?? [])
                 : [];
@@ -339,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/adapters/image-optimization-adapter.js

@@ -50,6 +50,12 @@ export async function defaultHandler(event, options) {
             process.env.HOST = headersHost;
         }
         const imageParams = validateImageParams(headers, queryString === null ? undefined : queryString);
+        // We return a 400 here if imageParams returns an errorMessage
+        // https://github.com/vercel/next.js/blob/512d8283054407ab92b2583ecce3b253c3be7b85/packages/next/src/server/next-server.ts#L937-L941
+        if ("errorMessage" in imageParams) {
+            error("Error during validation of image params", imageParams.errorMessage);
+            return buildFailureResponse(imageParams.errorMessage, options?.streamCreator, 400);
+        }
         let etag;
         // We don't cache any images, so in order to be able to return 304 responses, we compute an ETag from what is assumed to be static
         if (process.env.OPENNEXT_STATIC_ETAG) {
@@ -68,7 +74,8 @@ export async function defaultHandler(event, options) {
         return buildSuccessResponse(result, options?.streamCreator, etag);
     }
     catch (e) {
-        return buildFailureResponse(e, options?.streamCreator);
+        error("Failed to optimize image", e);
+        return buildFailureResponse("Internal server error", options?.streamCreator);
     }
 }
 //////////////////////
@@ -81,9 +88,6 @@ function validateImageParams(headers, query) {
     // @ts-ignore
     { headers }, query, nextConfig, false);
     debug("image params", imageParams);
-    if ("errorMessage" in imageParams) {
-        throw new Error(imageParams.errorMessage);
-    }
     return imageParams;
 }
 function computeEtag(imageParams) {
@@ -119,28 +123,26 @@ function buildSuccessResponse(result, streamCreator, etag) {
         headers,
     };
 }
-function buildFailureResponse(e, streamCreator) {
-    debug(e);
+function buildFailureResponse(errorMessage, streamCreator, statusCode = 500) {
+    debug(errorMessage, statusCode);
     if (streamCreator) {
         const response = new OpenNextNodeResponse(() => void 0, async () => void 0, streamCreator);
-        response.writeHead(500, {
+        response.writeHead(statusCode, {
             Vary: "Accept",
             "Cache-Control": "public,max-age=60,immutable",
-            "Content-Type": "application/json",
         });
-        response.end(e?.message || e?.toString() || "An error occurred");
+        response.end(errorMessage);
     }
     return {
         type: "core",
         isBase64Encoded: false,
-        statusCode: 500,
+        statusCode: statusCode,
         headers: {
             Vary: "Accept",
             // For failed images, allow client to retry after 1 minute.
             "Cache-Control": "public,max-age=60,immutable",
-            "Content-Type": "application/json",
         },
-        body: toReadableStream(e?.message || e?.toString() || "An error occurred"),
+        body: toReadableStream(errorMessage),
     };
 }
 const loader = await resolveImageLoader(globalThis.openNextConfig.imageOptimization?.loader ?? "s3");

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

@@ -17,6 +17,7 @@ export declare function getManifests(nextDir: string): {
 };
 export declare function copyTracedFiles({ buildOutputPath, packagePath, outputDir, routes, bundledNextServer, skipServerFiles, }: CopyTracedFilesOptions): Promise<{
     tracedFiles: string[];
+    nodePackages: Map<string, string>;
     manifests: {
         buildId: string;
         config: import("../types/next-types.js").NextConfig;

package/dist/build/copyTracedFiles.js

@@ -41,18 +41,38 @@ export async function copyTracedFiles({ buildOutputPath, packagePath, outputDir,
     const standaloneNextDir = path.join(standaloneDir, packagePath, ".next");
     const standaloneServerDir = path.join(standaloneNextDir, "server");
     const outputNextDir = path.join(outputDir, packagePath, ".next");
-    const extractFiles = (files, from = standaloneNextDir) => files.map((f) => path.resolve(from, f));
-    // On next 14+, we might not have to include those files
-    // For next 13, we need to include them otherwise we get runtime error
-    const requiredServerFiles = JSON.parse(readFileSync(path.join(dotNextDir, bundledNextServer
-        ? "next-minimal-server.js.nft.json"
-        : "next-server.js.nft.json"), "utf8"));
+    // Files to copy
+    // Map from files in the `.next/standalone` to files in the `.open-next` folder
     const filesToCopy = new Map();
+    // Node packages
+    // Map from folders in the project to folders in the `.open-next` folder
+    // The map might also include the mono-repo path.
+    const nodePackages = new Map();
+    /**
+     * Extracts files and node packages from a .nft.json file
+     * @param nftFile path to the .nft.json file relative to `.next/`
+     */
+    const processNftFile = (nftFile) => {
+        const subDir = path.dirname(nftFile);
+        const files = JSON.parse(readFileSync(path.join(dotNextDir, nftFile), "utf8")).files;
+        files.forEach((tracedPath) => {
+            const src = path.join(standaloneNextDir, subDir, tracedPath);
+            const dst = path.join(outputNextDir, subDir, tracedPath);
+            filesToCopy.set(src, dst);
+            const module = path.join(dotNextDir, subDir, tracedPath);
+            if (module.endsWith("package.json")) {
+                nodePackages.set(path.dirname(module), path.dirname(dst));
+            }
+        });
+    };
     // Files necessary by the server
     if (!skipServerFiles) {
-        extractFiles(requiredServerFiles.files).forEach((f) => {
-            filesToCopy.set(f, f.replace(standaloneDir, outputDir));
-        });
+        // On next 14+, we might not have to include those files
+        // For next 13, we need to include them otherwise we get runtime error
+        const nftFile = bundledNextServer
+            ? "next-minimal-server.js.nft.json"
+            : "next-server.js.nft.json";
+        processNftFile(nftFile);
     }
     // create directory for pages
     if (existsSync(path.join(standaloneNextDir, "server/pages"))) {
@@ -69,13 +89,12 @@ export async function copyTracedFiles({ buildOutputPath, packagePath, outputDir,
         recursive: true,
     });
     const computeCopyFilesForPage = (pagePath) => {
-        const fullFilePath = `server/${pagePath}.js`;
-        let requiredFiles;
+        const serverPath = `server/${pagePath}.js`;
         try {
-            requiredFiles = JSON.parse(readFileSync(path.join(standaloneNextDir, `${fullFilePath}.nft.json`), "utf8"));
+            processNftFile(`${serverPath}.nft.json`);
         }
         catch (e) {
-            if (existsSync(path.join(standaloneNextDir, fullFilePath))) {
+            if (existsSync(path.join(dotNextDir, serverPath))) {
                 //TODO: add a link to the docs
                 throw new Error(`
 --------------------------------------------------------------------------------
@@ -88,18 +107,14 @@ See the docs for more information on how to bundle edge runtime functions.
             throw new Error(`
 --------------------------------------------------------------------------------
 We cannot find the route for ${pagePath}.
-File ${fullFilePath} does not exist
+File ${serverPath} does not exist
 --------------------------------------------------------------------------------`);
         }
-        const dir = path.dirname(fullFilePath);
-        extractFiles(requiredFiles.files, path.join(standaloneNextDir, dir)).forEach((f) => {
-            filesToCopy.set(f, f.replace(standaloneDir, outputDir));
-        });
-        if (!existsSync(path.join(standaloneNextDir, fullFilePath))) {
+        if (!existsSync(path.join(standaloneNextDir, serverPath))) {
             throw new Error(`This error should only happen for static 404 and 500 page from page router. Report this if that's not the case.,
-        File ${fullFilePath} does not exist`);
+        File ${serverPath} does not exist`);
         }
-        filesToCopy.set(path.join(standaloneNextDir, fullFilePath), path.join(outputNextDir, fullFilePath));
+        filesToCopy.set(path.join(standaloneNextDir, serverPath), path.join(outputNextDir, serverPath));
     };
     const safeComputeCopyFilesForPage = (pagePath, alternativePath) => {
         try {
@@ -148,12 +163,15 @@ File ${fullFilePath} does not exist
     routes.forEach((route) => {
         computeCopyFilesForPage(route);
     });
+    // Only files that are actually copied
+    const tracedFiles = [];
     //Actually copy the files
     filesToCopy.forEach((to, from) => {
         // We don't want to copy excluded packages (i.e sharp)
         if (isExcluded(from)) {
             return;
         }
+        tracedFiles.push(to);
         mkdirSync(path.dirname(to), { recursive: true });
         let symlink = null;
         // For pnpm symlink we need to do that
@@ -233,7 +251,8 @@ File ${fullFilePath} does not exist
     }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
     return {
-        tracedFiles: Array.from(filesToCopy.values()),
+        tracedFiles,
+        nodePackages,
         manifests: getManifests(standaloneNextDir),
     };
 }

package/dist/build/createServerBundle.js

@@ -14,8 +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 { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "./patch/patches/index.js";
-import { patchBackgroundRevalidation } from "./patch/patches/patchBackgroundRevalidation.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();
@@ -86,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);
     }
@@ -123,6 +125,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchNextServer,
         patchEnvVars,
         patchBackgroundRevalidation,
+        patchUseCacheForISR,
         ...additionalCodePatches,
     ]);
     // Build Lambda code
@@ -135,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
@@ -160,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,4 +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,4 +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/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;
@@ -103,7 +104,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 +114,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 +143,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/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/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,4 +1,5 @@
 import fs from "node:fs";
+// TODO: fix this for monorepo
 const tagFile = "../../dynamodb-provider/dynamodb-cache.json";
 const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
@@ -26,7 +27,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/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/next-types.d.ts

@@ -75,6 +75,7 @@ export interface NextConfig {
     };
     images: ImageConfig;
     poweredByHeader?: boolean;
+    serverExternalPackages?: string[];
 }
 export interface RouteDefinition {
     page: string;

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 @@
+export declare function normalizePath(path: string): string;

package/dist/utils/normalize-path.js

@@ -0,0 +1,3 @@
+export function normalizePath(path) {
+    return path.replace(/\\/g, "/");
+}

package/package.json

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