@vercel/node 2.2.1-canary.1 → 2.3.0

package/dist/dev-server.js

@@ -70,6 +70,16 @@ 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 logError(error) {
+    console.error(error.message);
+    if (error.stack) {
+        // only show the stack trace if debug is enabled
+        // because it points to internals, not user code
+        const errorPrefixLength = 'Error: '.length;
+        const errorMessageLength = errorPrefixLength + error.message.length;
+        build_utils_1.debug(error.stack.substring(errorMessageLength + 1));
+    }
+}
 function listen(server, port, host) {
     return new Promise(resolve => {
         server.listen(port, host, () => {
@@ -115,81 +125,146 @@ async function serializeRequest(message) {
         body,
     });
 }
-async function createEdgeEventHandler(entrypoint) {
-    const buildResult = await ncc_1.default(entrypoint, { target: 'es2022' });
-    const userCode = buildResult.code;
-    const initialCode = `
-    ${userCode};
+async function compileUserCode(entrypoint) {
+    try {
+        const buildResult = await ncc_1.default(entrypoint, {
+            target: 'es2022',
+        });
+        const userCode = buildResult.code;
+        return `
+      ${userCode};
 
-    addEventListener('fetch', async (event) => {
-      let serializedRequest = await event.request.text();
-      let requestDetails = JSON.parse(serializedRequest);
+      addEventListener('fetch', async (event) => {
+        try {
+          let serializedRequest = await event.request.text();
+          let requestDetails = JSON.parse(serializedRequest);
 
-      let body;
+          let body;
 
-      if (requestDetails.method !== 'GET' && requestDetails.method !== 'HEAD') {
-        body = Uint8Array.from(atob(requestDetails.body), c => c.charCodeAt(0));
-      }
+          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 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
-      });
+          let request = new Request(requestUrl, {
+            headers: requestDetails.headers,
+            method: requestDetails.method,
+            body: body
+          });
 
-      event.request = request;
+          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);
+          let edgeHandler = module.exports.default;
+          if (!edgeHandler) {
+            throw new Error('No default export was found. Add a default export to handle requests.');
+          }
+
+          let response = await edgeHandler(event.request, event);
+
+          return event.respondWith(response);
+        } catch (error) {
+          // we can't easily show a meaningful stack trace
+          // so, stick to just the error message for now
+          event.respondWith(new Response(error.message, {
+            status: 500,
+            headers: {
+              'x-vercel-failed': 'edge-wrapper'
+            }
+          }));
+        }
+      })`;
+    }
+    catch (error) {
+        // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
+        // So, stick with just the message for now.
+        console.log(`Failed to instantiate edge runtime: ${error.message}`);
+        return undefined;
+    }
+}
+async function createEdgeRuntime(userCode) {
+    try {
+        if (!userCode) {
+            return undefined;
+        }
+        const edgeRuntime = new edge_runtime_1.EdgeRuntime({
+            initialCode: userCode,
+            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 server;
+    }
+    catch (error) {
+        // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
+        // So, stick with just the message for now.
+        console.log(`Failed to instantiate edge runtime: ${error.message}`);
+        return undefined;
+    }
+}
+async function createEdgeEventHandler(entrypoint) {
+    const userCode = await compileUserCode(entrypoint);
+    const server = await createEdgeRuntime(userCode);
     return async function (request) {
+        if (!server) {
+            // this error state is already logged, but we have to wait until here to exit the process
+            // this matches the serverless function bridge launcher's behavior when
+            // an error is thrown in the function
+            process.exit(1);
+        }
         const response = await node_fetch_1.default(server.url, {
+            redirect: 'manual',
             method: 'post',
             body: await serializeRequest(request),
         });
+        const body = await response.text();
+        const isUserError = response.headers.get('x-vercel-failed') === 'edge-wrapper';
+        if (isUserError && response.status >= 500) {
+            // this error was "unhandled" from the user code's perspective
+            console.log(`Unhandled rejection: ${body}`);
+            // this matches the serverless function bridge launcher's behavior when
+            // an error is thrown in the function
+            process.exit(1);
+        }
         return {
             statusCode: response.status,
             headers: response.headers.raw(),
-            body: await response.text(),
+            body,
             encoding: 'utf8',
         };
     };
 }
 const validRuntimes = ['experimental-edge'];
-function parseRuntime(entrypoint) {
+function parseRuntime(entrypoint, entryPointPath) {
     const project = new ts_morph_1.Project();
-    const staticConfig = static_config_1.getConfig(project, entrypoint);
+    const staticConfig = static_config_1.getConfig(project, entryPointPath);
     const runtime = staticConfig?.runtime;
     if (runtime && !validRuntimes.includes(runtime)) {
-        throw new Error(`Invalid function runtime for "${entrypoint}": ${runtime}`);
+        throw new Error(`Invalid function runtime "${runtime}" for "${entrypoint}". Valid runtimes are: ${JSON.stringify(validRuntimes)}`);
     }
     return runtime;
 }
-async function createEventHandler(entrypoint, options) {
-    const runtime = parseRuntime(entrypoint);
-    if (runtime === 'experimental-edge') {
-        return createEdgeEventHandler(entrypoint);
+async function createEventHandler(entrypoint, config, options) {
+    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 createServerlessEventHandler(entrypoint, options);
+    return createServerlessEventHandler(entryPointPath, options);
 }
 let handleEvent;
+let handlerEventError;
 async function main() {
     const config = JSON.parse(process.env.VERCEL_DEV_CONFIG || '{}');
     delete process.env.VERCEL_DEV_CONFIG;
@@ -198,8 +273,15 @@ 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 entryPointPath = path_1.join(process.cwd(), entrypoint);
-    handleEvent = await createEventHandler(entryPointPath, { shouldAddHelpers });
+    try {
+        handleEvent = await createEventHandler(entrypoint, config, {
+            shouldAddHelpers,
+        });
+    }
+    catch (error) {
+        logError(error);
+        handlerEventError = error;
+    }
     const address = proxyServer.address();
     if (typeof process.send === 'function') {
         process.send(address);
@@ -224,6 +306,12 @@ function rawBody(readable) {
 }
 exports.rawBody = rawBody;
 async function onDevRequest(req, res) {
+    if (handlerEventError) {
+        // this error state is already logged, but we have to wait until here to exit the process
+        // this matches the serverless function bridge launcher's behavior when
+        // an error is thrown in the function
+        process.exit(1);
+    }
     if (!handleEvent) {
         res.statusCode = 500;
         res.end('Bridge is not ready, please try again');
@@ -259,6 +347,6 @@ function fixConfigDev(config) {
 }
 exports.fixConfigDev = fixConfigDev;
 main().catch(err => {
-    console.error(err);
+    logError(err);
     process.exit(1);
 });

package/dist/index.js

@@ -307234,7 +307234,21 @@ const prepareCache = ({ repoRootPath, workPath }) => {
 exports.prepareCache = prepareCache;
 const startDevServer = async (opts) => {
     const { entrypoint, workPath, config, meta = {} } = opts;
-    const entryDir = path_1.join(workPath, path_1.dirname(entrypoint));
+    const entrypointPath = path_1.join(workPath, entrypoint);
+    if (config.middleware === true && typeof meta.requestUrl === 'string') {
+        // TODO: static config is also parsed in `dev-server.ts`.
+        // we should pass in this version as an env var instead.
+        const project = new ts_morph_1.Project();
+        const staticConfig = static_config_1.getConfig(project, entrypointPath);
+        // Middleware is a catch-all for all paths unless a `matcher` property is defined
+        const matchers = new RegExp(utils_1.getRegExpFromMatchers(staticConfig?.matcher));
+        if (!matchers.test(meta.requestUrl)) {
+            // If the "matchers" doesn't say to handle this
+            // path then skip middleware invocation
+            return null;
+        }
+    }
+    const entryDir = path_1.dirname(entrypointPath);
     const projectTsConfig = await build_utils_1.walkParentDirs({
         base: workPath,
         start: entryDir,
@@ -307263,6 +307277,9 @@ const startDevServer = async (opts) => {
         },
     });
     const { pid } = child;
+    if (!pid) {
+        throw new Error(`Child Process has no "pid" when forking: "${devServerPath}"`);
+    }
     const onMessage = once_1.default(child, 'message');
     const onExit = once_1.default.spread(child, 'exit');
     const result = await Promise.race([onMessage, onExit]);
@@ -307284,12 +307301,12 @@ const startDevServer = async (opts) => {
         // Got "exit" event from child process
         const [exitCode, signal] = result;
         const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
-        throw new Error(`\`node ${entrypoint}\` failed with ${reason}`);
+        throw new Error(`Function \`${entrypoint}\` failed with ${reason}`);
     }
 };
 exports.startDevServer = startDevServer;
 async function doTypeCheck({ entrypoint, workPath, meta = {} }, projectTsConfig) {
-    const { devCacheDir = path_1.join(workPath, '.now', 'cache') } = meta;
+    const { devCacheDir = path_1.join(workPath, '.vercel', 'cache') } = meta;
     const entrypointCacheDir = path_1.join(devCacheDir, 'node', entrypoint);
     // In order to type-check a single file, a standalone tsconfig
     // file needs to be created that inherits from the base one :(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.2.1-canary.1",
+  "version": "2.3.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@types/node": "*",
-    "@vercel/build-utils": "4.1.1-canary.1",
+    "@vercel/build-utils": "4.2.0",
     "@vercel/ncc": "0.24.0",
     "@vercel/node-bridge": "3.0.0",
     "@vercel/static-config": "2.0.1",
@@ -60,5 +60,5 @@
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "998f6bf6e65301a19a400886bcc37b2dbbcdabe3"
+  "gitHead": "eed39913e1394477b224c38efe29429b17eeada6"
 }