@opennextjs/aws 3.5.8 → 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
@@ -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/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/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.8",
+  "version": "3.6.0",
   "bin": {
     "open-next": "./dist/index.js"
   },