@opennextjs/aws 3.7.4 → 3.7.6

package/dist/build/copyTracedFiles.js

@@ -13,6 +13,10 @@ const EXCLUDED_PACKAGES = [
     // This seems to be only in Next 15
     // Some of sharp deps are under the @img scope
     "@img",
+    "typescript",
+    "next/dist/compiled/babel",
+    "next/dist/compiled/babel-packages",
+    "next/dist/compiled/amphtml-validator",
 ];
 function isExcluded(srcPath) {
     return EXCLUDED_PACKAGES.some((excluded) => srcPath.match(getCrossPlatformPathRegex(`/node_modules/${excluded}/`)));
@@ -167,7 +171,7 @@ File ${serverPath} does not exist
     const tracedFiles = [];
     //Actually copy the files
     filesToCopy.forEach((to, from) => {
-        // We don't want to copy excluded packages (i.e sharp)
+        // We don't want to copy excluded packages (e.g. sharp)
         if (isExcluded(from)) {
             return;
         }

package/dist/build/createAssets.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { loadConfig } from "../adapters/config/util.js";
+import { safeParseJsonFile } from "../utils/safe-json-parse.js";
 import logger from "../logger.js";
 import { isBinaryContentType } from "../utils/binary.js";
 import * as buildHelper from "./helper.js";
@@ -106,15 +107,20 @@ export function createCacheAssets(options) {
     // Generate cache file
     Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
         const cacheFileMeta = files.meta
-            ? JSON.parse(fs.readFileSync(files.meta, "utf8"))
+            ? safeParseJsonFile(fs.readFileSync(files.meta, "utf8"), cacheFilePath)
             : undefined;
+        const cacheJson = files.json
+            ? safeParseJsonFile(fs.readFileSync(files.json, "utf8"), cacheFilePath)
+            : undefined;
+        if ((files.meta && !cacheFileMeta) || (files.json && !cacheJson)) {
+            logger.warn(`Skipping invalid cache file: ${cacheFilePath}`);
+            return;
+        }
         const cacheFileContent = {
             type: files.body ? "route" : files.json ? "page" : "app",
             meta: cacheFileMeta,
             html: files.html ? fs.readFileSync(files.html, "utf8") : undefined,
-            json: files.json
-                ? JSON.parse(fs.readFileSync(files.json, "utf8"))
-                : undefined,
+            json: cacheJson,
             rsc: files.rsc ? fs.readFileSync(files.rsc, "utf8") : undefined,
             body: files.body
                 ? fs
@@ -138,7 +144,7 @@ export function createCacheAssets(options) {
         fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
         buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
             const fileContent = fs.readFileSync(absolutePath, "utf8");
-            const fileData = JSON.parse(fileContent);
+            const fileData = safeParseJsonFile(fileContent, absolutePath);
             fileData?.tags?.forEach((tag) => {
                 metaFiles.push({
                     tag: { S: path.posix.join(buildId, tag) },
@@ -156,8 +162,8 @@ export function createCacheAssets(options) {
         sourceDirs.forEach((sourceDir) => {
             buildHelper.traverseFiles(sourceDir, ({ absolutePath, relativePath }) => absolutePath.endsWith(".meta") && !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
                 const fileContent = fs.readFileSync(absolutePath, "utf8");
-                const fileData = JSON.parse(fileContent);
-                if (fileData.headers?.["x-next-cache-tags"]) {
+                const fileData = safeParseJsonFile(fileContent, absolutePath);
+                if (fileData?.headers?.["x-next-cache-tags"]) {
                     fileData.headers["x-next-cache-tags"]
                         .split(",")
                         .forEach((tag) => {

package/dist/build/createImageOptimizationBundle.js

@@ -76,7 +76,8 @@ export async function createImageOptimizationBundle(options) {
     const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
     installDependencies(outputPath, config.imageOptimization?.install ?? {
         packages: [`sharp@${sharpVersion}`],
-        arch: "arm64",
+        // By not specifying an arch, `npm install` will choose one for us (i.e. our system one)
+        arch: config.imageOptimization?.loader === "fs-dev" ? undefined : "arm64",
         nodeVersion: "18",
         libc: "glibc",
     });

package/dist/build/createServerBundle.js

@@ -126,6 +126,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patches.patchEnvVars,
         patches.patchBackgroundRevalidation,
         patches.patchUseCacheForISR,
+        patches.patchNodeEnvironment,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

package/dist/build/installDeps.js

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { execSync } from "node:child_process";
 import logger from "../logger.js";
+const AFFECTED_NODE_VERSIONS = ["22.17.0", "22.17.1", "22.18.0"];
 export function installDependencies(outputDir, installOptions) {
     try {
         if (!installOptions) {
@@ -37,8 +38,8 @@ export function installDependencies(outputDir, installOptions) {
         fs.cpSync(path.join(tempInstallDir, "node_modules"), path.join(outputDir, "node_modules"), { recursive: true, force: true, dereference: true });
         // This is a workaround for Node `22.17.0` and `22.17.1`
         // https://github.com/nodejs/node/issues/59168
-        const nodeVersion = process.version;
-        if (nodeVersion === "v22.17.0" || nodeVersion === "v22.17.1") {
+        const nodeVersion = process.versions.node;
+        if (AFFECTED_NODE_VERSIONS.includes(nodeVersion)) {
             const tempBinDir = path.join(tempInstallDir, "node_modules", ".bin");
             const outputBinDir = path.join(outputDir, "node_modules", ".bin");
             for (const fileName of fs.readdirSync(tempBinDir)) {

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

@@ -3,3 +3,4 @@ export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";
+export { patchNodeEnvironment } from "./patchNodeEnvironment.js";

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

@@ -3,3 +3,4 @@ export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";
+export { patchNodeEnvironment } from "./patchNodeEnvironment.js";

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

@@ -8,8 +8,4 @@ export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_
  * @returns A rule to replace the body with a `throw`
  */
 export declare function createEmptyBodyRule(methodName: string): string;
-/**
- * Drops `require("./node-environment-extensions/error-inspect");`
- */
-export declare const errorInspectRule = "\nrule:\n  pattern: require(\"./node-environment-extensions/error-inspect\");\nfix: |-\n  // Removed by OpenNext\n  // require(\"./node-environment-extensions/error-inspect\");\n";
 export declare const patchNextServer: CodePatcher;

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

@@ -48,16 +48,6 @@ fix: |-
   }
 `;
 }
-/**
- * Drops `require("./node-environment-extensions/error-inspect");`
- */
-export const errorInspectRule = `
-rule:
-  pattern: require("./node-environment-extensions/error-inspect");
-fix: |-
-  // Removed by OpenNext
-  // require("./node-environment-extensions/error-inspect");
-`;
 const pathFilter = getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
     escape: false,
 });
@@ -81,12 +71,6 @@ const babelPatches = [
         contentFilter: /runEdgeFunction\(/,
         patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
     },
-    // Drop `error-inspect` that pulls babel
-    {
-        pathFilter,
-        contentFilter: /error-inspect/,
-        patchCode: createPatchCode(errorInspectRule),
-    },
 ];
 export const patchNextServer = {
     name: "patch-next-server",

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

@@ -0,0 +1,8 @@
+import type { CodePatcher } from "../codePatcher.js";
+/**
+ * Drops `require("./node-environment-extensions/error-inspect");`
+ *
+ * This is to avoid pulling babel (~4MB)
+ */
+export declare const rule = "\nrule:\n  pattern: require(\"./node-environment-extensions/error-inspect\");\nfix: |-\n  // Removed by OpenNext\n  // require(\"./node-environment-extensions/error-inspect\");\n";
+export declare const patchNodeEnvironment: CodePatcher;

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

@@ -0,0 +1,27 @@
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
+/**
+ * Drops `require("./node-environment-extensions/error-inspect");`
+ *
+ * This is to avoid pulling babel (~4MB)
+ */
+export const rule = `
+rule:
+  pattern: require("./node-environment-extensions/error-inspect");
+fix: |-
+  // Removed by OpenNext
+  // require("./node-environment-extensions/error-inspect");
+`;
+export const patchNodeEnvironment = {
+    name: "patch-node-environment-error-inspect",
+    patches: [
+        {
+            pathFilter: getCrossPlatformPathRegex(String.raw `/next/dist/server/node-environment\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /error-inspect/,
+            patchCode: createPatchCode(rule),
+            versions: ">=15.0.0",
+        },
+    ],
+};

package/dist/build.js

@@ -28,10 +28,10 @@ export async function build(openNextConfigPath, nodeExternals) {
     // Build Next.js app
     printHeader("Building Next.js app");
     setStandaloneBuildMode(options);
+    buildHelper.initOutputDir(options);
     buildNextjsApp(options);
     // Generate deployable bundle
     printHeader("Generating bundle");
-    buildHelper.initOutputDir(options);
     // Compile cache.ts
     compileCache(options);
     // Compile middleware

package/dist/core/routing/cacheInterceptor.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
+import { isBinaryContentType } from "../../utils/binary";
 import { getTagsFromValue, hasBeenRevalidated } from "../../utils/cache";
 import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
@@ -174,7 +175,8 @@ export async function cacheInterceptor(event) {
                 return event;
             }
             // We need to check the tag cache now
-            if (cachedData.value?.type === "app") {
+            if (cachedData.value?.type === "app" ||
+                cachedData.value?.type === "route") {
                 const tags = getTagsFromValue(cachedData.value);
                 const _hasBeenRevalidated = await hasBeenRevalidated(localizedPath, tags, cachedData);
                 if (_hasBeenRevalidated) {
@@ -200,6 +202,21 @@ export async function cacheInterceptor(event) {
                         isBase64Encoded: false,
                     };
                 }
+                case "route": {
+                    const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified);
+                    const isBinary = isBinaryContentType(String(cachedData.value.meta?.headers?.["content-type"]));
+                    return {
+                        type: "core",
+                        statusCode: cachedData.value.meta?.status ?? 200,
+                        body: toReadableStream(cachedData.value.body, isBinary),
+                        headers: {
+                            ...cacheControl,
+                            ...cachedData.value.meta?.headers,
+                            vary: VARY_HEADER,
+                        },
+                        isBase64Encoded: isBinary,
+                    };
+                }
                 default:
                     return event;
             }

package/dist/http/openNextResponse.js

@@ -65,6 +65,12 @@ export class OpenNextNodeResponse extends Transform {
             statusCode <= 599) {
             this.statusCode = statusCode;
         }
+        // https://github.com/vercel/next.js/blob/ea08bf2/packages/next/src/server/web/spec-extension/adapters/next-request.ts#L46-L54
+        // We want to destroy this response when the original response/request is closed. (i.e when the client disconnects)
+        // This is to support `request.signal.onabort` in route handlers
+        streamCreator?.abortSignal?.addEventListener("abort", () => {
+            this.destroy();
+        });
     }
     // Necessary for next 12
     // We might have to implement all the methods here

package/dist/overrides/tagCache/fs-dev-nextMode.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    name: string;
+    mode: "nextMode";
+    getLastRevalidated: (tags: string[]) => Promise<number>;
+    hasBeenRevalidated: (tags: string[], lastModified?: number) => Promise<boolean>;
+    writeTags: (tags: string[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/tagCache/fs-dev-nextMode.js

@@ -0,0 +1,42 @@
+import { debug } from "../../adapters/logger";
+const tagsMap = new Map();
+export default {
+    name: "fs-dev-nextMode",
+    mode: "nextMode",
+    getLastRevalidated: async (tags) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return 0;
+        }
+        let lastRevalidated = 0;
+        tags.forEach((tag) => {
+            const tagTime = tagsMap.get(tag);
+            if (tagTime && tagTime > lastRevalidated) {
+                lastRevalidated = tagTime;
+            }
+        });
+        debug("getLastRevalidated result:", lastRevalidated);
+        return lastRevalidated;
+    },
+    hasBeenRevalidated: async (tags, lastModified) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return false;
+        }
+        const hasRevalidatedTag = tags.some((tag) => {
+            const tagRevalidatedAt = tagsMap.get(tag);
+            return tagRevalidatedAt ? tagRevalidatedAt > (lastModified ?? 0) : false;
+        });
+        debug("hasBeenRevalidated result:", hasRevalidatedTag);
+        return hasRevalidatedTag;
+    },
+    writeTags: async (tags) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache ||
+            tags.length === 0) {
+            return;
+        }
+        debug("writeTags", { tags: tags });
+        tags.forEach((tag) => {
+            tagsMap.set(tag, Date.now());
+        });
+        debug("writeTags completed, written", tags.length, "tags");
+    },
+};

package/dist/overrides/tagCache/fs-dev.js

@@ -4,31 +4,35 @@ import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const tagFile = path.join(getMonorepoRelativePath(), "dynamodb-provider/dynamodb-cache.json");
 const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
+const { NEXT_BUILD_ID } = process.env;
+function buildKey(key) {
+    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+}
 const tagCache = {
     name: "fs-dev",
     mode: "original",
     getByPath: async (path) => {
         return tags
-            .filter((tagPathMapping) => tagPathMapping.path.S === path)
-            .map((tag) => tag.tag.S);
+            .filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path))
+            .map((tag) => tag.tag.S.replace(`${NEXT_BUILD_ID}/`, ""));
     },
     getByTag: async (tag) => {
         return tags
-            .filter((tagPathMapping) => tagPathMapping.tag.S === tag)
-            .map((tag) => tag.path.S);
+            .filter((tagPathMapping) => tagPathMapping.tag.S === buildKey(tag))
+            .map((tagEntry) => tagEntry.path.S.replace(`${NEXT_BUILD_ID}/`, ""));
     },
     getLastModified: async (path, lastModified) => {
-        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === path &&
+        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path) &&
             Number.parseInt(tagPathMapping.revalidatedAt.N) > (lastModified ?? 0));
         return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
     },
     writeTags: async (newTags) => {
-        const newTagsSet = new Set(newTags.map(({ tag, path }) => `${tag}-${path}`));
+        const newTagsSet = new Set(newTags.map(({ tag, path }) => `${buildKey(tag)}-${buildKey(path)}`));
         const unchangedTags = tags.filter(({ tag, path }) => !newTagsSet.has(`${tag.S}-${path.S}`));
-        tags = unchangedTags.concat(newTags.map((tag) => ({
-            tag: { S: tag.tag },
-            path: { S: tag.path },
-            revalidatedAt: { N: String(tag.revalidatedAt ?? 1) },
+        tags = unchangedTags.concat(newTags.map((item) => ({
+            tag: { S: buildKey(item.tag) },
+            path: { S: buildKey(item.path) },
+            revalidatedAt: { N: `${item.revalidatedAt ?? Date.now()}` },
         })));
     },
 };

package/dist/overrides/wrappers/cloudflare-node.js

@@ -1,7 +1,7 @@
 import { Writable } from "node:stream";
 // Response with null body status (101, 204, 205, or 304) cannot have a body.
 const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
-const handler = async (handler, converter) => async (request, env, ctx) => {
+const handler = async (handler, converter) => async (request, env, ctx, abortSignal) => {
     globalThis.process = process;
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
@@ -38,6 +38,10 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
             resolveResponse(response);
             return Writable.fromWeb(writable);
         },
+        // This is for passing along the original abort signal from the initial Request you retrieve in your worker
+        // Ensures that the response we pass to NextServer is aborted if the request is aborted
+        // By doing this `request.signal.onabort` will work in route handlers
+        abortSignal: abortSignal,
     };
     ctx.waitUntil(handler(internalEvent, {
         streamCreator,

package/dist/overrides/wrappers/express-dev.js

@@ -4,6 +4,9 @@ import { NextConfig } from "../../adapters/config/index";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const wrapper = async (handler, converter) => {
     const app = express();
+    // We disable this cause we wanna use it ourself
+    // https://stackoverflow.com/a/13055495/16587222
+    app.disable("x-powered-by");
     // To serve static assets
     const basePath = NextConfig.basePath ?? "";
     app.use(basePath, express.static(path.join(getMonorepoRelativePath(), "assets")));
@@ -27,6 +30,7 @@ const wrapper = async (handler, converter) => {
             req.headers["x-forwarded-proto"] = req.protocol;
         }
         const internalEvent = await converter.convertFrom(req);
+        const abortController = new AbortController();
         const streamCreator = {
             writeHeaders: (prelude) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
@@ -35,7 +39,11 @@ const wrapper = async (handler, converter) => {
                 return res;
             },
             onFinish: () => { },
+            abortSignal: abortController.signal,
         };
+        res.on("close", () => {
+            abortController.abort();
+        });
         await handler(internalEvent, { streamCreator });
     });
     const server = app.listen(Number.parseInt(process.env.PORT ?? "3000", 10), () => {

package/dist/overrides/wrappers/node.js

@@ -3,6 +3,7 @@ import { debug, error } from "../../adapters/logger";
 const wrapper = async (handler, converter) => {
     const server = createServer(async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
+        const abortController = new AbortController();
         const streamCreator = {
             writeHeaders: (prelude) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
@@ -10,7 +11,11 @@ const wrapper = async (handler, converter) => {
                 res.flushHeaders();
                 return res;
             },
+            abortSignal: abortController.signal,
         };
+        res.on("close", () => {
+            abortController.abort();
+        });
         if (internalEvent.rawPath === "/__health") {
             res.writeHead(200, {
                 "Content-Type": "text/plain",
@@ -18,7 +23,9 @@ const wrapper = async (handler, converter) => {
             res.end("OK");
         }
         else {
-            await handler(internalEvent, { streamCreator });
+            await handler(internalEvent, {
+                streamCreator,
+            });
         }
     });
     await new Promise((resolve) => {

package/dist/types/open-next.d.ts

@@ -30,6 +30,7 @@ export interface StreamCreator {
     }): Writable;
     onWrite?: () => void;
     onFinish?: (length: number) => void;
+    abortSignal?: AbortSignal;
 }
 export type WaitUntil = (promise: Promise<void>) => void;
 export interface DangerousOptions {
@@ -99,7 +100,7 @@ export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"midd
 }
 export type IncludedQueue = "sqs" | "sqs-lite" | "direct" | "dummy";
 export type IncludedIncrementalCache = "s3" | "s3-lite" | "multi-tier-ddb-s3" | "fs-dev" | "dummy";
-export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dynamodb-nextMode" | "fs-dev" | "dummy";
+export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dynamodb-nextMode" | "fs-dev" | "fs-dev-nextMode" | "dummy";
 export type IncludedImageLoader = "s3" | "s3-lite" | "host" | "fs-dev" | "dummy";
 export type IncludedOriginResolver = "pattern-env" | "dummy";
 export type IncludedWarmer = "aws-lambda" | "dummy";

package/dist/utils/safe-json-parse.d.ts

@@ -0,0 +1 @@
+export declare function safeParseJsonFile<T = any>(input: string, filePath: string, fallback?: T): T | undefined;

package/dist/utils/safe-json-parse.js

@@ -0,0 +1,10 @@
+import logger from "../logger.js";
+export function safeParseJsonFile(input, filePath, fallback) {
+    try {
+        return JSON.parse(input);
+    }
+    catch (err) {
+        logger.warn(`Failed to parse JSON file "${filePath}". Error: ${err.message}`);
+        return fallback;
+    }
+}

package/package.json

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