@next-community/adapter-vercel 0.0.0

package/dist/node-handler.js

@@ -0,0 +1,260 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_handler_exports = {};
+__export(node_handler_exports, {
+  getHandlerSource: () => getHandlerSource
+});
+module.exports = __toCommonJS(node_handler_exports);
+const getHandlerSource = (ctx) => `
+  require('next/dist/server/node-environment');
+  require('next/dist/server/node-polyfill-crypto');
+  
+  try {
+    // this can fail to install if styled-jsx is not discoverable
+    // but this is tolerable as the require-hook is handling edge cases
+    require('next/dist/server/require-hook');
+  } catch (_) {}
+  
+  process.chdir(__dirname);
+  
+  module.exports = (${ctx.isMiddleware ? () => {
+  const path = require("path");
+  const relativeDistDir = process.env.__PRIVATE_RELATIVE_DIST_DIR;
+  const SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+  function getRequestContext() {
+    const fromSymbol = globalThis;
+    return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
+  }
+  return async function handler(request) {
+    console.log("middleware handler", request);
+    let middlewareHandler = await require("./" + path.posix.join(relativeDistDir, "server", "middleware.js"));
+    middlewareHandler = middlewareHandler.handler || middlewareHandler;
+    const context = getRequestContext();
+    const response = await middlewareHandler(request, {
+      waitUntil: context.waitUntil,
+      requestMeta: {
+        // we use '.' for relative project dir since we process.chdir
+        // to the same directory as the handler file so everything is
+        // relative to that/project dir
+        relativeProjectDir: "."
+      }
+    });
+    return response;
+  };
+} : (() => {
+  const path = require("path");
+  const relativeDistDir = process.env.__PRIVATE_RELATIVE_DIST_DIR;
+  const prerenderFallbackFalseMap = process.env.__PRIVATE_PRERENDER_FALLBACK_MAP;
+  const {
+    dynamicRoutes: dynamicRoutesRaw,
+    staticRoutes: staticRoutesRaw,
+    i18n
+  } = require("./" + path.posix.join(relativeDistDir, "routes-manifest.json"));
+  const hydrateRoutesManifestItem = (item) => {
+    return {
+      ...item,
+      regex: new RegExp(item.regex)
+    };
+  };
+  const dynamicRoutes = dynamicRoutesRaw.map(hydrateRoutesManifestItem);
+  const staticRoutes = staticRoutesRaw.map(hydrateRoutesManifestItem);
+  let appPathRoutesManifest = {};
+  try {
+    appPathRoutesManifest = require("./" + path.posix.join(
+      relativeDistDir,
+      "app-path-routes-manifest.json"
+    ));
+  } catch (_) {
+  }
+  const inversedAppRoutesManifest = Object.entries(
+    appPathRoutesManifest
+  ).reduce(
+    (manifest, [originalKey, normalizedKey]) => {
+      manifest[normalizedKey] = originalKey;
+      return manifest;
+    },
+    {}
+  );
+  function normalizeLocalePath(pathname, locales) {
+    if (!locales) return { pathname };
+    const lowercasedLocales = locales.map(
+      (locale) => locale.toLowerCase()
+    );
+    const segments = pathname.split("/", 2);
+    if (!segments[1]) return { pathname };
+    const segment = segments[1].toLowerCase();
+    const index = lowercasedLocales.indexOf(segment);
+    if (index < 0) return { pathname };
+    const detectedLocale = locales[index];
+    pathname = pathname.slice(detectedLocale.length + 1) || "/";
+    return { pathname, locale: detectedLocale };
+  }
+  function normalizeDataPath(pathname) {
+    if (!(pathname || "/").startsWith("/_next/data")) {
+      return pathname;
+    }
+    pathname = pathname.replace(/\/_next\/data\/[^/]{1,}/, "").replace(/\.json$/, "");
+    if (pathname === "/index") {
+      return "/";
+    }
+    return pathname;
+  }
+  function matchUrlToPage(req, urlPathname) {
+    urlPathname = normalizeDataPath(urlPathname);
+    console.log("before normalize", urlPathname);
+    for (const suffixRegex of [
+      /\.segments(\/.*)\.segment\.rsc$/,
+      /\.rsc$/
+    ]) {
+      urlPathname = urlPathname.replace(suffixRegex, "");
+    }
+    const urlPathnameWithLocale = urlPathname;
+    const normalizeResult = normalizeLocalePath(
+      urlPathname,
+      i18n?.locales
+    );
+    urlPathname = normalizeResult.pathname;
+    console.log("after normalize", normalizeResult);
+    urlPathname = urlPathname.replace(/\/$/, "") || "/";
+    for (const route of [...staticRoutes, ...dynamicRoutes]) {
+      if (route.regex.test(urlPathname)) {
+        const fallbackFalseMap = prerenderFallbackFalseMap[route.page];
+        if (fallbackFalseMap && !(fallbackFalseMap.includes(urlPathname) || fallbackFalseMap.includes(urlPathnameWithLocale))) {
+          console.log("fallback: false but not prerendered", {
+            page: route.page,
+            urlPathname,
+            urlPathnameWithLocale,
+            paths: Object.values(fallbackFalseMap)
+          });
+          continue;
+        }
+        console.log("matched route", route, urlPathname);
+        return {
+          matchedPathname: inversedAppRoutesManifest[route.page] || route.page,
+          locale: normalizeResult.locale
+        };
+      }
+    }
+    return {
+      matchedPathname: inversedAppRoutesManifest[urlPathname] || urlPathname,
+      locale: normalizeResult.locale
+    };
+  }
+  const SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+  function getRequestContext() {
+    const fromSymbol = globalThis;
+    return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
+  }
+  const RouterServerContextSymbol = Symbol.for(
+    "@next/router-server-methods"
+  );
+  const routerServerGlobal = globalThis;
+  if (!routerServerGlobal[RouterServerContextSymbol]) {
+    routerServerGlobal[RouterServerContextSymbol] = {};
+  }
+  routerServerGlobal[RouterServerContextSymbol]["."] = {
+    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");
+      } catch (_) {
+        mod = await require("./" + path.posix.join(
+          relativeDistDir,
+          "server",
+          "pages",
+          `_error.js`
+        ));
+        console.log("using _error for render404");
+      }
+      res.statusCode = 404;
+      if (mod) {
+        await mod.handler(req, res, {
+          waitUntil: getRequestContext().waitUntil
+        });
+      } else {
+        console.log(
+          "failed to find 404 module",
+          await require("fs").promises.readdir(
+            path.posix.join(relativeDistDir, "server", "pages")
+          ).catch((err) => err)
+        );
+        res.end("This page could not be found");
+      }
+    }
+  };
+  return async function handler(req, res) {
+    try {
+      const parsedUrl = new URL(req.url || "/", "http://n");
+      let urlPathname = req.headers["x-matched-path"];
+      if (typeof urlPathname !== "string") {
+        console.log("no x-matched-path", { url: req.url });
+        urlPathname = parsedUrl.pathname || "/";
+      }
+      const { matchedPathname: page, locale } = matchUrlToPage(
+        req,
+        urlPathname
+      );
+      const isAppDir = page.match(/\/(page|route)$/);
+      console.log("invoking handler", {
+        page,
+        url: req.url,
+        matchedPath: req.headers["x-matched-path"]
+      });
+      const mod = await require("./" + path.posix.join(
+        relativeDistDir,
+        "server",
+        isAppDir ? "app" : "pages",
+        `${page === "/" ? "index" : page}.js`
+      ));
+      await mod.handler(req, res, {
+        waitUntil: getRequestContext().waitUntil,
+        requestMeta: {
+          minimalMode: true,
+          // we use '.' for relative project dir since we process.chdir
+          // to the same directory as the handler file so everything is
+          // relative to that/project dir
+          relativeProjectDir: ".",
+          locale
+        }
+      });
+    } catch (error) {
+      console.error(`Failed to handle ${req.url}`, error);
+      throw error;
+    }
+  };
+}).toString()})()`.replaceAll(
+  "process.env.__PRIVATE_RELATIVE_DIST_DIR",
+  `"${ctx.projectRelativeDistDir}"`
+).replaceAll(
+  "process.env.__PRIVATE_PRERENDER_FALLBACK_MAP",
+  JSON.stringify(ctx.prerenderFallbackFalseMap)
+).replaceAll(
+  "process.env.__PRIVATE_NEXT_CONFIG",
+  JSON.stringify(ctx.nextConfig)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getHandlerSource
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@next-community/adapter-vercel",
+  "version": "0.0.0",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/bytes": "3.1.1",
+    "@types/convert-source-map": "1.5.2",
+    "@types/fs-extra": "8.0.0",
+    "@types/node": "14.18.33",
+    "@types/picomatch": "2.3.3",
+    "@types/webpack-sources": "3.2.0",
+    "@vercel/build-utils": "12.2.2",
+    "@vercel/routing-utils": "5.2.1",
+    "async-sema": "3.1.1",
+    "bytes": "3.1.2",
+    "convert-source-map": "1.8.0",
+    "esbuild": "0.25.10",
+    "fs-extra": "11.2.0",
+    "next": "16.1.1-canary.18",
+    "picomatch": "4.0.1",
+    "source-map": "0.7.4",
+    "webpack-sources": "3.2.3"
+  },
+  "peerDependencies": {
+    "next": ">= 16.1.1-canary.18"
+  },
+  "engines": {
+    "node": ">= 20.6.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist; tsc --noEmit && node --experimental-transform-types build.mts",
+    "test": "vitest"
+  }
+}