@opennextjs/aws 3.5.7 → 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/createServerBundle.js

@@ -14,8 +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 } from "./patch/patches/patchBackgroundRevalidation.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();

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