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

import { promises as fsPromises } from 'node:fs';
import { createServer as createHTTPServer } from 'node:http';
import { createServer as createHTTPSServer } from 'node:https';
import { createAsyncDisposable } from '@graphql-mesh/utils';
export 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');
}
export 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 fsPromises.readFile(caFileName);
        }
        if (sslCredentials.cert_file_name) {
            const certFileName = readRecognizedString(sslCredentials.cert_file_name);
            sslOptionsForNodeHttp.cert = await fsPromises.readFile(certFileName);
        }
        if (sslCredentials.dh_params_file_name) {
            const dhParamsFileName = readRecognizedString(sslCredentials.dh_params_file_name);
            sslOptionsForNodeHttp.dhparam = await fsPromises.readFile(dhParamsFileName);
        }
        if (sslCredentials.key_file_name) {
            const keyFileName = readRecognizedString(sslCredentials.key_file_name);
            sslOptionsForNodeHttp.key = await fsPromises.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 = createHTTPSServer(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(createAsyncDisposable(() => new Promise(resolve => {
                    log.info(`Closing server`);
                    server.closeAllConnections();
                    server.close(() => {
                        log.info(`Server closed`);
                        resolve();
                    });
                })));
            });
        });
    }
    const server = createHTTPServer({
        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(createAsyncDisposable(() => new Promise(resolve => {
                log.info(`Closing server`);
                server.closeAllConnections();
                server.close(() => {
                    log.info(`Server closed`);
                    resolve();
                });
            })));
        });
    });
}