@vercel/node 3.0.5 → 3.0.6

package/dist/serverless-functions/helpers.js

@@ -1,229 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addHelpers = exports.getBodyParser = void 0;
-const utils_1 = require("../utils");
-const stream_1 = require("stream");
-const content_type_1 = require("content-type");
-const querystring_1 = require("querystring");
-class ApiError extends Error {
-    constructor(statusCode, message) {
-        super(message);
-        this.statusCode = statusCode;
-    }
-}
-function normalizeContentType(contentType) {
-    if (!contentType) {
-        return 'text/plain';
-    }
-    const { type } = (0, content_type_1.parse)(contentType);
-    return type;
-}
-function getBodyParser(body, contentType) {
-    return function parseBody() {
-        const type = normalizeContentType(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') {
-            // note: querystring.parse does not produce an iterable object
-            // https://nodejs.org/api/querystring.html#querystring_querystring_parse_str_sep_eq_options
-            return (0, querystring_1.parse)(body.toString());
-        }
-        if (type === 'text/plain')
-            return body.toString();
-        return undefined;
-    };
-}
-exports.getBodyParser = getBodyParser;
-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

@@ -1,116 +0,0 @@
-import { addHelpers } from './helpers.js';
-import { createServer } from 'http';
-import { serializeBody } from '../utils.js';
-import exitHook from 'exit-hook';
-import { Headers, fetch } from 'undici';
-import { listen } from 'async-listen';
-import { isAbsolute } from 'path';
-import { pathToFileURL } from 'url';
-import zlib from 'zlib';
-const [NODE_MAJOR] = process.versions.node.split('.').map(v => Number(v));
-/* https://nextjs.org/docs/app/building-your-application/routing/router-handlers#supported-http-methods */
-const HTTP_METHODS = [
-    'GET',
-    'HEAD',
-    'OPTIONS',
-    'POST',
-    'PUT',
-    'DELETE',
-    'PATCH',
-];
-function compress(body, encoding) {
-    switch (encoding) {
-        case 'br':
-            return zlib.brotliCompressSync(body, {
-                params: {
-                    [zlib.constants.BROTLI_PARAM_QUALITY]: 0,
-                },
-            });
-        case 'gzip':
-            return zlib.gzipSync(body, {
-                level: zlib.constants.Z_BEST_SPEED,
-            });
-        case 'deflate':
-            return zlib.deflateSync(body, {
-                level: zlib.constants.Z_BEST_SPEED,
-            });
-        default:
-            throw new Error(`encoding '${encoding}' not supported`);
-    }
-}
-async function createServerlessServer(userCode) {
-    const server = createServer(userCode);
-    exitHook(() => server.close());
-    return { url: await listen(server) };
-}
-async function compileUserCode(entrypointPath, options) {
-    const id = isAbsolute(entrypointPath)
-        ? pathToFileURL(entrypointPath).href
-        : entrypointPath;
-    let listener = await import(id);
-    /**
-     * In some cases we might have nested default props due to TS => JS
-     */
-    for (let i = 0; i < 5; i++) {
-        if (listener.default)
-            listener = listener.default;
-    }
-    if (HTTP_METHODS.some(method => typeof listener[method] === 'function')) {
-        if (NODE_MAJOR < 18) {
-            throw new Error('Node.js v18 or above is required to use HTTP method exports in your functions.');
-        }
-        const { getWebExportsHandler } = await import('./helpers-web.js');
-        return getWebExportsHandler(listener, HTTP_METHODS);
-    }
-    return async (req, res) => {
-        if (options.shouldAddHelpers)
-            await addHelpers(req, res);
-        return listener(req, res);
-    };
-}
-export async function createServerlessEventHandler(entrypointPath, options) {
-    const userCode = await compileUserCode(entrypointPath, options);
-    const server = await createServerlessServer(userCode);
-    const isStreaming = options.mode === 'streaming';
-    return async function (request) {
-        const url = new URL(request.url ?? '/', server.url);
-        const response = await fetch(url, {
-            body: await serializeBody(request),
-            compress: !isStreaming,
-            // @ts-expect-error
-            headers: {
-                ...request.headers,
-                host: request.headers['x-forwarded-host'],
-            },
-            method: request.method,
-            redirect: 'manual',
-        });
-        let body = null;
-        let headers = response.headers;
-        if (isStreaming) {
-            body = response.body;
-        }
-        else {
-            body = Buffer.from(await response.arrayBuffer());
-            const contentEncoding = response.headers.get('content-encoding');
-            if (contentEncoding) {
-                body = compress(body, contentEncoding);
-                const clonedHeaders = [];
-                for (const [key, value] of response.headers.entries()) {
-                    if (key !== 'transfer-encoding') {
-                        // transfer-encoding is only for streaming response
-                        clonedHeaders.push([key, value]);
-                    }
-                }
-                clonedHeaders.push(['content-length', String(Buffer.byteLength(body))]);
-                headers = new Headers(clonedHeaders);
-            }
-        }
-        return {
-            status: response.status,
-            headers,
-            body,
-            encoding: 'utf8',
-        };
-    };
-}

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });