polyv-live-cli/dist/config/manager.js

CLI tool for managing PolyV live streaming services.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.configManager = exports.ConfigManager = void 0;
exports.loadConfig = loadConfig;
exports.getConfig = getConfig;
exports.reloadConfig = reloadConfig;
const errors_1 = require("../utils/errors");
const loader_1 = require("./loader");
const validator_1 = require("./validator");
const auth_1 = require("./auth");
const global_1 = require("./global");
class ConfigManager {
    constructor() {
        this.config = null;
        this.sources = null;
        this.loadedEnvFiles = [];
    }
    async load(options = {}) {
        this.config = null;
        this.sources = null;
        this.loadedEnvFiles = [];
        let { environment, source: environmentSource } = this.determineEnvironment(options);
        const envFileOptions = {
            baseDir: process.cwd(),
        };
        if (options.envFiles) {
            envFileOptions.additionalFiles = options.envFiles;
        }
        if (options.skipEnvFile) {
            envFileOptions.override = options.skipEnvFile;
        }
        const originalEnvVars = {};
        const configEnvVars = [
            'POLYV_ENVIRONMENT', 'POLYV_DEBUG', 'POLYV_TIMEOUT', 'POLYV_BASE_URL',
            'POLYV_MAX_RETRIES', 'POLYV_CONFIG_PATH', 'POLYV_APP_ID', 'POLYV_APP_SECRET', 'POLYV_USER_ID'
        ];
        for (const varName of configEnvVars) {
            originalEnvVars[varName] = process.env[varName];
        }
        if (environmentSource === 'default') {
            (0, loader_1.loadEnvironmentConfig)('production', envFileOptions, true);
            const newEnvResult = this.determineEnvironment(options);
            environment = newEnvResult.environment;
            environmentSource = newEnvResult.source;
        }
        const envFileResults = (0, loader_1.loadEnvironmentConfig)(environment, envFileOptions, true);
        for (const varName of configEnvVars) {
            if (originalEnvVars[varName] !== undefined) {
                process.env[varName] = originalEnvVars[varName];
            }
        }
        this.loadedEnvFiles = envFileResults
            .filter(result => result.loaded)
            .map(result => result.path);
        const rawConfig = (0, loader_1.extractRawConfig)();
        const parsedConfig = (0, validator_1.parseRawConfig)(rawConfig, environment);
        const cliConfig = this.loadCliConfig(options.cliOptions || {});
        if (cliConfig.errors.length > 0) {
            const errorMessage = `CLI configuration errors:\n${cliConfig.errors.map(e => `  • ${e}`).join('\n')}`;
            throw new errors_1.ConfigurationError(errorMessage);
        }
        const mergedConfig = this.mergeConfigurations(parsedConfig, cliConfig, environment, environmentSource, options.configPath);
        const configWithDefaults = (0, validator_1.applyDefaults)(mergedConfig.config, environment);
        const authConfig = this.createAuthConfig(configWithDefaults.auth);
        const finalConfig = {
            ...configWithDefaults,
            auth: authConfig,
        };
        const validation = (0, validator_1.validateAppConfig)(finalConfig);
        if (!validation.isValid) {
            const errorMessage = (0, validator_1.createConfigErrorMessage)(validation);
            throw new errors_1.ConfigurationError(errorMessage);
        }
        this.config = finalConfig;
        this.sources = mergedConfig.sources;
        return {
            config: finalConfig,
            sources: mergedConfig.sources,
            validation,
            loadedEnvFiles: this.loadedEnvFiles,
        };
    }
    getConfig() {
        return this.config;
    }
    getSources() {
        return this.sources;
    }
    getLoadedEnvFiles() {
        return [...this.loadedEnvFiles];
    }
    async reload(options = {}) {
        return this.load(options);
    }
    determineEnvironment(options) {
        if (options.environment) {
            return { environment: options.environment, source: 'cli' };
        }
        if (options.cliOptions && typeof options.cliOptions['environment'] === 'string') {
            const { validateEnvironment } = require('./loader');
            const env = validateEnvironment(options.cliOptions['environment']);
            if (env) {
                return { environment: env, source: 'cli' };
            }
        }
        const { validateEnvironment } = require('./loader');
        const envFromVar = validateEnvironment(process.env['POLYV_ENVIRONMENT']);
        if (envFromVar) {
            return { environment: envFromVar, source: 'env' };
        }
        return { environment: 'production', source: 'default' };
    }
    loadCliConfig(cliOptions) {
        const errors = [];
        const config = {
            auth: (0, auth_1.loadAuthFromCLI)(cliOptions),
            errors,
        };
        if (typeof cliOptions['environment'] === 'string') {
            const env = (0, loader_1.validateEnvironment)(cliOptions['environment']);
            if (env)
                config.environment = env;
        }
        if (typeof cliOptions['debug'] === 'boolean') {
            config.debug = cliOptions['debug'];
        }
        if (typeof cliOptions['timeout'] === 'string') {
            const timeout = (0, loader_1.parseInteger)(cliOptions['timeout'], 0, 1000, 300000);
            if (timeout > 0) {
                config.timeout = timeout;
            }
            else {
                errors.push(`Invalid timeout value '${cliOptions['timeout']}'. Must be between 1000 and 300000 milliseconds.`);
            }
        }
        if (typeof cliOptions['baseUrl'] === 'string') {
            const baseUrl = (0, loader_1.parseUrl)(cliOptions['baseUrl'], '');
            if (baseUrl)
                config.baseUrl = baseUrl;
        }
        if (typeof cliOptions['maxRetries'] === 'string') {
            const maxRetries = (0, loader_1.parseInteger)(cliOptions['maxRetries'], -1, 0, 10);
            if (maxRetries >= 0) {
                config.maxRetries = maxRetries;
            }
            else {
                errors.push(`Invalid maxRetries value '${cliOptions['maxRetries']}'. Must be between 0 and 10.`);
            }
        }
        if (typeof cliOptions['config'] === 'string') {
            config.configPath = cliOptions['config'];
        }
        return config;
    }
    mergeConfigurations(parsedConfig, cliConfig, environment, environmentSource, configPath) {
        const sources = {
            environment: environmentSource,
            debug: 'default',
            timeout: 'default',
            baseUrl: 'default',
            maxRetries: 'default',
        };
        const config = {
            environment: environment,
            debug: parsedConfig.debug,
            timeout: parsedConfig.timeout,
            baseUrl: parsedConfig.baseUrl,
            maxRetries: parsedConfig.maxRetries,
            auth: { ...parsedConfig.auth },
        };
        if (parsedConfig.configPath) {
            config.configPath = parsedConfig.configPath;
        }
        if (process.env['POLYV_DEBUG']) {
            sources.debug = 'env';
        }
        if (process.env['POLYV_TIMEOUT']) {
            sources.timeout = 'env';
        }
        if (process.env['POLYV_BASE_URL']) {
            sources.baseUrl = 'env';
        }
        if (process.env['POLYV_MAX_RETRIES']) {
            sources.maxRetries = 'env';
        }
        if (process.env['POLYV_CONFIG_PATH']) {
            sources.configPath = 'env';
        }
        if (cliConfig.debug !== undefined) {
            config.debug = cliConfig.debug;
            sources.debug = 'cli';
        }
        if (cliConfig.timeout !== undefined) {
            config.timeout = cliConfig.timeout;
            sources.timeout = 'cli';
        }
        if (cliConfig.baseUrl !== undefined) {
            config.baseUrl = cliConfig.baseUrl;
            sources.baseUrl = 'cli';
        }
        if (cliConfig.maxRetries !== undefined) {
            config.maxRetries = cliConfig.maxRetries;
            sources.maxRetries = 'cli';
        }
        if (cliConfig.configPath !== undefined) {
            config.configPath = cliConfig.configPath;
            sources.configPath = 'cli';
        }
        const envAuth = (0, auth_1.loadAuthFromEnv)();
        const globalConfigAuth = global_1.globalConfig.load();
        if (cliConfig.auth.appId) {
            config.auth.appId = cliConfig.auth.appId;
        }
        else if (envAuth.appId !== undefined) {
            config.auth.appId = envAuth.appId;
        }
        else if (globalConfigAuth.appId) {
            config.auth.appId = globalConfigAuth.appId;
        }
        if (cliConfig.auth.appSecret) {
            config.auth.appSecret = cliConfig.auth.appSecret;
        }
        else if (envAuth.appSecret !== undefined) {
            config.auth.appSecret = envAuth.appSecret;
        }
        else if (globalConfigAuth.appSecret) {
            config.auth.appSecret = globalConfigAuth.appSecret;
        }
        if (cliConfig.auth.userId) {
            config.auth.userId = cliConfig.auth.userId;
        }
        else if (envAuth.userId !== undefined) {
            config.auth.userId = envAuth.userId;
        }
        else if (globalConfigAuth.userId) {
            config.auth.userId = globalConfigAuth.userId;
        }
        if (!cliConfig.baseUrl && !process.env['POLYV_BASE_URL'] && globalConfigAuth.baseUrl) {
            config.baseUrl = globalConfigAuth.baseUrl;
            sources.baseUrl = 'global';
        }
        if (configPath) {
            const foundConfigFile = (0, loader_1.findConfigFile)(configPath);
            if (foundConfigFile) {
                config.configPath = foundConfigFile;
                sources.configPath = 'cli';
            }
        }
        return { config, sources };
    }
    createAuthConfig(authOptions) {
        if (!authOptions.appId || !authOptions.appSecret) {
            throw new errors_1.ConfigurationError('Auth configuration is incomplete');
        }
        return {
            appId: authOptions.appId,
            appSecret: authOptions.appSecret,
            ...(authOptions.userId && { userId: authOptions.userId }),
        };
    }
}
exports.ConfigManager = ConfigManager;
exports.configManager = new ConfigManager();
async function loadConfig(options = {}) {
    return exports.configManager.load(options);
}
function getConfig() {
    return exports.configManager.getConfig();
}
async function reloadConfig(options = {}) {
    return exports.configManager.reload(options);
}
//# sourceMappingURL=manager.js.map