@vercel/next 4.7.0 → 4.7.1

package/dist/index.js

@@ -12806,6 +12806,127 @@ function normalizeEdgeFunctionPath(shortPath, appPathRoutesManifest) {
   }
   return shortPath;
 }
+async function getNodeMiddleware({
+  config,
+  baseDir,
+  projectDir,
+  entryPath,
+  nextVersion,
+  nodeVersion,
+  lstatSema,
+  lstatResults,
+  pageExtensions,
+  routesManifest,
+  outputDirectory,
+  prerenderBypassToken,
+  isCorrectMiddlewareOrder,
+  functionsConfigManifest,
+  requiredServerFilesManifest
+}) {
+  const middlewareFunctionConfig = functionsConfigManifest?.functions["/_middleware"];
+  if (!middlewareFunctionConfig || !middlewareFunctionConfig.matchers) {
+    return null;
+  }
+  const routes = [];
+  const routeMatchers = getRouteMatchers(
+    { matchers: middlewareFunctionConfig.matchers },
+    routesManifest
+  );
+  for (const matcher of routeMatchers) {
+    const route = {
+      continue: true,
+      src: matcher.regexp,
+      has: matcher.has,
+      missing: [
+        {
+          type: "header",
+          key: "x-prerender-revalidate",
+          value: prerenderBypassToken
+        },
+        ...matcher.missing || []
+      ]
+    };
+    route.middlewarePath = "/_middleware";
+    route.middlewareRawSrc = matcher.originalSource ? [matcher.originalSource] : [];
+    if (isCorrectMiddlewareOrder) {
+      route.override = true;
+    }
+    routes.push(route);
+  }
+  const sourceFile = await getSourceFilePathFromPage({
+    workPath: entryPath,
+    page: normalizeSourceFilePageFromManifest("/middleware", "middleware", {}),
+    pageExtensions
+  });
+  const vercelConfigOpts = await (0, import_build_utils.getLambdaOptionsFromFunction)({
+    sourceFile,
+    config
+  });
+  const middlewareFile = import_path2.default.join(
+    entryPath,
+    outputDirectory,
+    "server",
+    "middleware.js"
+  );
+  const middlewareTrace = `${middlewareFile}.nft.json`;
+  const middlewareTraceDir = import_path2.default.dirname(middlewareTrace);
+  const { files } = JSON.parse(await import_fs_extra3.default.readFile(middlewareTrace, "utf8"));
+  const fileList = [];
+  const normalizedBaseDir = `${baseDir}${baseDir.endsWith(import_path2.default.sep) ? "" : import_path2.default.sep}`;
+  files.forEach((file) => {
+    const absolutePath = import_path2.default.join(middlewareTraceDir, file);
+    if (absolutePath.startsWith(normalizedBaseDir)) {
+      fileList.push(import_path2.default.relative(baseDir, absolutePath));
+    } else {
+      console.log("outside base dir", absolutePath);
+    }
+  });
+  const reasons = /* @__PURE__ */ new Map();
+  const tracedFiles = {};
+  await Promise.all(
+    fileList.map(
+      collectTracedFiles(baseDir, lstatResults, lstatSema, reasons, tracedFiles)
+    )
+  );
+  const launcherData = (await import_fs_extra3.default.readFile(import_path2.default.join(__dirname, "middleware-launcher.js"), "utf8")).replace(
+    /(?:var|const) conf = __NEXT_CONFIG__/,
+    `const conf = ${JSON.stringify({
+      ...requiredServerFilesManifest.config,
+      distDir: import_path2.default.relative(
+        projectDir,
+        import_path2.default.join(entryPath, outputDirectory)
+      )
+    })}`
+  ).replace("__NEXT_MIDDLEWARE_PATH__", `./.next/server/middleware.js`);
+  const lambda = new import_build_utils.NodejsLambda({
+    ...vercelConfigOpts,
+    runtime: nodeVersion,
+    handler: import_path2.default.join(
+      import_path2.default.relative(baseDir, projectDir),
+      "___next_launcher.cjs"
+    ),
+    useWebApi: true,
+    shouldAddHelpers: false,
+    shouldAddSourcemapSupport: false,
+    framework: {
+      slug: "nextjs",
+      version: nextVersion
+    },
+    files: {
+      ...tracedFiles,
+      [import_path2.default.relative(baseDir, middlewareFile)]: new import_build_utils.FileFsRef({
+        fsPath: middlewareFile
+      }),
+      [import_path2.default.join(import_path2.default.relative(baseDir, projectDir), "___next_launcher.cjs")]: new import_build_utils.FileBlob({ data: launcherData })
+    }
+  });
+  return {
+    routes,
+    lambdas: {
+      _middleware: lambda
+    }
+  };
+}
 async function getMiddlewareBundle({
   entryPath,
   outputDirectory,
@@ -14732,6 +14853,23 @@ ${JSON.stringify(
       true
     )];
   });
+  const nodeMiddleware = await getNodeMiddleware({
+    config,
+    baseDir,
+    projectDir,
+    entryPath,
+    nextVersion,
+    nodeVersion: nodeVersion.runtime,
+    lstatSema,
+    lstatResults,
+    pageExtensions: requiredServerFilesManifest.config.pageExtensions,
+    routesManifest,
+    outputDirectory,
+    prerenderBypassToken: prerenderManifest.bypassToken,
+    isCorrectMiddlewareOrder,
+    functionsConfigManifest,
+    requiredServerFilesManifest
+  });
   const middleware = await getMiddlewareBundle({
     config,
     entryPath,
@@ -14742,7 +14880,7 @@ ${JSON.stringify(
     nextVersion,
     appPathRoutesManifest: appPathRoutesManifest || {}
   });
-  const isNextDataServerResolving = middleware.staticRoutes.length > 0 && import_semver3.default.gte(nextVersion, NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION);
+  const isNextDataServerResolving = (middleware.staticRoutes.length > 0 || nodeMiddleware) && import_semver3.default.gte(nextVersion, NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION);
   const dynamicRoutes = await getDynamicRoutes({
     entryPath,
     entryDirectory,
@@ -14961,6 +15099,7 @@ ${JSON.stringify(
       ...staticDirectoryFiles,
       ...privateOutputs.files,
       ...middleware.edgeFunctions,
+      ...nodeMiddleware?.lambdas,
       ...isNextDataServerResolving ? {
         __next_data_catchall: nextDataCatchallOutput
       } : {}
@@ -15093,7 +15232,7 @@ ${JSON.stringify(
       // middleware comes directly after redirects but before
       // beforeFiles rewrites as middleware is not a "file" route
       ...routesManifest?.skipMiddlewareUrlNormalize ? denormalizeNextDataRoute(true) : [],
-      ...isCorrectMiddlewareOrder ? middleware.staticRoutes : [],
+      ...isCorrectMiddlewareOrder ? [...middleware.staticRoutes, ...nodeMiddleware?.routes || []] : [],
       ...routesManifest?.skipMiddlewareUrlNormalize ? normalizeNextDataRoute(true) : [],
       ...beforeFilesRewrites,
       // Make sure to 404 for the /404 path itself
@@ -15149,7 +15288,7 @@ ${JSON.stringify(
       // while middleware was in beta the order came right before
       // handle: 'filesystem' we maintain this for older versions
       // to prevent a local/deploy mismatch
-      ...!isCorrectMiddlewareOrder ? middleware.staticRoutes : [],
+      ...!isCorrectMiddlewareOrder ? [...middleware.staticRoutes, ...nodeMiddleware?.routes || []] : [],
       ...appDir ? [
         ...isAppClientSegmentCacheEnabled && rscPrefetchHeader && prefetchSegmentHeader && prefetchSegmentDirSuffix && prefetchSegmentSuffix ? [
           {

package/dist/middleware-launcher.js

@@ -0,0 +1,138 @@
+"use strict";
+
+// src/vercel-request-context.ts
+var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+function getContext() {
+  const fromSymbol = globalThis;
+  return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
+}
+
+// src/next-request-context.ts
+var import_async_hooks = require("async_hooks");
+var name = "@next/request-context";
+var NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for(name);
+var INTERNAL_STORAGE_FIELD_SYMBOL = Symbol.for("internal.storage");
+function getOrCreateContextSingleton() {
+  const _globalThis = globalThis;
+  if (!_globalThis[NEXT_REQUEST_CONTEXT_SYMBOL]) {
+    const storage = new import_async_hooks.AsyncLocalStorage();
+    const Context = {
+      get: () => storage.getStore(),
+      [INTERNAL_STORAGE_FIELD_SYMBOL]: storage
+    };
+    _globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = Context;
+  }
+  return _globalThis[NEXT_REQUEST_CONTEXT_SYMBOL];
+}
+var NextRequestContext = getOrCreateContextSingleton();
+function withNextRequestContext(value, callback) {
+  const storage = NextRequestContext[INTERNAL_STORAGE_FIELD_SYMBOL];
+  return storage.run(value, callback);
+}
+
+// src/edge-function-source/to-plain-headers.ts
+function toPlainHeaders(headers) {
+  const result = {};
+  if (!headers)
+    return result;
+  headers.forEach((value, key) => {
+    result[key] = value;
+    if (key.toLowerCase() === "set-cookie") {
+      result[key] = splitCookiesString(value);
+    }
+  });
+  return result;
+}
+function splitCookiesString(cookiesString) {
+  const cookiesStrings = [];
+  let pos = 0;
+  let start;
+  let ch;
+  let lastComma;
+  let nextStart;
+  let cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos)))
+      pos += 1;
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+
+// src/middleware-launcher.ts
+process.chdir(__dirname);
+var region = process.env.VERCEL_REGION || process.env.NOW_REGION;
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = region === "dev1" ? "development" : "production";
+}
+if (process.env.NODE_ENV !== "production" && region !== "dev1") {
+  console.warn(
+    `Warning: NODE_ENV was incorrectly set to "${process.env.NODE_ENV}", this value is being overridden to "production"`
+  );
+  process.env.NODE_ENV = "production";
+}
+var conf = __NEXT_CONFIG__;
+globalThis.AsyncLocalStorage = require("async_hooks").AsyncLocalStorage;
+var middlewareHandler = require("__NEXT_MIDDLEWARE_PATH__").default;
+var serve = async (request) => {
+  try {
+    const context = getContext();
+    return await withNextRequestContext(
+      { waitUntil: context.waitUntil },
+      async () => {
+        const result = await middlewareHandler({
+          request: {
+            url: request.url,
+            method: request.method,
+            headers: toPlainHeaders(request.headers),
+            nextConfig: conf,
+            page: "/middleware",
+            body: request.method !== "GET" && request.method !== "HEAD" ? request.body : void 0,
+            waitUntil: context.waitUntil
+          }
+        });
+        if (result.waitUntil && context.waitUntil) {
+          context.waitUntil(result.waitUntil);
+        }
+        return result.response;
+      }
+    );
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+};
+module.exports = serve;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",