@vercel/node 2.14.5 → 2.15.1

package/dist/edge-functions/edge-handler-template.js

@@ -10,14 +10,14 @@ function getUrl(url, headers) {
   return urlObj.toString();
 }
 
-async function respond(userEdgeHandler, event, options, dependencies) {
+async function respond(handler, event, options, dependencies) {
   const { Request, Response } = dependencies;
   const { isMiddleware } = options;
   event.request.headers.set(
     'host',
     event.request.headers.get('x-forwarded-host')
   );
-  let response = await userEdgeHandler(
+  let response = await handler(
     new Request(
       getUrl(event.request.url, event.request.headers),
       event.request
@@ -62,16 +62,34 @@ async function parseRequestEvent(event) {
 
 // This will be invoked by logic using this template
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-function registerFetchListener(userEdgeHandler, options, dependencies) {
+function registerFetchListener(module, options, dependencies) {
+  let handler;
+
   addEventListener('fetch', async event => {
     try {
-      const response = await respond(
-        userEdgeHandler,
-        event,
-        options,
-        dependencies
-      );
-      return event.respondWith(response);
+      if (typeof module.default === 'function') {
+        handler = module.default;
+      } else {
+        if (
+          ['GET', 'HEAD', 'OPTIONS', 'POST', 'PUT', 'DELETE', 'PATCH'].some(
+            method => typeof module[method] === 'function'
+          )
+        ) {
+          const method = event.request.method ?? 'GET';
+          handler =
+            typeof module[method] === 'function'
+              ? module[method]
+              : () => new dependencies.Response(null, { status: 405 });
+        }
+      }
+      if (!handler) {
+        const url = getUrl(event.request.url, event.request.headers);
+        throw new Error(
+          `No default or HTTP-named export was found at ${url}. Add one to handle requests. Learn more: https://vercel.link/creating-edge-middleware`
+        );
+      }
+      const response = await respond(handler, event, options, dependencies);
+      event.respondWith(response);
     } catch (error) {
       event.respondWith(toResponseError(error, dependencies.Response));
     }

package/dist/edge-functions/edge-handler.mjs

@@ -57,12 +57,7 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
 
       // user code
       ${compiledFile.text};
-      const userEdgeHandler = module.exports.default;
-      if (!userEdgeHandler) {
-        throw new Error(
-          'No default export was found. Add a default export to handle requests. Learn more: https://vercel.link/creating-edge-middleware'
-        );
-      }
+      const userModule = module.exports;
 
       // request metadata
       const isMiddleware = ${isMiddleware};
@@ -72,7 +67,7 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
       ${edgeHandlerTemplate};
       const dependencies = { Request, Response };
       const options = { isMiddleware, entrypointLabel };
-      registerFetchListener(userEdgeHandler, options, dependencies);
+      registerFetchListener(userModule, options, dependencies);
     `;
         return {
             userCode,

package/dist/index.js

@@ -139288,6 +139288,7 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
             shouldAddSourcemapSupport,
             awsLambdaHandler,
             supportsResponseStreaming,
+            maxDuration: staticConfig?.maxDuration,
         });
     }
     return { routes, output };
@@ -139906,7 +139907,11 @@ function entrypointToOutputPath(entrypoint, zeroConfig) {
 }
 exports.entrypointToOutputPath = entrypointToOutputPath;
 function logError(error) {
-    console.error(error.message);
+    let message = error.message;
+    if (!message.startsWith('Error:')) {
+        message = `Error: ${message}`;
+    }
+    console.error(message);
     if (error.stack) {
         // only show the stack trace if debug is enabled
         // because it points to internals, not user code

package/dist/serverless-functions/helpers-web.d.ts

@@ -0,0 +1,7 @@
+import type { ServerResponse, IncomingMessage } from 'http';
+/**
+ * When users export at least one HTTP handler, we will generate
+ * a generic handler routing to the right method. If there is no
+ * handler function exported returns null.
+ */
+export declare function getWebExportsHandler(listener: any, methods: string[]): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/serverless-functions/helpers-web.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebExportsHandler = void 0;
+const node_utils_1 = require("@edge-runtime/node-utils");
+class FetchEvent {
+    constructor(request) {
+        this.request = request;
+        this.response = null;
+        this.awaiting = new Set();
+    }
+    respondWith(response) {
+        this.response = response;
+    }
+    waitUntil() {
+        throw new Error('waitUntil is not implemented yet for Node.js');
+    }
+}
+const webHandlerToNodeHandler = (0, node_utils_1.buildToNodeHandler)({
+    Headers,
+    ReadableStream,
+    Request: class extends Request {
+        constructor(input, init) {
+            super(input, addDuplexToInit(init));
+        }
+    },
+    Uint8Array: Uint8Array,
+    FetchEvent: FetchEvent,
+}, { defaultOrigin: 'https://vercel.com' });
+/**
+ * When users export at least one HTTP handler, we will generate
+ * a generic handler routing to the right method. If there is no
+ * handler function exported returns null.
+ */
+function getWebExportsHandler(listener, methods) {
+    const handlerByMethod = {};
+    for (const key of methods) {
+        handlerByMethod[key] =
+            typeof listener[key] !== 'undefined'
+                ? webHandlerToNodeHandler(listener[key])
+                : defaultHttpHandler;
+    }
+    return (req, res) => {
+        const method = req.method ?? 'GET';
+        handlerByMethod[method](req, res);
+    };
+}
+exports.getWebExportsHandler = getWebExportsHandler;
+/**
+ * Add `duplex: 'half'` by default to all requests
+ * https://github.com/vercel/edge-runtime/blob/bf167c418247a79d3941bfce4a5d43c37f512502/packages/primitives/src/primitives/fetch.js#L22-L26
+ * https://developer.chrome.com/articles/fetch-streaming-requests/#streaming-request-bodies
+ */
+function addDuplexToInit(init) {
+    if (typeof init === 'undefined' || typeof init === 'object') {
+        return { duplex: 'half', ...init };
+    }
+    return init;
+}
+function defaultHttpHandler(_, res) {
+    res.statusCode = 405;
+    res.end();
+}

package/dist/serverless-functions/helpers.js

@@ -9,10 +9,17 @@ class ApiError extends Error {
         this.statusCode = statusCode;
     }
 }
+function normalizeContentType(contentType) {
+    if (!contentType) {
+        return 'text/plain';
+    }
+    const { parse: parseContentType } = require('content-type');
+    const { type } = parseContentType(contentType);
+    return type;
+}
 function getBodyParser(body, contentType) {
     return function parseBody() {
-        const { parse: parseContentType } = require('content-type');
-        const { type } = parseContentType(contentType);
+        const type = normalizeContentType(contentType);
         if (type === 'application/json') {
             try {
                 const str = body.toString();

package/dist/serverless-functions/serverless-handler.mjs

@@ -7,32 +7,50 @@ import fetch from 'node-fetch';
 import { listen } from 'async-listen';
 import { isAbsolute } from 'path';
 import { pathToFileURL } from 'url';
-async function createServerlessServer(userCode, options) {
-    const server = createServer(async (req, res) => {
-        if (options.shouldAddHelpers)
-            await addHelpers(req, res);
-        return userCode(req, res);
-    });
+const [NODE_MAJOR] = process.versions.node.split('.').map(v => Number(v));
+/* https://nextjs.org/docs/app/building-your-application/routing/router-handlers#supported-http-methods */
+const HTTP_METHODS = [
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+];
+async function createServerlessServer(userCode) {
+    const server = createServer(userCode);
     exitHook(() => server.close());
     return { url: await listen(server) };
 }
-async function compileUserCode(entrypointPath) {
+async function compileUserCode(entrypointPath, options) {
     const id = isAbsolute(entrypointPath)
         ? pathToFileURL(entrypointPath).href
         : entrypointPath;
-    let fn = await import(id);
+    let listener = await import(id);
     /**
      * In some cases we might have nested default props due to TS => JS
      */
     for (let i = 0; i < 5; i++) {
-        if (fn.default)
-            fn = fn.default;
+        if (listener.default)
+            listener = listener.default;
+    }
+    if (HTTP_METHODS.some(method => typeof listener[method] === 'function')) {
+        if (NODE_MAJOR < 18) {
+            throw new Error('Node.js v18 or above is required to use HTTP method exports in your functions.');
+        }
+        const { getWebExportsHandler } = await import('./helpers-web.js');
+        return getWebExportsHandler(listener, HTTP_METHODS);
     }
-    return fn;
+    return async (req, res) => {
+        if (options.shouldAddHelpers)
+            await addHelpers(req, res);
+        return listener(req, res);
+    };
 }
 export async function createServerlessEventHandler(entrypointPath, options) {
-    const userCode = await compileUserCode(entrypointPath);
-    const server = await createServerlessServer(userCode, options);
+    const userCode = await compileUserCode(entrypointPath, options);
+    const server = await createServerlessServer(userCode);
     return async function (request) {
         const url = new URL(request.url ?? '/', server.url);
         // @ts-expect-error

package/dist/utils.js

@@ -46,7 +46,11 @@ function entrypointToOutputPath(entrypoint, zeroConfig) {
 }
 exports.entrypointToOutputPath = entrypointToOutputPath;
 function logError(error) {
-    console.error(error.message);
+    let message = error.message;
+    if (!message.startsWith('Error:')) {
+        message = `Error: ${message}`;
+    }
+    console.error(message);
     if (error.stack) {
         // only show the stack trace if debug is enabled
         // because it points to internals, not user code

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.14.5",
+  "version": "2.15.1",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -13,6 +13,8 @@
     "dist"
   ],
   "dependencies": {
+    "@edge-runtime/node-utils": "2.0.3",
+    "@edge-runtime/primitives": "2.1.2",
     "@edge-runtime/vm": "2.0.0",
     "@types/node": "14.18.33",
     "@types/node-fetch": "2.6.3",