@opennextjs/aws 3.5.6 → 3.5.8

package/dist/adapters/cache.js

@@ -233,8 +233,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);

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/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/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

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

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

@@ -2,3 +2,4 @@ export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
 export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
+export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";

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

@@ -2,3 +2,4 @@ export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
 export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
+export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";

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/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/package.json

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