@vercel/node 2.9.13 → 2.10.0

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

@@ -2,9 +2,18 @@
 /* global addEventListener */
 
 function buildUrl(requestDetails) {
-  let proto = requestDetails.headers['x-forwarded-proto'].split(/\b/).shift(); // handling multi-protocol like https,http://...
-  let host = requestDetails.headers['x-forwarded-host'];
-  let path = requestDetails.url;
+  const host = requestDetails.headers['x-forwarded-host'] || '127.0.0.1';
+  const path = requestDetails.url || '/';
+
+  const allProtocols = requestDetails.headers['x-forwarded-proto'];
+  let proto;
+  if (allProtocols) {
+    // handle multi-protocol like: https,http://...
+    proto = allProtocols.split(/\b/).shift();
+  } else {
+    proto = 'http';
+  }
+
   return `${proto}://${host}${path}`;
 }
 
@@ -16,7 +25,7 @@ async function respond(
   dependencies
 ) {
   const { Request, Response } = dependencies;
-  const { isMiddleware, entrypointLabel } = options;
+  const { isMiddleware } = options;
 
   let body;
 
@@ -26,7 +35,7 @@ async function respond(
     }
   }
 
-  let request = new Request(buildUrl(requestDetails), {
+  const request = new Request(buildUrl(requestDetails), {
     headers: requestDetails.headers,
     method: requestDetails.method,
     body: body,
@@ -45,9 +54,7 @@ async function respond(
         },
       });
     } else {
-      throw new Error(
-        `Edge Function "${entrypointLabel}" did not return a response.`
-      );
+      throw new Error(`Edge Function did not return a response.`);
     }
   }
   return response;
@@ -68,8 +75,8 @@ function toResponseError(error, Response) {
 }
 
 async function parseRequestEvent(event) {
-  let serializedRequest = await event.request.text();
-  let requestDetails = JSON.parse(serializedRequest);
+  const serializedRequest = await event.request.text();
+  const requestDetails = JSON.parse(serializedRequest);
   return requestDetails;
 }
 
@@ -78,8 +85,8 @@ async function parseRequestEvent(event) {
 function registerFetchListener(userEdgeHandler, options, dependencies) {
   addEventListener('fetch', async event => {
     try {
-      let requestDetails = await parseRequestEvent(event);
-      let response = await respond(
+      const requestDetails = await parseRequestEvent(event);
+      const response = await respond(
         userEdgeHandler,
         requestDetails,
         event,

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

@@ -12,6 +12,7 @@ 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 edge_node_compat_plugin_1 = require("./edge-node-compat-plugin");
 const NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
 const NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
 if (!NODE_VERSION_MAJOR) {
@@ -30,6 +31,7 @@ async function serializeRequest(message) {
 }
 async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware) {
     const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
+    const nodeCompatPlugin = edge_node_compat_plugin_1.createNodeCompatPlugin();
     try {
         const result = await esbuild_1.default.build({
             // bundling behavior: use globals (like "browser") instead
@@ -41,7 +43,7 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
             sourcemap: 'inline',
             legalComments: 'none',
             bundle: true,
-            plugins: [edgeWasmPlugin],
+            plugins: [edgeWasmPlugin, nodeCompatPlugin.plugin],
             entryPoints: [entrypointFullPath],
             write: false,
             format: 'cjs',
@@ -79,7 +81,11 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
       };
       registerFetchListener(userEdgeHandler, options, dependencies);
     `;
-        return { userCode, wasmAssets };
+        return {
+            userCode,
+            wasmAssets,
+            nodeCompatBindings: nodeCompatPlugin.bindings,
+        };
     }
     catch (error) {
         // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
@@ -95,6 +101,7 @@ async function createEdgeRuntime(params) {
             return undefined;
         }
         const wasmBindings = await params.wasmAssets.getContext();
+        const nodeCompatBindings = params.nodeCompatBindings.getContext();
         const edgeRuntime = new edge_runtime_1.EdgeRuntime({
             initialCode: params.userCode,
             extend: (context) => {
@@ -107,6 +114,8 @@ async function createEdgeRuntime(params) {
                     process: {
                         env: process.env,
                     },
+                    // These are the global bindings for Node.js compatibility
+                    ...nodeCompatBindings,
                     // These are the global bindings for WebAssembly module
                     ...wasmBindings,
                 });

package/dist/edge-functions/edge-node-compat-plugin.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from 'esbuild';
+export declare class NodeCompatBindings {
+    private bindings;
+    use(modulePath: `node:${string}`): string;
+    getContext(): Record<string, unknown>;
+}
+/**
+ * Allows to enable Node.js compatibility by detecting namespaced `node:`
+ * imports and producing metadata to bind global variables for each.
+ * It requires from the consumer to add the imports.
+ */
+export declare function createNodeCompatPlugin(): {
+    plugin: Plugin;
+    bindings: NodeCompatBindings;
+};

package/dist/edge-functions/edge-node-compat-plugin.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeCompatPlugin = exports.NodeCompatBindings = void 0;
+const buffer_1 = __importDefault(require("buffer"));
+const events_1 = __importDefault(require("events"));
+const async_hooks_1 = __importDefault(require("async_hooks"));
+const assert_1 = __importDefault(require("assert"));
+const util_1 = __importDefault(require("util"));
+const SUPPORTED_NODE_MODULES = [
+    'buffer',
+    'events',
+    'assert',
+    'util',
+    'async_hooks',
+];
+const getSupportedNodeModuleRegex = () => new RegExp(`^(?:node:)?(?:${SUPPORTED_NODE_MODULES.join('|')})$`);
+function pick(obj, keys) {
+    const res = {};
+    for (const key of keys) {
+        res[key] = obj[key];
+    }
+    return res;
+}
+const NativeModuleMap = () => {
+    const mods = {
+        buffer: pick(buffer_1.default, [
+            'constants',
+            'kMaxLength',
+            'kStringMaxLength',
+            'Buffer',
+            'SlowBuffer',
+        ]),
+        events: pick(events_1.default, [
+            'EventEmitter',
+            'captureRejectionSymbol',
+            'defaultMaxListeners',
+            'errorMonitor',
+            'listenerCount',
+            'on',
+            'once',
+        ]),
+        async_hooks: pick(async_hooks_1.default, [
+            'AsyncLocalStorage',
+            'AsyncResource',
+        ]),
+        assert: pick(assert_1.default, [
+            'AssertionError',
+            'deepEqual',
+            'deepStrictEqual',
+            'doesNotMatch',
+            'doesNotReject',
+            'doesNotThrow',
+            'equal',
+            'fail',
+            'ifError',
+            'match',
+            'notDeepEqual',
+            'notDeepStrictEqual',
+            'notEqual',
+            'notStrictEqual',
+            'ok',
+            'rejects',
+            'strict',
+            'strictEqual',
+            'throws',
+        ]),
+        util: pick(util_1.default, [
+            '_extend',
+            'callbackify',
+            'format',
+            'inherits',
+            'promisify',
+            'types',
+        ]),
+    };
+    return new Map(Object.entries(mods));
+};
+const NODE_COMPAT_NAMESPACE = 'vercel-node-compat';
+class NodeCompatBindings {
+    constructor() {
+        this.bindings = new Map();
+    }
+    use(modulePath) {
+        const stripped = modulePath.replace(/^node:/, '');
+        const name = `__vc_node_${stripped}__`;
+        if (!this.bindings.has(modulePath)) {
+            const value = NativeModuleMap().get(stripped);
+            if (value === undefined) {
+                throw new Error(`Could not find module ${modulePath}`);
+            }
+            this.bindings.set(modulePath, {
+                modulePath: modulePath,
+                name,
+                value,
+            });
+        }
+        return name;
+    }
+    getContext() {
+        const context = {};
+        for (const binding of this.bindings.values()) {
+            context[binding.name] = binding.value;
+        }
+        return context;
+    }
+}
+exports.NodeCompatBindings = NodeCompatBindings;
+/**
+ * Allows to enable Node.js compatibility by detecting namespaced `node:`
+ * imports and producing metadata to bind global variables for each.
+ * It requires from the consumer to add the imports.
+ */
+function createNodeCompatPlugin() {
+    const bindings = new NodeCompatBindings();
+    const plugin = {
+        name: 'vc-node-compat',
+        setup(b) {
+            b.onResolve({ filter: getSupportedNodeModuleRegex() }, async (args) => {
+                const importee = args.path.replace('node:', '');
+                if (!SUPPORTED_NODE_MODULES.includes(importee)) {
+                    return;
+                }
+                return {
+                    namespace: NODE_COMPAT_NAMESPACE,
+                    path: args.path,
+                };
+            });
+            b.onLoad({ filter: /.+/, namespace: NODE_COMPAT_NAMESPACE }, async (args) => {
+                const fullName = args.path.startsWith('node:')
+                    ? args.path
+                    : `node:${args.path}`;
+                const globalName = bindings.use(fullName);
+                return {
+                    contents: `module.exports = ${globalName};`,
+                    loader: 'js',
+                };
+            });
+        },
+    };
+    return {
+        plugin,
+        bindings,
+    };
+}
+exports.createNodeCompatPlugin = createNodeCompatPlugin;

package/dist/index.js

@@ -302075,7 +302075,9 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
         shouldAddSourcemapSupport = true;
         return source;
     }
-    const conditions = isEdgeFunction ? ['worker', 'browser'] : undefined;
+    const conditions = isEdgeFunction
+        ? ['edge-light', 'browser', 'module', 'import', 'require']
+        : undefined;
     const { fileList, esmFileList, warnings } = await nft_1.nodeFileTrace([...inputFiles], {
         base: baseDir,
         processCwd: workPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.9.13",
+  "version": "2.10.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -31,7 +31,7 @@
   "dependencies": {
     "@edge-runtime/vm": "2.0.0",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "6.4.0",
+    "@vercel/build-utils": "6.5.0",
     "@vercel/node-bridge": "3.1.14",
     "@vercel/static-config": "2.0.14",
     "edge-runtime": "2.0.0",
@@ -64,5 +64,5 @@
     "test-listen": "1.1.0",
     "ts-morph": "12.0.0"
   },
-  "gitHead": "b2c68f1301b6a5eb41b6261b7faac6a8fa4c53eb"
+  "gitHead": "6a7fa1526c6652c24350ef4797664a945775cf52"
 }