@vercel/node 2.5.18 → 2.5.19

package/dist/dev-server.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixConfigDev = exports.onDevRequest = exports.rawBody = void 0;
+exports.fixConfigDev = exports.onDevRequest = void 0;
 const entrypoint = process.env.VERCEL_DEV_ENTRYPOINT;
 delete process.env.VERCEL_DEV_ENTRYPOINT;
 const tsconfig = process.env.VERCEL_DEV_TSCONFIG;
@@ -62,30 +59,11 @@ if (!process.env.VERCEL_DEV_IS_ESM) {
     useRequire = true;
 }
 const http_1 = require("http");
-const launcher_js_1 = require("@vercel/node-bridge/launcher.js");
-const build_utils_1 = require("@vercel/build-utils");
-const exit_hook_1 = __importDefault(require("exit-hook"));
-const edge_runtime_1 = require("edge-runtime");
 const static_config_1 = require("@vercel/static-config");
 const ts_morph_1 = require("ts-morph");
-const esbuild_1 = __importDefault(require("esbuild"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const edge_wasm_plugin_1 = require("./edge-wasm-plugin");
-const NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
-const NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
-if (!NODE_VERSION_MAJOR) {
-    throw new Error(`Unable to determine current node version: process.version=${process.version}`);
-}
-function logError(error) {
-    console.error(error.message);
-    if (error.stack) {
-        // only show the stack trace if debug is enabled
-        // because it points to internals, not user code
-        const errorPrefixLength = 'Error: '.length;
-        const errorMessageLength = errorPrefixLength + error.message.length;
-        build_utils_1.debug(error.stack.substring(errorMessageLength + 1));
-    }
-}
+const utils_1 = require("./utils");
+const edge_handler_1 = require("./edge-functions/edge-handler");
+const serverless_handler_1 = require("./serverless-functions/serverless-handler");
 function listen(server, port, host) {
     return new Promise(resolve => {
         server.listen(port, host, () => {
@@ -93,204 +71,6 @@ function listen(server, port, host) {
         });
     });
 }
-async function createServerlessEventHandler(entrypoint, options) {
-    const launcher = launcher_js_1.getVercelLauncher({
-        entrypointPath: entrypoint,
-        helpersPath: './helpers.js',
-        shouldAddHelpers: options.shouldAddHelpers,
-        useRequire,
-        // not used
-        bridgePath: '',
-        sourcemapSupportPath: '',
-    });
-    const bridge = launcher();
-    return async function (request) {
-        const body = await rawBody(request);
-        const event = {
-            Action: 'Invoke',
-            body: JSON.stringify({
-                method: request.method,
-                path: request.url,
-                headers: request.headers,
-                encoding: 'base64',
-                body: body.toString('base64'),
-            }),
-        };
-        return bridge.launcher(event, {
-            callbackWaitsForEmptyEventLoop: false,
-        });
-    };
-}
-async function serializeRequest(message) {
-    const bodyBuffer = await build_utils_1.streamToBuffer(message);
-    const body = bodyBuffer.toString('base64');
-    return JSON.stringify({
-        url: message.url,
-        method: message.method,
-        headers: message.headers,
-        body,
-    });
-}
-async function compileUserCode(entrypointPath, entrypointLabel, isMiddleware) {
-    const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
-    try {
-        const result = await esbuild_1.default.build({
-            // bundling behavior: use globals (like "browser") instead
-            // of "require" statements for core libraries (like "node")
-            platform: 'browser',
-            // target syntax: only use syntax available on the current
-            // version of node
-            target: NODE_VERSION_IDENTIFIER,
-            sourcemap: 'inline',
-            bundle: true,
-            plugins: [edgeWasmPlugin],
-            entryPoints: [entrypointPath],
-            write: false,
-            format: 'cjs',
-        });
-        const compiledFile = result.outputFiles?.[0];
-        if (!compiledFile) {
-            throw new Error(`Compilation of ${entrypointLabel} produced no output files.`);
-        }
-        const userCode = `
-      ${compiledFile.text};
-
-      const isMiddleware = ${isMiddleware};
-
-      addEventListener('fetch', async (event) => {
-        try {
-          let serializedRequest = await event.request.text();
-          let requestDetails = JSON.parse(serializedRequest);
-
-          let body;
-
-          if (requestDetails.method !== 'GET' && requestDetails.method !== 'HEAD') {
-            body = Uint8Array.from(atob(requestDetails.body), c => c.charCodeAt(0));
-          }
-
-          let requestUrl = requestDetails.headers['x-forwarded-proto'] + '://' + requestDetails.headers['x-forwarded-host'] + requestDetails.url;
-
-          let request = new Request(requestUrl, {
-            headers: requestDetails.headers,
-            method: requestDetails.method,
-            body: body
-          });
-
-          event.request = request;
-
-          let edgeHandler = module.exports.default;
-          if (!edgeHandler) {
-            throw new Error('No default export was found. Add a default export to handle requests. Learn more: https://vercel.link/creating-edge-middleware');
-          }
-
-          let response = await edgeHandler(event.request, event);
-
-          if (!response) {
-            if (isMiddleware) {
-              // allow empty responses to pass through
-              response = new Response(null, {
-                headers: {
-                  'x-middleware-next': '1',
-                },
-              });
-            } else {
-              throw new Error('Edge Function "${entrypointLabel}" did not return a response.');
-            }
-          }
-
-          return event.respondWith(response);
-        } catch (error) {
-          // we can't easily show a meaningful stack trace
-          // so, stick to just the error message for now
-          const msg = error.cause
-            ? (error.message + ': ' + (error.cause.message || error.cause))
-            : error.message;
-          event.respondWith(new Response(msg, {
-            status: 500,
-            headers: {
-              'x-vercel-failed': 'edge-wrapper'
-            }
-          }));
-        }
-      })`;
-        return { userCode, wasmAssets };
-    }
-    catch (error) {
-        // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
-        // So, stick with just the message for now.
-        console.error(`Failed to compile user code for edge runtime.`);
-        logError(error);
-        return undefined;
-    }
-}
-async function createEdgeRuntime(params) {
-    try {
-        if (!params) {
-            return undefined;
-        }
-        const wasmBindings = await params.wasmAssets.getContext();
-        const edgeRuntime = new edge_runtime_1.EdgeRuntime({
-            initialCode: params.userCode,
-            extend: (context) => {
-                Object.assign(context, {
-                    // This is required for esbuild wrapping logic to resolve
-                    module: {},
-                    // This is required for environment variable access.
-                    // In production, env var access is provided by static analysis
-                    // so that only the used values are available.
-                    process: {
-                        env: process.env,
-                    },
-                    // These are the global bindings for WebAssembly module
-                    ...wasmBindings,
-                });
-                return context;
-            },
-        });
-        const server = await edge_runtime_1.runServer({ runtime: edgeRuntime });
-        exit_hook_1.default(server.close);
-        return server;
-    }
-    catch (error) {
-        // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
-        // So, stick with just the message for now.
-        console.error('Failed to instantiate edge runtime.');
-        logError(error);
-        return undefined;
-    }
-}
-async function createEdgeEventHandler(entrypointPath, entrypointLabel, isMiddleware) {
-    const userCode = await compileUserCode(entrypointPath, entrypointLabel, isMiddleware);
-    const server = await createEdgeRuntime(userCode);
-    return async function (request) {
-        if (!server) {
-            // this error state is already logged, but we have to wait until here to exit the process
-            // this matches the serverless function bridge launcher's behavior when
-            // an error is thrown in the function
-            process.exit(1);
-        }
-        const response = await node_fetch_1.default(server.url, {
-            redirect: 'manual',
-            method: 'post',
-            body: await serializeRequest(request),
-        });
-        const body = await response.text();
-        const isUserError = response.headers.get('x-vercel-failed') === 'edge-wrapper';
-        if (isUserError && response.status >= 500) {
-            // this error was "unhandled" from the user code's perspective
-            console.log(`Unhandled rejection: ${body}`);
-            // this matches the serverless function bridge launcher's behavior when
-            // an error is thrown in the function
-            process.exit(1);
-        }
-        return {
-            statusCode: response.status,
-            headers: response.headers.raw(),
-            body,
-            encoding: 'utf8',
-        };
-    };
-}
 const validRuntimes = ['experimental-edge'];
 function parseRuntime(entrypoint, entryPointPath) {
     const project = new ts_morph_1.Project();
@@ -308,9 +88,12 @@ async function createEventHandler(entrypoint, config, options) {
     // an Edge Function, otherwise needs to be opted-in via
     // `export const config = { runtime: 'experimental-edge' }`
     if (config.middleware === true || runtime === 'experimental-edge') {
-        return createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false);
+        return edge_handler_1.createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false);
     }
-    return createServerlessEventHandler(entrypointPath, options);
+    return serverless_handler_1.createServerlessEventHandler(entrypointPath, {
+        shouldAddHelpers: options.shouldAddHelpers,
+        useRequire,
+    });
 }
 let handleEvent;
 let handlerEventError;
@@ -328,7 +111,7 @@ async function main() {
         });
     }
     catch (error) {
-        logError(error);
+        utils_1.logError(error);
         handlerEventError = error;
     }
     const address = proxyServer.address();
@@ -339,21 +122,6 @@ async function main() {
         console.log('Dev server listening:', address);
     }
 }
-function rawBody(readable) {
-    return new Promise((resolve, reject) => {
-        let bytes = 0;
-        const chunks = [];
-        readable.on('error', reject);
-        readable.on('data', chunk => {
-            chunks.push(chunk);
-            bytes += chunk.length;
-        });
-        readable.on('end', () => {
-            resolve(Buffer.concat(chunks, bytes));
-        });
-    });
-}
-exports.rawBody = rawBody;
 async function onDevRequest(req, res) {
     if (handlerEventError) {
         // this error state is already logged, but we have to wait until here to exit the process
@@ -396,6 +164,6 @@ function fixConfigDev(config) {
 }
 exports.fixConfigDev = fixConfigDev;
 main().catch(err => {
-    logError(err);
+    utils_1.logError(err);
     process.exit(1);
 });

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

@@ -0,0 +1,73 @@
+// provided by the edge runtime:
+/* global addEventListener Request Response atob */
+
+// provided by our edge handler logic:
+/* global IS_MIDDLEWARE ENTRYPOINT_LABEL */
+
+function buildUrl(requestDetails) {
+  let proto = requestDetails.headers['x-forwarded-proto'];
+  let host = requestDetails.headers['x-forwarded-host'];
+  let path = requestDetails.url;
+  return `${proto}://${host}${path}`;
+}
+
+addEventListener('fetch', async event => {
+  try {
+    let serializedRequest = await event.request.text();
+    let requestDetails = JSON.parse(serializedRequest);
+
+    let body;
+
+    if (requestDetails.method !== 'GET' && requestDetails.method !== 'HEAD') {
+      body = Uint8Array.from(atob(requestDetails.body), c => c.charCodeAt(0));
+    }
+
+    let request = new Request(buildUrl(requestDetails), {
+      headers: requestDetails.headers,
+      method: requestDetails.method,
+      body: body,
+    });
+
+    event.request = request;
+
+    let edgeHandler = module.exports.default;
+    if (!edgeHandler) {
+      throw new Error(
+        'No default export was found. Add a default export to handle requests. Learn more: https://vercel.link/creating-edge-middleware'
+      );
+    }
+
+    let response = await edgeHandler(event.request, event);
+
+    if (!response) {
+      if (IS_MIDDLEWARE) {
+        // allow empty responses to pass through
+        response = new Response(null, {
+          headers: {
+            'x-middleware-next': '1',
+          },
+        });
+      } else {
+        throw new Error(
+          `Edge Function "${ENTRYPOINT_LABEL}" did not return a response.`
+        );
+      }
+    }
+
+    return event.respondWith(response);
+  } catch (error) {
+    // we can't easily show a meaningful stack trace
+    // so, stick to just the error message for now
+    const msg = error.cause
+      ? error.message + ': ' + (error.cause.message || error.cause)
+      : error.message;
+    event.respondWith(
+      new Response(msg, {
+        status: 500,
+        headers: {
+          'x-vercel-failed': 'edge-wrapper',
+        },
+      })
+    );
+  }
+});

package/dist/edge-functions/edge-handler.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { VercelProxyResponse } from '@vercel/node-bridge/types';
+export declare function createEdgeEventHandler(entrypointPath: string, entrypointLabel: string, isMiddleware: boolean): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;

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

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEdgeEventHandler = void 0;
+const build_utils_1 = require("@vercel/build-utils");
+const exit_hook_1 = __importDefault(require("exit-hook"));
+const edge_runtime_1 = require("edge-runtime");
+const esbuild_1 = __importDefault(require("esbuild"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const edge_wasm_plugin_1 = require("./edge-wasm-plugin");
+const utils_1 = require("../utils");
+const fs_1 = require("fs");
+const NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
+const NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
+if (!NODE_VERSION_MAJOR) {
+    throw new Error(`Unable to determine current node version: process.version=${process.version}`);
+}
+const edgeHandlerTemplate = fs_1.readFileSync(`${__dirname}/edge-handler-template.js`);
+async function serializeRequest(message) {
+    const bodyBuffer = await build_utils_1.streamToBuffer(message);
+    const body = bodyBuffer.toString('base64');
+    return JSON.stringify({
+        url: message.url,
+        method: message.method,
+        headers: message.headers,
+        body,
+    });
+}
+async function compileUserCode(entrypointPath, entrypointLabel, isMiddleware) {
+    const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
+    try {
+        const result = await esbuild_1.default.build({
+            // bundling behavior: use globals (like "browser") instead
+            // of "require" statements for core libraries (like "node")
+            platform: 'browser',
+            // target syntax: only use syntax available on the current
+            // version of node
+            target: NODE_VERSION_IDENTIFIER,
+            sourcemap: 'inline',
+            legalComments: 'none',
+            bundle: true,
+            plugins: [edgeWasmPlugin],
+            entryPoints: [entrypointPath],
+            write: false,
+            format: 'cjs',
+        });
+        const compiledFile = result.outputFiles?.[0];
+        if (!compiledFile) {
+            throw new Error(`Compilation of ${entrypointLabel} produced no output files.`);
+        }
+        const userCode = `
+      // strict mode
+      "use strict";var regeneratorRuntime;
+
+      // user code
+      ${compiledFile.text};
+
+      // request metadata
+      const IS_MIDDLEWARE = ${isMiddleware};
+      const ENTRYPOINT_LABEL = '${entrypointLabel}';
+
+      // edge handler
+      ${edgeHandlerTemplate}
+    `;
+        return { userCode, wasmAssets };
+    }
+    catch (error) {
+        // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
+        // So, stick with just the message for now.
+        console.error(`Failed to compile user code for edge runtime.`);
+        utils_1.logError(error);
+        return undefined;
+    }
+}
+async function createEdgeRuntime(params) {
+    try {
+        if (!params) {
+            return undefined;
+        }
+        const wasmBindings = await params.wasmAssets.getContext();
+        const edgeRuntime = new edge_runtime_1.EdgeRuntime({
+            initialCode: params.userCode,
+            extend: (context) => {
+                Object.assign(context, {
+                    // This is required for esbuild wrapping logic to resolve
+                    module: {},
+                    // This is required for environment variable access.
+                    // In production, env var access is provided by static analysis
+                    // so that only the used values are available.
+                    process: {
+                        env: process.env,
+                    },
+                    // These are the global bindings for WebAssembly module
+                    ...wasmBindings,
+                });
+                return context;
+            },
+        });
+        const server = await edge_runtime_1.runServer({ runtime: edgeRuntime });
+        exit_hook_1.default(server.close);
+        return server;
+    }
+    catch (error) {
+        // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
+        // So, stick with just the message for now.
+        console.error('Failed to instantiate edge runtime.');
+        utils_1.logError(error);
+        return undefined;
+    }
+}
+async function createEdgeEventHandler(entrypointPath, entrypointLabel, isMiddleware) {
+    const userCode = await compileUserCode(entrypointPath, entrypointLabel, isMiddleware);
+    const server = await createEdgeRuntime(userCode);
+    return async function (request) {
+        if (!server) {
+            // this error state is already logged, but we have to wait until here to exit the process
+            // this matches the serverless function bridge launcher's behavior when
+            // an error is thrown in the function
+            process.exit(1);
+        }
+        const response = await node_fetch_1.default(server.url, {
+            redirect: 'manual',
+            method: 'post',
+            body: await serializeRequest(request),
+        });
+        const body = await response.text();
+        const isUserError = response.headers.get('x-vercel-failed') === 'edge-wrapper';
+        if (isUserError && response.status >= 500) {
+            // this error was "unhandled" from the user code's perspective
+            console.log(`Unhandled rejection: ${body}`);
+            // this matches the serverless function bridge launcher's behavior when
+            // an error is thrown in the function
+            process.exit(1);
+        }
+        return {
+            statusCode: response.status,
+            headers: response.headers.raw(),
+            body,
+            encoding: 'utf8',
+        };
+    };
+}
+exports.createEdgeEventHandler = createEdgeEventHandler;

package/dist/index.js

@@ -305529,9 +305529,10 @@ function filterDiagnostics(diagnostics, ignore) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
+exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const path_1 = __webpack_require__(85622);
 const path_to_regexp_1 = __webpack_require__(91786);
+const build_utils_1 = __webpack_require__(63445);
 function getRegExpFromMatchers(matcherOrMatchers) {
     if (!matcherOrMatchers) {
         return '^/.*$';
@@ -305573,6 +305574,17 @@ function entrypointToOutputPath(entrypoint, zeroConfig) {
     return entrypoint;
 }
 exports.entrypointToOutputPath = entrypointToOutputPath;
+function logError(error) {
+    console.error(error.message);
+    if (error.stack) {
+        // only show the stack trace if debug is enabled
+        // because it points to internals, not user code
+        const errorPrefixLength = 'Error: '.length;
+        const errorMessageLength = errorPrefixLength + error.message.length;
+        build_utils_1.debug(error.stack.substring(errorMessageLength + 1));
+    }
+}
+exports.logError = logError;
 
 
 /***/ }),

package/dist/serverless-functions/serverless-handler.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { VercelProxyResponse } from '@vercel/node-bridge/types';
+export declare function createServerlessEventHandler(entrypoint: string, options: {
+    shouldAddHelpers: boolean;
+    useRequire: boolean;
+}): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerlessEventHandler = void 0;
+const launcher_js_1 = require("@vercel/node-bridge/launcher.js");
+function rawBody(readable) {
+    return new Promise((resolve, reject) => {
+        let bytes = 0;
+        const chunks = [];
+        readable.on('error', reject);
+        readable.on('data', chunk => {
+            chunks.push(chunk);
+            bytes += chunk.length;
+        });
+        readable.on('end', () => {
+            resolve(Buffer.concat(chunks, bytes));
+        });
+    });
+}
+async function createServerlessEventHandler(entrypoint, options) {
+    const launcher = launcher_js_1.getVercelLauncher({
+        entrypointPath: entrypoint,
+        helpersPath: './helpers.js',
+        shouldAddHelpers: options.shouldAddHelpers,
+        useRequire: options.useRequire,
+        // not used
+        bridgePath: '',
+        sourcemapSupportPath: '',
+    });
+    const bridge = launcher();
+    return async function (request) {
+        const body = await rawBody(request);
+        const event = {
+            Action: 'Invoke',
+            body: JSON.stringify({
+                method: request.method,
+                path: request.url,
+                headers: request.headers,
+                encoding: 'base64',
+                body: body.toString('base64'),
+            }),
+        };
+        return bridge.launcher(event, {
+            callbackWaitsForEmptyEventLoop: false,
+        });
+    };
+}
+exports.createServerlessEventHandler = createServerlessEventHandler;

package/dist/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
+exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const path_1 = require("path");
 const path_to_regexp_1 = require("path-to-regexp");
+const build_utils_1 = require("@vercel/build-utils");
 function getRegExpFromMatchers(matcherOrMatchers) {
     if (!matcherOrMatchers) {
         return '^/.*$';
@@ -44,3 +45,14 @@ function entrypointToOutputPath(entrypoint, zeroConfig) {
     return entrypoint;
 }
 exports.entrypointToOutputPath = entrypointToOutputPath;
+function logError(error) {
+    console.error(error.message);
+    if (error.stack) {
+        // only show the stack trace if debug is enabled
+        // because it points to internals, not user code
+        const errorPrefixLength = 'Error: '.length;
+        const errorMessageLength = errorPrefixLength + error.message.length;
+        build_utils_1.debug(error.stack.substring(errorMessageLength + 1));
+    }
+}
+exports.logError = logError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.5.18",
+  "version": "2.5.19",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -31,7 +31,7 @@
   "dependencies": {
     "@edge-runtime/vm": "1.1.0-beta.32",
     "@types/node": "*",
-    "@vercel/build-utils": "5.5.0",
+    "@vercel/build-utils": "5.5.1",
     "@vercel/node-bridge": "3.0.0",
     "@vercel/static-config": "2.0.3",
     "edge-runtime": "1.1.0-beta.32",
@@ -61,5 +61,5 @@
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "a825bc95409aa1403e062e45afebe194c8197061"
+  "gitHead": "bf5cfa9a41f8c1f9e2a3d3fc30735708ca72ad09"
 }