@logistically/i18n-cli/dist/commands/config.js

Enterprise-grade CLI tool for extracting and managing translations in Logistically microservices

#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.showConfig = showConfig;
exports.validateConfig = validateConfig;
exports.setConfigValue = setConfigValue;
exports.resetConfig = resetConfig;
exports.createConfigCommand = createConfigCommand;
const commander_1 = require("commander");
const config_1 = require("../utils/config");
const logger_1 = require("../utils/logger");
const validator_1 = require("../utils/validator");
const logger = logger_1.Logger.getInstance();
async function showConfig(options) {
    const configManager = config_1.ConfigManager.getInstance();
    const config = await configManager.loadConfig();
    logger.header('Configuration');
    logger.info(`Config file: ${configManager.getConfigValue('configPath')}`);
    logger.info(`Environment: ${config.environment}`);
    logger.info(`Version: ${config.version}`);
    if (options.verbose) {
        logger.section('Logging Configuration');
        logger.info(`Level: ${config.logging.level}`);
        logger.info(`Format: ${config.logging.format}`);
        logger.info(`Output: ${config.logging.output}`);
        if (config.logging.filePath) {
            logger.info(`Log file: ${config.logging.filePath}`);
        }
        logger.section('Performance Configuration');
        logger.info(`Max concurrency: ${config.performance.maxConcurrency}`);
        logger.info(`Max file size: ${config.performance.maxFileSize}MB`);
        logger.info(`Timeout: ${config.performance.timeout}s`);
        logger.section('Security Configuration');
        logger.info(`Validate inputs: ${config.security.validateInputs}`);
        logger.info(`Sanitize outputs: ${config.security.sanitizeOutputs}`);
        logger.info(`Max key length: ${config.security.maxKeyLength}`);
        logger.section('Features Configuration');
        logger.info(`Enable validation: ${config.features.enableValidation}`);
        logger.info(`Enable backup: ${config.features.enableBackup}`);
        logger.info(`Enable dry run: ${config.features.enableDryRun}`);
        logger.info(`Enable progress bar: ${config.features.enableProgressBar}`);
    }
}
async function validateConfig() {
    const configManager = config_1.ConfigManager.getInstance();
    const config = await configManager.loadConfig();
    const securityContext = {
        inputValidation: true,
        outputSanitization: true,
        sanitizeOutputs: true,
        fileAccessControl: true,
        maxFileSize: 100,
        maxKeyLength: 200,
        allowedFileTypes: ['.json', '.yaml', '.yml']
    };
    const validator = new validator_1.Validator(securityContext);
    const validation = validator.validateConfiguration(config);
    if (validation.isValid) {
        logger.success('Configuration is valid');
    }
    else {
        logger.error('Configuration validation failed');
        logger.logValidationErrors(validation.errors, 'config');
    }
    if (validation.warnings.length > 0) {
        logger.logValidationWarnings(validation.warnings, 'config');
    }
}
async function setConfigValue(key, value) {
    const configManager = config_1.ConfigManager.getInstance();
    // Parse value based on type
    let parsedValue = value;
    if (value === 'true' || value === 'false') {
        parsedValue = value === 'true';
    }
    else if (!isNaN(Number(value))) {
        parsedValue = Number(value);
    }
    configManager.setConfigValue(key, parsedValue);
    await configManager.saveConfig({});
    logger.success(`Set ${key} = ${value}`);
}
async function resetConfig() {
    const configManager = config_1.ConfigManager.getInstance();
    // Create default configuration
    const defaultConfig = {
        version: '1.0.0',
        environment: 'development',
        logging: {
            level: 'info',
            format: 'text',
            output: 'console',
        },
        performance: {
            maxConcurrency: 4,
            maxFileSize: 10,
            timeout: 300,
        },
        security: {
            validateInputs: true,
            sanitizeOutputs: true,
            maxKeyLength: 200,
        },
        features: {
            enableValidation: true,
            enableBackup: true,
            enableDryRun: true,
            enableProgressBar: true,
        },
    };
    await configManager.saveConfig(defaultConfig);
    logger.success('Configuration reset to defaults');
}
function createConfigCommand() {
    const command = new commander_1.Command('config')
        .description('Manage CLI configuration')
        .addCommand(new commander_1.Command('show')
        .description('Show current configuration')
        .option('-v, --verbose', 'Show detailed configuration')
        .action(async (options) => {
        try {
            await showConfig(options);
        }
        catch (error) {
            logger.error(`Failed to show config: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }))
        .addCommand(new commander_1.Command('validate')
        .description('Validate current configuration')
        .action(async () => {
        try {
            await validateConfig();
        }
        catch (error) {
            logger.error(`Failed to validate config: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }))
        .addCommand(new commander_1.Command('set')
        .description('Set configuration value')
        .argument('<key>', 'Configuration key (e.g., logging.level)')
        .argument('<value>', 'Configuration value')
        .action(async (key, value) => {
        try {
            await setConfigValue(key, value);
        }
        catch (error) {
            logger.error(`Failed to set config: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }))
        .addCommand(new commander_1.Command('reset')
        .description('Reset configuration to defaults')
        .action(async () => {
        try {
            await resetConfig();
        }
        catch (error) {
            logger.error(`Failed to reset config: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }));
    return command;
}
//# sourceMappingURL=config.js.map