@opennextjs/aws 3.6.0 → 3.6.2

package/dist/build/compileConfig.js

@@ -83,5 +83,9 @@ export function compileOpenNextConfigEdge(sourcePath, outputDir, externals) {
         conditions: ["worker", "browser"],
         platform: "browser",
         external: externals,
+        define: {
+            // with the default esbuild config, the NODE_ENV will be set to "development", we don't want that
+            "process.env.NODE_ENV": '"production"',
+        },
     });
 }

package/dist/build/createMiddleware.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { loadFunctionsConfigManifest, loadMiddlewareManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
-import { buildEdgeBundle } from "./edge/createEdgeBundle.js";
+import { buildEdgeBundle, copyMiddlewareResources, } from "./edge/createEdgeBundle.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 import { buildBundledNodeMiddleware, buildExternalNodeMiddleware, } from "./middleware/buildNodeMiddleware.js";
@@ -31,6 +31,7 @@ export async function createMiddleware(options, { forceOnlyBuildOnce = false } =
     }
     if (config.middleware?.external) {
         const outputPath = path.join(outputDir, "middleware");
+        copyMiddlewareResources(options, edgeMiddlewareInfo, outputPath);
         fs.mkdirSync(outputPath, { recursive: true });
         // Copy open-next.config.mjs
         buildHelper.copyOpenNextConfig(options.buildDir, outputPath, await buildHelper.isEdgeRuntime(config.middleware.override));

package/dist/core/requestHandler.js

@@ -51,7 +51,11 @@ export async function openNextHandler(internalEvent, options) {
                 continue;
             }
             const key = rawKey.slice(MIDDLEWARE_HEADER_PREFIX_LEN);
-            overwrittenResponseHeaders[key] = value;
+            // We skip this header here since it is used by Next internally and we don't want it on the response headers.
+            // This header needs to be present in the request headers for processRequest, so cookies().get() from Next will work on initial render.
+            if (key !== "x-middleware-set-cookie") {
+                overwrittenResponseHeaders[key] = value;
+            }
             headers[key] = value;
             delete headers[rawKey];
         }
@@ -151,44 +155,68 @@ async function processRequest(req, res, routingResult) {
     // Next.js doesn't parse body if the property exists
     // https://github.com/dougmoscrop/serverless-http/issues/227
     delete req.body;
+    // Here we try to apply as much request metadata as possible
+    // We apply every metadata from `resolve-routes` https://github.com/vercel/next.js/blob/916f105b97211de50f8580f0b39c9e7c60de4886/packages/next/src/server/lib/router-utils/resolve-routes.ts
+    // and `router-server` https://github.com/vercel/next.js/blob/916f105b97211de50f8580f0b39c9e7c60de4886/packages/next/src/server/lib/router-server.ts
+    const initialURL = new URL(routingResult.initialURL);
+    let invokeStatus;
+    if (routingResult.internalEvent.rawPath === "/500") {
+        invokeStatus = 500;
+    }
+    else if (routingResult.internalEvent.rawPath === "/404") {
+        invokeStatus = 404;
+    }
+    const requestMetadata = {
+        isNextDataReq: routingResult.internalEvent.query.__nextDataReq === "1",
+        initURL: routingResult.initialURL,
+        initQuery: convertToQuery(initialURL.search),
+        initProtocol: initialURL.protocol,
+        defaultLocale: NextConfig.i18n?.defaultLocale,
+        locale: routingResult.locale,
+        middlewareInvoke: false,
+        // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
+        invokePath: routingResult.internalEvent.rawPath,
+        invokeQuery: routingResult.internalEvent.query,
+        // invokeStatus is only used for error pages
+        invokeStatus,
+    };
     try {
         //#override applyNextjsPrebundledReact
         setNextjsPrebundledReact(routingResult.internalEvent.rawPath);
         //#endOverride
-        // Here we try to apply as much request metadata as possible
-        // We apply every metadata from `resolve-routes` https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
-        // and `router-server` https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-server.ts
-        const initialURL = new URL(routingResult.initialURL);
-        let invokeStatus;
-        if (routingResult.internalEvent.rawPath === "/500") {
-            invokeStatus = 500;
-        }
-        else if (routingResult.internalEvent.rawPath === "/404") {
-            invokeStatus = 404;
-        }
-        const requestMetadata = {
-            isNextDataReq: routingResult.internalEvent.query.__nextDataReq === "1",
-            initURL: routingResult.initialURL,
-            initQuery: convertToQuery(initialURL.search),
-            initProtocol: initialURL.protocol,
-            defaultLocale: NextConfig.i18n?.defaultLocale,
-            locale: routingResult.locale,
-            middlewareInvoke: false,
-            // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
-            invokePath: routingResult.internalEvent.rawPath,
-            invokeQuery: routingResult.internalEvent.query,
-            // invokeStatus is only used for error pages
-            invokeStatus,
-        };
         // Next Server
         await requestHandler(requestMetadata)(req, res);
     }
     catch (e) {
         // This might fail when using bundled next, importing won't do the trick either
         if (e.constructor.name === "NoFallbackError") {
-            // Do we need to handle _not-found
-            // Ideally this should never get triggered and be intercepted by the routing handler
-            await tryRenderError("404", res, routingResult.internalEvent);
+            await handleNoFallbackError(req, res, routingResult, requestMetadata);
+        }
+        else {
+            error("NextJS request failed.", e);
+            await tryRenderError("500", res, routingResult.internalEvent);
+        }
+    }
+}
+async function handleNoFallbackError(req, res, routingResult, metadata, index = 1) {
+    if (index >= 5) {
+        await tryRenderError("500", res, routingResult.internalEvent);
+        return;
+    }
+    if (index >= routingResult.resolvedRoutes.length) {
+        await tryRenderError("404", res, routingResult.internalEvent);
+        return;
+    }
+    try {
+        await requestHandler({
+            ...routingResult,
+            invokeOutput: routingResult.resolvedRoutes[index].route,
+            ...metadata,
+        })(req, res);
+    }
+    catch (e) {
+        if (e.constructor.name === "NoFallbackError") {
+            await handleNoFallbackError(req, res, routingResult, metadata, index + 1);
         }
         else {
             error("NextJS request failed.", e);

package/dist/core/routing/cacheInterceptor.js

@@ -102,6 +102,32 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
         },
     };
 }
+/**
+ *
+ * https://github.com/vercel/next.js/blob/34039551d2e5f611c0abde31a197d9985918adaf/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts#L2-L10
+ */
+function escapePathDelimiters(segment, escapeEncoded) {
+    return segment.replace(new RegExp(`([/#?]${escapeEncoded ? "|%(2f|23|3f|5c)" : ""})`, "gi"), (char) => encodeURIComponent(char));
+}
+/**
+ *
+ * SSG cache key needs to be decoded, but some characters needs to be properly escaped
+ * https://github.com/vercel/next.js/blob/34039551d2e5f611c0abde31a197d9985918adaf/packages/next/src/server/lib/router-utils/decode-path-params.ts#L11-L26
+ */
+function decodePathParams(pathname) {
+    return pathname
+        .split("/")
+        .map((segment) => {
+        try {
+            return escapePathDelimiters(decodeURIComponent(segment), true);
+        }
+        catch (e) {
+            // If decodeURIComponent fails, we return the original segment
+            return segment;
+        }
+    })
+        .join("/");
+}
 export async function cacheInterceptor(event) {
     if (Boolean(event.headers["next-action"]) ||
         Boolean(event.headers["x-prerender-revalidate"]))
@@ -114,17 +140,15 @@ export async function cacheInterceptor(event) {
     }
     // We also need to remove trailing slash
     localizedPath = localizedPath.replace(/\/$/, "");
-    // If empty path, it means we want index
-    if (localizedPath === "") {
-        localizedPath = "index";
-    }
+    // Then we decode the path params
+    localizedPath = decodePathParams(localizedPath);
     debug("Checking cache for", localizedPath, PrerenderManifest);
-    const isISR = Object.keys(PrerenderManifest.routes).includes(localizedPath) ||
+    const isISR = Object.keys(PrerenderManifest.routes).includes(localizedPath ?? "/") ||
         Object.values(PrerenderManifest.dynamicRoutes).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
     debug("isISR", isISR);
     if (isISR) {
         try {
-            const cachedData = await globalThis.incrementalCache.get(localizedPath);
+            const cachedData = await globalThis.incrementalCache.get(localizedPath ?? "/index");
             debug("cached data in interceptor", cachedData);
             if (!cachedData?.value) {
                 return event;

package/dist/core/routing/matcher.js

@@ -1,8 +1,10 @@
 import { NextConfig } from "../../adapters/config/index";
 import { compile, match } from "path-to-regexp";
+import { normalizeRepeatedSlashes } from "../../utils/normalize-path";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { handleLocaleRedirect, localizePath } from "./i18n";
+import { dynamicRouteMatcher, staticRouteMatcher } from "./routeMatcher";
 import { constructNextUrl, convertFromQueryString, convertToQueryString, escapeRegex, getUrlParts, isExternal, unescapeRegex, } from "./util";
 const routeHasMatcher = (headers, cookies, query) => (redirect) => {
     switch (redirect.type) {
@@ -168,6 +170,25 @@ export function handleRewrites(event, rewrites) {
         isExternalRewrite,
     };
 }
+// Normalizes repeated slashes in the path e.g. hello//world -> hello/world
+// or backslashes to forward slashes. This prevents requests such as //domain
+// from invoking the middleware with `request.url === "domain"`.
+// See: https://github.com/vercel/next.js/blob/3ecf087f10fdfba4426daa02b459387bc9c3c54f/packages/next/src/server/base-server.ts#L1016-L1020
+function handleRepeatedSlashRedirect(event) {
+    // Redirect `https://example.com//foo` to `https://example.com/foo`.
+    if (event.rawPath.match(/(\\|\/\/)/)) {
+        return {
+            type: event.type,
+            statusCode: 308,
+            headers: {
+                Location: normalizeRepeatedSlashes(new URL(event.url)),
+            },
+            body: emptyReadableStream(),
+            isBase64Encoded: false,
+        };
+    }
+    return false;
+}
 function handleTrailingSlashRedirect(event) {
     // When rawPath is `//domain`, `url.host` would be `domain`.
     // https://github.com/opennextjs/opennextjs-aws/issues/355
@@ -214,6 +235,9 @@ function handleTrailingSlashRedirect(event) {
     return false;
 }
 export function handleRedirects(event, redirects) {
+    const repeatedSlashRedirect = handleRepeatedSlashRedirect(event);
+    if (repeatedSlashRedirect)
+        return repeatedSlashRedirect;
     const trailingSlashRedirect = handleTrailingSlashRedirect(event);
     if (trailingSlashRedirect)
         return trailingSlashRedirect;
@@ -265,9 +289,8 @@ export function fixDataPage(internalEvent, buildId) {
 export function handleFallbackFalse(internalEvent, prerenderManifest) {
     const { rawPath } = internalEvent;
     const { dynamicRoutes, routes } = prerenderManifest;
-    const routeFallback = Object.entries(dynamicRoutes)
-        .filter(([, { fallback }]) => fallback === false)
-        .some(([, { routeRegex }]) => {
+    const prerenderedFallbackRoutes = Object.entries(dynamicRoutes).filter(([, { fallback }]) => fallback === false);
+    const routeFallback = prerenderedFallbackRoutes.some(([, { routeRegex }]) => {
         const routeRegexExp = new RegExp(routeRegex);
         return routeRegexExp.test(rawPath);
     });
@@ -275,11 +298,21 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
     const routesAlreadyHaveLocale = locales?.includes(rawPath.split("/")[1]) ||
         // If we don't use locales, we don't need to add the default locale
         locales === undefined;
-    const localizedPath = routesAlreadyHaveLocale
+    let localizedPath = routesAlreadyHaveLocale
         ? rawPath
         : `/${NextConfig.i18n?.defaultLocale}${rawPath}`;
+    // We need to remove the trailing slash if it exists
+    if (NextConfig.trailingSlash && localizedPath.endsWith("/")) {
+        localizedPath = localizedPath.slice(0, -1);
+    }
+    const matchedStaticRoute = staticRouteMatcher(localizedPath);
+    const prerenderedFallbackRoutesName = prerenderedFallbackRoutes.map(([name]) => name);
+    const matchedDynamicRoute = dynamicRouteMatcher(localizedPath).filter(({ route }) => !prerenderedFallbackRoutesName.includes(route));
     const isPregenerated = Object.keys(routes).includes(localizedPath);
-    if (routeFallback && !isPregenerated) {
+    if (routeFallback &&
+        !isPregenerated &&
+        matchedStaticRoute.length === 0 &&
+        matchedDynamicRoute.length === 0) {
         return {
             event: {
                 ...internalEvent,

package/dist/core/routing/middleware.js

@@ -75,7 +75,6 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     // 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

package/dist/core/routing/routeMatcher.d.ts

@@ -1,10 +1,4 @@
-import type { RouteType } from "../../types/open-next";
+import type { ResolvedRoute } from "../../types/open-next";
 export declare const apiPrefix: string;
-export declare const staticRouteMatcher: (path: string) => {
-    route: string;
-    type: RouteType;
-}[];
-export declare const dynamicRouteMatcher: (path: string) => {
-    route: string;
-    type: RouteType;
-}[];
+export declare const staticRouteMatcher: (path: string) => ResolvedRoute[];
+export declare const dynamicRouteMatcher: (path: string) => ResolvedRoute[];

package/dist/overrides/converters/edge.js

@@ -55,7 +55,23 @@ const converter = {
         }
         const headers = new Headers();
         for (const [key, value] of Object.entries(result.headers)) {
-            headers.set(key, Array.isArray(value) ? value.join(",") : value);
+            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);
+                for (const cookie of cookies) {
+                    headers.append(key, cookie);
+                }
+                continue;
+            }
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    headers.append(key, v);
+                }
+            }
+            else {
+                headers.set(key, value);
+            }
         }
         return new Response(result.body, {
             status: result.statusCode,

package/dist/overrides/converters/node.js

@@ -17,7 +17,8 @@ const converter = {
             Array.isArray(value) ? value.join(",") : value,
         ])
             .filter(([key]) => key));
-        const url = new URL(req.url, `http://${extractHostFromHeaders(headers)}`);
+        // 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);
         return {
             type: "core",

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

@@ -1,9 +1,11 @@
 import fs from "node:fs";
+import path from "node:path";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
 export default {
     name: "fs-dev",
     load: async (url) => {
-        const basePath = "../../assets";
-        const body = fs.createReadStream(`${basePath}/${url}`);
+        const imagePath = path.join(getMonorepoRelativePath(), "assets", url);
+        const body = fs.createReadStream(imagePath);
         const contentType = url.endsWith(".png") ? "image/png" : "image/jpeg";
         return {
             body,

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

@@ -1,7 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const buildId = process.env.NEXT_BUILD_ID;
-const basePath = path.resolve(process.cwd(), `../../cache/${buildId}`);
+const basePath = path.join(getMonorepoRelativePath(), `cache/${buildId}`);
 const getCacheKey = (key) => {
     return path.join(basePath, `${key}.cache`);
 };

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

@@ -1,6 +1,7 @@
 import fs from "node:fs";
-// TODO: fix this for monorepo
-const tagFile = "../../dynamodb-provider/dynamodb-cache.json";
+import path from "node:path";
+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 tagCache = {

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

@@ -1,9 +1,11 @@
+import path from "node:path";
 import express from "express";
+import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const wrapper = async (handler, converter) => {
     const app = express();
     // To serve static assets
-    app.use(express.static("../../assets"));
-    const imageHandlerPath = "../../image-optimization-function/index.mjs";
+    app.use(express.static(path.join(getMonorepoRelativePath(), "assets")));
+    const imageHandlerPath = path.join(getMonorepoRelativePath(), "image-optimization-function/index.mjs");
     const imageHandler = await import(imageHandlerPath).then((m) => m.handler);
     app.all("/_next/image", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);

package/dist/plugins/edge.js

@@ -27,7 +27,7 @@ export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudflare, }
         name: "opennext-edge",
         setup(build) {
             logger.debug(chalk.blue("OpenNext Edge plugin"));
-            build.onResolve({ filter: /\.(mjs|wasm)$/g }, () => {
+            build.onResolve({ filter: /\.(mjs|wasm)$/ }, () => {
                 return {
                     external: true,
                 };

package/dist/types/global.d.ts

@@ -185,5 +185,10 @@ declare global {
      * Only available in main functions.
      */
     var __next_route_preloader: (stage: "waitUntil" | "start" | "warmerEvent" | "onDemand") => Promise<void>;
+    /**
+     * This is the relative package path of the monorepo. It will be an empty string "" in normal repos.
+     * ex. `packages/web`
+     */
+    var monorepoPackagePath: string;
 }
 export {};

package/dist/utils/normalize-path.d.ts

@@ -1 +1,3 @@
 export declare function normalizePath(path: string): string;
+export declare function normalizeRepeatedSlashes(url: URL): string;
+export declare function getMonorepoRelativePath(relativePath?: string): string;

package/dist/utils/normalize-path.js

@@ -1,3 +1,18 @@
+import path from "node:path";
 export function normalizePath(path) {
     return path.replace(/\\/g, "/");
 }
+// See: https://github.com/vercel/next.js/blob/3ecf087f10fdfba4426daa02b459387bc9c3c54f/packages/next/src/shared/lib/utils.ts#L348
+export function normalizeRepeatedSlashes(url) {
+    const urlNoQuery = url.host + url.pathname;
+    return `${url.protocol}//${urlNoQuery
+        .replace(/\\/g, "/")
+        .replace(/\/\/+/g, "/")}${url.search}`;
+}
+export function getMonorepoRelativePath(relativePath = "../..") {
+    return path.join(globalThis.monorepoPackagePath
+        .split("/")
+        .filter(Boolean)
+        .map(() => "..")
+        .join("/"), relativePath);
+}

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -14,8 +14,8 @@
   "main": "./dist/index.js",
   "exports": {
     "./*": {
-      "default": "./dist/*",
-      "types": "./dist/*.d.ts"
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*"
     }
   },
   "typesVersions": {
@@ -44,7 +44,7 @@
     "@tsconfig/node18": "^1.0.1",
     "aws4fetch": "^1.0.18",
     "chalk": "^5.3.0",
-    "esbuild": "0.19.2",
+    "esbuild": "0.25.4",
     "express": "5.0.1",
     "path-to-regexp": "^6.3.0",
     "urlpattern-polyfill": "^10.0.0",