@vercel/node 2.4.5 → 2.5.2

package/dist/dev-server.js

@@ -70,7 +70,7 @@ 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 util_1 = require("util");
+const edge_wasm_plugin_1 = require("./edge-wasm-plugin");
 function logError(error) {
     console.error(error.message);
     if (error.stack) {
@@ -127,12 +127,14 @@ async function serializeRequest(message) {
     });
 }
 async function compileUserCode(entrypointPath, entrypointLabel) {
+    const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
     try {
         const result = await esbuild_1.default.build({
             platform: 'node',
             target: 'node14',
             sourcemap: 'inline',
             bundle: true,
+            plugins: [edgeWasmPlugin],
             entryPoints: [entrypointPath],
             write: false,
             format: 'cjs',
@@ -141,9 +143,8 @@ async function compileUserCode(entrypointPath, entrypointLabel) {
         if (!compiledFile) {
             throw new Error(`Compilation of ${entrypointLabel} produced no output files.`);
         }
-        const userCode = new util_1.TextDecoder().decode(compiledFile.contents);
-        return `
-      ${userCode};
+        const userCode = `
+      ${compiledFile.text};
 
       addEventListener('fetch', async (event) => {
         try {
@@ -189,6 +190,7 @@ async function compileUserCode(entrypointPath, entrypointLabel) {
           }));
         }
       })`;
+        return { userCode, wasmAssets };
     }
     catch (error) {
         // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
@@ -198,23 +200,25 @@ async function compileUserCode(entrypointPath, entrypointLabel) {
         return undefined;
     }
 }
-async function createEdgeRuntime(userCode) {
+async function createEdgeRuntime(params) {
     try {
-        if (!userCode) {
+        if (!params) {
             return undefined;
         }
+        const wasmBindings = await params.wasmAssets.getContext();
         const edgeRuntime = new edge_runtime_1.EdgeRuntime({
-            initialCode: userCode,
+            initialCode: params.userCode,
             extend: (context) => {
                 Object.assign(context, {
-                    __dirname: '',
-                    module: {
-                        exports: {},
-                    },
+                    // 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,
                     },
-                });
+                }, wasmBindings);
                 return context;
             },
         });

package/dist/edge-wasm-plugin.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from 'esbuild';
+export declare class WasmAssets {
+    private readonly assets;
+    /**
+     * Declare a WebAssembly binding
+     */
+    declare(filePath: string): Promise<string>;
+    /**
+     * Get an object with the context needed to execute the code
+     * built with the plugin
+     */
+    getContext(): Promise<Record<string, WebAssembly.Module>>;
+    /**
+     * Allow to iterate easily
+     */
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+export declare function createEdgeWasmPlugin(): {
+    plugin: Plugin;
+    wasmAssets: WasmAssets;
+};

package/dist/edge-wasm-plugin.js

@@ -0,0 +1,82 @@
+"use strict";
+// copied from `edge-functions-bridge`:
+// https://github.com/vercel/runtimes/blob/c076db9e3ce5635f7c2690396e3d9f791a0fd808/packages/edge-functions-bridge/src/get-edge-function-source.ts#L282-L317
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEdgeWasmPlugin = exports.WasmAssets = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+class WasmAssets {
+    constructor() {
+        this.assets = new Map();
+    }
+    /**
+     * Declare a WebAssembly binding
+     */
+    async declare(filePath) {
+        const hash = sha1(await fs_1.promises.readFile(filePath));
+        const name = `wasm_${hash}`;
+        this.assets.set(name, filePath);
+        return name;
+    }
+    /**
+     * Get an object with the context needed to execute the code
+     * built with the plugin
+     */
+    async getContext() {
+        const promises = [];
+        const context = {};
+        for (const [name, filePath] of this.assets) {
+            promises.push((async () => {
+                const bytes = await fs_1.promises.readFile(filePath);
+                context[name] = await WebAssembly.compile(bytes);
+            })());
+        }
+        await Promise.all(promises);
+        return context;
+    }
+    /**
+     * Allow to iterate easily
+     */
+    [Symbol.iterator]() {
+        return this.assets[Symbol.iterator]();
+    }
+}
+exports.WasmAssets = WasmAssets;
+function createEdgeWasmPlugin() {
+    const wasmAssets = new WasmAssets();
+    const plugin = {
+        name: 'vercel-wasm',
+        setup(b) {
+            b.onResolve({ filter: /\.wasm\?module/i }, async (data) => {
+                const wasmFile = data.path.replace(/\?module$/, '');
+                const resolvedPath = await b.resolve(wasmFile, {
+                    importer: data.importer,
+                    resolveDir: data.resolveDir,
+                });
+                if (!resolvedPath.path) {
+                    return {
+                        errors: [
+                            { text: `WebAssembly file could not be located: ${wasmFile}` },
+                        ],
+                    };
+                }
+                const name = await wasmAssets.declare(resolvedPath.path);
+                return {
+                    path: name,
+                    namespace: 'vercel-wasm',
+                };
+            });
+            b.onLoad({ namespace: 'vercel-wasm', filter: /.+/ }, args => {
+                return {
+                    loader: 'js',
+                    contents: `export default globalThis[${JSON.stringify(args.path)}]`,
+                };
+            });
+        },
+    };
+    return { plugin, wasmAssets };
+}
+exports.createEdgeWasmPlugin = createEdgeWasmPlugin;
+function sha1(data) {
+    return crypto_1.createHash('sha1').update(data).digest('hex');
+}

package/dist/index.js

@@ -225030,6 +225030,177 @@ module.exports = {useNative, useNativeSync}
 }));
 
 
+/***/ }),
+
+/***/ 76171:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.RateLimit = exports.Sema = void 0;
+const events_1 = __importDefault(__webpack_require__(28614));
+function arrayMove(src, srcIndex, dst, dstIndex, len) {
+    for (let j = 0; j < len; ++j) {
+        dst[j + dstIndex] = src[j + srcIndex];
+        src[j + srcIndex] = void 0;
+    }
+}
+function pow2AtLeast(n) {
+    n = n >>> 0;
+    n = n - 1;
+    n = n | (n >> 1);
+    n = n | (n >> 2);
+    n = n | (n >> 4);
+    n = n | (n >> 8);
+    n = n | (n >> 16);
+    return n + 1;
+}
+function getCapacity(capacity) {
+    return pow2AtLeast(Math.min(Math.max(16, capacity), 1073741824));
+}
+// Deque is based on https://github.com/petkaantonov/deque/blob/master/js/deque.js
+// Released under the MIT License: https://github.com/petkaantonov/deque/blob/6ef4b6400ad3ba82853fdcc6531a38eb4f78c18c/LICENSE
+class Deque {
+    constructor(capacity) {
+        this._capacity = getCapacity(capacity);
+        this._length = 0;
+        this._front = 0;
+        this.arr = [];
+    }
+    push(item) {
+        const length = this._length;
+        this.checkCapacity(length + 1);
+        const i = (this._front + length) & (this._capacity - 1);
+        this.arr[i] = item;
+        this._length = length + 1;
+        return length + 1;
+    }
+    pop() {
+        const length = this._length;
+        if (length === 0) {
+            return void 0;
+        }
+        const i = (this._front + length - 1) & (this._capacity - 1);
+        const ret = this.arr[i];
+        this.arr[i] = void 0;
+        this._length = length - 1;
+        return ret;
+    }
+    shift() {
+        const length = this._length;
+        if (length === 0) {
+            return void 0;
+        }
+        const front = this._front;
+        const ret = this.arr[front];
+        this.arr[front] = void 0;
+        this._front = (front + 1) & (this._capacity - 1);
+        this._length = length - 1;
+        return ret;
+    }
+    get length() {
+        return this._length;
+    }
+    checkCapacity(size) {
+        if (this._capacity < size) {
+            this.resizeTo(getCapacity(this._capacity * 1.5 + 16));
+        }
+    }
+    resizeTo(capacity) {
+        const oldCapacity = this._capacity;
+        this._capacity = capacity;
+        const front = this._front;
+        const length = this._length;
+        if (front + length > oldCapacity) {
+            const moveItemsCount = (front + length) & (oldCapacity - 1);
+            arrayMove(this.arr, 0, this.arr, oldCapacity, moveItemsCount);
+        }
+    }
+}
+class ReleaseEmitter extends events_1.default {
+}
+function isFn(x) {
+    return typeof x === 'function';
+}
+function defaultInit() {
+    return '1';
+}
+class Sema {
+    constructor(nr, { initFn = defaultInit, pauseFn, resumeFn, capacity = 10, } = {}) {
+        if (isFn(pauseFn) !== isFn(resumeFn)) {
+            throw new Error('pauseFn and resumeFn must be both set for pausing');
+        }
+        this.nrTokens = nr;
+        this.free = new Deque(nr);
+        this.waiting = new Deque(capacity);
+        this.releaseEmitter = new ReleaseEmitter();
+        this.noTokens = initFn === defaultInit;
+        this.pauseFn = pauseFn;
+        this.resumeFn = resumeFn;
+        this.paused = false;
+        this.releaseEmitter.on('release', (token) => {
+            const p = this.waiting.shift();
+            if (p) {
+                p.resolve(token);
+            }
+            else {
+                if (this.resumeFn && this.paused) {
+                    this.paused = false;
+                    this.resumeFn();
+                }
+                this.free.push(token);
+            }
+        });
+        for (let i = 0; i < nr; i++) {
+            this.free.push(initFn());
+        }
+    }
+    tryAcquire() {
+        return this.free.pop();
+    }
+    async acquire() {
+        let token = this.tryAcquire();
+        if (token !== void 0) {
+            return token;
+        }
+        return new Promise((resolve, reject) => {
+            if (this.pauseFn && !this.paused) {
+                this.paused = true;
+                this.pauseFn();
+            }
+            this.waiting.push({ resolve, reject });
+        });
+    }
+    release(token) {
+        this.releaseEmitter.emit('release', this.noTokens ? '1' : token);
+    }
+    drain() {
+        const a = new Array(this.nrTokens);
+        for (let i = 0; i < this.nrTokens; i++) {
+            a[i] = this.acquire();
+        }
+        return Promise.all(a);
+    }
+    nrWaiting() {
+        return this.waiting.length;
+    }
+}
+exports.Sema = Sema;
+function RateLimit(rps, { timeUnit = 1000, uniformDistribution = false, } = {}) {
+    const sema = new Sema(uniformDistribution ? 1 : rps);
+    const delay = uniformDistribution ? timeUnit / rps : timeUnit;
+    return async function rl() {
+        await sema.acquire();
+        setTimeout(() => sema.release(), delay);
+    };
+}
+exports.RateLimit = RateLimit;
+
+
 /***/ }),
 
 /***/ 10031:
@@ -226530,6 +226701,7 @@ const fsSymbols = {
     stat: FS_FN,
     statSync: FS_FN
 };
+const fsExtraSymbols = Object.assign(Object.assign({}, fsSymbols), { pathExists: FS_FN, pathExistsSync: FS_FN, readJson: FS_FN, readJSON: FS_FN, readJsonSync: FS_FN, readJSONSync: FS_FN });
 const staticModules = Object.assign(Object.create(null), {
     bindings: {
         default: BINDINGS
@@ -226544,6 +226716,8 @@ const staticModules = Object.assign(Object.create(null), {
         }
     },
     fs: Object.assign({ default: fsSymbols }, fsSymbols),
+    'fs-extra': Object.assign({ default: fsExtraSymbols }, fsExtraSymbols),
+    'graceful-fs': Object.assign({ default: fsSymbols }, fsSymbols),
     process: Object.assign({ default: staticProcess }, staticProcess),
     // populated below
     path: {
@@ -227351,6 +227525,7 @@ const resolve_dependency_1 = __importDefault(__webpack_require__(62278));
 const micromatch_1 = __webpack_require__(1189);
 const sharedlib_emit_1 = __webpack_require__(62985);
 const path_2 = __webpack_require__(85622);
+const async_sema_1 = __webpack_require__(76171);
 const fsReadFile = graceful_fs_1.default.promises.readFile;
 const fsReadlink = graceful_fs_1.default.promises.readlink;
 const fsStat = graceful_fs_1.default.promises.stat;
@@ -227385,7 +227560,10 @@ async function nodeFileTrace(files, opts = {}) {
 exports.nodeFileTrace = nodeFileTrace;
 ;
 class Job {
-    constructor({ base = process.cwd(), processCwd, exports, conditions = exports || ['node'], exportsOnly = false, paths = {}, ignore, log = false, mixedModules = false, ts = true, analysis = {}, cache, }) {
+    constructor({ base = process.cwd(), processCwd, exports, conditions = exports || ['node'], exportsOnly = false, paths = {}, ignore, log = false, mixedModules = false, ts = true, analysis = {}, cache, 
+    // we use a default of 1024 concurrency to balance
+    // performance and memory usage for fs operations
+    fileIOConcurrency = 1024, }) {
         this.reasons = new Map();
         this.ts = ts;
         base = path_1.resolve(base);
@@ -227429,6 +227607,7 @@ class Job {
         this.paths = resolvedPaths;
         this.log = log;
         this.mixedModules = mixedModules;
+        this.fileIOQueue = new async_sema_1.Sema(fileIOConcurrency);
         this.analysis = {};
         if (analysis !== false) {
             Object.assign(this.analysis, {
@@ -227461,6 +227640,7 @@ class Job {
         const cached = this.symlinkCache.get(path);
         if (cached !== undefined)
             return cached;
+        await this.fileIOQueue.acquire();
         try {
             const link = await fsReadlink(path);
             // also copy stat cache to symlink
@@ -227476,6 +227656,9 @@ class Job {
             this.symlinkCache.set(path, null);
             return null;
         }
+        finally {
+            this.fileIOQueue.release();
+        }
     }
     async isFile(path) {
         const stats = await this.stat(path);
@@ -227493,6 +227676,7 @@ class Job {
         const cached = this.statCache.get(path);
         if (cached)
             return cached;
+        await this.fileIOQueue.acquire();
         try {
             const stats = await fsStat(path);
             this.statCache.set(path, stats);
@@ -227505,6 +227689,9 @@ class Job {
             }
             throw e;
         }
+        finally {
+            this.fileIOQueue.release();
+        }
     }
     async resolve(id, parent, job, cjsResolve) {
         return resolve_dependency_1.default(id, parent, job, cjsResolve);
@@ -227513,6 +227700,7 @@ class Job {
         const cached = this.fileCache.get(path);
         if (cached !== undefined)
             return cached;
+        await this.fileIOQueue.acquire();
         try {
             const source = (await fsReadFile(path)).toString();
             this.fileCache.set(path, source);
@@ -227525,6 +227713,9 @@ class Job {
             }
             throw e;
         }
+        finally {
+            this.fileIOQueue.release();
+        }
     }
     async realpath(path, parent, seen = new Set()) {
         if (seen.has(path))
@@ -304518,6 +304709,7 @@ const path_1 = __webpack_require__(85622);
 const ts_morph_1 = __webpack_require__(4490);
 const once_1 = __importDefault(__webpack_require__(8478));
 const nft_1 = __webpack_require__(39582);
+const resolve_dependency_1 = __importDefault(__webpack_require__(62278));
 const build_utils_1 = __webpack_require__(63445);
 Object.defineProperty(exports, "shouldServe", ({ enumerable: true, get: function () { return build_utils_1.shouldServe; } }));
 const static_config_1 = __webpack_require__(76849);
@@ -304549,7 +304741,7 @@ function renameTStoJS(path) {
     }
     return path;
 }
-async function compile(workPath, baseDir, entrypointPath, config, nodeVersion) {
+async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, isEdgeFunction) {
     const inputFiles = new Set([entrypointPath]);
     const preparedFiles = {};
     const sourceCache = new Map();
@@ -304598,35 +304790,56 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion) {
         processCwd: workPath,
         ts: true,
         mixedModules: true,
+        resolve(id, parent, job, cjsResolve) {
+            const normalizedWasmImports = id.replace(/\.wasm\?module$/i, '.wasm');
+            return resolve_dependency_1.default(normalizedWasmImports, parent, job, cjsResolve);
+        },
         ignore: config.excludeFiles,
         async readFile(fsPath) {
             const relPath = path_1.relative(baseDir, fsPath);
+            // If this file has already been read then return from the cache
             const cached = sourceCache.get(relPath);
-            if (cached)
-                return cached.toString();
-            // null represents a not found
-            if (cached === null)
-                return null;
+            if (typeof cached !== 'undefined')
+                return cached;
             try {
+                let entry;
                 let source = fs_1.readFileSync(fsPath);
-                if ((fsPath.endsWith('.ts') && !fsPath.endsWith('.d.ts')) ||
-                    fsPath.endsWith('.tsx')) {
-                    source = compileTypeScript(fsPath, source.toString());
-                }
                 const { mode } = fs_1.lstatSync(fsPath);
-                let entry;
                 if (build_utils_1.isSymbolicLink(mode)) {
                     entry = new build_utils_1.FileFsRef({ fsPath, mode });
                 }
-                else {
+                if (isEdgeFunction && path_1.basename(fsPath) === 'package.json') {
+                    // For Edge Functions, patch "main" field to prefer "browser" or "module"
+                    const pkgJson = JSON.parse(source.toString());
+                    for (const prop of ['browser', 'module']) {
+                        const val = pkgJson[prop];
+                        if (typeof val === 'string') {
+                            build_utils_1.debug(`Using "${prop}" field in ${fsPath}`);
+                            pkgJson.main = val;
+                            // Create the `entry` with the original so that the output is unmodified
+                            if (!entry) {
+                                entry = new build_utils_1.FileBlob({ data: source, mode });
+                            }
+                            // Return the modified `package.json` to nft
+                            source = JSON.stringify(pkgJson);
+                            break;
+                        }
+                    }
+                }
+                if ((fsPath.endsWith('.ts') && !fsPath.endsWith('.d.ts')) ||
+                    fsPath.endsWith('.tsx')) {
+                    source = compileTypeScript(fsPath, source.toString());
+                }
+                if (!entry) {
                     entry = new build_utils_1.FileBlob({ data: source, mode });
                 }
                 fsCache.set(relPath, entry);
                 sourceCache.set(relPath, source);
-                return source.toString();
+                return source;
             }
             catch (e) {
                 if (e.code === 'ENOENT' || e.code === 'EISDIR') {
+                    // `null` represents a not found
                     sourceCache.set(relPath, null);
                     return null;
                 }
@@ -304741,14 +304954,6 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
     await build_utils_1.runPackageJsonScript(entrypointFsDirname, 
     // Don't consider "build" script since its intended for frontend code
     ['vercel-build', 'now-build'], spawnOpts);
-    build_utils_1.debug('Tracing input files...');
-    const traceTime = Date.now();
-    const { preparedFiles, shouldAddSourcemapSupport } = await compile(workPath, baseDir, entrypointPath, config, nodeVersion);
-    build_utils_1.debug(`Trace complete [${Date.now() - traceTime}ms]`);
-    let routes;
-    let output;
-    const handler = renameTStoJS(path_1.relative(baseDir, entrypointPath));
-    const outputPath = utils_1.entrypointToOutputPath(entrypoint, config.zeroConfig);
     const isMiddleware = config.middleware === true;
     // Will output an `EdgeFunction` for when `config.middleware = true`
     // (i.e. for root-level "middleware" file) or if source code contains:
@@ -304762,6 +304967,14 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
         }
         isEdgeFunction = staticConfig.runtime === 'experimental-edge';
     }
+    build_utils_1.debug('Tracing input files...');
+    const traceTime = Date.now();
+    const { preparedFiles, shouldAddSourcemapSupport } = await compile(workPath, baseDir, entrypointPath, config, nodeVersion, isEdgeFunction);
+    build_utils_1.debug(`Trace complete [${Date.now() - traceTime}ms]`);
+    let routes;
+    let output;
+    const handler = renameTStoJS(path_1.relative(baseDir, entrypointPath));
+    const outputPath = utils_1.entrypointToOutputPath(entrypoint, config.zeroConfig);
     // Add a `route` for Middleware
     if (isMiddleware) {
         if (!isEdgeFunction) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.4.5",
+  "version": "2.5.2",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -11,9 +11,9 @@
   },
   "scripts": {
     "build": "node build",
-    "test-integration-once": "yarn test test/integration.test.js",
     "test": "jest --env node --verbose --bail --runInBand",
     "test-unit": "yarn test test/prepare-cache.test.ts test/utils.test.ts",
+    "test-integration-once": "yarn test test/integration-*.test.js",
     "prepublishOnly": "node build"
   },
   "files": [
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@types/node": "*",
-    "@vercel/build-utils": "5.0.4",
+    "@vercel/build-utils": "5.0.7",
     "@vercel/node-bridge": "3.0.0",
     "@vercel/static-config": "2.0.1",
     "edge-runtime": "1.0.1",
@@ -53,7 +53,7 @@
     "@types/node-fetch": "^2.6.1",
     "@types/test-listen": "1.1.0",
     "@vercel/ncc": "0.24.0",
-    "@vercel/nft": "0.20.1",
+    "@vercel/nft": "0.21.0",
     "content-type": "1.0.4",
     "cookie": "0.4.0",
     "etag": "1.8.1",
@@ -61,5 +61,5 @@
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "3d3774ee7e3d344b3292d2166d485bdf41a68d4c"
+  "gitHead": "e8c7db59cf2746422f1f7e14cc6b7f901c243d50"
 }