@morojs/moro 1.5.17 → 1.6.1

package/dist/core/config/config-validator.js

@@ -1,765 +0,0 @@
-"use strict";
-/**
- * Configuration Validator - Type-Safe Schema Validation
- *
- * This module provides runtime validation for configuration objects using
- * simple TypeScript functions that match the type definitions exactly.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigValidationError = void 0;
-exports.validateConfig = validateConfig;
-const logger_1 = require("../logger");
-const logger = (0, logger_1.createFrameworkLogger)('ConfigValidator');
-/**
- * Configuration validation error with detailed context
- */
-class ConfigValidationError extends Error {
-    field;
-    value;
-    expectedType;
-    constructor(field, value, expectedType, message) {
-        super(`Configuration validation failed for '${field}': ${message}`);
-        this.field = field;
-        this.value = value;
-        this.expectedType = expectedType;
-        this.name = 'ConfigValidationError';
-    }
-}
-exports.ConfigValidationError = ConfigValidationError;
-/**
- * Validate and normalize a complete configuration object
- * This ensures type safety and provides helpful error messages
- */
-function validateConfig(config) {
-    logger.debug('Validating configuration');
-    try {
-        const validatedConfig = {
-            server: validateServerConfig(config.server, 'server'),
-            serviceDiscovery: validateServiceDiscoveryConfig(config.serviceDiscovery, 'serviceDiscovery'),
-            database: validateDatabaseConfig(config.database, 'database'),
-            modules: validateModuleDefaultsConfig(config.modules, 'modules'),
-            logging: validateLoggingConfig(config.logging, 'logging'),
-            security: validateSecurityConfig(config.security, 'security'),
-            external: validateExternalServicesConfig(config.external, 'external'),
-            performance: validatePerformanceConfig(config.performance, 'performance'),
-            websocket: validateWebSocketConfig(config.websocket, 'websocket'),
-        };
-        logger.debug('Configuration validation successful');
-        return validatedConfig;
-    }
-    catch (error) {
-        if (error instanceof ConfigValidationError) {
-            logger.error(`❌ Configuration validation failed for '${error.field}':`, error.message);
-            // Provide helpful hints
-            provideValidationHints(error);
-            throw error;
-        }
-        logger.error('❌ Unexpected configuration validation error:', String(error));
-        throw new Error(`Configuration validation failed: ${String(error)}`);
-    }
-}
-/**
- * Validate server configuration
- */
-function validateServerConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Server configuration must be an object');
-    }
-    return {
-        port: validatePort(config.port, `${path}.port`),
-        host: validateString(config.host, `${path}.host`),
-        maxConnections: validateNumber(config.maxConnections, `${path}.maxConnections`, { min: 1 }),
-        timeout: validateNumber(config.timeout, `${path}.timeout`, { min: 1000 }),
-        bodySizeLimit: validateString(config.bodySizeLimit, `${path}.bodySizeLimit`),
-        requestTracking: {
-            enabled: validateBoolean(config.requestTracking?.enabled, `${path}.requestTracking.enabled`),
-        },
-        errorBoundary: {
-            enabled: validateBoolean(config.errorBoundary?.enabled, `${path}.errorBoundary.enabled`),
-        },
-    };
-}
-/**
- * Validate service discovery configuration
- */
-function validateServiceDiscoveryConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Service discovery configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        type: validateEnum(config.type, ['memory', 'consul', 'kubernetes'], `${path}.type`),
-        consulUrl: validateString(config.consulUrl, `${path}.consulUrl`),
-        kubernetesNamespace: validateString(config.kubernetesNamespace, `${path}.kubernetesNamespace`),
-        healthCheckInterval: validateNumber(config.healthCheckInterval, `${path}.healthCheckInterval`, {
-            min: 1000,
-        }),
-        retryAttempts: validateNumber(config.retryAttempts, `${path}.retryAttempts`, { min: 0 }),
-    };
-}
-/**
- * Validate database configuration
- */
-function validateDatabaseConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Database configuration must be an object');
-    }
-    const result = {};
-    // Optional URL
-    if (config.url !== undefined) {
-        result.url = validateString(config.url, `${path}.url`);
-    }
-    // Optional Redis - only validate if present
-    if (config.redis !== undefined) {
-        result.redis = validateRedisConfig(config.redis, `${path}.redis`);
-    }
-    // Optional MySQL - only validate if present
-    if (config.mysql !== undefined) {
-        result.mysql = validateMySQLConfig(config.mysql, `${path}.mysql`);
-    }
-    // Optional PostgreSQL - only validate if present
-    if (config.postgresql !== undefined) {
-        result.postgresql = validatePostgreSQLConfig(config.postgresql, `${path}.postgresql`);
-    }
-    // Optional SQLite - only validate if present
-    if (config.sqlite !== undefined) {
-        result.sqlite = validateSQLiteConfig(config.sqlite, `${path}.sqlite`);
-    }
-    // Optional MongoDB - only validate if present
-    if (config.mongodb !== undefined) {
-        result.mongodb = validateMongoDBConfig(config.mongodb, `${path}.mongodb`);
-    }
-    return result;
-}
-/**
- * Validate Redis configuration
- */
-function validateRedisConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Redis configuration must be an object');
-    }
-    return {
-        url: validateString(config.url, `${path}.url`),
-        maxRetries: validateNumber(config.maxRetries, `${path}.maxRetries`, { min: 0 }),
-        retryDelay: validateNumber(config.retryDelay, `${path}.retryDelay`, { min: 0 }),
-        keyPrefix: validateString(config.keyPrefix, `${path}.keyPrefix`),
-    };
-}
-/**
- * Validate MySQL configuration
- */
-function validateMySQLConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'MySQL configuration must be an object');
-    }
-    const result = {
-        host: validateString(config.host, `${path}.host`),
-        port: validatePort(config.port, `${path}.port`),
-        connectionLimit: validateNumber(config.connectionLimit, `${path}.connectionLimit`, { min: 1 }),
-        acquireTimeout: validateNumber(config.acquireTimeout, `${path}.acquireTimeout`, { min: 1000 }),
-        timeout: validateNumber(config.timeout, `${path}.timeout`, { min: 1000 }),
-    };
-    // Optional fields
-    if (config.database !== undefined) {
-        result.database = validateString(config.database, `${path}.database`);
-    }
-    if (config.username !== undefined) {
-        result.username = validateString(config.username, `${path}.username`);
-    }
-    if (config.password !== undefined) {
-        result.password = validateString(config.password, `${path}.password`);
-    }
-    return result;
-}
-/**
- * Validate PostgreSQL configuration
- */
-function validatePostgreSQLConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'PostgreSQL configuration must be an object');
-    }
-    const result = {
-        host: validateString(config.host, `${path}.host`),
-        port: validatePort(config.port, `${path}.port`),
-        connectionLimit: validateNumber(config.connectionLimit, `${path}.connectionLimit`, { min: 1 }),
-    };
-    // Optional fields
-    if (config.database !== undefined) {
-        result.database = validateString(config.database, `${path}.database`);
-    }
-    if (config.user !== undefined) {
-        result.user = validateString(config.user, `${path}.user`);
-    }
-    if (config.password !== undefined) {
-        result.password = validateString(config.password, `${path}.password`);
-    }
-    if (config.ssl !== undefined) {
-        result.ssl = validateBoolean(config.ssl, `${path}.ssl`);
-    }
-    return result;
-}
-/**
- * Validate SQLite configuration
- */
-function validateSQLiteConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'SQLite configuration must be an object');
-    }
-    const result = {
-        filename: validateString(config.filename, `${path}.filename`),
-    };
-    // Optional fields
-    if (config.memory !== undefined) {
-        result.memory = validateBoolean(config.memory, `${path}.memory`);
-    }
-    if (config.verbose !== undefined) {
-        result.verbose = validateBoolean(config.verbose, `${path}.verbose`);
-    }
-    return result;
-}
-/**
- * Validate MongoDB configuration
- */
-function validateMongoDBConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'MongoDB configuration must be an object');
-    }
-    const result = {};
-    // Either url or host+port
-    if (config.url !== undefined) {
-        result.url = validateString(config.url, `${path}.url`);
-    }
-    if (config.host !== undefined) {
-        result.host = validateString(config.host, `${path}.host`);
-    }
-    if (config.port !== undefined) {
-        result.port = validatePort(config.port, `${path}.port`);
-    }
-    if (config.database !== undefined) {
-        result.database = validateString(config.database, `${path}.database`);
-    }
-    if (config.username !== undefined) {
-        result.username = validateString(config.username, `${path}.username`);
-    }
-    if (config.password !== undefined) {
-        result.password = validateString(config.password, `${path}.password`);
-    }
-    return result;
-}
-/**
- * Validate module defaults configuration
- */
-function validateModuleDefaultsConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Module defaults configuration must be an object');
-    }
-    return {
-        cache: validateCacheConfig(config.cache, `${path}.cache`),
-        rateLimit: validateRateLimitConfig(config.rateLimit, `${path}.rateLimit`),
-        validation: validateValidationConfig(config.validation, `${path}.validation`),
-        autoDiscovery: validateAutoDiscoveryConfig(config.autoDiscovery, `${path}.autoDiscovery`),
-    };
-}
-/**
- * Validate auto-discovery configuration
- */
-function validateAutoDiscoveryConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Auto-discovery configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        paths: validateStringArray(config.paths, `${path}.paths`),
-        patterns: validateStringArray(config.patterns, `${path}.patterns`),
-        recursive: validateBoolean(config.recursive, `${path}.recursive`),
-        loadingStrategy: validateEnum(config.loadingStrategy, ['eager', 'lazy', 'conditional'], `${path}.loadingStrategy`),
-        watchForChanges: validateBoolean(config.watchForChanges, `${path}.watchForChanges`),
-        ignorePatterns: validateStringArray(config.ignorePatterns, `${path}.ignorePatterns`),
-        loadOrder: validateEnum(config.loadOrder, ['alphabetical', 'dependency', 'custom'], `${path}.loadOrder`),
-        failOnError: validateBoolean(config.failOnError, `${path}.failOnError`),
-        maxDepth: validateNumber(config.maxDepth, `${path}.maxDepth`),
-    };
-}
-/**
- * Validate cache configuration
- */
-function validateCacheConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Cache configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        defaultTtl: validateNumber(config.defaultTtl, `${path}.defaultTtl`, { min: 0 }),
-        maxSize: validateNumber(config.maxSize, `${path}.maxSize`, { min: 1 }),
-        strategy: validateEnum(config.strategy, ['lru', 'lfu', 'fifo'], `${path}.strategy`),
-    };
-}
-/**
- * Validate rate limit configuration
- */
-function validateRateLimitConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Rate limit configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        defaultRequests: validateNumber(config.defaultRequests, `${path}.defaultRequests`, { min: 1 }),
-        defaultWindow: validateNumber(config.defaultWindow, `${path}.defaultWindow`, { min: 1000 }),
-        skipSuccessfulRequests: validateBoolean(config.skipSuccessfulRequests, `${path}.skipSuccessfulRequests`),
-        skipFailedRequests: validateBoolean(config.skipFailedRequests, `${path}.skipFailedRequests`),
-    };
-}
-/**
- * Validate validation configuration
- */
-function validateValidationConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Validation configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        stripUnknown: validateBoolean(config.stripUnknown, `${path}.stripUnknown`),
-        abortEarly: validateBoolean(config.abortEarly, `${path}.abortEarly`),
-    };
-}
-/**
- * Validate logging configuration
- */
-function validateLoggingConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Logging configuration must be an object');
-    }
-    return {
-        level: validateEnum(config.level, ['debug', 'info', 'warn', 'error', 'fatal'], `${path}.level`),
-        format: validateEnum(config.format, ['pretty', 'json', 'compact'], `${path}.format`),
-        enableColors: validateBoolean(config.enableColors, `${path}.enableColors`),
-        enableTimestamp: validateBoolean(config.enableTimestamp, `${path}.enableTimestamp`),
-        enableContext: validateBoolean(config.enableContext, `${path}.enableContext`),
-        outputs: validateLoggingOutputsConfig(config.outputs, `${path}.outputs`),
-    };
-}
-/**
- * Validate logging outputs configuration
- */
-function validateLoggingOutputsConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Logging outputs configuration must be an object');
-    }
-    return {
-        console: validateBoolean(config.console, `${path}.console`),
-        file: validateLoggingFileConfig(config.file, `${path}.file`),
-        webhook: validateLoggingWebhookConfig(config.webhook, `${path}.webhook`),
-    };
-}
-/**
- * Validate logging file configuration
- */
-function validateLoggingFileConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Logging file configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        path: validateString(config.path, `${path}.path`),
-        maxSize: validateString(config.maxSize, `${path}.maxSize`),
-        maxFiles: validateNumber(config.maxFiles, `${path}.maxFiles`, { min: 1 }),
-    };
-}
-/**
- * Validate logging webhook configuration
- */
-function validateLoggingWebhookConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Logging webhook configuration must be an object');
-    }
-    const result = {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        headers: validateObject(config.headers, `${path}.headers`),
-    };
-    // Optional URL
-    if (config.url !== undefined) {
-        result.url = validateString(config.url, `${path}.url`);
-    }
-    return result;
-}
-/**
- * Validate security configuration
- */
-function validateSecurityConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Security configuration must be an object');
-    }
-    return {
-        cors: validateCorsConfig(config.cors, `${path}.cors`),
-        helmet: validateHelmetConfig(config.helmet, `${path}.helmet`),
-        rateLimit: validateSecurityRateLimitConfig(config.rateLimit, `${path}.rateLimit`),
-    };
-}
-/**
- * Validate CORS configuration
- */
-function validateCorsConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'CORS configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        origin: validateCorsOrigin(config.origin, `${path}.origin`),
-        methods: validateStringArray(config.methods, `${path}.methods`),
-        allowedHeaders: validateStringArray(config.allowedHeaders, `${path}.allowedHeaders`),
-        credentials: validateBoolean(config.credentials, `${path}.credentials`),
-    };
-}
-/**
- * Validate CORS origin (can be string, array, or boolean)
- */
-function validateCorsOrigin(value, path) {
-    if (typeof value === 'boolean' || typeof value === 'string') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return validateStringArray(value, path);
-    }
-    throw new ConfigValidationError(path, value, 'string | string[] | boolean', 'Must be a string, array of strings, or boolean');
-}
-/**
- * Validate helmet configuration
- */
-function validateHelmetConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Helmet configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        contentSecurityPolicy: validateBoolean(config.contentSecurityPolicy, `${path}.contentSecurityPolicy`),
-        hsts: validateBoolean(config.hsts, `${path}.hsts`),
-        noSniff: validateBoolean(config.noSniff, `${path}.noSniff`),
-        frameguard: validateBoolean(config.frameguard, `${path}.frameguard`),
-    };
-}
-/**
- * Validate security rate limit configuration
- */
-function validateSecurityRateLimitConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Security rate limit configuration must be an object');
-    }
-    return {
-        global: validateGlobalRateLimitConfig(config.global, `${path}.global`),
-    };
-}
-/**
- * Validate global rate limit configuration
- */
-function validateGlobalRateLimitConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Global rate limit configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        requests: validateNumber(config.requests, `${path}.requests`, { min: 1 }),
-        window: validateNumber(config.window, `${path}.window`, { min: 1000 }),
-    };
-}
-/**
- * Validate external services configuration
- */
-function validateExternalServicesConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'External services configuration must be an object');
-    }
-    const result = {};
-    // Optional services - only validate if present
-    if (config.stripe !== undefined) {
-        result.stripe = validateStripeConfig(config.stripe, `${path}.stripe`);
-    }
-    if (config.paypal !== undefined) {
-        result.paypal = validatePayPalConfig(config.paypal, `${path}.paypal`);
-    }
-    if (config.smtp !== undefined) {
-        result.smtp = validateSMTPConfig(config.smtp, `${path}.smtp`);
-    }
-    return result;
-}
-/**
- * Validate Stripe configuration
- */
-function validateStripeConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Stripe configuration must be an object');
-    }
-    const result = {};
-    // Optional fields
-    if (config.secretKey !== undefined) {
-        result.secretKey = validateString(config.secretKey, `${path}.secretKey`);
-    }
-    if (config.publishableKey !== undefined) {
-        result.publishableKey = validateString(config.publishableKey, `${path}.publishableKey`);
-    }
-    if (config.webhookSecret !== undefined) {
-        result.webhookSecret = validateString(config.webhookSecret, `${path}.webhookSecret`);
-    }
-    if (config.apiVersion !== undefined) {
-        result.apiVersion = validateString(config.apiVersion, `${path}.apiVersion`);
-    }
-    else {
-        result.apiVersion = '2023-10-16'; // Default API version
-    }
-    return result;
-}
-/**
- * Validate PayPal configuration
- */
-function validatePayPalConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'PayPal configuration must be an object');
-    }
-    const result = {
-        environment: validateEnum(config.environment, ['sandbox', 'production'], `${path}.environment`),
-    };
-    // Optional fields
-    if (config.clientId !== undefined) {
-        result.clientId = validateString(config.clientId, `${path}.clientId`);
-    }
-    if (config.clientSecret !== undefined) {
-        result.clientSecret = validateString(config.clientSecret, `${path}.clientSecret`);
-    }
-    if (config.webhookId !== undefined) {
-        result.webhookId = validateString(config.webhookId, `${path}.webhookId`);
-    }
-    return result;
-}
-/**
- * Validate SMTP configuration
- */
-function validateSMTPConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'SMTP configuration must be an object');
-    }
-    const result = {
-        port: validatePort(config.port, `${path}.port`),
-        secure: validateBoolean(config.secure, `${path}.secure`),
-    };
-    // Optional fields
-    if (config.host !== undefined) {
-        result.host = validateString(config.host, `${path}.host`);
-    }
-    if (config.username !== undefined) {
-        result.username = validateString(config.username, `${path}.username`);
-    }
-    if (config.password !== undefined) {
-        result.password = validateString(config.password, `${path}.password`);
-    }
-    return result;
-}
-/**
- * Validate performance configuration
- */
-function validatePerformanceConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Performance configuration must be an object');
-    }
-    return {
-        compression: validateCompressionConfig(config.compression, `${path}.compression`),
-        circuitBreaker: validateCircuitBreakerConfig(config.circuitBreaker, `${path}.circuitBreaker`),
-        clustering: validateClusteringConfig(config.clustering, `${path}.clustering`),
-    };
-}
-/**
- * Validate compression configuration
- */
-function validateCompressionConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Compression configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        level: validateNumber(config.level, `${path}.level`, { min: 1, max: 9 }),
-        threshold: validateNumber(config.threshold, `${path}.threshold`, { min: 0 }),
-    };
-}
-/**
- * Validate circuit breaker configuration
- */
-function validateCircuitBreakerConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Circuit breaker configuration must be an object');
-    }
-    return {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-        failureThreshold: validateNumber(config.failureThreshold, `${path}.failureThreshold`, {
-            min: 1,
-        }),
-        resetTimeout: validateNumber(config.resetTimeout, `${path}.resetTimeout`, { min: 1000 }),
-        monitoringPeriod: validateNumber(config.monitoringPeriod, `${path}.monitoringPeriod`, {
-            min: 1000,
-        }),
-    };
-}
-/**
- * Validate clustering configuration
- */
-function validateClusteringConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'Clustering configuration must be an object');
-    }
-    const result = {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-    };
-    // Workers can be number or 'auto'
-    if (typeof config.workers === 'string' && config.workers === 'auto') {
-        result.workers = 'auto';
-    }
-    else {
-        result.workers = validateNumber(config.workers, `${path}.workers`, { min: 1 });
-    }
-    // Optional memoryPerWorkerGB
-    if (config.memoryPerWorkerGB !== undefined) {
-        result.memoryPerWorkerGB = validateNumber(config.memoryPerWorkerGB, `${path}.memoryPerWorkerGB`, { min: 0.1 });
-    }
-    return result;
-}
-/**
- * Validate WebSocket configuration
- */
-function validateWebSocketConfig(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'WebSocket configuration must be an object');
-    }
-    const result = {
-        enabled: validateBoolean(config.enabled, `${path}.enabled`),
-    };
-    // Optional fields
-    if (config.adapter !== undefined) {
-        result.adapter = validateString(config.adapter, `${path}.adapter`);
-    }
-    if (config.compression !== undefined) {
-        result.compression = validateBoolean(config.compression, `${path}.compression`);
-    }
-    if (config.customIdGenerator !== undefined) {
-        result.customIdGenerator = config.customIdGenerator; // Function - no validation needed
-    }
-    if (config.options !== undefined) {
-        result.options = validateWebSocketOptions(config.options, `${path}.options`);
-    }
-    return result;
-}
-/**
- * Validate WebSocket options
- */
-function validateWebSocketOptions(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'WebSocket options must be an object');
-    }
-    const result = {};
-    if (config.cors !== undefined) {
-        result.cors = validateWebSocketCorsOptions(config.cors, `${path}.cors`);
-    }
-    if (config.path !== undefined) {
-        result.path = validateString(config.path, `${path}.path`);
-    }
-    if (config.maxPayloadLength !== undefined) {
-        result.maxPayloadLength = validateNumber(config.maxPayloadLength, `${path}.maxPayloadLength`, {
-            min: 1024,
-        });
-    }
-    return result;
-}
-/**
- * Validate WebSocket CORS options
- */
-function validateWebSocketCorsOptions(config, path) {
-    if (!config || typeof config !== 'object') {
-        throw new ConfigValidationError(path, config, 'object', 'WebSocket CORS options must be an object');
-    }
-    const result = {};
-    if (config.origin !== undefined) {
-        result.origin = validateCorsOrigin(config.origin, `${path}.origin`);
-    }
-    if (config.credentials !== undefined) {
-        result.credentials = validateBoolean(config.credentials, `${path}.credentials`);
-    }
-    return result;
-}
-// Basic validation functions
-function validatePort(value, path) {
-    const num = Number(value);
-    if (isNaN(num) || num < 1 || num > 65535) {
-        throw new ConfigValidationError(path, value, 'number (1-65535)', 'Must be a number between 1 and 65535');
-    }
-    return num;
-}
-function validateBoolean(value, path) {
-    if (value === 'true' || value === true)
-        return true;
-    if (value === 'false' || value === false)
-        return false;
-    if (value === '1' || value === 1)
-        return true;
-    if (value === '0' || value === 0)
-        return false;
-    throw new ConfigValidationError(path, value, 'boolean', 'Must be a boolean (true/false) or numeric (1/0)');
-}
-function validateNumber(value, path, options = {}) {
-    const num = Number(value);
-    if (isNaN(num)) {
-        throw new ConfigValidationError(path, value, 'number', 'Must be a valid number');
-    }
-    if (options.min !== undefined && num < options.min) {
-        throw new ConfigValidationError(path, value, `number >= ${options.min}`, `Must be at least ${options.min}`);
-    }
-    if (options.max !== undefined && num > options.max) {
-        throw new ConfigValidationError(path, value, `number <= ${options.max}`, `Must be at most ${options.max}`);
-    }
-    return num;
-}
-function validateString(value, path) {
-    if (typeof value !== 'string') {
-        throw new ConfigValidationError(path, value, 'string', 'Must be a string');
-    }
-    return value;
-}
-function validateEnum(value, validValues, path) {
-    const str = validateString(value, path);
-    if (!validValues.includes(str)) {
-        throw new ConfigValidationError(path, value, `one of: ${validValues.join(', ')}`, `Must be one of: ${validValues.join(', ')}`);
-    }
-    return str;
-}
-function validateStringArray(value, path) {
-    if (!Array.isArray(value)) {
-        // Try to parse comma-separated string
-        if (typeof value === 'string') {
-            return value
-                .split(',')
-                .map(s => s.trim())
-                .filter(s => s.length > 0);
-        }
-        throw new ConfigValidationError(path, value, 'string[]', 'Must be an array or comma-separated string');
-    }
-    return value.map((item, index) => validateString(item, `${path}[${index}]`));
-}
-function validateObject(value, path) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new ConfigValidationError(path, value, 'object', 'Must be an object');
-    }
-    return value;
-}
-/**
- * Provide helpful validation hints based on the error
- */
-function provideValidationHints(error) {
-    if (error.field.includes('port')) {
-        logger.error('  💡 Hint: Ports must be numbers between 1 and 65535');
-    }
-    if (error.field.includes('url')) {
-        logger.error('  💡 Hint: URLs must include protocol (http:// or https://)');
-    }
-    if (error.field.includes('environment')) {
-        logger.error('  💡 Hint: NODE_ENV must be one of: development, staging, production');
-    }
-    if (error.field.includes('level')) {
-        logger.error('  💡 Hint: Log level must be one of: debug, info, warn, error, fatal');
-    }
-}
-//# sourceMappingURL=config-validator.js.map