@graphql-mesh/serve-cli/cjs/nodeHttp.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.readRecognizedString = readRecognizedString;
exports.startNodeHttpServer = startNodeHttpServer;
const node_fs_1 = require("node:fs");
const node_http_1 = require("node:http");
const node_https_1 = require("node:https");
const utils_1 = require("@graphql-mesh/utils");
function readRecognizedString(recognizedString) {
    if (typeof recognizedString === 'string') {
        return recognizedString;
    }
    if (Buffer.isBuffer(recognizedString)) {
        return recognizedString.toString('utf-8');
    }
    return Buffer.from(recognizedString).toString('utf-8');
}
async function startNodeHttpServer({ handler, log, protocol, host, port, sslCredentials, maxHeaderSize, }) {
    if (sslCredentials) {
        const sslOptionsForNodeHttp = {};
        if (sslCredentials.ca_file_name) {
            const caFileName = readRecognizedString(sslCredentials.ca_file_name);
            sslOptionsForNodeHttp.ca = await node_fs_1.promises.readFile(caFileName);
        }
        if (sslCredentials.cert_file_name) {
            const certFileName = readRecognizedString(sslCredentials.cert_file_name);
            sslOptionsForNodeHttp.cert = await node_fs_1.promises.readFile(certFileName);
        }
        if (sslCredentials.dh_params_file_name) {
            const dhParamsFileName = readRecognizedString(sslCredentials.dh_params_file_name);
            sslOptionsForNodeHttp.dhparam = await node_fs_1.promises.readFile(dhParamsFileName);
        }
        if (sslCredentials.key_file_name) {
            const keyFileName = readRecognizedString(sslCredentials.key_file_name);
            sslOptionsForNodeHttp.key = await node_fs_1.promises.readFile(keyFileName);
        }
        if (sslCredentials.passphrase) {
            const passphrase = readRecognizedString(sslCredentials.passphrase);
            sslOptionsForNodeHttp.passphrase = passphrase;
        }
        if (sslCredentials.ssl_ciphers) {
            const sslCiphers = readRecognizedString(sslCredentials.ssl_ciphers);
            sslOptionsForNodeHttp.ciphers = sslCiphers;
        }
        if (sslCredentials.ssl_prefer_low_memory_usage) {
            sslOptionsForNodeHttp.honorCipherOrder = true;
        }
        const server = (0, node_https_1.createServer)(sslOptionsForNodeHttp, handler);
        log.info(`Starting server on ${protocol}://${host}:${port}`);
        return new Promise((resolve, reject) => {
            server.once('error', reject);
            server.listen(port, host, () => {
                log.info(`Server started on ${protocol}://${host}:${port}`);
                resolve((0, utils_1.createAsyncDisposable)(() => new Promise(resolve => {
                    log.info(`Closing server`);
                    server.closeAllConnections();
                    server.close(() => {
                        log.info(`Server closed`);
                        resolve();
                    });
                })));
            });
        });
    }
    const server = (0, node_http_1.createServer)({
        maxHeaderSize,
    }, handler);
    log.info(`Starting server on ${protocol}://${host}:${port}`);
    return new Promise((resolve, reject) => {
        server.once('error', reject);
        server.listen(port, host, () => {
            log.info(`Server started on ${protocol}://${host}:${port}`);
            resolve((0, utils_1.createAsyncDisposable)(() => new Promise(resolve => {
                log.info(`Closing server`);
                server.closeAllConnections();
                server.close(() => {
                    log.info(`Server closed`);
                    resolve();
                });
            })));
        });
    });
}