@vercel/node 2.1.1-canary.0 → 2.2.0

package/dist/dev-server.js

@@ -1,4 +1,7 @@
 "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;
 const entrypoint = process.env.VERCEL_DEV_ENTRYPOINT;
@@ -60,6 +63,13 @@ if (!process.env.VERCEL_DEV_IS_ESM) {
 }
 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 ncc_1 = __importDefault(require("@vercel/ncc"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
 function listen(server, port, host) {
     return new Promise(resolve => {
         server.listen(port, host, () => {
@@ -67,7 +77,119 @@ function listen(server, port, host) {
         });
     });
 }
-let bridge = undefined;
+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 createEdgeEventHandler(entrypoint) {
+    const buildResult = await ncc_1.default(entrypoint, { target: 'es2022' });
+    const userCode = buildResult.code;
+    const initialCode = `
+    ${userCode};
+
+    addEventListener('fetch', async (event) => {
+      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;
+      let response = edgeHandler(event.request, event);
+      return event.respondWith(response);
+    })`;
+    const edgeRuntime = new edge_runtime_1.EdgeRuntime({
+        initialCode,
+        extend: (context) => {
+            Object.assign(context, {
+                __dirname: '',
+                module: {
+                    exports: {},
+                },
+            });
+            return context;
+        },
+    });
+    const server = await edge_runtime_1.runServer({ runtime: edgeRuntime });
+    exit_hook_1.default(server.close);
+    return async function (request) {
+        const response = await node_fetch_1.default(server.url, {
+            method: 'post',
+            body: await serializeRequest(request),
+        });
+        return {
+            statusCode: response.status,
+            headers: response.headers.raw(),
+            body: await response.text(),
+            encoding: 'utf8',
+        };
+    };
+}
+const validRuntimes = ['experimental-edge'];
+function parseRuntime(entrypoint) {
+    const project = new ts_morph_1.Project();
+    const staticConfig = static_config_1.getConfig(project, entrypoint);
+    const runtime = staticConfig?.runtime;
+    if (runtime && !validRuntimes.includes(runtime)) {
+        throw new Error(`Invalid function runtime for "${entrypoint}": ${runtime}`);
+    }
+    return runtime;
+}
+async function createEventHandler(entrypoint, options) {
+    const runtime = parseRuntime(entrypoint);
+    if (runtime === 'experimental-edge') {
+        return createEdgeEventHandler(entrypoint);
+    }
+    return createServerlessEventHandler(entrypoint, options);
+}
+let handleEvent;
 async function main() {
     const config = JSON.parse(process.env.VERCEL_DEV_CONFIG || '{}');
     delete process.env.VERCEL_DEV_CONFIG;
@@ -76,16 +198,8 @@ async function main() {
     const shouldAddHelpers = !(config.helpers === false || buildEnv.NODEJS_HELPERS === '0');
     const proxyServer = http_1.createServer(onDevRequest);
     await listen(proxyServer, 0, '127.0.0.1');
-    const launcher = launcher_js_1.getVercelLauncher({
-        entrypointPath: path_1.join(process.cwd(), entrypoint),
-        helpersPath: './helpers.js',
-        shouldAddHelpers,
-        useRequire,
-        // not used
-        bridgePath: '',
-        sourcemapSupportPath: '',
-    });
-    bridge = launcher();
+    const entryPointPath = path_1.join(process.cwd(), entrypoint);
+    handleEvent = await createEventHandler(entryPointPath, { shouldAddHelpers });
     const address = proxyServer.address();
     if (typeof process.send === 'function') {
         process.send(address);
@@ -110,32 +224,25 @@ function rawBody(readable) {
 }
 exports.rawBody = rawBody;
 async function onDevRequest(req, res) {
-    const body = await rawBody(req);
-    const event = {
-        Action: 'Invoke',
-        body: JSON.stringify({
-            method: req.method,
-            path: req.url,
-            headers: req.headers,
-            encoding: 'base64',
-            body: body.toString('base64'),
-        }),
-    };
-    if (!bridge) {
+    if (!handleEvent) {
         res.statusCode = 500;
         res.end('Bridge is not ready, please try again');
         return;
     }
-    const result = await bridge.launcher(event, {
-        callbackWaitsForEmptyEventLoop: false,
-    });
-    res.statusCode = result.statusCode;
-    for (const [key, value] of Object.entries(result.headers)) {
-        if (typeof value !== 'undefined') {
-            res.setHeader(key, value);
+    try {
+        const result = await handleEvent(req);
+        res.statusCode = result.statusCode;
+        for (const [key, value] of Object.entries(result.headers)) {
+            if (typeof value !== 'undefined') {
+                res.setHeader(key, value);
+            }
         }
+        res.end(Buffer.from(result.body, result.encoding));
+    }
+    catch (error) {
+        res.statusCode = 500;
+        res.end(error.stack);
     }
-    res.end(Buffer.from(result.body, result.encoding));
 }
 exports.onDevRequest = onDevRequest;
 function fixConfigDev(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.1.1-canary.0",
+  "version": "2.2.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -31,7 +31,13 @@
   },
   "dependencies": {
     "@types/node": "*",
+    "@vercel/build-utils": "4.1.1-canary.1",
+    "@vercel/ncc": "0.24.0",
     "@vercel/node-bridge": "3.0.0",
+    "@vercel/static-config": "2.0.1",
+    "edge-runtime": "1.0.1",
+    "exit-hook": "2.2.1",
+    "node-fetch": "2.6.1",
     "ts-node": "8.9.1",
     "typescript": "4.3.4"
   },
@@ -44,17 +50,14 @@
     "@types/cookie": "0.3.3",
     "@types/etag": "1.8.0",
     "@types/jest": "27.4.1",
+    "@types/node-fetch": "^2.6.1",
     "@types/test-listen": "1.1.0",
-    "@vercel/build-utils": "4.1.1-canary.0",
-    "@vercel/ncc": "0.24.0",
     "@vercel/nft": "0.19.1",
-    "@vercel/static-config": "2.0.1",
     "content-type": "1.0.4",
     "cookie": "0.4.0",
     "etag": "1.8.1",
-    "node-fetch": "2.6.1",
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "4bf6295d7a1d6544f195d76a2a4aedb476fa7dc1"
+  "gitHead": "0ace69ef754fd37a2df043e02a2278570c87ea32"
 }