@now/node/dist/dev-server.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.onDevRequest = exports.rawBody = void 0;
const entrypoint = process.env.VERCEL_DEV_ENTRYPOINT;
delete process.env.VERCEL_DEV_ENTRYPOINT;
const tsconfig = process.env.VERCEL_DEV_TSCONFIG;
delete process.env.VERCEL_DEV_TSCONFIG;
if (!entrypoint) {
    throw new Error('`VERCEL_DEV_ENTRYPOINT` must be defined');
}
const fs_1 = __importDefault(require("fs"));
const ts_node_1 = require("ts-node");
// Use the project's version of TypeScript if available,
// otherwise fall back to using the copy that `@now/node` uses.
let compiler;
try {
    compiler = require.resolve('typescript', {
        paths: [process.cwd()],
    });
}
catch (e) {
    compiler = 'typescript';
}
// Assume Node 10
let target = 'es2018';
const nodeMajor = Number(process.versions.node.split('.')[0]);
if (nodeMajor >= 14) {
    target = 'es2020';
}
else if (nodeMajor >= 12) {
    target = 'es2019';
}
if (tsconfig) {
    try {
        const tsconfigParsed = JSON.parse(fs_1.default.readFileSync(tsconfig, 'utf8'));
        if (tsconfigParsed.compilerOptions &&
            tsconfigParsed.compilerOptions.target) {
            target = tsconfigParsed.compilerOptions.target;
        }
    }
    catch (err) {
        if (err.code !== 'ENOENT') {
            console.error(`Error while parsing "${tsconfig}"`);
            throw err;
        }
    }
}
ts_node_1.register({
    compiler,
    compilerOptions: {
        allowJs: true,
        esModuleInterop: true,
        jsx: 'react',
        module: 'commonjs',
        target,
    },
    project: tsconfig || undefined,
    transpileOnly: true,
});
const http_1 = require("http");
const path_1 = require("path");
const launcher_1 = require("./launcher");
function listen(server, port, host) {
    return new Promise(resolve => {
        server.listen(port, host, () => {
            resolve();
        });
    });
}
let bridge = undefined;
async function main() {
    const config = JSON.parse(process.env.VERCEL_DEV_CONFIG || '{}');
    delete process.env.VERCEL_DEV_CONFIG;
    const buildEnv = JSON.parse(process.env.VERCEL_DEV_BUILD_ENV || '{}');
    delete process.env.VERCEL_DEV_BUILD_ENV;
    const shouldAddHelpers = !(config.helpers === false || buildEnv.NODEJS_HELPERS === '0');
    bridge = launcher_1.getNowLauncher({
        entrypointPath: path_1.join(process.cwd(), entrypoint),
        helpersPath: './helpers',
        shouldAddHelpers,
        bridgePath: 'not used',
        sourcemapSupportPath: 'not used',
    })();
    const proxyServer = http_1.createServer(onDevRequest);
    await listen(proxyServer, 0, '127.0.0.1');
    const address = proxyServer.address();
    if (typeof process.send === 'function') {
        process.send(address);
    }
    else {
        console.log('Dev server listening:', address);
    }
}
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));
        });
    });
}
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) {
        res.statusCode = 500;
        res.end('Bridge is not defined');
        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);
        }
    }
    res.end(Buffer.from(result.body, result.encoding));
}
exports.onDevRequest = onDevRequest;
main().catch(err => {
    console.error(err);
    process.exit(1);
});