@vercel/node 5.7.0-canary.20260211174907.cdd2da6 → 5.7.1

package/dist/bundling-handler.js

@@ -0,0 +1,259 @@
+//
+// Unified Lambda handler for bundled vanilla API routes.
+// All bundleable lambdas share this exact file (same handler digest).
+// It reads x-matched-path to determine which entrypoint to invoke.
+//
+// IMPORTANT: This file must remain entrypoint-agnostic. Do not embed
+// any path-specific constants. The x-matched-path header is set by
+// route rules injected by the builder.
+//
+// This runs at Lambda runtime where the handler is invoked with (req, res).
+// User modules are in the Lambda's file tree alongside this file.
+//
+// Supports all handler shapes:
+//   1. Function export:  module.exports = (req, res) => { ... }
+//   2. Web handlers:     export function GET(request) { ... }
+//   3. Fetch handler:    export function fetch(request) { ... }
+//   4. Server handler:   http.createServer(...).listen()
+//
+
+const http = require('http');
+const { existsSync } = require('fs');
+const { resolve } = require('path');
+const { pathToFileURL } = require('url');
+const { Readable } = require('stream');
+
+const HTTP_METHODS = [
+  'GET',
+  'HEAD',
+  'OPTIONS',
+  'POST',
+  'PUT',
+  'DELETE',
+  'PATCH',
+];
+
+const handlerCache = Object.create(null);
+
+/**
+ * Resolve an extensionless entrypoint to an actual file path.
+ * Tries common JS extensions in order, returning the first match.
+ */
+function resolveEntrypoint(name) {
+  const base = resolve('./' + name);
+  for (const ext of ['.js', '.cjs', '.mjs']) {
+    const p = base + ext;
+    if (existsSync(p)) return p;
+  }
+  // If base is a directory, look for index files inside it
+  if (existsSync(base)) {
+    for (const ext of ['.js', '.cjs', '.mjs']) {
+      const p = resolve(base, 'index' + ext);
+      if (existsSync(p)) return p;
+    }
+  }
+  return null;
+}
+
+/**
+ * Load a module via dynamic import(). Works for both CJS and ESM regardless
+ * of the file extension or the package.json "type" field.
+ */
+async function loadModule(filePath) {
+  return import(pathToFileURL(filePath).href);
+}
+
+/**
+ * Unwrap nested default exports (common with TS/ESM compiled to CJS).
+ */
+function unwrapDefaults(mod) {
+  for (let i = 0; i < 5; i++) {
+    if (mod && mod.default) mod = mod.default;
+    else break;
+  }
+  return mod;
+}
+
+/**
+ * Create a Node.js (req, res) handler from web handler exports (GET, POST, fetch, etc.).
+ * Uses Node.js 18+ built-in Web API globals (Request, Response).
+ */
+function createWebHandler(listener) {
+  const methods = Object.create(null);
+
+  // If fetch is exported, it handles all methods
+  if (typeof listener.fetch === 'function') {
+    for (const m of HTTP_METHODS) {
+      methods[m] = listener.fetch;
+    }
+  }
+
+  // Named method exports override fetch
+  for (const m of HTTP_METHODS) {
+    if (typeof listener[m] === 'function') {
+      methods[m] = listener[m];
+    }
+  }
+
+  return async (req, res) => {
+    const method = req.method || 'GET';
+    const fn = methods[method];
+    if (!fn) {
+      res.statusCode = 405;
+      res.end('Method Not Allowed');
+      return;
+    }
+
+    // Build a Web API Request from the Node.js IncomingMessage
+    const proto = req.headers['x-forwarded-proto'] || 'https';
+    const host =
+      req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
+    const url = new URL(req.url || '/', `${proto}://${host}`);
+
+    const init = { method, headers: req.headers, duplex: 'half' };
+    if (method !== 'GET' && method !== 'HEAD') {
+      init.body = Readable.toWeb(req);
+    }
+
+    const request = new Request(url, init);
+    let response;
+    try {
+      response = await fn(request);
+    } catch {
+      res.statusCode = 500;
+      res.end('Internal Server Error');
+      return;
+    }
+
+    // Write the Web API Response back to the Node.js ServerResponse
+    res.statusCode = response.status;
+    for (const [key, value] of response.headers) {
+      res.appendHeader(key, value);
+    }
+
+    if (response.body) {
+      for await (const chunk of response.body) {
+        res.write(chunk);
+      }
+    }
+    res.end();
+  };
+}
+
+/**
+ * Compile a user module and return a (req, res) handler regardless of
+ * export shape. Mirrors the detection logic in serverless-handler.mts.
+ */
+async function compileUserCode(filePath) {
+  let server = null;
+  let serverFound;
+
+  // Monkey-patch http.Server.prototype.listen to capture server instances
+  // created during module import (e.g. Express apps calling app.listen()).
+  const originalListen = http.Server.prototype.listen;
+  http.Server.prototype.listen = function () {
+    server = this;
+    http.Server.prototype.listen = originalListen;
+    if (serverFound) serverFound();
+    return this;
+  };
+
+  try {
+    let listener = await loadModule(filePath);
+    listener = unwrapDefaults(listener);
+
+    // 1. Web handlers (GET, POST, fetch, etc.)
+    const isWebHandler =
+      HTTP_METHODS.some(m => typeof listener[m] === 'function') ||
+      typeof listener.fetch === 'function';
+
+    if (isWebHandler) {
+      return createWebHandler(listener);
+    }
+
+    // 2. Function handler: (req, res) => { ... }
+    if (typeof listener === 'function') {
+      return listener;
+    }
+
+    // 3. Server handler: http.createServer(...).listen()
+    //    Wait briefly for async server creation if not captured yet.
+    if (!server) {
+      await new Promise(r => {
+        serverFound = r;
+        setTimeout(r, 1000);
+      });
+    }
+
+    if (server) {
+      // Start the captured server on a random port and proxy requests to it.
+      await new Promise(r => server.listen(0, '127.0.0.1', r));
+      const { port } = server.address();
+
+      return (req, res) => {
+        const proxyReq = http.request(
+          {
+            hostname: '127.0.0.1',
+            port,
+            path: req.url,
+            method: req.method,
+            headers: {
+              ...req.headers,
+              host: req.headers['x-forwarded-host'] || req.headers.host,
+            },
+          },
+          proxyRes => {
+            res.writeHead(proxyRes.statusCode, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.on('error', err => {
+          res.statusCode = 502;
+          res.end('Proxy error: ' + err.message);
+        });
+        req.pipe(proxyReq);
+      };
+    }
+
+    throw new Error(
+      "Can't detect handler export shape for " +
+        filePath +
+        '. Expected a function export, HTTP method exports (GET, POST, ...), or an http.Server.'
+    );
+  } finally {
+    http.Server.prototype.listen = originalListen;
+  }
+}
+
+module.exports = async (req, res) => {
+  const matchedPath = req.headers['x-matched-path'];
+  if (typeof matchedPath !== 'string' || !matchedPath) {
+    res.statusCode = 500;
+    res.end(
+      'Missing x-matched-path header. The bundled handler requires route-level header injection.'
+    );
+    return;
+  }
+
+  // Convert matched path to entrypoint name.
+  // x-matched-path "/" maps to "index", "/api/hello" maps to "api/hello".
+  const entrypoint = matchedPath.replace(/^\//, '') || 'index';
+
+  if (!handlerCache[entrypoint]) {
+    const filePath = resolveEntrypoint(entrypoint);
+    if (!filePath) {
+      res.statusCode = 404;
+      res.end('No handler found for ' + entrypoint);
+      return;
+    }
+    // Store the Promise immediately so concurrent requests to the same
+    // entrypoint share one compileUserCode() call instead of racing.
+    handlerCache[entrypoint] = compileUserCode(filePath).catch(err => {
+      delete handlerCache[entrypoint]; // Allow retry on next request
+      throw err;
+    });
+  }
+
+  const handler = await handlerCache[entrypoint];
+  return handler(req, res);
+};

package/dist/dev-server.mjs

@@ -662,16 +662,13 @@ var Awaiter = class {
       () => this.promises.size > 0 ? this.waitForBatch() : Promise.resolve()
     );
     this.waitUntil = (promise) => {
-      this.promises.add(promise);
+      const handledPromise = Promise.resolve(promise).catch(this.onError);
+      this.promises.add(handledPromise);
     };
     this.waitForBatch = async () => {
       const promises = Array.from(this.promises);
       this.promises.clear();
-      await Promise.all(
-        promises.map(
-          (promise) => Promise.resolve(promise).then(() => void 0, this.onError)
-        )
-      );
+      await Promise.all(promises);
     };
     this.onError = onError ?? console.error;
   }
@@ -907,7 +904,7 @@ function getBodyParser(body, contentType) {
       try {
         const str = body.toString();
         return str ? JSON.parse(str) : {};
-      } catch (error) {
+      } catch (_error) {
         throw new ApiError(400, "Invalid JSON");
       }
     }
@@ -1251,10 +1248,13 @@ async function createEventHandler(entrypoint2, config, options) {
   const staticConfig = parseConfig(entrypointPath);
   const runtime = staticConfig?.runtime;
   validateConfiguredRuntime(runtime, entrypoint2);
-  const { maxDuration } = await getLambdaOptionsFromFunction({
-    sourceFile: entrypoint2,
-    config
-  });
+  const { maxDuration: configMaxDuration } = await getLambdaOptionsFromFunction(
+    {
+      sourceFile: entrypoint2,
+      config
+    }
+  );
+  const maxDuration = typeof configMaxDuration === "number" ? configMaxDuration : void 0;
   const isMiddleware = config.middleware === true;
   const useEdgeRuntime = isMiddleware && !runtime || isEdgeRuntime(runtime);
   if (useEdgeRuntime) {

package/dist/edge-handler-template.js

@@ -61,7 +61,6 @@ async function parseRequestEvent(event) {
 }
 
 // This will be invoked by logic using this template
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function registerFetchListener(module, options, dependencies) {
   let handler;