@vercel/node 2.4.3 → 2.5.0

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) {
@@ -126,24 +126,25 @@ async function serializeRequest(message) {
         body,
     });
 }
-async function compileUserCode(entrypoint) {
+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,
-            entryPoints: [entrypoint],
+            plugins: [edgeWasmPlugin],
+            entryPoints: [entrypointPath],
             write: false,
             format: 'cjs',
         });
         const compiledFile = result.outputFiles?.[0];
         if (!compiledFile) {
-            throw new Error(`Compilation of ${entrypoint} produced no output files.`);
+            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 {
@@ -173,6 +174,10 @@ async function compileUserCode(entrypoint) {
 
           let response = await edgeHandler(event.request, event);
 
+          if (!response) {
+            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
@@ -185,6 +190,7 @@ async function compileUserCode(entrypoint) {
           }));
         }
       })`;
+        return { userCode, wasmAssets };
     }
     catch (error) {
         // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
@@ -194,20 +200,24 @@ async function compileUserCode(entrypoint) {
         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: {},
                     },
-                });
+                    process: {
+                        env: process.env,
+                    },
+                }, wasmBindings);
                 return context;
             },
         });
@@ -223,8 +233,8 @@ async function createEdgeRuntime(userCode) {
         return undefined;
     }
 }
-async function createEdgeEventHandler(entrypoint) {
-    const userCode = await compileUserCode(entrypoint);
+async function createEdgeEventHandler(entrypointPath, entrypointLabel) {
+    const userCode = await compileUserCode(entrypointPath, entrypointLabel);
     const server = await createEdgeRuntime(userCode);
     return async function (request) {
         if (!server) {
@@ -266,15 +276,15 @@ function parseRuntime(entrypoint, entryPointPath) {
     return runtime;
 }
 async function createEventHandler(entrypoint, config, options) {
-    const entryPointPath = path_1.join(process.cwd(), entrypoint);
-    const runtime = parseRuntime(entrypoint, entryPointPath);
+    const entrypointPath = path_1.join(process.cwd(), entrypoint);
+    const runtime = parseRuntime(entrypoint, entrypointPath);
     // `middleware.js`/`middleware.ts` file is always run as
     // 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);
+        return createEdgeEventHandler(entrypointPath, entrypoint);
     }
-    return createServerlessEventHandler(entryPointPath, options);
+    return createServerlessEventHandler(entrypointPath, options);
 }
 let handleEvent;
 let handlerEventError;

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');
+}