@morojs/moro 1.6.1 → 1.6.3

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

@@ -0,0 +1,791 @@
+/**
+ * Configuration Validator - Type-Safe Schema Validation
+ *
+ * This module provides runtime validation for configuration objects using
+ * simple TypeScript functions that match the type definitions exactly.
+ */
+import { createFrameworkLogger } from '../logger/index.js';
+const logger = createFrameworkLogger('ConfigValidator');
+/**
+ * Configuration validation error with detailed context
+ */
+export 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';
+    }
+}
+/**
+ * Validate and normalize a complete configuration object
+ * This ensures type safety and provides helpful error messages
+ */
+export 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');
+    }
+    const result = {
+        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`),
+        },
+        requestLogging: {
+            enabled: validateBoolean(config.requestLogging?.enabled, `${path}.requestLogging.enabled`),
+        },
+        errorBoundary: {
+            enabled: validateBoolean(config.errorBoundary?.enabled, `${path}.errorBoundary.enabled`),
+        },
+    };
+    // Optional uWebSockets configuration
+    if (config.useUWebSockets !== undefined) {
+        result.useUWebSockets = validateBoolean(config.useUWebSockets, `${path}.useUWebSockets`);
+    }
+    // Optional SSL configuration
+    if (config.ssl !== undefined) {
+        result.ssl = validateSSLConfig(config.ssl, `${path}.ssl`);
+    }
+    return result;
+}
+/**
+ * Validate SSL configuration
+ */
+function validateSSLConfig(config, path) {
+    if (!config || typeof config !== 'object') {
+        throw new ConfigValidationError(path, config, 'object', 'SSL configuration must be an object');
+    }
+    const result = {};
+    if (config.key_file_name !== undefined) {
+        result.key_file_name = validateString(config.key_file_name, `${path}.key_file_name`);
+    }
+    if (config.cert_file_name !== undefined) {
+        result.cert_file_name = validateString(config.cert_file_name, `${path}.cert_file_name`);
+    }
+    if (config.passphrase !== undefined) {
+        result.passphrase = validateString(config.passphrase, `${path}.passphrase`);
+    }
+    return result;
+}
+/**
+ * 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