@opennextjs/aws 3.6.2 → 3.6.3

package/README.md

@@ -96,6 +96,8 @@ To run `OpenNext` locally:
    path/to/opennextjs-aws/packages/open-next/dist/index.js build
    ```
 
+There is also a way to run OpenNext locally. You can read a guide about it [here](https://opennext.js.org/aws/contribute/local_run). Its mostly used for development/debugging purposes.
+
 ### Coldstart
 
 OpenNext provide you with a warmer function that can be used to reduce cold start.

package/dist/adapters/config/index.d.ts

@@ -23,6 +23,7 @@ export declare const RoutesManifest: {
 };
 export declare const ConfigHeaders: import("../../types/next-types").Header[] | undefined;
 export declare const PrerenderManifest: import("../../types/next-types").PrerenderManifest;
+export declare const PagesManifest: Record<string, string>;
 export declare const AppPathsManifestKeys: string[];
 export declare const MiddlewareManifest: import("../../types/next-types").MiddlewareManifest;
 export declare const AppPathsManifest: Record<string, string>;

package/dist/adapters/config/index.js

@@ -1,10 +1,9 @@
 import path from "node:path";
 import { debug } from "../logger";
-import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPagesManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
 export const NEXT_DIR = path.join(__dirname, ".next");
 export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
 debug({ NEXT_DIR, OPEN_NEXT_DIR });
-//TODO: inject these values at build time
 export const NextConfig = /* @__PURE__ */ loadConfig(NEXT_DIR);
 export const BuildId = /* @__PURE__ */ loadBuildId(NEXT_DIR);
 export const HtmlPages = /* @__PURE__ */ loadHtmlPages(NEXT_DIR);
@@ -13,6 +12,7 @@ export const RoutesManifest = /* @__PURE__ */ loadRoutesManifest(NEXT_DIR);
 export const ConfigHeaders = /* @__PURE__ */ loadConfigHeaders(NEXT_DIR);
 export const PrerenderManifest = 
 /* @__PURE__ */ loadPrerenderManifest(NEXT_DIR);
+export const PagesManifest = /* @__PURE__ */ loadPagesManifest(NEXT_DIR);
 export const AppPathsManifestKeys = 
 /* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
 export const MiddlewareManifest = 

package/dist/adapters/config/util.d.ts

@@ -2,7 +2,7 @@ import type { FunctionsConfigManifest, MiddlewareManifest, NextConfig, Prerender
 import type { PublicFiles } from "../../build";
 export declare function loadConfig(nextDir: string): NextConfig;
 export declare function loadBuildId(nextDir: string): string;
-export declare function loadPagesManifest(nextDir: string): any;
+export declare function loadPagesManifest(nextDir: string): Record<string, string>;
 export declare function loadHtmlPages(nextDir: string): string[];
 export declare function loadPublicAssets(openNextDir: string): PublicFiles;
 export declare function loadRoutesManifest(nextDir: string): {

package/dist/build/copyTracedFiles.d.ts

@@ -10,7 +10,7 @@ export declare function getManifests(nextDir: string): {
     buildId: string;
     config: import("../types/next-types.js").NextConfig;
     prerenderManifest: import("../types/next-types.js").PrerenderManifest;
-    pagesManifest: any;
+    pagesManifest: Record<string, string>;
     appPathsManifest: Record<string, string>;
     middlewareManifest: import("../types/next-types.js").MiddlewareManifest;
     functionsConfigManifest: import("../types/next-types.js").FunctionsConfigManifest;
@@ -22,7 +22,7 @@ export declare function copyTracedFiles({ buildOutputPath, packagePath, outputDi
         buildId: string;
         config: import("../types/next-types.js").NextConfig;
         prerenderManifest: import("../types/next-types.js").PrerenderManifest;
-        pagesManifest: any;
+        pagesManifest: Record<string, string>;
         appPathsManifest: Record<string, string>;
         middlewareManifest: import("../types/next-types.js").MiddlewareManifest;
         functionsConfigManifest: import("../types/next-types.js").FunctionsConfigManifest;

package/dist/core/routing/matcher.js

@@ -302,7 +302,11 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
         ? rawPath
         : `/${NextConfig.i18n?.defaultLocale}${rawPath}`;
     // We need to remove the trailing slash if it exists
-    if (NextConfig.trailingSlash && localizedPath.endsWith("/")) {
+    if (
+    // Not if localizedPath is "/" tho, because that would not make it find `isPregenerated` below since it would be try to match an empty string.
+    localizedPath !== "/" &&
+        NextConfig.trailingSlash &&
+        localizedPath.endsWith("/")) {
         localizedPath = localizedPath.slice(0, -1);
     }
     const matchedStaticRoute = staticRouteMatcher(localizedPath);

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

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

package/dist/core/routing/routeMatcher.js

@@ -1,12 +1,10 @@
-import { AppPathRoutesManifest, RoutesManifest } from "../../adapters/config/index";
+import { AppPathRoutesManifest, PagesManifest, RoutesManifest, } from "../../adapters/config/index";
 // Add the locale prefix to the regex so we correctly match the rawPath
 const optionalLocalePrefixRegex = `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`;
 // Add the basepath prefix to the regex so we correctly match the rawPath
 const optionalBasepathPrefixRegex = RoutesManifest.basePath
     ? `^${RoutesManifest.basePath}/?`
     : "^/";
-// Add the basePath prefix to the api routes
-export const apiPrefix = `${RoutesManifest.basePath ?? ""}/api`;
 const optionalPrefix = optionalLocalePrefixRegex.replace("^/", optionalBasepathPrefixRegex);
 function routeMatcher(routeDefinitions) {
     const regexp = routeDefinitions.map((route) => ({
@@ -41,5 +39,32 @@ function routeMatcher(routeDefinitions) {
         });
     };
 }
-export const staticRouteMatcher = routeMatcher(RoutesManifest.routes.static);
+export const staticRouteMatcher = routeMatcher([
+    ...RoutesManifest.routes.static,
+    ...getStaticAPIRoutes(),
+]);
 export const dynamicRouteMatcher = routeMatcher(RoutesManifest.routes.dynamic);
+/**
+ * Returns static API routes for both app and pages router cause Next will filter them out in staticRoutes in `routes-manifest.json`.
+ * We also need to filter out page files that are under `app/api/*` as those would not be present in the routes manifest either.
+ * This line from Next.js skips it:
+ * https://github.com/vercel/next.js/blob/ded56f952154a40dcfe53bdb38c73174e9eca9e5/packages/next/src/build/index.ts#L1299
+ *
+ * Without it handleFallbackFalse will 404 on static API routes if there is a catch-all route on root level.
+ */
+function getStaticAPIRoutes() {
+    const createRouteDefinition = (route) => ({
+        page: route,
+        regex: `^${route}(?:/)?$`,
+    });
+    const dynamicRoutePages = new Set(RoutesManifest.routes.dynamic.map(({ page }) => page));
+    const pagesStaticAPIRoutes = Object.keys(PagesManifest)
+        .filter((route) => route.startsWith("/api/") && !dynamicRoutePages.has(route))
+        .map(createRouteDefinition);
+    // We filter out both static API and page routes from the app paths manifest
+    const appPathsStaticAPIRoutes = Object.values(AppPathRoutesManifest)
+        .filter((route) => route.startsWith("/api/") ||
+        (route === "/api" && !dynamicRoutePages.has(route)))
+        .map(createRouteDefinition);
+    return [...pagesStaticAPIRoutes, ...appPathsStaticAPIRoutes];
+}

package/dist/core/routingHandler.js

@@ -4,7 +4,7 @@ import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
-import { apiPrefix, dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
+import { dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
 import { constructNextUrl } from "./routing/util";
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
@@ -55,6 +55,9 @@ export default async function routingHandler(event) {
         }
         const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
         if (redirect) {
+            // We need to encode the value in the Location header to make sure it is valid according to RFC
+            // https://stackoverflow.com/a/7654605/16587222
+            redirect.headers.Location = new URL(redirect.headers.Location).href;
             debug("redirect", redirect);
             return redirect;
         }
@@ -85,9 +88,14 @@ export default async function routingHandler(event) {
             internalEvent = afterRewrites.internalEvent;
             isExternalRewrite = afterRewrites.isExternalRewrite;
         }
+        let isISR = false;
         // We want to run this just before the dynamic route check
-        const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
-        internalEvent = fallbackEvent;
+        // We can skip it if its an external rewrite
+        if (!isExternalRewrite) {
+            const fallbackResult = handleFallbackFalse(internalEvent, PrerenderManifest);
+            internalEvent = fallbackResult.event;
+            isISR = fallbackResult.isISR;
+        }
         const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
         const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
         if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
@@ -96,17 +104,11 @@ export default async function routingHandler(event) {
             internalEvent = fallbackRewrites.internalEvent;
             isExternalRewrite = fallbackRewrites.isExternalRewrite;
         }
-        // Api routes are not present in the routes manifest except if they're not behind /api
-        // /api even if it's a page route doesn't get generated in the manifest
-        // Ideally we would need to properly check api routes here
-        const isApiRoute = internalEvent.rawPath === apiPrefix ||
-            internalEvent.rawPath.startsWith(`${apiPrefix}/`);
         const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
         const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
         // If we still haven't found a route, we show the 404 page
         // We need to ensure that rewrites are applied before showing the 404 page
         if (!(isRouteFoundBeforeAllRewrites ||
-            isApiRoute ||
             isNextImageRoute ||
             // We need to check again once all rewrites have been applied
             staticRouteMatcher(internalEvent.rawPath).length > 0 ||

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

@@ -1,10 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
+import { NextConfig } from "../../adapters/config/index";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
 export default {
     name: "fs-dev",
     load: async (url) => {
-        const imagePath = path.join(getMonorepoRelativePath(), "assets", url);
+        const urlWithoutBasePath = NextConfig.basePath
+            ? url.slice(NextConfig.basePath.length)
+            : url;
+        const imagePath = path.join(getMonorepoRelativePath(), "assets", urlWithoutBasePath);
         const body = fs.createReadStream(imagePath);
         const contentType = url.endsWith(".png") ? "image/png" : "image/jpeg";
         return {

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

@@ -1,13 +1,15 @@
 import path from "node:path";
 import express from "express";
+import { NextConfig } from "../../adapters/config/index";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const wrapper = async (handler, converter) => {
     const app = express();
     // To serve static assets
-    app.use(express.static(path.join(getMonorepoRelativePath(), "assets")));
+    const basePath = NextConfig.basePath ?? "";
+    app.use(basePath, 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) => {
+    app.all(`${NextConfig.basePath ?? ""}/_next/image`, async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
         const streamCreator = {
             writeHeaders: (prelude) => {

package/package.json

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