@vercel/node 2.11.0 → 2.13.0

package/dist/serverless-functions/helpers.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHelpers = void 0;
+const utils_1 = require("../utils");
+const stream_1 = require("stream");
+class ApiError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+function getBodyParser(body, contentType) {
+    return function parseBody() {
+        const { parse: parseContentType } = require('content-type');
+        const { type } = parseContentType(contentType);
+        if (type === 'application/json') {
+            try {
+                const str = body.toString();
+                return str ? JSON.parse(str) : {};
+            }
+            catch (error) {
+                throw new ApiError(400, 'Invalid JSON');
+            }
+        }
+        if (type === 'application/octet-stream')
+            return body;
+        if (type === 'application/x-www-form-urlencoded') {
+            const { parse: parseQS } = require('querystring');
+            // note: querystring.parse does not produce an iterable object
+            // https://nodejs.org/api/querystring.html#querystring_querystring_parse_str_sep_eq_options
+            return parseQS(body.toString());
+        }
+        if (type === 'text/plain')
+            return body.toString();
+        return undefined;
+    };
+}
+function getQueryParser({ url = '/' }) {
+    return function parseQuery() {
+        const { parse: parseURL } = require('url');
+        return parseURL(url, true).query;
+    };
+}
+function getCookieParser(req) {
+    return function parseCookie() {
+        const header = req.headers.cookie;
+        if (!header)
+            return {};
+        const { parse } = require('cookie');
+        return parse(Array.isArray(header) ? header.join(';') : header);
+    };
+}
+function status(res, statusCode) {
+    res.statusCode = statusCode;
+    return res;
+}
+function setCharset(type, charset) {
+    const { parse, format } = require('content-type');
+    const parsed = parse(type);
+    parsed.parameters.charset = charset;
+    return format(parsed);
+}
+function redirect(res, statusOrUrl, url) {
+    if (typeof statusOrUrl === 'string') {
+        url = statusOrUrl;
+        statusOrUrl = 307;
+    }
+    if (typeof statusOrUrl !== 'number' || typeof url !== 'string') {
+        throw new Error(`Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').`);
+    }
+    res.writeHead(statusOrUrl, { Location: url }).end();
+    return res;
+}
+function setLazyProp(req, prop, getter) {
+    const opts = { configurable: true, enumerable: true };
+    const optsReset = { ...opts, writable: true };
+    Object.defineProperty(req, prop, {
+        ...opts,
+        get: () => {
+            const value = getter();
+            // we set the property on the object to avoid recalculating it
+            Object.defineProperty(req, prop, { ...optsReset, value });
+            return value;
+        },
+        set: value => {
+            Object.defineProperty(req, prop, { ...optsReset, value });
+        },
+    });
+}
+function createETag(body, encoding) {
+    const etag = require('etag');
+    const buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;
+    return etag(buf, { weak: true });
+}
+function json(req, res, jsonBody) {
+    const body = JSON.stringify(jsonBody);
+    if (!res.getHeader('content-type')) {
+        res.setHeader('content-type', 'application/json; charset=utf-8');
+    }
+    return send(req, res, body);
+}
+function send(req, res, body) {
+    let chunk = body;
+    let encoding;
+    switch (typeof chunk) {
+        // string defaulting to html
+        case 'string':
+            if (!res.getHeader('content-type')) {
+                res.setHeader('content-type', 'text/html');
+            }
+            break;
+        case 'boolean':
+        case 'number':
+        case 'object':
+            if (chunk === null) {
+                chunk = '';
+            }
+            else if (Buffer.isBuffer(chunk)) {
+                if (!res.getHeader('content-type')) {
+                    res.setHeader('content-type', 'application/octet-stream');
+                }
+            }
+            else {
+                return json(req, res, chunk);
+            }
+            break;
+    }
+    // write strings in utf-8
+    if (typeof chunk === 'string') {
+        encoding = 'utf8';
+        // reflect this in content-type
+        const type = res.getHeader('content-type');
+        if (typeof type === 'string') {
+            res.setHeader('content-type', setCharset(type, 'utf-8'));
+        }
+    }
+    // populate Content-Length
+    let len;
+    if (chunk !== undefined) {
+        if (Buffer.isBuffer(chunk)) {
+            // get length of Buffer
+            len = chunk.length;
+        }
+        else if (typeof chunk === 'string') {
+            if (chunk.length < 1000) {
+                // just calculate length small chunk
+                len = Buffer.byteLength(chunk, encoding);
+            }
+            else {
+                // convert chunk to Buffer and calculate
+                const buf = Buffer.from(chunk, encoding);
+                len = buf.length;
+                chunk = buf;
+                encoding = undefined;
+            }
+        }
+        else {
+            throw new Error('`body` is not a valid string, object, boolean, number, Stream, or Buffer');
+        }
+        if (len !== undefined) {
+            res.setHeader('content-length', len);
+        }
+    }
+    // populate ETag
+    let etag;
+    if (!res.getHeader('etag') &&
+        len !== undefined &&
+        (etag = createETag(chunk, encoding))) {
+        res.setHeader('etag', etag);
+    }
+    // strip irrelevant headers
+    if (204 === res.statusCode || 304 === res.statusCode) {
+        res.removeHeader('Content-Type');
+        res.removeHeader('Content-Length');
+        res.removeHeader('Transfer-Encoding');
+        chunk = '';
+    }
+    if (req.method === 'HEAD') {
+        // skip body for HEAD
+        res.end();
+    }
+    else if (encoding) {
+        // respond with encoding
+        res.end(chunk, encoding);
+    }
+    else {
+        // respond without encoding
+        res.end(chunk);
+    }
+    return res;
+}
+function restoreBody(req, body) {
+    const replicateBody = new stream_1.PassThrough();
+    const on = replicateBody.on.bind(replicateBody);
+    const originalOn = req.on.bind(req);
+    req.read = replicateBody.read.bind(replicateBody);
+    req.on = req.addListener = (name, cb) => 
+    // @ts-expect-error
+    name === 'data' || name === 'end' ? on(name, cb) : originalOn(name, cb);
+    replicateBody.write(body);
+    replicateBody.end();
+}
+async function readBody(req) {
+    const body = (await (0, utils_1.serializeBody)(req)) || Buffer.from('');
+    restoreBody(req, body);
+    return body;
+}
+async function addHelpers(_req, _res) {
+    const req = _req;
+    const res = _res;
+    setLazyProp(req, 'cookies', getCookieParser(req));
+    setLazyProp(req, 'query', getQueryParser(req));
+    const contentType = req.headers['content-type'];
+    const body = contentType === undefined ? Buffer.from('') : await readBody(req);
+    setLazyProp(req, 'body', getBodyParser(body, contentType));
+    res.status = statusCode => status(res, statusCode);
+    res.redirect = (statusOrUrl, url) => redirect(res, statusOrUrl, url);
+    res.send = body => send(req, res, body);
+    res.json = jsonBody => json(req, res, jsonBody);
+}
+exports.addHelpers = addHelpers;

package/dist/serverless-functions/serverless-handler.mjs

@@ -0,0 +1,65 @@
+import { addHelpers } from './helpers.js';
+import { createServer } from 'http';
+import { serializeBody } from '../utils.js';
+import { streamToBuffer } from '@vercel/build-utils';
+import exitHook from 'exit-hook';
+import fetch from 'node-fetch';
+import asyncListen from 'async-listen';
+import { isAbsolute } from 'path';
+import { pathToFileURL } from 'url';
+const { default: listen } = asyncListen;
+async function createServerlessServer(userCode, options) {
+    const server = createServer(async (req, res) => {
+        if (options.shouldAddHelpers)
+            await addHelpers(req, res);
+        return userCode(req, res);
+    });
+    exitHook(() => server.close());
+    return { url: await listen(server) };
+}
+async function compileUserCode(entrypointPath) {
+    const id = isAbsolute(entrypointPath)
+        ? pathToFileURL(entrypointPath).href
+        : entrypointPath;
+    let fn = await import(id);
+    /**
+     * In some cases we might have nested default props due to TS => JS
+     */
+    for (let i = 0; i < 5; i++) {
+        if (fn.default)
+            fn = fn.default;
+    }
+    return fn;
+}
+export async function createServerlessEventHandler(entrypointPath, options) {
+    const userCode = await compileUserCode(entrypointPath);
+    const server = await createServerlessServer(userCode, options);
+    return async function (request) {
+        const url = new URL(request.url ?? '/', server.url);
+        // @ts-expect-error
+        const response = await fetch(url, {
+            body: await serializeBody(request),
+            headers: {
+                ...request.headers,
+                host: request.headers['x-forwarded-host'],
+            },
+            method: request.method,
+            redirect: 'manual',
+        });
+        let body;
+        if (options.mode === 'streaming') {
+            body = response.body;
+        }
+        else {
+            body = await streamToBuffer(response.body);
+            response.headers.delete('transfer-encoding');
+            response.headers.set('content-length', body.length);
+        }
+        return {
+            status: response.status,
+            headers: response.headers,
+            body,
+            encoding: 'utf8',
+        };
+    };
+}

package/dist/typescript.js

@@ -229,7 +229,7 @@ function register(opts = {}) {
             const diagnosticList = filterDiagnostics(diagnostics, ignoreDiagnostics);
             reportTSError(diagnosticList, config.options.noEmitOnError);
             if (output.emitSkipped) {
-                throw new TypeError(`${path_1.relative(cwd, fileName)}: Emit skipped`);
+                throw new TypeError(`${(0, path_1.relative)(cwd, fileName)}: Emit skipped`);
             }
             // Throw an error when requiring `.d.ts` files.
             if (output.outputFiles.length === 0) {
@@ -237,7 +237,7 @@ function register(opts = {}) {
                     'This is usually the result of a faulty configuration or import. ' +
                     'Make sure there is a `.js`, `.json` or another executable extension and ' +
                     'loader (attached before `ts-node`) available alongside ' +
-                    `\`${path_1.basename(fileName)}\`.`);
+                    `\`${(0, path_1.basename)(fileName)}\`.`);
             }
             const file = {
                 code: output.outputFiles[1].text,
@@ -265,7 +265,7 @@ function register(opts = {}) {
      */
     function readConfig(configFileName) {
         let config = { compilerOptions: {} };
-        const basePath = normalizeSlashes(path_1.dirname(configFileName));
+        const basePath = normalizeSlashes((0, path_1.dirname)(configFileName));
         // Read project configuration when available.
         if (configFileName) {
             const result = ts.readConfigFile(configFileName, readFile);
@@ -307,7 +307,7 @@ function register(opts = {}) {
         const output = {
             code: value,
             map: Object.assign(JSON.parse(sourceMap), {
-                file: path_1.basename(fileName),
+                file: (0, path_1.basename)(fileName),
                 sources: [fileName],
             }),
         };

package/dist/utils.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
-const path_1 = require("path");
-const path_to_regexp_1 = require("path-to-regexp");
+exports.serializeBody = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const build_utils_1 = require("@vercel/build-utils");
+const path_to_regexp_1 = require("path-to-regexp");
+const path_1 = require("path");
 function getRegExpFromMatchers(matcherOrMatchers) {
     if (!matcherOrMatchers) {
         return '^/.*$';
@@ -22,9 +22,9 @@ function getRegExpFromMatcher(matcher, index, allMatchers) {
     if (!matcher.startsWith('/')) {
         throw new Error(`Middleware's \`config.matcher\` values must start with "/". Received: ${matcher}`);
     }
-    const regExps = [path_to_regexp_1.pathToRegexp(matcher).source];
+    const regExps = [(0, path_to_regexp_1.pathToRegexp)(matcher).source];
     if (matcher === '/' && !allMatchers.includes('/index')) {
-        regExps.push(path_to_regexp_1.pathToRegexp('/index').source);
+        regExps.push((0, path_to_regexp_1.pathToRegexp)('/index').source);
     }
     return regExps;
 }
@@ -39,7 +39,7 @@ function getRegExpFromMatcher(matcher, index, allMatchers) {
  */
 function entrypointToOutputPath(entrypoint, zeroConfig) {
     if (zeroConfig) {
-        const ext = path_1.extname(entrypoint);
+        const ext = (0, path_1.extname)(entrypoint);
         return entrypoint.slice(0, entrypoint.length - ext.length);
     }
     return entrypoint;
@@ -52,7 +52,7 @@ function logError(error) {
         // 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));
+        (0, build_utils_1.debug)(error.stack.substring(errorMessageLength + 1));
     }
 }
 exports.logError = logError;
@@ -66,3 +66,9 @@ function isEdgeRuntime(runtime) {
         Object.values(EdgeRuntimes).includes(runtime));
 }
 exports.isEdgeRuntime = isEdgeRuntime;
+async function serializeBody(request) {
+    return request.method !== 'GET' && request.method !== 'HEAD'
+        ? await (0, build_utils_1.streamToBuffer)(request)
+        : undefined;
+}
+exports.serializeBody = serializeBody;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.11.0",
+  "version": "2.13.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "build": "node build",
-    "test": "jest --env node --verbose --bail --runInBand",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --env node --verbose --bail --runInBand",
     "test-unit": "pnpm test test/unit",
     "test-e2e": "pnpm test test/integration"
   },
@@ -21,17 +21,19 @@
   "dependencies": {
     "@edge-runtime/vm": "2.0.0",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "6.7.1",
-    "@vercel/node-bridge": "4.0.1",
-    "@vercel/static-config": "2.0.16",
-    "edge-runtime": "2.0.0",
+    "@types/node-fetch": "2.6.3",
+    "@vercel/build-utils": "6.7.2",
+    "@vercel/error-utils": "1.0.8",
+    "@vercel/static-config": "2.0.17",
+    "async-listen": "1.2.0",
+    "edge-runtime": "2.1.4",
     "esbuild": "0.14.47",
     "exit-hook": "2.2.1",
-    "node-fetch": "2.6.7",
+    "node-fetch": "2.6.9",
     "path-to-regexp": "6.2.1",
     "ts-morph": "12.0.0",
     "ts-node": "10.9.1",
-    "typescript": "4.3.4"
+    "typescript": "4.9.5"
   },
   "devDependencies": {
     "@babel/core": "7.5.0",
@@ -41,18 +43,18 @@
     "@types/content-type": "1.1.3",
     "@types/cookie": "0.3.3",
     "@types/etag": "1.8.0",
-    "@types/jest": "27.4.1",
-    "@types/node-fetch": "^2.6.1",
+    "@types/jest": "29.5.0",
     "@types/test-listen": "1.1.0",
     "@vercel/ncc": "0.24.0",
     "@vercel/nft": "0.22.5",
     "content-type": "1.0.4",
     "cookie": "0.4.0",
+    "cross-env": "7.0.3",
     "etag": "1.8.1",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "a63b9d960bec291e152308c30074843aab802c8d"
+  "gitHead": "2de365f9cfea3ce283d2bf855507c71209f1e3d8"
 }

package/dist/edge-functions/edge-handler.d.ts

@@ -1,4 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
-import { VercelProxyResponse } from '@vercel/node-bridge/types';
-export declare function createEdgeEventHandler(entrypointFullPath: string, entrypointRelativePath: string, isMiddleware: boolean, isZeroConfig?: boolean): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;

package/dist/edge-functions/edge-node-compat-plugin.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin } from 'esbuild';
-export declare class NodeCompatBindings {
-    private bindings;
-    use(modulePath: `node:${string}`): string;
-    getContext(): Record<string, unknown>;
-}
-/**
- * Allows to enable Node.js compatibility by detecting namespaced `node:`
- * imports and producing metadata to bind global variables for each.
- * It requires from the consumer to add the imports.
- */
-export declare function createNodeCompatPlugin(): {
-    plugin: Plugin;
-    bindings: NodeCompatBindings;
-};

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

@@ -1,21 +0,0 @@
-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/fork-dev-server.d.ts

@@ -1,34 +0,0 @@
-/// <reference types="node" />
-import { Config, Meta } from '@vercel/build-utils';
-import { ChildProcess } from 'child_process';
-export declare function forkDevServer(options: {
-    tsConfig: any;
-    config: Config;
-    maybeTranspile: boolean;
-    workPath: string | undefined;
-    isTypeScript: boolean;
-    isEsm: boolean;
-    require_: NodeRequire;
-    entrypoint: string;
-    meta: Meta;
-    /**
-     * A path to the dev-server path. This is used in tests.
-     */
-    devServerPath?: string;
-}): ChildProcess & {
-    pid: number;
-};
-/**
- * When launching a dev-server, we want to know its state.
- * This function will be used to know whether it was exited (due to some error),
- * or it is listening to new requests, and we can start proxying requests.
- */
-export declare function readMessage(child: ChildProcess): Promise<{
-    state: 'message';
-    value: {
-        port: number;
-    };
-} | {
-    state: 'exit';
-    value: [number, string | null];
-}>;

package/dist/serverless-functions/serverless-handler.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
-import { VercelProxyResponse } from '@vercel/node-bridge/types';
-export declare function createServerlessEventHandler(entrypoint: string, options: {
-    shouldAddHelpers: boolean;
-    useRequire: boolean;
-}): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;

package/dist/serverless-functions/serverless-handler.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServerlessEventHandler = void 0;
-const launcher_js_1 = require("@vercel/node-bridge/launcher.js");
-function rawBody(readable) {
-    return new Promise((resolve, reject) => {
-        let bytes = 0;
-        const chunks = [];
-        readable.on('error', reject);
-        readable.on('data', chunk => {
-            chunks.push(chunk);
-            bytes += chunk.length;
-        });
-        readable.on('end', () => {
-            resolve(Buffer.concat(chunks, bytes));
-        });
-    });
-}
-async function createServerlessEventHandler(entrypoint, options) {
-    const launcher = launcher_js_1.getVercelLauncher({
-        entrypointPath: entrypoint,
-        helpersPath: './helpers.js',
-        shouldAddHelpers: options.shouldAddHelpers,
-        useRequire: options.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,
-        });
-    };
-}
-exports.createServerlessEventHandler = createServerlessEventHandler;