@opennextjs/aws 3.5.6 → 3.5.7

package/dist/build/createAssets.d.ts

@@ -1,6 +1,16 @@
 import type { TagCacheMetaFile } from "../types/cache.js";
 import * as buildHelper from "./helper.js";
-export declare function createStaticAssets(options: buildHelper.BuildOptions): void;
+/**
+ * Copy the static assets to the output folder
+ *
+ * WARNING: `useBasePath` should be set to `false` when the output file is used.
+ *
+ * @param options OpenNext build options
+ * @param useBasePath whether to copy files into the to Next.js configured basePath
+ */
+export declare function createStaticAssets(options: buildHelper.BuildOptions, { useBasePath }?: {
+    useBasePath?: boolean | undefined;
+}): void;
 /**
  * Create the cache assets.
  *

package/dist/build/createAssets.js

@@ -1,16 +1,31 @@
 import fs from "node:fs";
 import path from "node:path";
+import { loadConfig } from "../adapters/config/util.js";
 import logger from "../logger.js";
 import { isBinaryContentType } from "../utils/binary.js";
 import * as buildHelper from "./helper.js";
-export function createStaticAssets(options) {
+/**
+ * Copy the static assets to the output folder
+ *
+ * WARNING: `useBasePath` should be set to `false` when the output file is used.
+ *
+ * @param options OpenNext build options
+ * @param useBasePath whether to copy files into the to Next.js configured basePath
+ */
+export function createStaticAssets(options, { useBasePath = false } = {}) {
     logger.info("Bundling static assets...");
     const { appBuildOutputPath, appPublicPath, outputDir, appPath } = options;
+    const NextConfig = loadConfig(path.join(appBuildOutputPath, ".next"));
+    const basePath = useBasePath ? (NextConfig.basePath ?? "") : "";
     // Create output folder
-    const outputPath = path.join(outputDir, "assets");
+    const outputPath = path.join(outputDir, "assets", basePath);
     fs.mkdirSync(outputPath, { recursive: true });
     /**
-     * Next.js outputs assets into multiple files. Copy into the same directory.
+     * Next.js outputs assets into multiple files.
+     *
+     * Copy into the same directory:
+     * - `.open-next/assets` when `useBasePath` is `false`
+     * - `.open-next/assets/basePath` when `useBasePath` is `true`
      *
      * Copy over:
      * - .next/BUILD_ID => BUILD_ID

package/dist/build/createServerBundle.js

@@ -15,6 +15,7 @@ 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";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -121,6 +122,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchUnstableCacheForISR,
         patchNextServer,
         patchEnvVars,
+        patchBackgroundRevalidation,
         ...additionalCodePatches,
     ]);
     // Build Lambda code
@@ -146,6 +148,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
                 ...(isAfter142 ? ["patchAsyncStorage"] : []),
+                ...(isAfter141 ? ["appendPrefetch"] : []),
             ],
         }),
         openNextReplacementPlugin({

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

@@ -0,0 +1,11 @@
+export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        regex: \"!cachedResponse.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
+export declare const patchBackgroundRevalidation: {
+    name: string;
+    patches: {
+        versions: ">=14.1.0";
+        field: {
+            pathFilter: RegExp;
+            patchCode: import("../codePatcher.js").PatchCodeFn;
+        };
+    }[];
+};

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

@@ -0,0 +1,27 @@
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
+export const rule = `
+rule:
+  kind: binary_expression
+  all:
+    - has:
+        kind: unary_expression
+        regex: "!cachedResponse.isStale"
+    -  has:
+         kind: member_expression
+         regex: "context.isPrefetch"
+fix:
+  'true'`;
+export const patchBackgroundRevalidation = {
+    name: "patchBackgroundRevalidation",
+    patches: [
+        {
+            // TODO: test for earlier versions of Next
+            versions: ">=14.1.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
+                patchCode: createPatchCode(rule),
+            },
+        },
+    ],
+};

package/dist/core/requestHandler.js

@@ -115,7 +115,12 @@ export async function openNextHandler(internalEvent, options) {
             // 1. We could just let the revalidation go as normal, but due to race conditions the revalidation will be unreliable
             // 2. We could alter the lastModified time of our cache to make next believe that the cache is fresh, but this could cause issues with stale data since the cdn will cache the stale data as if it was fresh
             // 3. OUR CHOICE: We could pass a purpose prefetch header to the serverless function to make next believe that the request is a prefetch request and not trigger revalidation (This could potentially break in the future if next changes the behavior of prefetch requests)
-            headers: { ...headers, purpose: "prefetch" },
+            headers: {
+                ...headers,
+                //#override appendPrefetch
+                purpose: "prefetch",
+                //#endOverride
+            },
             body: preprocessedEvent.body,
             remoteAddress: preprocessedEvent.remoteAddress,
         };

package/dist/core/routing/middleware.js

@@ -71,13 +71,15 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     const responseHeaders = result.headers;
     const reqHeaders = {};
     const resHeaders = {};
-    responseHeaders.delete("x-middleware-override-headers");
-    /*  Next will set the header `x-middleware-set-cookie` when you `set-cookie` in the middleware.
-     *  We can delete it here since it will be set in `set-cookie` aswell. Next removes this header in the response themselves.
-     * `x-middleware-next` is set when you invoke `NextResponse.next()`. We can delete it here aswell.
-     */
-    responseHeaders.delete("x-middleware-set-cookie");
-    responseHeaders.delete("x-middleware-next");
+    // 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
+        "content-encoding",
+    ];
     const xMiddlewareKey = "x-middleware-request-";
     responseHeaders.forEach((value, key) => {
         if (key.startsWith(xMiddlewareKey)) {
@@ -85,6 +87,8 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
             reqHeaders[k] = value;
         }
         else {
+            if (filteredHeaders.includes(key.toLowerCase()))
+                return;
             if (key.toLowerCase() === "set-cookie") {
                 resHeaders[key] = resHeaders[key]
                     ? [...resHeaders[key], value]
@@ -95,20 +99,6 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
             }
         }
     });
-    // If the middleware returned a Redirect, we set the `Location` header with
-    // the redirected url and end the response.
-    if (statusCode >= 300 && statusCode < 400) {
-        resHeaders.location =
-            responseHeaders.get("location") ?? resHeaders.location;
-        // res.setHeader("Location", location);
-        return {
-            body: emptyReadableStream(),
-            type: internalEvent.type,
-            statusCode: statusCode,
-            headers: resHeaders,
-            isBase64Encoded: false,
-        };
-    }
     // If the middleware returned a Rewrite, set the `url` to the pathname of the rewrite
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
@@ -134,11 +124,11 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
             });
         }
     }
-    // If the middleware returned a `NextResponse`, pipe the body to res. This will return
-    // the body immediately to the client.
-    if (result.body) {
+    // If the middleware wants to directly return a response (i.e. not using `NextResponse.next()` or `NextResponse.rewrite()`)
+    // we return the response directly
+    if (!rewriteUrl && !responseHeaders.get("x-middleware-next")) {
         // transfer response body to res
-        const body = result.body;
+        const body = result.body ?? emptyReadableStream();
         return {
             type: internalEvent.type,
             statusCode: statusCode,

package/package.json

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