@opennextjs/aws 4.1.7 → 4.1.8

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

@@ -1,9 +1,10 @@
-export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        pattern: \"!$ENTRY.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
+export declare const rule = "\nrule:\n  kind: binary_expression\n  # The names are mangled in the minified runtimes\n  pattern: \"!$ENTRY.isStale || $CONTEXT.isPrefetch\"\n  all:\n    # It has to be the whole check, not a part of a bigger expression\n    - not:\n        inside:\n          kind: binary_expression\n    # It has to be guarded by the on-demand revalidation check\n    - inside:\n        kind: if_statement\n        stopBy: end\n        has:\n          field: condition\n          stopBy: end\n          any:\n            # Next 15.5+ and its minified runtime copies use the same context object\n            - pattern: \"!$CONTEXT.isOnDemandRevalidate\"\n            # Earlier unminified versions keep this flag in a local\n            - pattern: \"!isOnDemandRevalidate\"\nfix:\n  'true'";
 export declare const patchBackgroundRevalidation: {
     name: string;
     patches: {
         versions: ">=14.1.0";
         pathFilter: RegExp;
+        contentFilter: RegExp;
         patchCode: import("../codePatcher.js").PatchCodeFn;
     }[];
 };

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

@@ -1,15 +1,31 @@
 import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
 import { createPatchCode } from "../astCodePatcher.js";
+// Matches the check that decides whether a cached entry can be served as is in `ResponseCache.get`:
+//   if (entry && !context.isOnDemandRevalidate) { ...; if (!entry.isStale || context.isPrefetch) return ... }
+// which is minified in the compiled runtimes as:
+//   if ((a = ...) && !r.isOnDemandRevalidate && (n(a), i = !0, !a.isStale || r.isPrefetch)) return a;
 export const rule = `
 rule:
   kind: binary_expression
+  # The names are mangled in the minified runtimes
+  pattern: "!$ENTRY.isStale || $CONTEXT.isPrefetch"
   all:
-    - has:
-        kind: unary_expression
-        pattern: "!$ENTRY.isStale"
-    -  has:
-         kind: member_expression
-         regex: "context.isPrefetch"
+    # It has to be the whole check, not a part of a bigger expression
+    - not:
+        inside:
+          kind: binary_expression
+    # It has to be guarded by the on-demand revalidation check
+    - inside:
+        kind: if_statement
+        stopBy: end
+        has:
+          field: condition
+          stopBy: end
+          any:
+            # Next 15.5+ and its minified runtime copies use the same context object
+            - pattern: "!$CONTEXT.isOnDemandRevalidate"
+            # Earlier unminified versions keep this flag in a local
+            - pattern: "!isOnDemandRevalidate"
 fix:
   'true'`;
 export const patchBackgroundRevalidation = {
@@ -18,7 +34,10 @@ export const patchBackgroundRevalidation = {
         {
             // TODO: test for earlier versions of Next
             versions: ">=14.1.0",
-            pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
+            // Since Next 15.5 route modules use their own `ResponseCache`, which is inlined (and minified)
+            // in `next/dist/compiled/next-server/*.runtime.prod.js`
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/response-cache/index\.js|\.runtime\.prod\.js)$`, { escape: false }),
+            contentFilter: /\.isStale\s*\|\|\s*[\w$]+\.isPrefetch/,
             patchCode: createPatchCode(rule),
         },
     ],

package/dist/utils/promise.d.ts

@@ -13,8 +13,25 @@ export declare class DetachedPromise<T = any> {
 }
 export declare class DetachedPromiseRunner {
     private promises;
+    /**
+     * Create a deferred promise tracked by this runner.
+     *
+     * @returns The tracked promise and its resolve/reject functions.
+     */
     withResolvers<T>(): DetachedPromise<T>;
+    /**
+     * Track background work and handle failures immediately.
+     *
+     * @param promise Work to await, including work registered during an active drain.
+     * @returns Nothing; failures are logged rather than propagated.
+     */
     add<T>(promise: Promise<T>): void;
+    /**
+     * Drain tracked work, including additions made while earlier work is pending.
+     *
+     * Work started after the drain has settled still needs a new runtime waitUntil.
+     * @returns Resolves when all work registered during this drain has settled.
+     */
     await(): Promise<void>;
 }
 export declare function runWithOpenNextRequestContext<T>({ isISRRevalidation, waitUntil, requestId, }: {

package/dist/utils/promise.js

@@ -28,23 +28,41 @@ export class DetachedPromise {
 }
 export class DetachedPromiseRunner {
     promises = [];
+    /**
+     * Create a deferred promise tracked by this runner.
+     *
+     * @returns The tracked promise and its resolve/reject functions.
+     */
     withResolvers() {
         const detachedPromise = new DetachedPromise();
-        this.promises.push(detachedPromise);
+        this.add(detachedPromise.promise);
         return detachedPromise;
     }
+    /**
+     * Track background work and handle failures immediately.
+     *
+     * @param promise Work to await, including work registered during an active drain.
+     * @returns Nothing; failures are logged rather than propagated.
+     */
     add(promise) {
-        const detachedPromise = new DetachedPromise();
-        this.promises.push(detachedPromise);
-        promise.then(detachedPromise.resolve, detachedPromise.reject);
+        // A late promise may reject before the current batch finishes. Attach its
+        // rejection handler now so it cannot become an unhandled rejection.
+        this.promises.push(promise.then(() => { }, error));
     }
+    /**
+     * Drain tracked work, including additions made while earlier work is pending.
+     *
+     * Work started after the drain has settled still needs a new runtime waitUntil.
+     * @returns Resolves when all work registered during this drain has settled.
+     */
     async await() {
         debug(`Awaiting ${this.promises.length} detached promises`);
-        const results = await Promise.allSettled(this.promises.map((p) => p.promise));
-        const rejectedPromises = results.filter((r) => r.status === "rejected");
-        rejectedPromises.forEach((r) => {
-            error(r.reason);
-        });
+        let awaited = 0;
+        while (awaited < this.promises.length) {
+            const batch = this.promises.slice(awaited);
+            awaited = this.promises.length;
+            await Promise.all(batch);
+        }
     }
 }
 async function awaitAllDetachedPromise() {

package/package.json

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