verdaccio/build/lib/bootstrap.js

A lightweight private npm proxy registry

Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const require_runtime = require("../_virtual/_rolldown/runtime.js");
require("./constants.js");
const require_lib_logger_index = require("./logger/index.js");
const require_lib_utils = require("./utils.js");
const require_api_index = require("../api/index.js");
const require_lib_experiments = require("./experiments.js");
let lodash = require("lodash");
lodash = require_runtime.__toESM(lodash);
let _verdaccio_config = require("@verdaccio/config");
let fs = require("fs");
fs = require_runtime.__toESM(fs);
let url = require("url");
url = require_runtime.__toESM(url);
let console = require("console");
let constants = require("constants");
constants = require_runtime.__toESM(constants);
let http = require("http");
http = require_runtime.__toESM(http);
let https = require("https");
https = require_runtime.__toESM(https);
let _verdaccio_core = require("@verdaccio/core");
//#region src/lib/bootstrap.ts
/**
* Trigger the server after configuration has been loaded.
* @param {Object} config
* @param {Object} cliArguments
* @param {String} configPath
* @param {String} pkgVersion
* @param {String} pkgName
* @deprecated use runServer instead
*/
function startVerdaccio(config, cliListen, configPath, pkgVersion, pkgName, callback) {
	if (lodash.default.isObject(config) === false) throw new Error(_verdaccio_core.API_ERROR.CONFIG_BAD_FORMAT);
	require_lib_utils.initLogger(config);
	require_lib_experiments.displayExperimentsInfoBox({
		...config?.flags || {},
		...config?.experiments || {}
	});
	require_lib_logger_index.logger.warn("This is a deprecated method, please use runServer instead");
	require_api_index.default(config).then((app) => {
		const addr = (0, _verdaccio_config.getListenAddress)(cliListen ?? config?.listen, require_lib_logger_index.logger);
		let webServer;
		if (addr.proto === "https") webServer = handleHTTPS(app, configPath, config);
		else webServer = http.default.createServer(app);
		if (webServer && typeof config?.server?.keepAliveTimeout === "number") webServer.keepAliveTimeout = config.server.keepAliveTimeout * 1e3;
		unlinkAddressPath(addr);
		callback(webServer, addr, pkgName, pkgVersion);
	});
}
function unlinkAddressPath(addr) {
	if (addr.path && fs.default.existsSync(addr.path)) fs.default.unlinkSync(addr.path);
}
function handleHTTPS(app, configPath, config) {
	try {
		let httpsOptions = { secureOptions: constants.default.SSL_OP_NO_SSLv2 | constants.default.SSL_OP_NO_SSLv3 };
		const keyCertConfig = config.https;
		const pfxConfig = config.https;
		const missingKeyCert = !(keyCertConfig.key && keyCertConfig.cert);
		(0, console.debug)("missingKeyCert", missingKeyCert);
		const missingPfx = !pfxConfig.pfx;
		(0, console.debug)("missingPfx", missingPfx);
		if (missingKeyCert && missingPfx) {
			(0, console.debug)("No HTTPS configuration found");
			require_lib_utils.logHTTPSWarning(configPath);
			throw new Error("No HTTPS configuration found");
		}
		(0, console.debug)("HTTPS configuration found");
		if (pfxConfig.pfx) {
			(0, console.debug)("Using PFX configuration");
			const { pfx, passphrase } = pfxConfig;
			httpsOptions = lodash.default.assign(httpsOptions, {
				pfx: fs.default.readFileSync(pfx),
				passphrase: passphrase || ""
			});
		} else {
			(0, console.debug)("Using Key/Cert configuration");
			const { key, cert, ca } = keyCertConfig;
			httpsOptions = lodash.default.assign(httpsOptions, {
				key: fs.default.readFileSync(key),
				cert: fs.default.readFileSync(cert),
				...ca && { ca: fs.default.readFileSync(ca) }
			});
		}
		return https.default.createServer(httpsOptions, app);
	} catch (err) {
		require_lib_logger_index.logger.fatal({ err }, "cannot create https server: @{err.message}");
		process.exit(2);
	}
}
/**
*
* @param webServer
* @param addr
* @param pkgName
* @param pkgVersion
* @deprecated use initServer instead
*/
function listenDefaultCallback(webServer, addr, pkgName, pkgVersion) {
	const server = webServer.listen(addr.port || addr.path, addr.host, () => {
		if (lodash.default.isFunction(process.send)) process.send({ verdaccio_started: true });
	}).on("error", function(err) {
		require_lib_logger_index.logger.fatal({ err }, "cannot create http server: @{err.message}");
		process.exit(2);
	});
	function handleShutdownGracefully() {
		require_lib_logger_index.logger.fatal("received shutdown signal - closing server gracefully...");
		server.close(() => {
			require_lib_logger_index.logger.info("server closed.");
			process.exit(0);
		});
	}
	if (process.env.VERDACCIO_HANDLE_KILL_SIGNALS === "true") {
		process.on("SIGINT", handleShutdownGracefully);
		process.on("SIGTERM", handleShutdownGracefully);
		process.on("SIGHUP", handleShutdownGracefully);
	}
	require_lib_logger_index.logger.warn({
		addr: addr.path ? url.default.format({
			protocol: "unix",
			pathname: addr.path
		}) : url.default.format({
			protocol: addr.proto,
			hostname: addr.host,
			port: addr.port,
			pathname: "/"
		}),
		version: pkgName + "/" + pkgVersion
	}, "http address - @{addr} - @{version}");
}
//#endregion
exports.listenDefaultCallback = listenDefaultCallback;
exports.startVerdaccio = startVerdaccio;

//# sourceMappingURL=bootstrap.js.map