@next-community/adapter-vercel 0.0.0 → 0.0.1-beta.1

package/dist/index.js

@@ -9650,7 +9650,7 @@ async function validateSize(script, wasmFiles) {
 // src/outputs.ts
 var import_node_handler = require("./node-handler");
 function fallbackHasFilePath(fallback) {
-  return fallback !== void 0 && "filePath" in fallback;
+  return fallback !== void 0 && "filePath" in fallback && typeof fallback.filePath === "string";
 }
 var copy = async (src, dest) => {
   await import_fs_extra3.default.remove(dest);
@@ -9841,8 +9841,11 @@ async function handleNodeOutputs(nodeOutputs, {
 }
 async function handlePrerenderOutputs(prerenderOutputs, {
   config,
+  hasAppEntries,
   vercelOutputDir,
-  nodeOutputsParentMap
+  nodeOutputsParentMap,
+  rscContentType,
+  varyHeader
 }) {
   const prerenderParentIds = /* @__PURE__ */ new Set();
   const fsSema = new import_async_sema.Sema(16, { capacity: prerenderOutputs.length });
@@ -9864,7 +9867,18 @@ async function handlePrerenderOutputs(prerenderOutputs, {
             output.pathname,
             config
           )}.prerender-fallback${import_node_path.default.extname(output.fallback.filePath)}`
-        ) : void 0;
+        ) : (
+          // Use the fallback value for the RSC route if the route doesn't
+          // vary based on the route parameters and there's an actual postponed
+          // state to fallback to.
+          output.fallback?.postponedState && output.config.allowQuery && output.config.allowQuery.length === 0 ? import_node_path.default.join(
+            functionsDir,
+            `${normalizeIndexPathname(
+              output.pathname,
+              config
+            )}.prerender-fallback${import_node_path.default.extname(output.pathname)}`
+          ) : void 0
+        );
         const { parentOutputId } = output;
         prerenderParentIds.add(parentOutputId);
         const parentNodeOutput = nodeOutputsParentMap.get(parentOutputId);
@@ -9901,18 +9915,27 @@ async function handlePrerenderOutputs(prerenderOutputs, {
         }
         const initialHeaders = Object.assign(
           {},
+          hasAppEntries ? { vary: varyHeader } : {},
           output.fallback?.initialHeaders
         );
+        const isRscOutput = import_node_path.default.extname(output.pathname) === ".rsc";
         if (output.fallback?.postponedState && fallbackHasFilePath(output.fallback) && prerenderFallbackPath) {
-          const fallbackHtml = await import_promises.default.readFile(
+          const fallbackContent = await import_promises.default.readFile(
             output.fallback.filePath,
             "utf8"
           );
           await writeIfNotExists(
             prerenderFallbackPath,
-            `${output.fallback.postponedState}${fallbackHtml}`
+            `${output.fallback.postponedState}${fallbackContent}`
+          );
+          const originContentType = isRscOutput ? rscContentType : "text/html; charset=utf-8";
+          initialHeaders["content-type"] = `application/x-nextjs-pre-render; state-length=${output.fallback.postponedState.length}; origin=${JSON.stringify(originContentType)}`;
+        } else if (output.fallback?.postponedState && !fallbackHasFilePath(output.fallback) && prerenderFallbackPath) {
+          await writeIfNotExists(
+            prerenderFallbackPath,
+            output.fallback.postponedState
           );
-          initialHeaders["content-type"] = `application/x-nextjs-pre-render; state-length=${output.fallback.postponedState.length}; origin="text/html; charset=utf-8"`;
+          initialHeaders["content-type"] = `application/x-nextjs-pre-render; state-length=${output.fallback.postponedState.length}; origin=${JSON.stringify(rscContentType)}`;
         }
         await import_promises.default.mkdir(import_node_path.default.dirname(prerenderConfigPath), { recursive: true });
         await writeIfNotExists(
@@ -9936,18 +9959,24 @@ async function handlePrerenderOutputs(prerenderOutputs, {
               fallback: prerenderFallbackPath ? import_node_path.default.posix.relative(
                 import_node_path.default.dirname(prerenderConfigPath),
                 prerenderFallbackPath
-              ) : void 0,
+              ) : null,
               chain: output.pprChain ? {
                 ...output.pprChain,
-                outputPath: import_node_path.default.posix.join(parentNodeOutput.pathname)
+                outputPath: import_node_path.default.posix.join(
+                  "./",
+                  `${normalizeIndexPathname(output.pathname, config)}`
+                )
               } : void 0
             }
           )
         );
-        if (fallbackHasFilePath(output.fallback) && prerenderFallbackPath && // if postponed state is present we write the fallback file above
+        if (fallbackHasFilePath(output.fallback) && prerenderFallbackPath && // if postponed state is not present we write the fallback file above
         !output.fallback.postponedState) {
           await copy(output.fallback.filePath, prerenderFallbackPath);
         }
+        if (output.fallback && Object.keys(initialHeaders || {}).length === 0) {
+          throw new Error("empty initialHeaders");
+        }
       } catch (err) {
         console.error(`Failed to handle output:`, output);
         throw err;
@@ -9982,11 +10011,10 @@ async function handleEdgeOutputs(edgeOutputs, {
         if (jsRegex.test(fsPath)) {
           files[relPath] = import_node_path.default.posix.relative(repoRoot, fsPath);
         } else {
-          const assetPath = import_node_path.default.posix.join("assets", relPath);
-          files[assetPath] = import_node_path.default.posix.relative(repoRoot, fsPath);
+          files[`assets/${relPath}`] = import_node_path.default.posix.relative(repoRoot, fsPath);
           nonJsAssetFiles.push({
             name: relPath,
-            path: assetPath
+            path: `assets/${relPath}`
           });
         }
       }
@@ -9995,8 +10023,8 @@ async function handleEdgeOutputs(edgeOutputs, {
       }
       files[import_node_path.default.posix.relative(projectDir, output.filePath)] = import_node_path.default.posix.relative(repoRoot, output.filePath);
       const filePaths = [
-        import_node_path.default.posix.relative(projectDir, output.filePath),
-        ...Object.values(output.assets).map((item) => import_node_path.default.posix.relative(projectDir, item)).filter((item) => jsRegex.test(item))
+        ...Object.values(output.assets).map((item) => import_node_path.default.posix.relative(projectDir, item)).filter((item) => jsRegex.test(item)),
+        import_node_path.default.posix.relative(projectDir, output.filePath)
       ];
       const params = {
         name: output.id.replace(/\.rsc$/, ""),
@@ -10191,6 +10219,10 @@ function modifyWithRewriteHeaders(rewrites, {
         if (index !== -1) {
           query = query.substring(0, index);
         }
+        query = query.split("&").filter((part) => {
+          const key = part.split("=")[0];
+          return !key.startsWith("nxtP") && !key.startsWith("nxtI");
+        }).join("&") || null;
       } else {
         index = pathname.indexOf("#");
         if (index !== -1) {
@@ -10511,22 +10543,26 @@ var myAdapter = {
       ...outputs.appPages,
       ...outputs.appRoutes,
       ...outputs.pages,
-      ...outputs.pagesApi
+      ...outputs.pagesApi,
+      ...outputs.staticFiles
     ]) {
-      if (output.pathname.endsWith("/_not-found")) {
-        hasNotFoundOutput = true;
-      }
       if (output.pathname.endsWith("/404")) {
+        hasNotFoundOutput = false;
         has404Output = true;
       }
+      if (!has404Output && output.pathname.endsWith("/_not-found")) {
+        hasNotFoundOutput = true;
+      }
       if (output.pathname.endsWith("/500")) {
         has500Output = true;
       }
-      if (output.runtime === "nodejs") {
-        nodeOutputsParentMap.set(output.id, output);
-        nodeOutputs.push(output);
-      } else if (output.runtime === "edge") {
-        edgeOutputs.push(output);
+      if ("runtime" in output) {
+        if (output.runtime === "nodejs") {
+          nodeOutputsParentMap.set(output.id, output);
+          nodeOutputs.push(output);
+        } else if (output.runtime === "edge") {
+          edgeOutputs.push(output);
+        }
       }
     }
     for (const output of outputs.staticFiles) {
@@ -10591,8 +10627,11 @@ var myAdapter = {
     });
     await handlePrerenderOutputs(outputs.prerenders, {
       config,
+      hasAppEntries: outputs.appPages.length > 0,
+      varyHeader: routing.rsc.varyHeader,
       vercelOutputDir,
-      nodeOutputsParentMap
+      nodeOutputsParentMap,
+      rscContentType: routing.rsc.contentTypeHeader
     });
     const shouldHandleSegmentPrefetches = outputs.appPages.length > 0;
     const convertedRewrites = normalizeRewrites(routing);

package/dist/node-handler.js

@@ -22,6 +22,7 @@ __export(node_handler_exports, {
 });
 module.exports = __toCommonJS(node_handler_exports);
 const getHandlerSource = (ctx) => `
+  process.env.NODE_ENV = 'production';
   require('next/dist/server/node-environment');
   require('next/dist/server/node-polyfill-crypto');
   
@@ -33,7 +34,7 @@ const getHandlerSource = (ctx) => `
   
   process.chdir(__dirname);
   
-  module.exports = (${ctx.isMiddleware ? () => {
+  const _n_handler = (${ctx.isMiddleware ? () => {
   const path = require("path");
   const relativeDistDir = process.env.__PRIVATE_RELATIVE_DIST_DIR;
   const SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
@@ -69,11 +70,22 @@ const getHandlerSource = (ctx) => `
   const hydrateRoutesManifestItem = (item) => {
     return {
       ...item,
-      regex: new RegExp(item.regex)
+      namedRegex: new RegExp(item.namedRegex || item.regex)
     };
   };
+  const matchOperatorsRegex = /[|\\{}()[\]^$+*?.-]/g;
+  function escapeStringRegexp(str) {
+    return str.replace(matchOperatorsRegex, "\\$&");
+  }
   const dynamicRoutes = dynamicRoutesRaw.map(hydrateRoutesManifestItem);
-  const staticRoutes = staticRoutesRaw.map(hydrateRoutesManifestItem);
+  const staticRoutes = staticRoutesRaw.map((route) => {
+    return {
+      ...route,
+      namedRegex: new RegExp(
+        "^" + escapeStringRegexp(route.page) + "$"
+      )
+    };
+  });
   let appPathRoutesManifest = {};
   try {
     appPathRoutesManifest = require("./" + path.posix.join(
@@ -115,7 +127,7 @@ const getHandlerSource = (ctx) => `
     }
     return pathname;
   }
-  function matchUrlToPage(req, urlPathname) {
+  function matchUrlToPage(urlPathname) {
     urlPathname = normalizeDataPath(urlPathname);
     console.log("before normalize", urlPathname);
     for (const suffixRegex of [
@@ -132,8 +144,20 @@ const getHandlerSource = (ctx) => `
     urlPathname = normalizeResult.pathname;
     console.log("after normalize", normalizeResult);
     urlPathname = urlPathname.replace(/\/$/, "") || "/";
+    const combinedRoutes = [...staticRoutes, ...dynamicRoutes];
+    for (const route of combinedRoutes) {
+      if (route.page === urlPathname) {
+        console.log("matched direct page", route);
+        return {
+          matchedPathname: inversedAppRoutesManifest[route.page] || route.page,
+          locale: normalizeResult.locale
+        };
+      }
+    }
     for (const route of [...staticRoutes, ...dynamicRoutes]) {
-      if (route.regex.test(urlPathname)) {
+      console.log("testing", route.namedRegex, "against", urlPathname);
+      const matches = urlPathname.match(route.namedRegex);
+      if (matches || urlPathname === "/index" && route.namedRegex.test("/")) {
         const fallbackFalseMap = prerenderFallbackFalseMap[route.page];
         if (fallbackFalseMap && !(fallbackFalseMap.includes(urlPathname) || fallbackFalseMap.includes(urlPathnameWithLocale))) {
           console.log("fallback: false but not prerendered", {
@@ -144,10 +168,11 @@ const getHandlerSource = (ctx) => `
           });
           continue;
         }
-        console.log("matched route", route, urlPathname);
+        console.log("matched route", route, urlPathname, matches);
         return {
           matchedPathname: inversedAppRoutesManifest[route.page] || route.page,
-          locale: normalizeResult.locale
+          locale: normalizeResult.locale,
+          matches
         };
       }
     }
@@ -172,13 +197,26 @@ const getHandlerSource = (ctx) => `
     async render404(req, res) {
       let mod;
       try {
-        mod = await require("./" + path.posix.join(
-          relativeDistDir,
-          "server",
-          "pages",
-          `404.js`
-        ));
-        console.log("using 404.js for render404");
+        try {
+          mod = await require("./" + path.posix.join(
+            relativeDistDir,
+            "server",
+            "app",
+            `_not-found`,
+            "page.js"
+          ));
+          console.log("using _not-found.js for render404");
+        } catch {
+        }
+        if (!mod) {
+          mod = await require("./" + path.posix.join(
+            relativeDistDir,
+            "server",
+            "pages",
+            `404.js`
+          ));
+          console.log("using 404.js for render404");
+        }
       } catch (_) {
         mod = await require("./" + path.posix.join(
           relativeDistDir,
@@ -204,7 +242,7 @@ const getHandlerSource = (ctx) => `
       }
     }
   };
-  return async function handler(req, res) {
+  return async function handler(req, res, internalMetadata) {
     try {
       const parsedUrl = new URL(req.url || "/", "http://n");
       let urlPathname = req.headers["x-matched-path"];
@@ -212,11 +250,24 @@ const getHandlerSource = (ctx) => `
         console.log("no x-matched-path", { url: req.url });
         urlPathname = parsedUrl.pathname || "/";
       }
-      const { matchedPathname: page, locale } = matchUrlToPage(
-        req,
-        urlPathname
-      );
+      const {
+        matchedPathname: page,
+        locale,
+        matches
+      } = matchUrlToPage(urlPathname);
       const isAppDir = page.match(/\/(page|route)$/);
+      let addedMatchesToUrl = false;
+      for (const matchKey in matches?.groups || {}) {
+        const matchValue = matches?.groups?.[matchKey];
+        if (!parsedUrl.searchParams.has(matchKey) && matchValue) {
+          parsedUrl.searchParams.set(matchKey, matchValue);
+          addedMatchesToUrl = true;
+        }
+      }
+      if (addedMatchesToUrl) {
+        console.log("updating URL with new matches", matches, req.url);
+        req.url = `${parsedUrl.pathname}${parsedUrl.searchParams.size > 0 ? "?" : ""}${parsedUrl.searchParams.toString()}`;
+      }
       console.log("invoking handler", {
         page,
         url: req.url,
@@ -231,6 +282,7 @@ const getHandlerSource = (ctx) => `
       await mod.handler(req, res, {
         waitUntil: getRequestContext().waitUntil,
         requestMeta: {
+          ...internalMetadata,
           minimalMode: true,
           // we use '.' for relative project dir since we process.chdir
           // to the same directory as the handler file so everything is
@@ -244,7 +296,18 @@ const getHandlerSource = (ctx) => `
       throw error;
     }
   };
-}).toString()})()`.replaceAll(
+}).toString()})()
+  
+  module.exports = _n_handler
+  
+  ${ctx.isMiddleware ? "" : `
+    module.exports.getRequestHandlerWithMetadata = (metadata) => {
+      console.log('using getRequestHandlerWithMetadata', metadata)
+      return (req, res) => _n_handler(req, res, metadata)
+    }
+  `}
+  
+  `.replaceAll(
   "process.env.__PRIVATE_RELATIVE_DIST_DIR",
   `"${ctx.projectRelativeDistDir}"`
 ).replaceAll(

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@next-community/adapter-vercel",
-  "version": "0.0.0",
+  "version": "0.0.1-beta.1",
   "type": "commonjs",
   "main": "dist/index.js",
   "files": [
     "dist"
   ],
+  "repository": {
+    "url": "https://github.com/nextjs/adapter-vercel"
+  },
   "devDependencies": {
     "@types/bytes": "3.1.1",
     "@types/convert-source-map": "1.5.2",