@opennextjs/aws 3.6.4 → 3.6.6

package/README.md

@@ -23,7 +23,7 @@ OpenNext takes the Next.js build output and converts it into packages that can b
 
 ## Features
 
-OpenNext aims to support all Next.js 14 features. Some features are work in progress. If you are running into any problems make sure to check the [docs](https://opennext.js.org/aws) first before you open a [new issue](/issues/new) or visit our [Discord](https://discord.gg/opennextjs) to let us know!
+OpenNext aims to support all Next.js 15 features. Some features are work in progress. If you are running into any problems make sure to check the [docs](https://opennext.js.org/aws) first before you open a [new issue](/issues/new) or visit our [Discord](https://discord.gg/opennextjs) to let us know!
 
 - [x] App & Pages Router
 - [x] API routes

package/dist/build/copyTracedFiles.js

@@ -1,5 +1,5 @@
 import url from "node:url";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { loadAppPathsManifest, loadBuildId, loadConfig, loadFunctionsConfigManifest, loadMiddlewareManifest, loadPagesManifest, loadPrerenderManifest, } from "../adapters/config/util.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -223,15 +223,15 @@ File ${serverPath} does not exist
             copyFileSync(path.join(standaloneNextDir, filePath), path.join(outputNextDir, filePath));
         }
     };
+    const manifests = getManifests(standaloneNextDir);
+    const { config, prerenderManifest, pagesManifest } = manifests;
     // Get all the static files - Should be only for pages dir
     // Ideally we would filter only those that might get accessed in this specific functions
     // Maybe even move this to s3 directly
     if (hasPageDir) {
         // First we get truly static files - i.e. pages without getStaticProps
-        const staticFiles = Object.values(loadPagesManifest(standaloneNextDir));
+        const staticFiles = Object.values(pagesManifest);
         // Then we need to get all fallback: true dynamic routes html
-        const prerenderManifest = loadPrerenderManifest(standaloneNextDir);
-        const config = loadConfig(standaloneNextDir);
         const locales = config.i18n?.locales;
         Object.values(prerenderManifest.dynamicRoutes).forEach((route) => {
             if (typeof route.fallback === "string") {
@@ -249,10 +249,15 @@ File ${serverPath} does not exist
             .filter((file) => file.endsWith(".html"))
             .forEach((file) => copyStaticFile(`server/${file}`));
     }
+    // Copy .next/static/css from standalone to output dir
+    // needed for optimizeCss feature to work
+    if (config.experimental.optimizeCss) {
+        cpSync(path.join(standaloneNextDir, "static", "css"), path.join(outputNextDir, "static", "css"), { recursive: true });
+    }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
     return {
         tracedFiles,
         nodePackages,
-        manifests: getManifests(standaloneNextDir),
+        manifests,
     };
 }

package/dist/build/createAssets.js

@@ -62,44 +62,46 @@ export function createCacheAssets(options) {
     const packagePath = buildHelper.getPackagePath(options);
     const buildId = buildHelper.getBuildId(options);
     let useTagCache = false;
-    // Copy pages to cache folder
     const dotNextPath = path.join(appBuildOutputPath, ".next/standalone", packagePath);
-    const outputPath = path.join(outputDir, "cache", buildId);
-    [".next/server/pages", ".next/server/app"]
+    const outputCachePath = path.join(outputDir, "cache", buildId);
+    fs.mkdirSync(outputCachePath, { recursive: true });
+    const sourceDirs = [".next/server/pages", ".next/server/app"]
         .map((dir) => path.join(dotNextPath, dir))
-        .filter(fs.existsSync)
-        .forEach((dir) => fs.cpSync(dir, outputPath, { recursive: true }));
-    // Remove non-cache files
+        .filter(fs.existsSync);
     const htmlPages = buildHelper.getHtmlPages(dotNextPath);
-    buildHelper.removeFiles(outputPath, ({ relativePath }) => relativePath.endsWith(".js") ||
+    const isFileSkipped = (relativePath) => relativePath.endsWith(".js") ||
         relativePath.endsWith(".js.nft.json") ||
-        (relativePath.endsWith(".html") && htmlPages.has(relativePath)));
+        (relativePath.endsWith(".html") && htmlPages.has(relativePath));
     // Merge cache files into a single file
     const cacheFilesPath = {};
-    buildHelper.traverseFiles(outputPath, () => true, ({ absolutePath }) => {
-        const ext = path.extname(absolutePath);
-        switch (ext) {
-            case ".meta":
-            case ".html":
-            case ".json":
-            case ".body":
-            case ".rsc": {
-                const newFilePath = absolutePath
-                    .substring(0, absolutePath.length - ext.length)
-                    .replace(/\.prefetch$/, "")
-                    .concat(".cache");
-                cacheFilesPath[newFilePath] = {
-                    [ext.slice(1)]: absolutePath,
-                    ...cacheFilesPath[newFilePath],
-                };
-                break;
+    // Process each source directory
+    sourceDirs.forEach((sourceDir) => {
+        buildHelper.traverseFiles(sourceDir, ({ relativePath }) => !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
+            const ext = path.extname(absolutePath);
+            switch (ext) {
+                case ".meta":
+                case ".html":
+                case ".json":
+                case ".body":
+                case ".rsc": {
+                    const newFilePath = path
+                        .join(outputCachePath, relativePath)
+                        .substring(0, path.join(outputCachePath, relativePath).length - ext.length)
+                        .replace(/\.prefetch$/, "")
+                        .concat(".cache");
+                    cacheFilesPath[newFilePath] = {
+                        [ext.slice(1)]: absolutePath,
+                        ...cacheFilesPath[newFilePath],
+                    };
+                    break;
+                }
+                case ".map":
+                    break;
+                default:
+                    logger.warn(`Unknown file extension: ${ext}`);
+                    break;
             }
-            case ".map":
-                break;
-            default:
-                logger.warn(`Unknown file extension: ${ext}`);
-                break;
-        }
+        });
     });
     // Generate cache file
     Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
@@ -122,6 +124,8 @@ export function createCacheAssets(options) {
                     : "utf8")
                 : undefined,
         };
+        // Ensure directory exists before writing
+        fs.mkdirSync(path.dirname(cacheFilePath), { recursive: true });
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
     });
     // We need to traverse the cache to find every .meta file
@@ -149,36 +153,36 @@ export function createCacheAssets(options) {
     if (!options.config.dangerous?.disableTagCache) {
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
-        buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
-            const fileContent = fs.readFileSync(absolutePath, "utf8");
-            const fileData = JSON.parse(fileContent);
-            if (fileData.headers?.["x-next-cache-tags"]) {
-                fileData.headers["x-next-cache-tags"]
-                    .split(",")
-                    .forEach((tag) => {
-                    // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
-                    metaFiles.push({
-                        tag: { S: path.posix.join(buildId, tag.trim()) },
-                        path: {
-                            S: path.posix.join(buildId, relativePath.replace(".meta", "")),
-                        },
-                        // We don't care about the revalidation time here, we just need to make sure it's there
-                        revalidatedAt: { N: "1" },
+        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"]) {
+                    fileData.headers["x-next-cache-tags"]
+                        .split(",")
+                        .forEach((tag) => {
+                        // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
+                        metaFiles.push({
+                            tag: { S: path.posix.join(buildId, tag.trim()) },
+                            path: {
+                                S: path.posix.join(buildId, relativePath.replace(".meta", "")),
+                            },
+                            // We don't care about the revalidation time here, we just need to make sure it's there
+                            revalidatedAt: { N: "1" },
+                        });
                     });
-                });
-            }
+                }
+            });
         });
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");
-            //Copy open-next.config.mjs into the bundle
+            // Copy open-next.config.mjs into the bundle
             fs.mkdirSync(providerPath, { recursive: true });
             buildHelper.copyOpenNextConfig(options.buildDir, providerPath);
             // TODO: check if metafiles doesn't contain duplicates
             fs.writeFileSync(path.join(providerPath, "dynamodb-cache.json"), JSON.stringify(metaFiles));
         }
     }
-    // We need to remove files later because we need the metafiles for dynamodb tags cache
-    buildHelper.removeFiles(outputPath, ({ relativePath }) => !relativePath.endsWith(".cache"));
     return { useTagCache, metaFiles };
 }

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 { patchBackgroundRevalidation, patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patch/patches/index.js";
+import * as patches from "./patch/patches/index.js";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -119,13 +119,13 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     });
     const additionalCodePatches = codeCustomization?.additionalCodePatches ?? [];
     await applyCodePatches(options, tracedFiles, manifests, [
-        patchFetchCacheSetMissingWaitUntil,
-        patchFetchCacheForISR,
-        patchUnstableCacheForISR,
-        patchNextServer,
-        patchEnvVars,
-        patchBackgroundRevalidation,
-        patchUseCacheForISR,
+        patches.patchFetchCacheSetMissingWaitUntil,
+        patches.patchFetchCacheForISR,
+        patches.patchUnstableCacheForISR,
+        patches.patchNextServer,
+        patches.patchEnvVars,
+        patches.patchBackgroundRevalidation,
+        patches.patchUseCacheForISR,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

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

@@ -1,5 +1,15 @@
 import type { CodePatcher } from "../codePatcher.js";
-export declare const minimalRule = "\nrule:\n  kind: member_expression\n  pattern: process.env.NEXT_MINIMAL\n  any:\n    - inside:\n        kind: parenthesized_expression\n        stopBy: end\n        inside:\n          kind: if_statement\n          any:\n            - inside:\n                kind: statement_block\n                inside:\n                  kind: method_definition\n                  any:\n                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}\n                    - has: {kind: property_identifier, field: name, regex: runMiddleware}\n                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}\n            - has:\n                kind: statement_block\n                has:\n                  kind: expression_statement\n                  pattern: res.statusCode = 400;\nfix:\n  'true'\n";
-export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any: \n      - has: \n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has: \n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
-export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: getMiddlewareManifest\nfix:\n  '{return null;}'\n";
+export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any:\n      - has:\n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has:\n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
+export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: ^getMiddlewareManifest$\nfix:\n  '{return null;}'\n";
+/**
+ * Swaps the body for a throwing implementation
+ *
+ * @param methodName The name of the method
+ * @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

@@ -1,51 +1,24 @@
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
 import { createPatchCode } from "../astCodePatcher.js";
-// This rule will replace the `NEXT_MINIMAL` env variable with true in multiple places to avoid executing unwanted path (i.e. next middleware, edge functions and image optimization)
-export const minimalRule = `
-rule:
-  kind: member_expression
-  pattern: process.env.NEXT_MINIMAL
-  any:
-    - inside:
-        kind: parenthesized_expression
-        stopBy: end
-        inside:
-          kind: if_statement
-          any:
-            - inside:
-                kind: statement_block
-                inside:
-                  kind: method_definition
-                  any:
-                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}
-                    - has: {kind: property_identifier, field: name, regex: runMiddleware}
-                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}
-            - has:
-                kind: statement_block
-                has:
-                  kind: expression_statement
-                  pattern: res.statusCode = 400;
-fix:
-  'true'
-`;
-// This rule will disable the background preloading of route done by NextServer by default during the creation of NextServer
+// Disable the background preloading of route done by NextServer by default during the creation of NextServer
 export const disablePreloadingRule = `
 rule:
   kind: statement_block
   inside:
     kind: if_statement
-    any: 
-      - has: 
+    any:
+      - has:
           kind: member_expression
           pattern: this.nextConfig.experimental.preloadEntriesOnStart
           stopBy: end
-      - has: 
+      - has:
           kind: binary_expression
           pattern: appDocumentPreloading === true
           stopBy: end
 fix:
   '{}'
 `;
-// This rule is mostly for splitted edge functions so that we don't try to match them on the other non edge functions
+// Mostly for splitted edge functions so that we don't try to match them on the other non edge functions
 export const removeMiddlewareManifestRule = `
 rule:
   kind: statement_block
@@ -53,39 +26,104 @@ rule:
     kind: method_definition
     has:
       kind: property_identifier
-      regex: getMiddlewareManifest
+      regex: ^getMiddlewareManifest$
 fix:
   '{return null;}'
 `;
+/**
+ * Swaps the body for a throwing implementation
+ *
+ * @param methodName The name of the method
+ * @returns A rule to replace the body with a `throw`
+ */
+export function createEmptyBodyRule(methodName) {
+    return `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { async ${methodName}($$$PARAMS) { $$$_ } }"
+fix: |-
+  async ${methodName}($$$PARAMS) {
+    throw new Error("${methodName} should not be called with OpenNext");
+  }
+`;
+}
+/**
+ * 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,
+});
+/**
+ * Patches to avoid pulling babel (~4MB).
+ *
+ * Details:
+ * - empty `NextServer#runMiddleware` and `NextServer#runEdgeFunction` that are not used
+ * - drop `next/dist/server/node-environment-extensions/error-inspect.js`
+ */
+const babelPatches = [
+    // Empty the body of `NextServer#runMiddleware`
+    {
+        field: {
+            pathFilter,
+            contentFilter: /runMiddleware\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
+        },
+    },
+    // Empty the body of `NextServer#runEdgeFunction`
+    {
+        field: {
+            pathFilter,
+            contentFilter: /runEdgeFunction\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
+        },
+    },
+    // Drop `error-inspect` that pulls babel
+    {
+        field: {
+            pathFilter,
+            contentFilter: /error-inspect/,
+            patchCode: createPatchCode(errorInspectRule),
+        },
+    },
+];
 export const patchNextServer = {
     name: "patch-next-server",
     patches: [
-        // Skip executing next middleware, edge functions and image optimization inside NextServer
+        // Empty the body of `NextServer#imageOptimizer` - unused in OpenNext
         {
-            versions: ">=15.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
-                contentFilter: /process\.env\.NEXT_MINIMAL/,
-                patchCode: createPatchCode(minimalRule),
+                pathFilter,
+                contentFilter: /imageOptimizer\(/,
+                patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
             },
         },
-        // Disable Next background preloading done at creation of `NetxServer`
+        // Disable Next background preloading done at creation of `NextServer`
         {
-            versions: ">=15.0.0",
+            versions: ">=14.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
+                pathFilter,
                 contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
                 patchCode: createPatchCode(disablePreloadingRule),
             },
         },
         // Don't match edge functions in `NextServer`
         {
-            versions: ">=15.0.0",
+            // Next 12 and some version of 13 use the bundled middleware/edge function
+            versions: ">=14.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
+                pathFilter,
                 contentFilter: /getMiddlewareManifest/,
                 patchCode: createPatchCode(removeMiddlewareManifestRule),
             },
         },
+        ...babelPatches,
     ],
 };

package/dist/core/routing/cacheInterceptor.js

@@ -92,7 +92,8 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
-        statusCode: 200,
+        // sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
+        statusCode: cachedValue.meta?.status ?? 200,
         body: toReadableStream(body, false),
         isBase64Encoded: false,
         headers: {

package/dist/core/routing/matcher.js

@@ -259,7 +259,8 @@ export function handleRedirects(event, redirects) {
 }
 export function fixDataPage(internalEvent, buildId) {
     const { rawPath, query } = internalEvent;
-    const dataPattern = `${NextConfig.basePath ?? ""}/_next/data/${buildId}`;
+    const basePath = NextConfig.basePath ?? "";
+    const dataPattern = `${basePath}/_next/data/${buildId}`;
     // Return 404 for data requests that don't match the buildId
     if (rawPath.startsWith("/_next/data") && !rawPath.startsWith(dataPattern)) {
         return {
@@ -273,9 +274,9 @@ export function fixDataPage(internalEvent, buildId) {
         };
     }
     if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
-        const newPath = rawPath
+        const newPath = `${basePath}${rawPath
             .slice(dataPattern.length, -".json".length)
-            .replace(/^\/index$/, "/");
+            .replace(/^\/index$/, "/")}`;
         query.__nextDataReq = "1";
         return {
             ...internalEvent,

package/dist/http/openNextResponse.js

@@ -1,6 +1,6 @@
 import { Transform } from "node:stream";
 import { debug } from "../adapters/logger";
-import { parseCookies, parseHeaders } from "./util";
+import { parseHeaders, parseSetCookieHeader } from "./util";
 const SET_COOKIE_HEADER = "set-cookie";
 const CANNOT_BE_USED = "This cannot be used in OpenNext";
 // We only need to implement the methods that are used by next.js
@@ -127,7 +127,7 @@ export class OpenNextNodeResponse extends Transform {
                         ...this.initialHeaders,
                         ...this.headers,
                     };
-            const initialCookies = parseCookies(this.initialHeaders[SET_COOKIE_HEADER]?.toString());
+            const initialCookies = parseSetCookieHeader(this.initialHeaders[SET_COOKIE_HEADER]?.toString());
             this._cookies =
                 mergeHeadersPriority === "middleware"
                     ? [...this._cookies, ...initialCookies]

package/dist/http/util.d.ts

@@ -1,7 +1,13 @@
 import type http from "node:http";
 export declare const parseHeaders: (headers?: http.OutgoingHttpHeader[] | http.OutgoingHttpHeaders) => Record<string, string>;
 export declare const convertHeader: (header: http.OutgoingHttpHeader) => string;
-export declare function parseCookies(cookies: string | string[] | null | undefined): string[];
+/**
+ * Parses a (comma-separated) list of Set-Cookie headers
+ *
+ * @param cookies A comma-separated list of Set-Cookie headers or a list of Set-Cookie headers
+ * @returns A list of Set-Cookie header
+ */
+export declare function parseSetCookieHeader(cookies: string | string[] | null | undefined): string[];
 /**
  *
  * Get the query object from an iterable of [key, value] pairs

package/dist/http/util.js

@@ -20,13 +20,23 @@ export const convertHeader = (header) => {
     }
     return String(header);
 };
-export function parseCookies(cookies) {
+/**
+ * Parses a (comma-separated) list of Set-Cookie headers
+ *
+ * @param cookies A comma-separated list of Set-Cookie headers or a list of Set-Cookie headers
+ * @returns A list of Set-Cookie header
+ */
+export function parseSetCookieHeader(cookies) {
     if (!cookies) {
         return [];
     }
-    return typeof cookies === "string"
-        ? cookies.split(/(?<!Expires=\w+),/i).map((c) => c.trim())
-        : cookies;
+    if (typeof cookies === "string") {
+        // Split the cookie string on ",".
+        // Note that "," can also appear in the Expires value (i.e. `Expires=Thu, 01 June`)
+        // so we have to skip it with a negative lookbehind.
+        return cookies.split(/(?<!Expires=\w+),/i).map((c) => c.trim());
+    }
+    return cookies;
 }
 /**
  *

package/dist/overrides/converters/aws-apigw-v2.js

@@ -1,4 +1,4 @@
-import { parseCookies } from "../../http/util";
+import { parseSetCookieHeader } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery } from "../../core/routing/util";
@@ -87,7 +87,7 @@ async function convertToApiGatewayProxyResultV2(result) {
     const response = {
         statusCode: result.statusCode,
         headers,
-        cookies: parseCookies(result.headers["set-cookie"]),
+        cookies: parseSetCookieHeader(result.headers["set-cookie"]),
         body,
         isBase64Encoded: result.isBase64Encoded,
     };

package/dist/overrides/converters/aws-cloudfront.js

@@ -1,4 +1,4 @@
-import { parseCookies } from "../../http/util";
+import { parseSetCookieHeader } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { convertToQuery, convertToQueryString } from "../../core/routing/util";
@@ -84,7 +84,7 @@ function convertToCloudfrontHeaders(headers, directResponse) {
         (directResponse ? !cloudfrontReadOnlyHeaders.includes(key) : true))
         .forEach(([key, value]) => {
         if (key === "set-cookie") {
-            cloudfrontHeaders[key] = parseCookies(`${value}`).map((cookie) => ({
+            cloudfrontHeaders[key] = parseSetCookieHeader(`${value}`).map((cookie) => ({
                 key,
                 value: cookie,
             }));

package/dist/overrides/converters/edge.js

@@ -1,6 +1,9 @@
 import { Buffer } from "node:buffer";
-import { parseCookies } from "../../http/util";
+import cookieParser from "cookie";
+import { parseSetCookieHeader } from "../../http/util";
 import { getQueryFromSearchParams } from "./utils.js";
+// https://fetch.spec.whatwg.org/#statuses
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
 const converter = {
     convertFrom: async (event) => {
         const url = new URL(event.url);
@@ -15,7 +18,10 @@ const converter = {
         const rawPath = url.pathname;
         const method = event.method;
         const shouldHaveBody = method !== "GET" && method !== "HEAD";
-        const cookies = Object.fromEntries(parseCookies(event.headers.get("cookie")).map((cookie) => cookie.split("=")));
+        const cookieHeader = event.headers.get("cookie");
+        const cookies = cookieHeader
+            ? cookieParser.parse(cookieHeader)
+            : {};
         return {
             type: "core",
             method,
@@ -58,7 +64,7 @@ const converter = {
             if (key === "set-cookie" && typeof value === "string") {
                 // If the value is a string, we need to parse it into an array
                 // This is the case for middleware direct result
-                const cookies = parseCookies(value);
+                const cookies = parseSetCookieHeader(value);
                 for (const cookie of cookies) {
                     headers.append(key, cookie);
                 }
@@ -73,7 +79,11 @@ const converter = {
                 headers.set(key, value);
             }
         }
-        return new Response(result.body, {
+        // We should not return a body for statusCode's that doesn't allow bodies
+        const body = NULL_BODY_STATUSES.has(result.statusCode)
+            ? null
+            : result.body;
+        return new Response(body, {
             status: result.statusCode,
             headers,
         });

package/dist/overrides/converters/node.js

@@ -1,4 +1,4 @@
-import { parseCookies } from "../../http/util";
+import cookieParser from "cookie";
 import { extractHostFromHeaders, getQueryFromSearchParams } from "./utils.js";
 const converter = {
     convertFrom: async (req) => {
@@ -20,6 +20,10 @@ const converter = {
         // https://nodejs.org/api/http.html#messageurl
         const url = new URL(`${req.protocol ? req.protocol : "http"}://${extractHostFromHeaders(headers)}${req.url}`);
         const query = getQueryFromSearchParams(url.searchParams);
+        const cookieHeader = req.headers.cookie;
+        const cookies = cookieHeader
+            ? cookieParser.parse(cookieHeader)
+            : {};
         return {
             type: "core",
             method: req.method ?? "GET",
@@ -31,10 +35,7 @@ const converter = {
                 req.socket.remoteAddress ??
                 "::1",
             query,
-            cookies: Object.fromEntries(parseCookies(req.headers.cookie)?.map((cookie) => {
-                const [key, value] = cookie.split("=");
-                return [key, value];
-            }) ?? []),
+            cookies,
         };
     },
     // Nothing to do here, it's streaming

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

@@ -72,10 +72,12 @@ export interface NextConfig {
     experimental: {
         serverActions?: boolean;
         appDir?: boolean;
+        optimizeCss?: boolean;
     };
     images: ImageConfig;
     poweredByHeader?: boolean;
     serverExternalPackages?: string[];
+    deploymentId?: string;
 }
 export interface RouteDefinition {
     page: string;

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.6.4",
+  "version": "3.6.6",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -44,6 +44,7 @@
     "@tsconfig/node18": "^1.0.1",
     "aws4fetch": "^1.0.18",
     "chalk": "^5.3.0",
+    "cookie": "^1.0.2",
     "esbuild": "0.25.4",
     "express": "5.0.1",
     "path-to-regexp": "^6.3.0",