@morojs/moro 1.3.0 → 1.5.0

package/src/core/config/loader.ts

@@ -1,6 +1,17 @@
 // Configuration Loader - Environment Variable Mapping and Validation
-import { ZodError } from 'zod';
-import { ConfigSchema, AppConfig } from './schema';
+import { ConfigSchema, AppConfig, DEFAULT_CONFIG } from './schema';
+import {
+  validatePort,
+  validateBoolean,
+  validateNumber,
+  validateString,
+  validateUrl,
+  validateEnum,
+  validateStringArray,
+  validateOptional,
+  coerceEnvValue,
+  ConfigValidationError,
+} from './validation';
 import { createFrameworkLogger } from '../logger';
 import { loadConfigFileSync, applyConfigAsEnvironmentVariables } from './file-loader';
 
@@ -12,9 +23,9 @@ const logger = createFrameworkLogger('Config');
  * @returns Validated and typed application configuration
  */
 export function loadConfig(): AppConfig {
-  logger.debug('Loading configuration from config files and environment variables');
+  logger.debug('Loading configuration with TypeScript validation');
 
-  // First, try to load from config file and apply as environment variables (synchronously)
+  // First, try to load from config file and apply as environment variables
   try {
     const fileConfig = loadConfigFileSync();
     if (fileConfig) {
@@ -28,283 +39,596 @@ export function loadConfig(): AppConfig {
     );
   }
 
-  // Map environment variables to configuration structure
-  const envConfig = {
-    server: {
-      port: process.env.PORT || process.env.MORO_PORT,
-      host: process.env.HOST || process.env.MORO_HOST,
-      environment: process.env.NODE_ENV || process.env.MORO_ENV,
-      maxConnections: process.env.MAX_CONNECTIONS || process.env.MORO_MAX_CONNECTIONS,
-      timeout: process.env.REQUEST_TIMEOUT || process.env.MORO_TIMEOUT,
-    },
-
-    serviceDiscovery: {
-      enabled: process.env.SERVICE_DISCOVERY_ENABLED || process.env.MORO_SERVICE_DISCOVERY,
-      type: process.env.DISCOVERY_TYPE || process.env.MORO_DISCOVERY_TYPE,
-      consulUrl: process.env.CONSUL_URL || process.env.MORO_CONSUL_URL,
-      kubernetesNamespace: process.env.K8S_NAMESPACE || process.env.MORO_K8S_NAMESPACE,
-      healthCheckInterval: process.env.HEALTH_CHECK_INTERVAL || process.env.MORO_HEALTH_INTERVAL,
-      retryAttempts: process.env.DISCOVERY_RETRY_ATTEMPTS || process.env.MORO_DISCOVERY_RETRIES,
-    },
-
-    database: {
-      url: process.env.DATABASE_URL || process.env.MORO_DATABASE_URL,
-      redis: {
-        url: process.env.REDIS_URL || process.env.MORO_REDIS_URL,
-        maxRetries: process.env.REDIS_MAX_RETRIES || process.env.MORO_REDIS_RETRIES,
-        retryDelay: process.env.REDIS_RETRY_DELAY || process.env.MORO_REDIS_DELAY,
-        keyPrefix: process.env.REDIS_KEY_PREFIX || process.env.MORO_REDIS_PREFIX,
+  try {
+    // Build configuration using robust validation functions
+    const config: AppConfig = {
+      server: {
+        port: validatePort(
+          coerceEnvValue(process.env.PORT || process.env.MORO_PORT || '') ||
+            DEFAULT_CONFIG.server.port,
+          'server.port'
+        ),
+        host: validateString(
+          process.env.HOST || process.env.MORO_HOST || DEFAULT_CONFIG.server.host,
+          'server.host'
+        ),
+        environment: validateEnum(
+          process.env.NODE_ENV || process.env.MORO_ENV || DEFAULT_CONFIG.server.environment,
+          ['development', 'staging', 'production'] as const,
+          'server.environment'
+        ),
+        maxConnections: validateNumber(
+          coerceEnvValue(process.env.MAX_CONNECTIONS || process.env.MORO_MAX_CONNECTIONS || '') ||
+            DEFAULT_CONFIG.server.maxConnections,
+          'server.maxConnections',
+          { min: 1 }
+        ),
+        timeout: validateNumber(
+          coerceEnvValue(process.env.REQUEST_TIMEOUT || process.env.MORO_TIMEOUT || '') ||
+            DEFAULT_CONFIG.server.timeout,
+          'server.timeout',
+          { min: 1000 }
+        ),
       },
-      mysql: process.env.MYSQL_HOST
-        ? {
-            host: process.env.MYSQL_HOST || process.env.MORO_MYSQL_HOST,
-            port: process.env.MYSQL_PORT || process.env.MORO_MYSQL_PORT,
-            database: process.env.MYSQL_DATABASE || process.env.MORO_MYSQL_DB,
-            username: process.env.MYSQL_USERNAME || process.env.MORO_MYSQL_USER,
-            password: process.env.MYSQL_PASSWORD || process.env.MORO_MYSQL_PASS,
-            connectionLimit:
-              process.env.MYSQL_CONNECTION_LIMIT || process.env.MORO_MYSQL_CONNECTIONS,
-            acquireTimeout:
-              process.env.MYSQL_ACQUIRE_TIMEOUT || process.env.MORO_MYSQL_ACQUIRE_TIMEOUT,
-            timeout: process.env.MYSQL_TIMEOUT || process.env.MORO_MYSQL_TIMEOUT,
-          }
-        : undefined,
-    },
 
-    modules: {
-      cache: {
-        enabled: process.env.CACHE_ENABLED || process.env.MORO_CACHE_ENABLED,
-        defaultTtl: process.env.DEFAULT_CACHE_TTL || process.env.MORO_CACHE_TTL,
-        maxSize: process.env.CACHE_MAX_SIZE || process.env.MORO_CACHE_SIZE,
-        strategy: process.env.CACHE_STRATEGY || process.env.MORO_CACHE_STRATEGY,
-      },
-      rateLimit: {
-        enabled: process.env.RATE_LIMIT_ENABLED || process.env.MORO_RATE_LIMIT_ENABLED,
-        defaultRequests:
-          process.env.DEFAULT_RATE_LIMIT_REQUESTS || process.env.MORO_RATE_LIMIT_REQUESTS,
-        defaultWindow: process.env.DEFAULT_RATE_LIMIT_WINDOW || process.env.MORO_RATE_LIMIT_WINDOW,
-        skipSuccessfulRequests:
-          process.env.RATE_LIMIT_SKIP_SUCCESS || process.env.MORO_RATE_LIMIT_SKIP_SUCCESS,
-        skipFailedRequests:
-          process.env.RATE_LIMIT_SKIP_FAILED || process.env.MORO_RATE_LIMIT_SKIP_FAILED,
+      serviceDiscovery: {
+        enabled: validateBoolean(
+          coerceEnvValue(
+            process.env.SERVICE_DISCOVERY_ENABLED || process.env.MORO_SERVICE_DISCOVERY || ''
+          ) ?? DEFAULT_CONFIG.serviceDiscovery.enabled,
+          'serviceDiscovery.enabled'
+        ),
+        type: validateEnum(
+          process.env.DISCOVERY_TYPE ||
+            process.env.MORO_DISCOVERY_TYPE ||
+            DEFAULT_CONFIG.serviceDiscovery.type,
+          ['memory', 'consul', 'kubernetes'] as const,
+          'serviceDiscovery.type'
+        ),
+        consulUrl: validateUrl(
+          process.env.CONSUL_URL ||
+            process.env.MORO_CONSUL_URL ||
+            DEFAULT_CONFIG.serviceDiscovery.consulUrl,
+          'serviceDiscovery.consulUrl'
+        ),
+        kubernetesNamespace: validateString(
+          process.env.KUBERNETES_NAMESPACE ||
+            process.env.MORO_KUBERNETES_NAMESPACE ||
+            DEFAULT_CONFIG.serviceDiscovery.kubernetesNamespace,
+          'serviceDiscovery.kubernetesNamespace'
+        ),
+        healthCheckInterval: validateNumber(
+          coerceEnvValue(
+            process.env.HEALTH_CHECK_INTERVAL || process.env.MORO_HEALTH_CHECK_INTERVAL || ''
+          ) || DEFAULT_CONFIG.serviceDiscovery.healthCheckInterval,
+          'serviceDiscovery.healthCheckInterval',
+          { min: 1000 }
+        ),
+        retryAttempts: validateNumber(
+          coerceEnvValue(process.env.RETRY_ATTEMPTS || process.env.MORO_RETRY_ATTEMPTS || '') ||
+            DEFAULT_CONFIG.serviceDiscovery.retryAttempts,
+          'serviceDiscovery.retryAttempts',
+          { min: 0 }
+        ),
       },
-      validation: {
-        enabled: process.env.VALIDATION_ENABLED || process.env.MORO_VALIDATION_ENABLED,
-        stripUnknown: process.env.VALIDATION_STRIP_UNKNOWN || process.env.MORO_VALIDATION_STRIP,
-        abortEarly: process.env.VALIDATION_ABORT_EARLY || process.env.MORO_VALIDATION_ABORT,
+
+      database: {
+        url: validateOptional(process.env.DATABASE_URL, validateString, 'database.url'),
+        redis: {
+          url: validateString(
+            process.env.REDIS_URL ||
+              process.env.MORO_REDIS_URL ||
+              DEFAULT_CONFIG.database.redis.url,
+            'database.redis.url'
+          ),
+          maxRetries: validateNumber(
+            coerceEnvValue(process.env.REDIS_MAX_RETRIES || process.env.MORO_REDIS_RETRIES || '') ||
+              DEFAULT_CONFIG.database.redis.maxRetries,
+            'database.redis.maxRetries',
+            { min: 0 }
+          ),
+          retryDelay: validateNumber(
+            coerceEnvValue(process.env.REDIS_RETRY_DELAY || process.env.MORO_REDIS_DELAY || '') ||
+              DEFAULT_CONFIG.database.redis.retryDelay,
+            'database.redis.retryDelay',
+            { min: 100 }
+          ),
+          keyPrefix: validateString(
+            process.env.REDIS_KEY_PREFIX ||
+              process.env.MORO_REDIS_PREFIX ||
+              DEFAULT_CONFIG.database.redis.keyPrefix,
+            'database.redis.keyPrefix'
+          ),
+        },
+        mysql: process.env.MYSQL_HOST
+          ? {
+              host: validateString(process.env.MYSQL_HOST, 'database.mysql.host'),
+              port: validatePort(
+                process.env.MYSQL_PORT || process.env.MORO_MYSQL_PORT || '3306',
+                'database.mysql.port'
+              ),
+              database: validateOptional(
+                process.env.MYSQL_DATABASE || process.env.MORO_MYSQL_DB,
+                validateString,
+                'database.mysql.database'
+              ),
+              username: validateOptional(
+                process.env.MYSQL_USERNAME || process.env.MORO_MYSQL_USER,
+                validateString,
+                'database.mysql.username'
+              ),
+              password: validateOptional(
+                process.env.MYSQL_PASSWORD || process.env.MORO_MYSQL_PASS,
+                validateString,
+                'database.mysql.password'
+              ),
+              connectionLimit: validateNumber(
+                coerceEnvValue(
+                  process.env.MYSQL_CONNECTION_LIMIT || process.env.MORO_MYSQL_CONNECTIONS || ''
+                ) || 10,
+                'database.mysql.connectionLimit',
+                { min: 1 }
+              ),
+              acquireTimeout: validateNumber(
+                coerceEnvValue(
+                  process.env.MYSQL_ACQUIRE_TIMEOUT || process.env.MORO_MYSQL_ACQUIRE_TIMEOUT || ''
+                ) || 60000,
+                'database.mysql.acquireTimeout',
+                { min: 1000 }
+              ),
+              timeout: validateNumber(
+                coerceEnvValue(process.env.MYSQL_TIMEOUT || process.env.MORO_MYSQL_TIMEOUT || '') ||
+                  60000,
+                'database.mysql.timeout',
+                { min: 1000 }
+              ),
+            }
+          : undefined,
       },
-    },
 
-    logging: {
-      level: process.env.LOG_LEVEL || process.env.MORO_LOG_LEVEL,
-      format: process.env.LOG_FORMAT || process.env.MORO_LOG_FORMAT,
-      enableColors: process.env.NO_COLOR ? false : process.env.LOG_COLORS !== 'false',
-      enableTimestamp: process.env.LOG_TIMESTAMP !== 'false',
-      enableContext: process.env.LOG_CONTEXT !== 'false',
-      outputs: {
-        console: process.env.LOG_CONSOLE !== 'false',
-        file: {
-          enabled: process.env.LOG_FILE_ENABLED === 'true' || process.env.MORO_LOG_FILE === 'true',
-          path: process.env.LOG_FILE_PATH || process.env.MORO_LOG_PATH,
-          maxSize: process.env.LOG_FILE_MAX_SIZE || process.env.MORO_LOG_MAX_SIZE,
-          maxFiles: process.env.LOG_FILE_MAX_FILES || process.env.MORO_LOG_MAX_FILES,
+      modules: {
+        cache: {
+          enabled: validateBoolean(
+            coerceEnvValue(process.env.CACHE_ENABLED || process.env.MORO_CACHE_ENABLED || '') ??
+              DEFAULT_CONFIG.modules.cache.enabled,
+            'modules.cache.enabled'
+          ),
+          defaultTtl: validateNumber(
+            coerceEnvValue(process.env.CACHE_TTL || process.env.MORO_CACHE_TTL || '') ||
+              DEFAULT_CONFIG.modules.cache.defaultTtl,
+            'modules.cache.defaultTtl',
+            { min: 0 }
+          ),
+          maxSize: validateNumber(
+            coerceEnvValue(process.env.CACHE_MAX_SIZE || process.env.MORO_CACHE_MAX_SIZE || '') ||
+              DEFAULT_CONFIG.modules.cache.maxSize,
+            'modules.cache.maxSize',
+            { min: 1 }
+          ),
+          strategy: validateEnum(
+            process.env.CACHE_STRATEGY ||
+              process.env.MORO_CACHE_STRATEGY ||
+              DEFAULT_CONFIG.modules.cache.strategy,
+            ['lru', 'lfu', 'fifo'] as const,
+            'modules.cache.strategy'
+          ),
+        },
+        rateLimit: {
+          enabled: validateBoolean(
+            coerceEnvValue(
+              process.env.RATE_LIMIT_ENABLED || process.env.MORO_RATE_LIMIT_ENABLED || ''
+            ) ?? DEFAULT_CONFIG.modules.rateLimit.enabled,
+            'modules.rateLimit.enabled'
+          ),
+          defaultRequests: validateNumber(
+            coerceEnvValue(
+              process.env.RATE_LIMIT_REQUESTS || process.env.MORO_RATE_LIMIT_REQUESTS || ''
+            ) || DEFAULT_CONFIG.modules.rateLimit.defaultRequests,
+            'modules.rateLimit.defaultRequests',
+            { min: 1 }
+          ),
+          defaultWindow: validateNumber(
+            coerceEnvValue(
+              process.env.RATE_LIMIT_WINDOW || process.env.MORO_RATE_LIMIT_WINDOW || ''
+            ) || DEFAULT_CONFIG.modules.rateLimit.defaultWindow,
+            'modules.rateLimit.defaultWindow',
+            { min: 1000 }
+          ),
+          skipSuccessfulRequests: validateBoolean(
+            coerceEnvValue(
+              process.env.RATE_LIMIT_SKIP_SUCCESS || process.env.MORO_RATE_LIMIT_SKIP_SUCCESS || ''
+            ) ?? DEFAULT_CONFIG.modules.rateLimit.skipSuccessfulRequests,
+            'modules.rateLimit.skipSuccessfulRequests'
+          ),
+          skipFailedRequests: validateBoolean(
+            coerceEnvValue(
+              process.env.RATE_LIMIT_SKIP_FAILED || process.env.MORO_RATE_LIMIT_SKIP_FAILED || ''
+            ) ?? DEFAULT_CONFIG.modules.rateLimit.skipFailedRequests,
+            'modules.rateLimit.skipFailedRequests'
+          ),
         },
-        webhook: {
-          enabled:
-            process.env.LOG_WEBHOOK_ENABLED === 'true' || process.env.MORO_LOG_WEBHOOK === 'true',
-          url: process.env.LOG_WEBHOOK_URL || process.env.MORO_LOG_WEBHOOK_URL,
-          headers: parseJsonEnv(
-            process.env.LOG_WEBHOOK_HEADERS || process.env.MORO_LOG_WEBHOOK_HEADERS,
-            {}
+        validation: {
+          enabled: validateBoolean(
+            coerceEnvValue(
+              process.env.VALIDATION_ENABLED || process.env.MORO_VALIDATION_ENABLED || ''
+            ) ?? DEFAULT_CONFIG.modules.validation.enabled,
+            'modules.validation.enabled'
+          ),
+          stripUnknown: validateBoolean(
+            coerceEnvValue(
+              process.env.VALIDATION_STRIP_UNKNOWN ||
+                process.env.MORO_VALIDATION_STRIP_UNKNOWN ||
+                ''
+            ) ?? DEFAULT_CONFIG.modules.validation.stripUnknown,
+            'modules.validation.stripUnknown'
+          ),
+          abortEarly: validateBoolean(
+            coerceEnvValue(
+              process.env.VALIDATION_ABORT_EARLY || process.env.MORO_VALIDATION_ABORT_EARLY || ''
+            ) ?? DEFAULT_CONFIG.modules.validation.abortEarly,
+            'modules.validation.abortEarly'
           ),
         },
       },
-    },
 
-    security: {
-      cors: {
-        enabled: process.env.CORS_ENABLED !== 'false',
-        origin: parseArrayOrString(process.env.CORS_ORIGIN || process.env.MORO_CORS_ORIGIN),
-        methods: parseArrayEnv(process.env.CORS_METHODS || process.env.MORO_CORS_METHODS),
-        allowedHeaders: parseArrayEnv(process.env.CORS_HEADERS || process.env.MORO_CORS_HEADERS),
-        credentials: process.env.CORS_CREDENTIALS === 'true',
-      },
-      helmet: {
-        enabled: process.env.HELMET_ENABLED !== 'false',
-        contentSecurityPolicy: process.env.HELMET_CSP !== 'false',
-        hsts: process.env.HELMET_HSTS !== 'false',
-        noSniff: process.env.HELMET_NO_SNIFF !== 'false',
-        frameguard: process.env.HELMET_FRAMEGUARD !== 'false',
-      },
-      rateLimit: {
-        global: {
-          enabled: process.env.GLOBAL_RATE_LIMIT_ENABLED === 'true',
-          requests: process.env.GLOBAL_RATE_LIMIT_REQUESTS || process.env.MORO_GLOBAL_RATE_REQUESTS,
-          window: process.env.GLOBAL_RATE_LIMIT_WINDOW || process.env.MORO_GLOBAL_RATE_WINDOW,
+      logging: {
+        level: validateEnum(
+          process.env.LOG_LEVEL || process.env.MORO_LOG_LEVEL || DEFAULT_CONFIG.logging.level,
+          ['debug', 'info', 'warn', 'error', 'fatal'] as const,
+          'logging.level'
+        ),
+        format: validateEnum(
+          process.env.LOG_FORMAT || process.env.MORO_LOG_FORMAT || DEFAULT_CONFIG.logging.format,
+          ['pretty', 'json', 'compact'] as const,
+          'logging.format'
+        ),
+        enableColors: validateBoolean(
+          coerceEnvValue(process.env.LOG_COLORS || process.env.MORO_LOG_COLORS || '') ??
+            DEFAULT_CONFIG.logging.enableColors,
+          'logging.enableColors'
+        ),
+        enableTimestamp: validateBoolean(
+          coerceEnvValue(process.env.LOG_TIMESTAMP || process.env.MORO_LOG_TIMESTAMP || '') ??
+            DEFAULT_CONFIG.logging.enableTimestamp,
+          'logging.enableTimestamp'
+        ),
+        enableContext: validateBoolean(
+          coerceEnvValue(process.env.LOG_CONTEXT || process.env.MORO_LOG_CONTEXT || '') ??
+            DEFAULT_CONFIG.logging.enableContext,
+          'logging.enableContext'
+        ),
+        outputs: {
+          console: validateBoolean(
+            coerceEnvValue(process.env.LOG_CONSOLE || process.env.MORO_LOG_CONSOLE || '') ??
+              DEFAULT_CONFIG.logging.outputs.console,
+            'logging.outputs.console'
+          ),
+          file: {
+            enabled: validateBoolean(
+              coerceEnvValue(
+                process.env.LOG_FILE_ENABLED || process.env.MORO_LOG_FILE_ENABLED || ''
+              ) ?? DEFAULT_CONFIG.logging.outputs.file.enabled,
+              'logging.outputs.file.enabled'
+            ),
+            path: validateString(
+              process.env.LOG_FILE_PATH ||
+                process.env.MORO_LOG_FILE_PATH ||
+                DEFAULT_CONFIG.logging.outputs.file.path,
+              'logging.outputs.file.path'
+            ),
+            maxSize: validateString(
+              process.env.LOG_FILE_MAX_SIZE ||
+                process.env.MORO_LOG_FILE_MAX_SIZE ||
+                DEFAULT_CONFIG.logging.outputs.file.maxSize,
+              'logging.outputs.file.maxSize'
+            ),
+            maxFiles: validateNumber(
+              coerceEnvValue(
+                process.env.LOG_FILE_MAX_FILES || process.env.MORO_LOG_FILE_MAX_FILES || ''
+              ) || DEFAULT_CONFIG.logging.outputs.file.maxFiles,
+              'logging.outputs.file.maxFiles',
+              { min: 1 }
+            ),
+          },
+          webhook: {
+            enabled: validateBoolean(
+              coerceEnvValue(
+                process.env.LOG_WEBHOOK_ENABLED || process.env.MORO_LOG_WEBHOOK_ENABLED || ''
+              ) ?? DEFAULT_CONFIG.logging.outputs.webhook.enabled,
+              'logging.outputs.webhook.enabled'
+            ),
+            url: validateOptional(
+              process.env.LOG_WEBHOOK_URL || process.env.MORO_LOG_WEBHOOK_URL,
+              validateUrl,
+              'logging.outputs.webhook.url'
+            ),
+            headers: DEFAULT_CONFIG.logging.outputs.webhook.headers,
+          },
         },
       },
-    },
 
-    external: {
-      stripe:
-        process.env.STRIPE_SECRET_KEY || process.env.MORO_STRIPE_SECRET
-          ? {
-              secretKey: process.env.STRIPE_SECRET_KEY || process.env.MORO_STRIPE_SECRET,
-              publishableKey: process.env.STRIPE_PUBLISHABLE_KEY || process.env.MORO_STRIPE_PUBLIC,
-              webhookSecret: process.env.STRIPE_WEBHOOK_SECRET || process.env.MORO_STRIPE_WEBHOOK,
-              apiVersion: process.env.STRIPE_API_VERSION || process.env.MORO_STRIPE_VERSION,
-            }
-          : undefined,
-
-      paypal:
-        process.env.PAYPAL_CLIENT_ID || process.env.MORO_PAYPAL_CLIENT
-          ? {
-              clientId: process.env.PAYPAL_CLIENT_ID || process.env.MORO_PAYPAL_CLIENT,
-              clientSecret: process.env.PAYPAL_CLIENT_SECRET || process.env.MORO_PAYPAL_SECRET,
-              webhookId: process.env.PAYPAL_WEBHOOK_ID || process.env.MORO_PAYPAL_WEBHOOK,
-              environment: process.env.PAYPAL_ENVIRONMENT || process.env.MORO_PAYPAL_ENV,
-            }
-          : undefined,
-
-      smtp:
-        process.env.SMTP_HOST || process.env.MORO_SMTP_HOST
-          ? {
-              host: process.env.SMTP_HOST || process.env.MORO_SMTP_HOST,
-              port: process.env.SMTP_PORT || process.env.MORO_SMTP_PORT,
-              secure: process.env.SMTP_SECURE === 'true',
-              username: process.env.SMTP_USERNAME || process.env.MORO_SMTP_USER,
-              password: process.env.SMTP_PASSWORD || process.env.MORO_SMTP_PASS,
-            }
-          : undefined,
-    },
-
-    performance: {
-      compression: {
-        enabled: process.env.COMPRESSION_ENABLED !== 'false',
-        level: process.env.COMPRESSION_LEVEL || process.env.MORO_COMPRESSION_LEVEL,
-        threshold: process.env.COMPRESSION_THRESHOLD || process.env.MORO_COMPRESSION_THRESHOLD,
-      },
-      circuitBreaker: {
-        enabled: process.env.CIRCUIT_BREAKER_ENABLED !== 'false',
-        failureThreshold: process.env.CIRCUIT_BREAKER_THRESHOLD || process.env.MORO_CB_THRESHOLD,
-        resetTimeout: process.env.CIRCUIT_BREAKER_RESET || process.env.MORO_CB_RESET,
-        monitoringPeriod: process.env.CIRCUIT_BREAKER_MONITOR || process.env.MORO_CB_MONITOR,
+      security: {
+        cors: {
+          enabled: validateBoolean(
+            coerceEnvValue(process.env.CORS_ENABLED || process.env.MORO_CORS_ENABLED || '') ??
+              DEFAULT_CONFIG.security.cors.enabled,
+            'security.cors.enabled'
+          ),
+          origin:
+            process.env.CORS_ORIGIN ||
+            process.env.MORO_CORS_ORIGIN ||
+            DEFAULT_CONFIG.security.cors.origin,
+          methods: validateStringArray(
+            process.env.CORS_METHODS ||
+              process.env.MORO_CORS_METHODS ||
+              DEFAULT_CONFIG.security.cors.methods,
+            'security.cors.methods'
+          ),
+          allowedHeaders: validateStringArray(
+            process.env.CORS_HEADERS ||
+              process.env.MORO_CORS_HEADERS ||
+              DEFAULT_CONFIG.security.cors.allowedHeaders,
+            'security.cors.allowedHeaders'
+          ),
+          credentials: validateBoolean(
+            coerceEnvValue(
+              process.env.CORS_CREDENTIALS || process.env.MORO_CORS_CREDENTIALS || ''
+            ) ?? DEFAULT_CONFIG.security.cors.credentials,
+            'security.cors.credentials'
+          ),
+        },
+        helmet: {
+          enabled: validateBoolean(
+            coerceEnvValue(process.env.HELMET_ENABLED || process.env.MORO_HELMET_ENABLED || '') ??
+              DEFAULT_CONFIG.security.helmet.enabled,
+            'security.helmet.enabled'
+          ),
+          contentSecurityPolicy: validateBoolean(
+            coerceEnvValue(process.env.HELMET_CSP || process.env.MORO_HELMET_CSP || '') ??
+              DEFAULT_CONFIG.security.helmet.contentSecurityPolicy,
+            'security.helmet.contentSecurityPolicy'
+          ),
+          hsts: validateBoolean(
+            coerceEnvValue(process.env.HELMET_HSTS || process.env.MORO_HELMET_HSTS || '') ??
+              DEFAULT_CONFIG.security.helmet.hsts,
+            'security.helmet.hsts'
+          ),
+          noSniff: validateBoolean(
+            coerceEnvValue(process.env.HELMET_NO_SNIFF || process.env.MORO_HELMET_NO_SNIFF || '') ??
+              DEFAULT_CONFIG.security.helmet.noSniff,
+            'security.helmet.noSniff'
+          ),
+          frameguard: validateBoolean(
+            coerceEnvValue(
+              process.env.HELMET_FRAMEGUARD || process.env.MORO_HELMET_FRAMEGUARD || ''
+            ) ?? DEFAULT_CONFIG.security.helmet.frameguard,
+            'security.helmet.frameguard'
+          ),
+        },
+        rateLimit: {
+          global: {
+            enabled: validateBoolean(
+              coerceEnvValue(
+                process.env.GLOBAL_RATE_LIMIT_ENABLED ||
+                  process.env.MORO_GLOBAL_RATE_LIMIT_ENABLED ||
+                  ''
+              ) ?? DEFAULT_CONFIG.security.rateLimit.global.enabled,
+              'security.rateLimit.global.enabled'
+            ),
+            requests: validateNumber(
+              coerceEnvValue(
+                process.env.GLOBAL_RATE_LIMIT_REQUESTS ||
+                  process.env.MORO_GLOBAL_RATE_LIMIT_REQUESTS ||
+                  ''
+              ) || DEFAULT_CONFIG.security.rateLimit.global.requests,
+              'security.rateLimit.global.requests',
+              { min: 1 }
+            ),
+            window: validateNumber(
+              coerceEnvValue(
+                process.env.GLOBAL_RATE_LIMIT_WINDOW ||
+                  process.env.MORO_GLOBAL_RATE_LIMIT_WINDOW ||
+                  ''
+              ) || DEFAULT_CONFIG.security.rateLimit.global.window,
+              'security.rateLimit.global.window',
+              { min: 1000 }
+            ),
+          },
+        },
       },
-      clustering: {
-        enabled: process.env.CLUSTERING_ENABLED === 'true',
-        workers: process.env.CLUSTER_WORKERS || process.env.MORO_WORKERS,
+
+      external: {
+        stripe: {
+          secretKey: validateOptional(
+            process.env.STRIPE_SECRET_KEY,
+            validateString,
+            'external.stripe.secretKey'
+          ),
+          publishableKey: validateOptional(
+            process.env.STRIPE_PUBLISHABLE_KEY,
+            validateString,
+            'external.stripe.publishableKey'
+          ),
+          webhookSecret: validateOptional(
+            process.env.STRIPE_WEBHOOK_SECRET,
+            validateString,
+            'external.stripe.webhookSecret'
+          ),
+          apiVersion: validateString(
+            process.env.STRIPE_API_VERSION ||
+              DEFAULT_CONFIG.external.stripe?.apiVersion ||
+              '2023-10-16',
+            'external.stripe.apiVersion'
+          ),
+        },
+        paypal: {
+          clientId: validateOptional(
+            process.env.PAYPAL_CLIENT_ID,
+            validateString,
+            'external.paypal.clientId'
+          ),
+          clientSecret: validateOptional(
+            process.env.PAYPAL_CLIENT_SECRET,
+            validateString,
+            'external.paypal.clientSecret'
+          ),
+          webhookId: validateOptional(
+            process.env.PAYPAL_WEBHOOK_ID,
+            validateString,
+            'external.paypal.webhookId'
+          ),
+          environment: validateEnum(
+            process.env.PAYPAL_ENVIRONMENT ||
+              DEFAULT_CONFIG.external.paypal?.environment ||
+              'sandbox',
+            ['sandbox', 'production'] as const,
+            'external.paypal.environment'
+          ),
+        },
+        smtp: {
+          host: validateOptional(process.env.SMTP_HOST, validateString, 'external.smtp.host'),
+          port: validatePort(
+            process.env.SMTP_PORT || (DEFAULT_CONFIG.external.smtp?.port || 587).toString(),
+            'external.smtp.port'
+          ),
+          secure: validateBoolean(
+            coerceEnvValue(process.env.SMTP_SECURE || '') ??
+              (DEFAULT_CONFIG.external.smtp?.secure || false),
+            'external.smtp.secure'
+          ),
+          username: validateOptional(
+            process.env.SMTP_USERNAME,
+            validateString,
+            'external.smtp.username'
+          ),
+          password: validateOptional(
+            process.env.SMTP_PASSWORD,
+            validateString,
+            'external.smtp.password'
+          ),
+        },
       },
-    },
-  };
 
-  // Validate and transform configuration using Zod
-  try {
-    const validatedConfig = ConfigSchema.parse(envConfig);
+      performance: {
+        compression: {
+          enabled: validateBoolean(
+            coerceEnvValue(
+              process.env.COMPRESSION_ENABLED || process.env.MORO_COMPRESSION_ENABLED || ''
+            ) ?? DEFAULT_CONFIG.performance.compression.enabled,
+            'performance.compression.enabled'
+          ),
+          level: validateNumber(
+            coerceEnvValue(
+              process.env.COMPRESSION_LEVEL || process.env.MORO_COMPRESSION_LEVEL || ''
+            ) || DEFAULT_CONFIG.performance.compression.level,
+            'performance.compression.level',
+            { min: 1, max: 9 }
+          ),
+          threshold: validateNumber(
+            coerceEnvValue(
+              process.env.COMPRESSION_THRESHOLD || process.env.MORO_COMPRESSION_THRESHOLD || ''
+            ) || DEFAULT_CONFIG.performance.compression.threshold,
+            'performance.compression.threshold',
+            { min: 0 }
+          ),
+        },
+        circuitBreaker: {
+          enabled: validateBoolean(
+            coerceEnvValue(
+              process.env.CIRCUIT_BREAKER_ENABLED || process.env.MORO_CIRCUIT_BREAKER_ENABLED || ''
+            ) ?? DEFAULT_CONFIG.performance.circuitBreaker.enabled,
+            'performance.circuitBreaker.enabled'
+          ),
+          failureThreshold: validateNumber(
+            coerceEnvValue(
+              process.env.CIRCUIT_BREAKER_THRESHOLD ||
+                process.env.MORO_CIRCUIT_BREAKER_THRESHOLD ||
+                ''
+            ) || DEFAULT_CONFIG.performance.circuitBreaker.failureThreshold,
+            'performance.circuitBreaker.failureThreshold',
+            { min: 1 }
+          ),
+          resetTimeout: validateNumber(
+            coerceEnvValue(
+              process.env.CIRCUIT_BREAKER_RESET || process.env.MORO_CIRCUIT_BREAKER_RESET || ''
+            ) || DEFAULT_CONFIG.performance.circuitBreaker.resetTimeout,
+            'performance.circuitBreaker.resetTimeout',
+            { min: 1000 }
+          ),
+          monitoringPeriod: validateNumber(
+            coerceEnvValue(
+              process.env.CIRCUIT_BREAKER_MONITOR || process.env.MORO_CIRCUIT_BREAKER_MONITOR || ''
+            ) || DEFAULT_CONFIG.performance.circuitBreaker.monitoringPeriod,
+            'performance.circuitBreaker.monitoringPeriod',
+            { min: 1000 }
+          ),
+        },
+        clustering: {
+          enabled: validateBoolean(
+            coerceEnvValue(
+              process.env.CLUSTERING_ENABLED || process.env.MORO_CLUSTERING_ENABLED || ''
+            ) ?? DEFAULT_CONFIG.performance.clustering.enabled,
+            'performance.clustering.enabled'
+          ),
+          workers:
+            process.env.CLUSTERING_WORKERS === 'auto' ||
+            process.env.MORO_CLUSTERING_WORKERS === 'auto'
+              ? 'auto'
+              : validateNumber(
+                  coerceEnvValue(
+                    process.env.CLUSTERING_WORKERS || process.env.MORO_CLUSTERING_WORKERS || ''
+                  ) || DEFAULT_CONFIG.performance.clustering.workers,
+                  'performance.clustering.workers',
+                  { min: 1 }
+                ),
+        },
+      },
+    };
 
-    logger.info('Configuration loaded and validated successfully');
+    logger.info('Configuration loaded and validated successfully with TypeScript');
     logger.debug(
-      'Configuration details:',
+      'Configuration summary:',
       JSON.stringify({
-        server: {
-          port: validatedConfig.server.port,
-          environment: validatedConfig.server.environment,
-        },
+        server: { port: config.server.port, environment: config.server.environment },
         serviceDiscovery: {
-          enabled: validatedConfig.serviceDiscovery.enabled,
-          type: validatedConfig.serviceDiscovery.type,
+          enabled: config.serviceDiscovery.enabled,
+          type: config.serviceDiscovery.type,
         },
         modules: {
-          cacheEnabled: validatedConfig.modules.cache.enabled,
-          rateLimitEnabled: validatedConfig.modules.rateLimit.enabled,
+          cache: config.modules.cache.enabled,
+          rateLimit: config.modules.rateLimit.enabled,
+          validation: config.modules.validation.enabled,
         },
       })
     );
 
-    return validatedConfig;
+    return config;
   } catch (error) {
     logger.error('❌ Configuration validation failed');
 
-    if (error instanceof ZodError) {
-      logger.error('Configuration errors:');
-      error.issues.forEach((err: any) => {
-        const path = err.path.join('.');
-        logger.error(`  - ${path}: ${err.message}`);
+    if (error instanceof ConfigValidationError) {
+      logger.error(`Configuration error in '${error.field}': ${error.message}`);
+      logger.error(`  Value: ${JSON.stringify(error.value)}`);
 
-        // Provide helpful hints for common errors
-        if (path.includes('port') && err.code === 'invalid_type') {
-          logger.error(`    Hint: PORT must be a number between 1 and 65535`);
-        }
-        if (path.includes('url') && err.code === 'invalid_string') {
-          logger.error(`    Hint: URLs must include protocol (http:// or https://)`);
-        }
-        if (path.includes('environment') && err.code === 'invalid_enum_value') {
-          logger.error(`    Hint: NODE_ENV must be one of: development, staging, production`);
-        }
-      });
-
-      logger.error('\nConfiguration Help:');
-      logger.error('  - Use MORO_* prefixed environment variables for framework-specific config');
-      logger.error('  - Check .env.example for available configuration options');
-      logger.error('  - See documentation for detailed configuration guide');
+      // Provide helpful hints
+      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');
+      }
     } else {
       logger.error('Unexpected configuration error:', String(error));
     }
 
-    process.exit(1);
-  }
-}
-
-/**
- * Parse JSON environment variable safely
- */
-function parseJsonEnv(value: string | undefined, defaultValue: any): any {
-  if (!value) return defaultValue;
-
-  try {
-    return JSON.parse(value);
-  } catch {
-    logger.warn(`Invalid JSON in environment variable, using default:`, value);
-    return defaultValue;
-  }
-}
+    logger.error('\nConfiguration Help:');
+    logger.error('  - Use MORO_* prefixed environment variables for framework-specific config');
+    logger.error('  - Check .env.example for available configuration options');
+    logger.error('  - See documentation for detailed configuration guide');
 
-/**
- * Parse comma-separated array environment variable
- */
-function parseArrayEnv(value: string | undefined): string[] | undefined {
-  if (!value) return undefined;
-  return value
-    .split(',')
-    .map(item => item.trim())
-    .filter(Boolean);
-}
-
-/**
- * Parse array or string environment variable
- */
-function parseArrayOrString(value: string | undefined): string | string[] | boolean | undefined {
-  if (!value) return undefined;
-
-  // If it contains commas, treat as array
-  if (value.includes(',')) {
-    return parseArrayEnv(value);
-  }
-
-  // Special boolean values
-  if (value === 'true') return true;
-  if (value === 'false') return false;
-
-  return value;
-}
-
-/**
- * Get environment variable with multiple possible names
- */
-function getEnvVar(...names: (string | undefined)[]): string | undefined {
-  for (const name of names) {
-    if (name && process.env[name]) {
-      return process.env[name];
-    }
+    process.exit(1);
   }
-  return undefined;
 }