@vercel/node 2.2.1-canary.0 → 2.3.1

package/dist/dev-server.js

@@ -68,8 +68,19 @@ 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 esbuild_1 = __importDefault(require("esbuild"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const util_1 = require("util");
+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 +126,158 @@ 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 result = await esbuild_1.default.build({
+            platform: 'node',
+            target: 'node14',
+            sourcemap: 'inline',
+            bundle: true,
+            entryPoints: [entrypoint],
+            write: false,
+            format: 'cjs',
+        });
+        const compiledFile = result.outputFiles?.[0];
+        if (!compiledFile) {
+            throw new Error(`Compilation of ${entrypoint} produced no output files.`);
+        }
+        const userCode = new util_1.TextDecoder().decode(compiledFile.contents);
+        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.error(`Failed to instantiate edge runtime.`);
+        logError(error);
+        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.error('Failed to instantiate edge runtime.');
+        logError(error);
+        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 +286,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 +319,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 +360,6 @@ function fixConfigDev(config) {
 }
 exports.fixConfigDev = fixConfigDev;
 main().catch(err => {
-    console.error(err);
+    logError(err);
     process.exit(1);
 });

package/dist/index.js

@@ -296058,6 +296058,423 @@ module.exports = {
 }
 
 
+/***/ }),
+
+/***/ 91786:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pathToRegexp = exports.tokensToRegexp = exports.regexpToFunction = exports.match = exports.tokensToFunction = exports.compile = exports.parse = void 0;
+/**
+ * Tokenize input string.
+ */
+function lexer(str) {
+    var tokens = [];
+    var i = 0;
+    while (i < str.length) {
+        var char = str[i];
+        if (char === "*" || char === "+" || char === "?") {
+            tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+            continue;
+        }
+        if (char === "\\") {
+            tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+            continue;
+        }
+        if (char === "{") {
+            tokens.push({ type: "OPEN", index: i, value: str[i++] });
+            continue;
+        }
+        if (char === "}") {
+            tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+            continue;
+        }
+        if (char === ":") {
+            var name = "";
+            var j = i + 1;
+            while (j < str.length) {
+                var code = str.charCodeAt(j);
+                if (
+                // `0-9`
+                (code >= 48 && code <= 57) ||
+                    // `A-Z`
+                    (code >= 65 && code <= 90) ||
+                    // `a-z`
+                    (code >= 97 && code <= 122) ||
+                    // `_`
+                    code === 95) {
+                    name += str[j++];
+                    continue;
+                }
+                break;
+            }
+            if (!name)
+                throw new TypeError("Missing parameter name at ".concat(i));
+            tokens.push({ type: "NAME", index: i, value: name });
+            i = j;
+            continue;
+        }
+        if (char === "(") {
+            var count = 1;
+            var pattern = "";
+            var j = i + 1;
+            if (str[j] === "?") {
+                throw new TypeError("Pattern cannot start with \"?\" at ".concat(j));
+            }
+            while (j < str.length) {
+                if (str[j] === "\\") {
+                    pattern += str[j++] + str[j++];
+                    continue;
+                }
+                if (str[j] === ")") {
+                    count--;
+                    if (count === 0) {
+                        j++;
+                        break;
+                    }
+                }
+                else if (str[j] === "(") {
+                    count++;
+                    if (str[j + 1] !== "?") {
+                        throw new TypeError("Capturing groups are not allowed at ".concat(j));
+                    }
+                }
+                pattern += str[j++];
+            }
+            if (count)
+                throw new TypeError("Unbalanced pattern at ".concat(i));
+            if (!pattern)
+                throw new TypeError("Missing pattern at ".concat(i));
+            tokens.push({ type: "PATTERN", index: i, value: pattern });
+            i = j;
+            continue;
+        }
+        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+    }
+    tokens.push({ type: "END", index: i, value: "" });
+    return tokens;
+}
+/**
+ * Parse a string for the raw tokens.
+ */
+function parse(str, options) {
+    if (options === void 0) { options = {}; }
+    var tokens = lexer(str);
+    var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
+    var defaultPattern = "[^".concat(escapeString(options.delimiter || "/#?"), "]+?");
+    var result = [];
+    var key = 0;
+    var i = 0;
+    var path = "";
+    var tryConsume = function (type) {
+        if (i < tokens.length && tokens[i].type === type)
+            return tokens[i++].value;
+    };
+    var mustConsume = function (type) {
+        var value = tryConsume(type);
+        if (value !== undefined)
+            return value;
+        var _a = tokens[i], nextType = _a.type, index = _a.index;
+        throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
+    };
+    var consumeText = function () {
+        var result = "";
+        var value;
+        while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
+            result += value;
+        }
+        return result;
+    };
+    while (i < tokens.length) {
+        var char = tryConsume("CHAR");
+        var name = tryConsume("NAME");
+        var pattern = tryConsume("PATTERN");
+        if (name || pattern) {
+            var prefix = char || "";
+            if (prefixes.indexOf(prefix) === -1) {
+                path += prefix;
+                prefix = "";
+            }
+            if (path) {
+                result.push(path);
+                path = "";
+            }
+            result.push({
+                name: name || key++,
+                prefix: prefix,
+                suffix: "",
+                pattern: pattern || defaultPattern,
+                modifier: tryConsume("MODIFIER") || "",
+            });
+            continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+            path += value;
+            continue;
+        }
+        if (path) {
+            result.push(path);
+            path = "";
+        }
+        var open = tryConsume("OPEN");
+        if (open) {
+            var prefix = consumeText();
+            var name_1 = tryConsume("NAME") || "";
+            var pattern_1 = tryConsume("PATTERN") || "";
+            var suffix = consumeText();
+            mustConsume("CLOSE");
+            result.push({
+                name: name_1 || (pattern_1 ? key++ : ""),
+                pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
+                prefix: prefix,
+                suffix: suffix,
+                modifier: tryConsume("MODIFIER") || "",
+            });
+            continue;
+        }
+        mustConsume("END");
+    }
+    return result;
+}
+exports.parse = parse;
+/**
+ * Compile a string to a template function for the path.
+ */
+function compile(str, options) {
+    return tokensToFunction(parse(str, options), options);
+}
+exports.compile = compile;
+/**
+ * Expose a method for transforming tokens into the path function.
+ */
+function tokensToFunction(tokens, options) {
+    if (options === void 0) { options = {}; }
+    var reFlags = flags(options);
+    var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
+    // Compile all the tokens into regexps.
+    var matches = tokens.map(function (token) {
+        if (typeof token === "object") {
+            return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
+        }
+    });
+    return function (data) {
+        var path = "";
+        for (var i = 0; i < tokens.length; i++) {
+            var token = tokens[i];
+            if (typeof token === "string") {
+                path += token;
+                continue;
+            }
+            var value = data ? data[token.name] : undefined;
+            var optional = token.modifier === "?" || token.modifier === "*";
+            var repeat = token.modifier === "*" || token.modifier === "+";
+            if (Array.isArray(value)) {
+                if (!repeat) {
+                    throw new TypeError("Expected \"".concat(token.name, "\" to not repeat, but got an array"));
+                }
+                if (value.length === 0) {
+                    if (optional)
+                        continue;
+                    throw new TypeError("Expected \"".concat(token.name, "\" to not be empty"));
+                }
+                for (var j = 0; j < value.length; j++) {
+                    var segment = encode(value[j], token);
+                    if (validate && !matches[i].test(segment)) {
+                        throw new TypeError("Expected all \"".concat(token.name, "\" to match \"").concat(token.pattern, "\", but got \"").concat(segment, "\""));
+                    }
+                    path += token.prefix + segment + token.suffix;
+                }
+                continue;
+            }
+            if (typeof value === "string" || typeof value === "number") {
+                var segment = encode(String(value), token);
+                if (validate && !matches[i].test(segment)) {
+                    throw new TypeError("Expected \"".concat(token.name, "\" to match \"").concat(token.pattern, "\", but got \"").concat(segment, "\""));
+                }
+                path += token.prefix + segment + token.suffix;
+                continue;
+            }
+            if (optional)
+                continue;
+            var typeOfMessage = repeat ? "an array" : "a string";
+            throw new TypeError("Expected \"".concat(token.name, "\" to be ").concat(typeOfMessage));
+        }
+        return path;
+    };
+}
+exports.tokensToFunction = tokensToFunction;
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+function match(str, options) {
+    var keys = [];
+    var re = pathToRegexp(str, keys, options);
+    return regexpToFunction(re, keys, options);
+}
+exports.match = match;
+/**
+ * Create a path match function from `path-to-regexp` output.
+ */
+function regexpToFunction(re, keys, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;
+    return function (pathname) {
+        var m = re.exec(pathname);
+        if (!m)
+            return false;
+        var path = m[0], index = m.index;
+        var params = Object.create(null);
+        var _loop_1 = function (i) {
+            if (m[i] === undefined)
+                return "continue";
+            var key = keys[i - 1];
+            if (key.modifier === "*" || key.modifier === "+") {
+                params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {
+                    return decode(value, key);
+                });
+            }
+            else {
+                params[key.name] = decode(m[i], key);
+            }
+        };
+        for (var i = 1; i < m.length; i++) {
+            _loop_1(i);
+        }
+        return { path: path, index: index, params: params };
+    };
+}
+exports.regexpToFunction = regexpToFunction;
+/**
+ * Escape a regular expression string.
+ */
+function escapeString(str) {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+}
+/**
+ * Get the flags for a regexp from the options.
+ */
+function flags(options) {
+    return options && options.sensitive ? "" : "i";
+}
+/**
+ * Pull out keys from a regexp.
+ */
+function regexpToRegexp(path, keys) {
+    if (!keys)
+        return path;
+    var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+    var index = 0;
+    var execResult = groupsRegex.exec(path.source);
+    while (execResult) {
+        keys.push({
+            // Use parenthesized substring match if available, index otherwise
+            name: execResult[1] || index++,
+            prefix: "",
+            suffix: "",
+            modifier: "",
+            pattern: "",
+        });
+        execResult = groupsRegex.exec(path.source);
+    }
+    return path;
+}
+/**
+ * Transform an array into a regexp.
+ */
+function arrayToRegexp(paths, keys, options) {
+    var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });
+    return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+}
+/**
+ * Create a path regexp from string input.
+ */
+function stringToRegexp(path, keys, options) {
+    return tokensToRegexp(parse(path, options), keys, options);
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+function tokensToRegexp(tokens, keys, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
+    var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
+    var delimiterRe = "[".concat(escapeString(delimiter), "]");
+    var route = start ? "^" : "";
+    // Iterate over the tokens and create our regexp string.
+    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        if (typeof token === "string") {
+            route += escapeString(encode(token));
+        }
+        else {
+            var prefix = escapeString(encode(token.prefix));
+            var suffix = escapeString(encode(token.suffix));
+            if (token.pattern) {
+                if (keys)
+                    keys.push(token);
+                if (prefix || suffix) {
+                    if (token.modifier === "+" || token.modifier === "*") {
+                        var mod = token.modifier === "*" ? "?" : "";
+                        route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
+                    }
+                    else {
+                        route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
+                    }
+                }
+                else {
+                    if (token.modifier === "+" || token.modifier === "*") {
+                        route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")");
+                    }
+                    else {
+                        route += "(".concat(token.pattern, ")").concat(token.modifier);
+                    }
+                }
+            }
+            else {
+                route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
+            }
+        }
+    }
+    if (end) {
+        if (!strict)
+            route += "".concat(delimiterRe, "?");
+        route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
+    }
+    else {
+        var endToken = tokens[tokens.length - 1];
+        var isEndDelimited = typeof endToken === "string"
+            ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1
+            : endToken === undefined;
+        if (!strict) {
+            route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
+        }
+        if (!isEndDelimited) {
+            route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
+        }
+    }
+    return new RegExp(route, flags(options));
+}
+exports.tokensToRegexp = tokensToRegexp;
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ */
+function pathToRegexp(path, keys, options) {
+    if (path instanceof RegExp)
+        return regexpToRegexp(path, keys);
+    if (Array.isArray(path))
+        return arrayToRegexp(path, keys, options);
+    return stringToRegexp(path, keys, options);
+}
+exports.pathToRegexp = pathToRegexp;
+//# sourceMappingURL=index.js.map
+
 /***/ }),
 
 /***/ 92879:
@@ -306526,6 +306943,7 @@ 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);
 const typescript_1 = __webpack_require__(80774);
+const utils_1 = __webpack_require__(84411);
 function isPortInfo(v) {
     return v && typeof v.port === 'number';
 }
@@ -306754,33 +307172,37 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
     const outputName = config.zeroConfig
         ? handler.substring(0, handler.length - 3)
         : handler;
+    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:
     // `export const config = { runtime: 'experimental-edge' }`
-    let isEdgeFunction = false;
-    // Add a catch-all `route` for Middleware
-    if (config.middleware === true) {
+    let isEdgeFunction = isMiddleware;
+    const project = new ts_morph_1.Project();
+    const staticConfig = static_config_1.getConfig(project, entrypointPath);
+    if (staticConfig?.runtime) {
+        if (!ALLOWED_RUNTIMES.includes(staticConfig.runtime)) {
+            throw new Error(`Unsupported "runtime" property in \`config\`: ${JSON.stringify(staticConfig.runtime)} (must be one of: ${JSON.stringify(ALLOWED_RUNTIMES)})`);
+        }
+        isEdgeFunction = staticConfig.runtime === 'experimental-edge';
+    }
+    // Add a `route` for Middleware
+    if (isMiddleware) {
+        if (!isEdgeFunction) {
+            // Root-level middleware file can not have `export const config = { runtime: 'nodejs' }`
+            throw new Error(`Middleware file can not be a Node.js Serverless Function`);
+        }
+        // Middleware is a catch-all for all paths unless a `matcher` property is defined
+        const src = utils_1.getRegExpFromMatchers(staticConfig?.matcher);
         routes = [
             {
-                src: '/.*',
+                src,
                 middlewarePath: config.zeroConfig
                     ? outputName
                     : path_1.relative(baseDir, entrypointPath),
                 continue: true,
+                override: true,
             },
         ];
-        // Middleware is implicitly an Edge Function
-        isEdgeFunction = true;
-    }
-    if (!isEdgeFunction) {
-        const project = new ts_morph_1.Project();
-        const staticConfig = static_config_1.getConfig(project, entrypointPath);
-        if (staticConfig?.runtime) {
-            if (!ALLOWED_RUNTIMES.includes(staticConfig.runtime)) {
-                throw new Error(`Unsupported "runtime" property in \`config\`: ${JSON.stringify(staticConfig.runtime)} (must be one of: ${JSON.stringify(ALLOWED_RUNTIMES)})`);
-            }
-            isEdgeFunction = staticConfig.runtime === 'experimental-edge';
-        }
     }
     if (isEdgeFunction) {
         output = new build_utils_1.EdgeFunction({
@@ -306812,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,
@@ -306841,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]);
@@ -306862,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 :(
@@ -307283,6 +307722,38 @@ function filterDiagnostics(diagnostics, ignore) {
 }
 
 
+/***/ }),
+
+/***/ 84411:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getRegExpFromMatchers = void 0;
+const path_to_regexp_1 = __webpack_require__(91786);
+function getRegExpFromMatchers(matcherOrMatchers) {
+    if (!matcherOrMatchers) {
+        return '^/.*$';
+    }
+    const matchers = Array.isArray(matcherOrMatchers)
+        ? matcherOrMatchers
+        : [matcherOrMatchers];
+    return matchers.map(getRegExpFromMatcher).join('|');
+}
+exports.getRegExpFromMatchers = getRegExpFromMatchers;
+function getRegExpFromMatcher(matcher) {
+    if (typeof matcher !== 'string') {
+        throw new Error('`matcher` must be a path matcher or an array of path matchers');
+    }
+    if (!matcher.startsWith('/')) {
+        throw new Error('`matcher`: path matcher must start with /');
+    }
+    const re = path_to_regexp_1.pathToRegexp(matcher);
+    return re.source;
+}
+
+
 /***/ }),
 
 /***/ 80918:

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function getRegExpFromMatchers(matcherOrMatchers: unknown): string;

package/dist/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegExpFromMatchers = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+function getRegExpFromMatchers(matcherOrMatchers) {
+    if (!matcherOrMatchers) {
+        return '^/.*$';
+    }
+    const matchers = Array.isArray(matcherOrMatchers)
+        ? matcherOrMatchers
+        : [matcherOrMatchers];
+    return matchers.map(getRegExpFromMatcher).join('|');
+}
+exports.getRegExpFromMatchers = getRegExpFromMatchers;
+function getRegExpFromMatcher(matcher) {
+    if (typeof matcher !== 'string') {
+        throw new Error('`matcher` must be a path matcher or an array of path matchers');
+    }
+    if (!matcher.startsWith('/')) {
+        throw new Error('`matcher`: path matcher must start with /');
+    }
+    const re = path_to_regexp_1.pathToRegexp(matcher);
+    return re.source;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.2.1-canary.0",
+  "version": "2.3.1",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@types/node": "*",
-    "@vercel/build-utils": "4.1.1-canary.1",
-    "@vercel/ncc": "0.24.0",
+    "@vercel/build-utils": "4.2.0",
     "@vercel/node-bridge": "3.0.0",
     "@vercel/static-config": "2.0.1",
     "edge-runtime": "1.0.1",
+    "esbuild": "0.14.47",
     "exit-hook": "2.2.1",
     "node-fetch": "2.6.1",
     "ts-node": "8.9.1",
@@ -52,12 +52,14 @@
     "@types/jest": "27.4.1",
     "@types/node-fetch": "^2.6.1",
     "@types/test-listen": "1.1.0",
+    "@vercel/ncc": "0.24.0",
     "@vercel/nft": "0.19.1",
     "content-type": "1.0.4",
     "cookie": "0.4.0",
     "etag": "1.8.1",
+    "path-to-regexp": "6.2.1",
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "4f8f3d373f4e42fe1afecd16a4cfc4fe57835be7"
+  "gitHead": "b399fe7037eb3e4c42167ba28e82c9ce0332f7a0"
 }