@vercel/node 2.9.14 → 2.10.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.9.14",
+  "version": "2.10.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -64,5 +64,5 @@
     "test-listen": "1.1.0",
     "ts-morph": "12.0.0"
   },
-  "gitHead": "ab9915af32e54338845f6ff32340dd0189474c55"
+  "gitHead": "6a7fa1526c6652c24350ef4797664a945775cf52"
 }