@opennextjs/aws 4.1.4 → 4.1.5

package/dist/adapters/composable-cache.js

@@ -1,13 +1,34 @@
 import { isStale, writeTags } from "../utils/cache";
 import { fromReadableStream, toReadableStream } from "../utils/stream";
 import { debug } from "./logger";
-const pendingWritePromiseMap = new Map();
+/**
+ * In-flight writes are tracked per request, not per module.
+ *
+ * A module-scope map is per isolate. On a runtime that serves one request per
+ * sandbox that is the same as per request, but on a runtime that serves many
+ * concurrent requests from one isolate (e.g. Cloudflare Workers) a pending
+ * write promise created in request A would be handed to request B. If A's
+ * context is torn down before the write settles, B awaits a promise that never
+ * resolves, `.finally()` never runs, and the key stays poisoned for the life of
+ * the isolate.
+ *
+ * `RequestCache` is the per-request store the tag caches already use for this.
+ * Scoping the map to it keeps the read-coherence a `get` needs for a write in
+ * flight from the same render while making a cross-request share impossible.
+ * With no ALS store (e.g. at build time) the dedupe is skipped and `get` falls
+ * through to the incremental cache.
+ */
+const PENDING_WRITES_CACHE_KEY = "composable-cache:pending-writes";
+const getPendingWritePromiseMap = () => globalThis.__openNextAls
+    ?.getStore()
+    ?.requestCache?.getOrCreate(PENDING_WRITES_CACHE_KEY);
 export default {
     async get(cacheKey) {
         try {
             // We first check if we have a pending write for this cache key
             // If we do, we return the pending promise instead of fetching the cache
-            if (pendingWritePromiseMap.has(cacheKey)) {
+            const pendingWritePromiseMap = getPendingWritePromiseMap();
+            if (pendingWritePromiseMap?.has(cacheKey)) {
                 const stored = pendingWritePromiseMap.get(cacheKey);
                 if (stored) {
                     return stored.then((entry) => ({
@@ -69,9 +90,10 @@ export default {
             ...entry,
             value: await fromReadableStream(entry.value),
         }));
-        pendingWritePromiseMap.set(cacheKey, promiseEntry);
+        const pendingWritePromiseMap = getPendingWritePromiseMap();
+        pendingWritePromiseMap?.set(cacheKey, promiseEntry);
         const entry = await promiseEntry.finally(() => {
-            pendingWritePromiseMap.delete(cacheKey);
+            pendingWritePromiseMap?.delete(cacheKey);
         });
         await globalThis.incrementalCache.set(cacheKey, {
             ...entry,

package/dist/build/buildNextApp.js

@@ -15,5 +15,10 @@ export function buildNextjsApp(options) {
     cp.execSync(command, {
         stdio: "inherit",
         cwd: path.dirname(options.appPackageJsonPath),
+        // `setStandaloneBuildMode` mutates `process.env` right before this call.
+        // Node forwards those mutations to the child by default, but Bun resolves
+        // the child environment from a snapshot taken at startup unless `env` is
+        // passed explicitly, so `NEXT_PRIVATE_STANDALONE` never reaches the build.
+        env: process.env,
     });
 }

package/dist/core/routing/cacheInterceptor.js

@@ -38,7 +38,9 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
     // calculate age
     const age = Math.round((Date.now() - (lastModified ?? 0)) / 1000);
     const hash = (str) => createHash("md5").update(str).digest("hex");
-    const etag = hash(body);
+    // RFC 9110 entity-tag is a quoted opaque-tag. CloudFront drops unquoted ETags
+    // when serving compressed objects.
+    const etag = `"${hash(body)}"`;
     if (revalidate === 0) {
         // This one should never happen
         return {

package/dist/core/routing/middleware.js

@@ -1,4 +1,5 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
+import { parseSetCookieHeader } from "../../http/util.js";
 import { ISR_HEADER, PRERENDER_REVALIDATE_HEADER } from "../../utils/cacheHeaders.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { getQueryFromSearchParams } from "../../overrides/converters/utils.js";
@@ -112,7 +113,12 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
             }
         }
     });
-    const setCookies = responseHeaders.getSetCookie();
+    // Next folds the cookies set through `cookies()` in the middleware into a single
+    // comma-joined `set-cookie` header, so each entry here may be compound.
+    // Next itself splits them back in `runMiddleware` (`next-server.ts`).
+    const setCookies = responseHeaders
+        .getSetCookie()
+        .flatMap((maybeCompoundCookie) => parseSetCookieHeader(maybeCompoundCookie));
     if (setCookies.length > 0) {
         resHeaders["set-cookie"] = setCookies;
     }

package/package.json

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