@opennextjs/aws 3.6.0 → 3.6.1

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

@@ -114,17 +114,13 @@ 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";
-    }
     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

@@ -3,6 +3,7 @@ import { compile, match } from "path-to-regexp";
 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) {
@@ -265,9 +266,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 +275,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/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/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,2 @@
 export declare function normalizePath(path: string): string;
+export declare function getMonorepoRelativePath(relativePath?: string): string;

package/dist/utils/normalize-path.js

@@ -1,3 +1,11 @@
+import path from "node:path";
 export function normalizePath(path) {
     return path.replace(/\\/g, "/");
 }
+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.1",
   "bin": {
     "open-next": "./dist/index.js"
   },