@morojs/moro 1.6.1 → 1.6.2

package/src/types/config.ts

@@ -3,9 +3,24 @@
 export interface ServerConfig {
   port: number;
   host: string;
-  environment: 'development' | 'staging' | 'production';
   maxConnections: number;
   timeout: number;
+  bodySizeLimit: string;
+  requestTracking: {
+    enabled: boolean;
+  };
+  requestLogging: {
+    enabled: boolean;
+  };
+  errorBoundary: {
+    enabled: boolean;
+  };
+  useUWebSockets?: boolean; // Enable uWebSockets for both HTTP and WebSocket
+  ssl?: {
+    key_file_name?: string;
+    cert_file_name?: string;
+    passphrase?: string;
+  };
 }
 
 export interface ServiceDiscoveryConfig {
@@ -19,7 +34,7 @@ export interface ServiceDiscoveryConfig {
 
 export interface DatabaseConfig {
   url?: string;
-  redis: {
+  redis?: {
     url: string;
     maxRetries: number;
     retryDelay: number;
@@ -35,6 +50,28 @@ export interface DatabaseConfig {
     acquireTimeout: number;
     timeout: number;
   };
+  postgresql?: {
+    host: string;
+    port: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    connectionLimit: number;
+    ssl?: boolean;
+  };
+  sqlite?: {
+    filename: string;
+    memory?: boolean;
+    verbose?: boolean;
+  };
+  mongodb?: {
+    url?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+  };
 }
 
 export interface ModuleDefaultsConfig {
@@ -56,6 +93,18 @@ export interface ModuleDefaultsConfig {
     stripUnknown: boolean;
     abortEarly: boolean;
   };
+  autoDiscovery: {
+    enabled: boolean;
+    paths: string[];
+    patterns: string[];
+    recursive: boolean;
+    loadingStrategy: 'eager' | 'lazy' | 'conditional';
+    watchForChanges: boolean;
+    ignorePatterns: string[];
+    loadOrder: 'alphabetical' | 'dependency' | 'custom';
+    failOnError: boolean;
+    maxDepth: number;
+  };
 }
 
 export interface LoggingConfig {
@@ -141,6 +190,28 @@ export interface PerformanceConfig {
   clustering: {
     enabled: boolean;
     workers: number | 'auto';
+    memoryPerWorkerGB?: number;
+  };
+}
+
+export interface WebSocketConfig {
+  enabled: boolean;
+  adapter?: string | 'socket.io' | 'ws' | 'uws';
+  compression?: boolean;
+  customIdGenerator?: () => string;
+  options?: {
+    cors?: {
+      origin?: string | string[];
+      credentials?: boolean;
+    };
+    path?: string;
+    maxPayloadLength?: number;
+    idleTimeout?: number;
+    ssl?: {
+      key_file_name?: string;
+      cert_file_name?: string;
+      passphrase?: string;
+    };
   };
 }
 
@@ -154,4 +225,5 @@ export interface AppConfig {
   security: SecurityConfig;
   external: ExternalServicesConfig;
   performance: PerformanceConfig;
+  websocket: WebSocketConfig;
 }

package/src/types/core.ts

@@ -1,56 +1,58 @@
 // Core Framework Types
-import { RuntimeConfig } from './runtime';
-import { LogLevel, LoggerOptions } from './logger';
+import { RuntimeConfig } from './runtime.js';
+import { LogLevel, LoggerOptions } from './logger.js';
+import { AppConfig } from './config.js';
 
 export interface MoroOptions {
-  autoDiscover?: boolean;
-  modulesPath?: string;
+  autoDiscover?:
+    | boolean
+    | {
+        enabled?: boolean;
+        paths?: string[];
+        patterns?: string[];
+        recursive?: boolean;
+        loadingStrategy?: 'eager' | 'lazy' | 'conditional';
+        watchForChanges?: boolean;
+        ignorePatterns?: string[];
+        loadOrder?: 'alphabetical' | 'dependency' | 'custom';
+        failOnError?: boolean;
+        maxDepth?: number;
+      };
+  modulesPath?: string; // Deprecated: use autoDiscover.paths instead
   middleware?: any[];
-  database?: any;
+
+  // Runtime configuration
+  runtime?: RuntimeConfig;
+
+  // HTTP/WebSocket options
+  http2?: boolean;
+  https?: {
+    key: string | Buffer;
+    cert: string | Buffer;
+    ca?: string | Buffer;
+  };
+  websocket?:
+    | {
+        enabled?: boolean;
+        adapter?: any;
+        compression?: boolean;
+        customIdGenerator?: () => string;
+        options?: any;
+      }
+    | false;
+
+  // Simplified config options (these map to the full config)
   cors?: boolean | object;
   compression?: boolean | object;
   helmet?: boolean | object;
-  // Runtime configuration
-  runtime?: RuntimeConfig;
-  // Logger configuration
   logger?: LoggerOptions | boolean;
-  // Module configuration
-  modules?: {
-    cache?: {
-      enabled?: boolean;
-      defaultTtl?: number;
-      maxSize?: number;
-      strategy?: 'lru' | 'lfu' | 'fifo';
-    };
-    rateLimit?: {
-      enabled?: boolean;
-      defaultRequests?: number;
-      defaultWindow?: number;
-      skipSuccessfulRequests?: boolean;
-      skipFailedRequests?: boolean;
-    };
-    validation?: {
-      enabled?: boolean;
-      stripUnknown?: boolean;
-      abortEarly?: boolean;
-    };
-  };
-  // Performance configuration
-  performance?: {
-    clustering?: {
-      enabled?: boolean;
-      workers?: number | 'auto';
-    };
-    compression?: {
-      enabled?: boolean;
-      level?: number;
-      threshold?: number;
-    };
-    circuitBreaker?: {
-      enabled?: boolean;
-      failureThreshold?: number;
-      resetTimeout?: number;
-      monitoringPeriod?: number;
-    };
-  };
+
+  // Direct config overrides (partial)
+  server?: Partial<AppConfig['server']>;
+  database?: Partial<AppConfig['database']>;
+  modules?: Partial<AppConfig['modules']>;
+  logging?: Partial<AppConfig['logging']>;
+  security?: Partial<AppConfig['security']>;
+  external?: Partial<AppConfig['external']>;
+  performance?: Partial<AppConfig['performance']>;
 }

package/src/types/hooks.ts

@@ -1,5 +1,5 @@
 // Hooks and Middleware Types
-import { HttpRequest, HttpResponse } from './http';
+import { HttpRequest, HttpResponse } from '../core/http/index.js';
 
 export type HookFunction = (...args: any[]) => Promise<any> | any;
 

package/src/types/http.ts

@@ -22,9 +22,20 @@ export interface CookieOptions {
   sameSite?: 'strict' | 'lax' | 'none';
   domain?: string;
   path?: string;
+  // Security options
+  critical?: boolean; // Mark as critical for security (throws on late set)
+  throwOnLateSet?: boolean; // Force throw if headers already sent
 }
 
-export interface HttpResponse extends ServerResponse {
+export interface ResponseState {
+  headersSent: boolean;
+  statusCode: number;
+  headers: Record<string, any>;
+  finished: boolean;
+  writable: boolean;
+}
+
+export interface MoroResponseMethods {
   json(data: any): void;
   status(code: number): HttpResponse;
   send(data: string | Buffer): void;
@@ -33,8 +44,19 @@ export interface HttpResponse extends ServerResponse {
   redirect(url: string, status?: number): void;
   sendFile(filePath: string): Promise<void>;
   render?(template: string, data?: any): Promise<void>;
+
+  // Header management utilities
+  hasHeader(name: string): boolean;
+  setBulkHeaders(headers: Record<string, string | number>): HttpResponse;
+  appendHeader(name: string, value: string | string[]): HttpResponse;
+
+  // Response state utilities
+  canSetHeaders(): boolean;
+  getResponseState(): ResponseState;
 }
 
+export type HttpResponse = ServerResponse & MoroResponseMethods;
+
 export type HttpHandler = (req: HttpRequest, res: HttpResponse) => Promise<void> | void;
 export type Middleware = (
   req: HttpRequest,

package/src/types/logger.ts

@@ -30,6 +30,7 @@ export interface LoggerOptions {
   outputs?: LogOutput[];
   filters?: LogFilter[];
   maxEntries?: number;
+  maxBufferSize?: number;
 }
 
 export interface LogOutput {
@@ -60,11 +61,17 @@ export interface Logger {
 
   // Configuration
   setLevel(level: LogLevel): void;
+  getLevel(): LogLevel;
   addOutput(output: LogOutput): void;
   removeOutput(name: string): void;
   addFilter(filter: LogFilter): void;
   removeFilter(name: string): void;
 
+  // Cleanup
+  flush(): void;
+  flushBuffer(): void;
+  destroy(): void;
+
   // Metrics and history
   getHistory(count?: number): LogEntry[];
   getMetrics(): LogMetrics;
@@ -78,6 +85,7 @@ export interface LogMetrics {
   averageLogRate: number;
   errorRate: number;
   memoryUsage: number;
+  outputErrors?: Record<string, number>;
 }
 
 export interface ColorScheme {
@@ -90,4 +98,5 @@ export interface ColorScheme {
   context: string;
   metadata: string;
   performance: string;
+  reset: string;
 }

package/src/types/module.ts

@@ -7,6 +7,11 @@ export interface ModuleRoute {
   cache?: { ttl: number; key?: string };
   rateLimit?: { requests: number; window: number };
   middleware?: string[];
+  auth?: {
+    roles?: string[];
+    permissions?: string[];
+    optional?: boolean;
+  };
 }
 
 export interface ModuleSocket {
@@ -57,6 +62,13 @@ export interface InternalRouteDefinition {
   validation?: any;
   cache?: CacheConfig;
   rateLimit?: RateLimitConfig;
+  auth?: {
+    roles?: string[];
+    permissions?: string[];
+    optional?: boolean;
+  };
+  // Allow additional properties for extensibility
+  [key: string]: any;
 }
 
 export interface WebSocketDefinition {

package/src/types/runtime.ts

@@ -1,5 +1,5 @@
 // Runtime abstraction types for multi-environment support
-import { HttpRequest, HttpResponse } from './http';
+import { HttpRequest, HttpResponse } from '../core/http/index.js';
 
 export type RuntimeType = 'node' | 'vercel-edge' | 'aws-lambda' | 'cloudflare-workers';
 

package/tsconfig.json

@@ -2,7 +2,8 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "commonjs",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "lib": ["ES2022"],
     "outDir": "./dist",
     "rootDir": "./src",
@@ -14,7 +15,8 @@
     "emitDecoratorMetadata": true,
     "resolveJsonModule": true,
     "declaration": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "isolatedModules": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/dist/core/config/loader.d.ts

@@ -1,7 +0,0 @@
-import { AppConfig } from './schema';
-/**
- * Load and validate configuration from config files and environment variables
- * Priority: Environment Variables > Config File > Schema Defaults
- * @returns Validated and typed application configuration
- */
-export declare function loadConfig(): AppConfig;

package/dist/core/config/loader.js

@@ -1,269 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadConfig = loadConfig;
-// Configuration Loader - Environment Variable Mapping and Validation
-const schema_1 = require("./schema");
-const validation_1 = require("./validation");
-const logger_1 = require("../logger");
-const file_loader_1 = require("./file-loader");
-const logger = (0, logger_1.createFrameworkLogger)('Config');
-/**
- * Load and validate configuration from config files and environment variables
- * Priority: Environment Variables > Config File > Schema Defaults
- * @returns Validated and typed application configuration
- */
-function loadConfig() {
-    logger.debug('Loading configuration with TypeScript validation');
-    // First, try to load from config file and apply as environment variables
-    try {
-        const fileConfig = (0, file_loader_1.loadConfigFileSync)();
-        if (fileConfig) {
-            logger.debug('Applying config file values as environment variables');
-            (0, file_loader_1.applyConfigAsEnvironmentVariables)(fileConfig);
-        }
-    }
-    catch (error) {
-        logger.warn('Config file loading failed, continuing with environment variables only:', String(error));
-    }
-    try {
-        // Build configuration using robust validation functions
-        const config = {
-            server: {
-                port: (0, validation_1.validatePort)((0, validation_1.coerceEnvValue)(process.env.PORT || process.env.MORO_PORT || '') ||
-                    schema_1.DEFAULT_CONFIG.server.port, 'server.port'),
-                host: (0, validation_1.validateString)(process.env.HOST || process.env.MORO_HOST || schema_1.DEFAULT_CONFIG.server.host, 'server.host'),
-                environment: (0, validation_1.validateEnum)(process.env.NODE_ENV || process.env.MORO_ENV || schema_1.DEFAULT_CONFIG.server.environment, ['development', 'staging', 'production'], 'server.environment'),
-                maxConnections: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.MAX_CONNECTIONS || process.env.MORO_MAX_CONNECTIONS || '') ||
-                    schema_1.DEFAULT_CONFIG.server.maxConnections, 'server.maxConnections', { min: 1 }),
-                timeout: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.REQUEST_TIMEOUT || process.env.MORO_TIMEOUT || '') ||
-                    schema_1.DEFAULT_CONFIG.server.timeout, 'server.timeout', { min: 1000 }),
-            },
-            serviceDiscovery: {
-                enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.SERVICE_DISCOVERY_ENABLED || process.env.MORO_SERVICE_DISCOVERY || '') ?? schema_1.DEFAULT_CONFIG.serviceDiscovery.enabled, 'serviceDiscovery.enabled'),
-                type: (0, validation_1.validateEnum)(process.env.DISCOVERY_TYPE ||
-                    process.env.MORO_DISCOVERY_TYPE ||
-                    schema_1.DEFAULT_CONFIG.serviceDiscovery.type, ['memory', 'consul', 'kubernetes'], 'serviceDiscovery.type'),
-                consulUrl: (0, validation_1.validateUrl)(process.env.CONSUL_URL ||
-                    process.env.MORO_CONSUL_URL ||
-                    schema_1.DEFAULT_CONFIG.serviceDiscovery.consulUrl, 'serviceDiscovery.consulUrl'),
-                kubernetesNamespace: (0, validation_1.validateString)(process.env.KUBERNETES_NAMESPACE ||
-                    process.env.MORO_KUBERNETES_NAMESPACE ||
-                    schema_1.DEFAULT_CONFIG.serviceDiscovery.kubernetesNamespace, 'serviceDiscovery.kubernetesNamespace'),
-                healthCheckInterval: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.HEALTH_CHECK_INTERVAL || process.env.MORO_HEALTH_CHECK_INTERVAL || '') || schema_1.DEFAULT_CONFIG.serviceDiscovery.healthCheckInterval, 'serviceDiscovery.healthCheckInterval', { min: 1000 }),
-                retryAttempts: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.RETRY_ATTEMPTS || process.env.MORO_RETRY_ATTEMPTS || '') ||
-                    schema_1.DEFAULT_CONFIG.serviceDiscovery.retryAttempts, 'serviceDiscovery.retryAttempts', { min: 0 }),
-            },
-            database: {
-                url: (0, validation_1.validateOptional)(process.env.DATABASE_URL, validation_1.validateString, 'database.url'),
-                redis: {
-                    url: (0, validation_1.validateString)(process.env.REDIS_URL ||
-                        process.env.MORO_REDIS_URL ||
-                        schema_1.DEFAULT_CONFIG.database.redis.url, 'database.redis.url'),
-                    maxRetries: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.REDIS_MAX_RETRIES || process.env.MORO_REDIS_RETRIES || '') ||
-                        schema_1.DEFAULT_CONFIG.database.redis.maxRetries, 'database.redis.maxRetries', { min: 0 }),
-                    retryDelay: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.REDIS_RETRY_DELAY || process.env.MORO_REDIS_DELAY || '') ||
-                        schema_1.DEFAULT_CONFIG.database.redis.retryDelay, 'database.redis.retryDelay', { min: 100 }),
-                    keyPrefix: (0, validation_1.validateString)(process.env.REDIS_KEY_PREFIX ||
-                        process.env.MORO_REDIS_PREFIX ||
-                        schema_1.DEFAULT_CONFIG.database.redis.keyPrefix, 'database.redis.keyPrefix'),
-                },
-                mysql: process.env.MYSQL_HOST
-                    ? {
-                        host: (0, validation_1.validateString)(process.env.MYSQL_HOST, 'database.mysql.host'),
-                        port: (0, validation_1.validatePort)(process.env.MYSQL_PORT || process.env.MORO_MYSQL_PORT || '3306', 'database.mysql.port'),
-                        database: (0, validation_1.validateOptional)(process.env.MYSQL_DATABASE || process.env.MORO_MYSQL_DB, validation_1.validateString, 'database.mysql.database'),
-                        username: (0, validation_1.validateOptional)(process.env.MYSQL_USERNAME || process.env.MORO_MYSQL_USER, validation_1.validateString, 'database.mysql.username'),
-                        password: (0, validation_1.validateOptional)(process.env.MYSQL_PASSWORD || process.env.MORO_MYSQL_PASS, validation_1.validateString, 'database.mysql.password'),
-                        connectionLimit: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.MYSQL_CONNECTION_LIMIT || process.env.MORO_MYSQL_CONNECTIONS || '') || 10, 'database.mysql.connectionLimit', { min: 1 }),
-                        acquireTimeout: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.MYSQL_ACQUIRE_TIMEOUT || process.env.MORO_MYSQL_ACQUIRE_TIMEOUT || '') || 60000, 'database.mysql.acquireTimeout', { min: 1000 }),
-                        timeout: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.MYSQL_TIMEOUT || process.env.MORO_MYSQL_TIMEOUT || '') ||
-                            60000, 'database.mysql.timeout', { min: 1000 }),
-                    }
-                    : undefined,
-            },
-            modules: {
-                cache: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.CACHE_ENABLED || process.env.MORO_CACHE_ENABLED || '') ??
-                        schema_1.DEFAULT_CONFIG.modules.cache.enabled, 'modules.cache.enabled'),
-                    defaultTtl: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.CACHE_TTL || process.env.MORO_CACHE_TTL || '') ||
-                        schema_1.DEFAULT_CONFIG.modules.cache.defaultTtl, 'modules.cache.defaultTtl', { min: 0 }),
-                    maxSize: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.CACHE_MAX_SIZE || process.env.MORO_CACHE_MAX_SIZE || '') ||
-                        schema_1.DEFAULT_CONFIG.modules.cache.maxSize, 'modules.cache.maxSize', { min: 1 }),
-                    strategy: (0, validation_1.validateEnum)(process.env.CACHE_STRATEGY ||
-                        process.env.MORO_CACHE_STRATEGY ||
-                        schema_1.DEFAULT_CONFIG.modules.cache.strategy, ['lru', 'lfu', 'fifo'], 'modules.cache.strategy'),
-                },
-                rateLimit: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.RATE_LIMIT_ENABLED || process.env.MORO_RATE_LIMIT_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.modules.rateLimit.enabled, 'modules.rateLimit.enabled'),
-                    defaultRequests: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.RATE_LIMIT_REQUESTS || process.env.MORO_RATE_LIMIT_REQUESTS || '') || schema_1.DEFAULT_CONFIG.modules.rateLimit.defaultRequests, 'modules.rateLimit.defaultRequests', { min: 1 }),
-                    defaultWindow: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.RATE_LIMIT_WINDOW || process.env.MORO_RATE_LIMIT_WINDOW || '') || schema_1.DEFAULT_CONFIG.modules.rateLimit.defaultWindow, 'modules.rateLimit.defaultWindow', { min: 1000 }),
-                    skipSuccessfulRequests: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.RATE_LIMIT_SKIP_SUCCESS || process.env.MORO_RATE_LIMIT_SKIP_SUCCESS || '') ?? schema_1.DEFAULT_CONFIG.modules.rateLimit.skipSuccessfulRequests, 'modules.rateLimit.skipSuccessfulRequests'),
-                    skipFailedRequests: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.RATE_LIMIT_SKIP_FAILED || process.env.MORO_RATE_LIMIT_SKIP_FAILED || '') ?? schema_1.DEFAULT_CONFIG.modules.rateLimit.skipFailedRequests, 'modules.rateLimit.skipFailedRequests'),
-                },
-                validation: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.VALIDATION_ENABLED || process.env.MORO_VALIDATION_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.modules.validation.enabled, 'modules.validation.enabled'),
-                    stripUnknown: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.VALIDATION_STRIP_UNKNOWN ||
-                        process.env.MORO_VALIDATION_STRIP_UNKNOWN ||
-                        '') ?? schema_1.DEFAULT_CONFIG.modules.validation.stripUnknown, 'modules.validation.stripUnknown'),
-                    abortEarly: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.VALIDATION_ABORT_EARLY || process.env.MORO_VALIDATION_ABORT_EARLY || '') ?? schema_1.DEFAULT_CONFIG.modules.validation.abortEarly, 'modules.validation.abortEarly'),
-                },
-            },
-            logging: {
-                level: (0, validation_1.validateEnum)(process.env.LOG_LEVEL || process.env.MORO_LOG_LEVEL || schema_1.DEFAULT_CONFIG.logging.level, ['debug', 'info', 'warn', 'error', 'fatal'], 'logging.level'),
-                format: (0, validation_1.validateEnum)(process.env.LOG_FORMAT || process.env.MORO_LOG_FORMAT || schema_1.DEFAULT_CONFIG.logging.format, ['pretty', 'json', 'compact'], 'logging.format'),
-                enableColors: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.LOG_COLORS || process.env.MORO_LOG_COLORS || '') ??
-                    schema_1.DEFAULT_CONFIG.logging.enableColors, 'logging.enableColors'),
-                enableTimestamp: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.LOG_TIMESTAMP || process.env.MORO_LOG_TIMESTAMP || '') ??
-                    schema_1.DEFAULT_CONFIG.logging.enableTimestamp, 'logging.enableTimestamp'),
-                enableContext: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.LOG_CONTEXT || process.env.MORO_LOG_CONTEXT || '') ??
-                    schema_1.DEFAULT_CONFIG.logging.enableContext, 'logging.enableContext'),
-                outputs: {
-                    console: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.LOG_CONSOLE || process.env.MORO_LOG_CONSOLE || '') ??
-                        schema_1.DEFAULT_CONFIG.logging.outputs.console, 'logging.outputs.console'),
-                    file: {
-                        enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.LOG_FILE_ENABLED || process.env.MORO_LOG_FILE_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.logging.outputs.file.enabled, 'logging.outputs.file.enabled'),
-                        path: (0, validation_1.validateString)(process.env.LOG_FILE_PATH ||
-                            process.env.MORO_LOG_FILE_PATH ||
-                            schema_1.DEFAULT_CONFIG.logging.outputs.file.path, 'logging.outputs.file.path'),
-                        maxSize: (0, validation_1.validateString)(process.env.LOG_FILE_MAX_SIZE ||
-                            process.env.MORO_LOG_FILE_MAX_SIZE ||
-                            schema_1.DEFAULT_CONFIG.logging.outputs.file.maxSize, 'logging.outputs.file.maxSize'),
-                        maxFiles: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.LOG_FILE_MAX_FILES || process.env.MORO_LOG_FILE_MAX_FILES || '') || schema_1.DEFAULT_CONFIG.logging.outputs.file.maxFiles, 'logging.outputs.file.maxFiles', { min: 1 }),
-                    },
-                    webhook: {
-                        enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.LOG_WEBHOOK_ENABLED || process.env.MORO_LOG_WEBHOOK_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.logging.outputs.webhook.enabled, 'logging.outputs.webhook.enabled'),
-                        url: (0, validation_1.validateOptional)(process.env.LOG_WEBHOOK_URL || process.env.MORO_LOG_WEBHOOK_URL, validation_1.validateUrl, 'logging.outputs.webhook.url'),
-                        headers: schema_1.DEFAULT_CONFIG.logging.outputs.webhook.headers,
-                    },
-                },
-            },
-            security: {
-                cors: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.CORS_ENABLED || process.env.MORO_CORS_ENABLED || '') ??
-                        schema_1.DEFAULT_CONFIG.security.cors.enabled, 'security.cors.enabled'),
-                    origin: process.env.CORS_ORIGIN ||
-                        process.env.MORO_CORS_ORIGIN ||
-                        schema_1.DEFAULT_CONFIG.security.cors.origin,
-                    methods: (0, validation_1.validateStringArray)(process.env.CORS_METHODS ||
-                        process.env.MORO_CORS_METHODS ||
-                        schema_1.DEFAULT_CONFIG.security.cors.methods, 'security.cors.methods'),
-                    allowedHeaders: (0, validation_1.validateStringArray)(process.env.CORS_HEADERS ||
-                        process.env.MORO_CORS_HEADERS ||
-                        schema_1.DEFAULT_CONFIG.security.cors.allowedHeaders, 'security.cors.allowedHeaders'),
-                    credentials: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.CORS_CREDENTIALS || process.env.MORO_CORS_CREDENTIALS || '') ?? schema_1.DEFAULT_CONFIG.security.cors.credentials, 'security.cors.credentials'),
-                },
-                helmet: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.HELMET_ENABLED || process.env.MORO_HELMET_ENABLED || '') ??
-                        schema_1.DEFAULT_CONFIG.security.helmet.enabled, 'security.helmet.enabled'),
-                    contentSecurityPolicy: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.HELMET_CSP || process.env.MORO_HELMET_CSP || '') ??
-                        schema_1.DEFAULT_CONFIG.security.helmet.contentSecurityPolicy, 'security.helmet.contentSecurityPolicy'),
-                    hsts: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.HELMET_HSTS || process.env.MORO_HELMET_HSTS || '') ??
-                        schema_1.DEFAULT_CONFIG.security.helmet.hsts, 'security.helmet.hsts'),
-                    noSniff: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.HELMET_NO_SNIFF || process.env.MORO_HELMET_NO_SNIFF || '') ??
-                        schema_1.DEFAULT_CONFIG.security.helmet.noSniff, 'security.helmet.noSniff'),
-                    frameguard: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.HELMET_FRAMEGUARD || process.env.MORO_HELMET_FRAMEGUARD || '') ?? schema_1.DEFAULT_CONFIG.security.helmet.frameguard, 'security.helmet.frameguard'),
-                },
-                rateLimit: {
-                    global: {
-                        enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.GLOBAL_RATE_LIMIT_ENABLED ||
-                            process.env.MORO_GLOBAL_RATE_LIMIT_ENABLED ||
-                            '') ?? schema_1.DEFAULT_CONFIG.security.rateLimit.global.enabled, 'security.rateLimit.global.enabled'),
-                        requests: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.GLOBAL_RATE_LIMIT_REQUESTS ||
-                            process.env.MORO_GLOBAL_RATE_LIMIT_REQUESTS ||
-                            '') || schema_1.DEFAULT_CONFIG.security.rateLimit.global.requests, 'security.rateLimit.global.requests', { min: 1 }),
-                        window: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.GLOBAL_RATE_LIMIT_WINDOW ||
-                            process.env.MORO_GLOBAL_RATE_LIMIT_WINDOW ||
-                            '') || schema_1.DEFAULT_CONFIG.security.rateLimit.global.window, 'security.rateLimit.global.window', { min: 1000 }),
-                    },
-                },
-            },
-            external: {
-                stripe: {
-                    secretKey: (0, validation_1.validateOptional)(process.env.STRIPE_SECRET_KEY, validation_1.validateString, 'external.stripe.secretKey'),
-                    publishableKey: (0, validation_1.validateOptional)(process.env.STRIPE_PUBLISHABLE_KEY, validation_1.validateString, 'external.stripe.publishableKey'),
-                    webhookSecret: (0, validation_1.validateOptional)(process.env.STRIPE_WEBHOOK_SECRET, validation_1.validateString, 'external.stripe.webhookSecret'),
-                    apiVersion: (0, validation_1.validateString)(process.env.STRIPE_API_VERSION ||
-                        schema_1.DEFAULT_CONFIG.external.stripe?.apiVersion ||
-                        '2023-10-16', 'external.stripe.apiVersion'),
-                },
-                paypal: {
-                    clientId: (0, validation_1.validateOptional)(process.env.PAYPAL_CLIENT_ID, validation_1.validateString, 'external.paypal.clientId'),
-                    clientSecret: (0, validation_1.validateOptional)(process.env.PAYPAL_CLIENT_SECRET, validation_1.validateString, 'external.paypal.clientSecret'),
-                    webhookId: (0, validation_1.validateOptional)(process.env.PAYPAL_WEBHOOK_ID, validation_1.validateString, 'external.paypal.webhookId'),
-                    environment: (0, validation_1.validateEnum)(process.env.PAYPAL_ENVIRONMENT ||
-                        schema_1.DEFAULT_CONFIG.external.paypal?.environment ||
-                        'sandbox', ['sandbox', 'production'], 'external.paypal.environment'),
-                },
-                smtp: {
-                    host: (0, validation_1.validateOptional)(process.env.SMTP_HOST, validation_1.validateString, 'external.smtp.host'),
-                    port: (0, validation_1.validatePort)(process.env.SMTP_PORT || (schema_1.DEFAULT_CONFIG.external.smtp?.port || 587).toString(), 'external.smtp.port'),
-                    secure: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.SMTP_SECURE || '') ??
-                        (schema_1.DEFAULT_CONFIG.external.smtp?.secure || false), 'external.smtp.secure'),
-                    username: (0, validation_1.validateOptional)(process.env.SMTP_USERNAME, validation_1.validateString, 'external.smtp.username'),
-                    password: (0, validation_1.validateOptional)(process.env.SMTP_PASSWORD, validation_1.validateString, 'external.smtp.password'),
-                },
-            },
-            performance: {
-                compression: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.COMPRESSION_ENABLED || process.env.MORO_COMPRESSION_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.performance.compression.enabled, 'performance.compression.enabled'),
-                    level: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.COMPRESSION_LEVEL || process.env.MORO_COMPRESSION_LEVEL || '') || schema_1.DEFAULT_CONFIG.performance.compression.level, 'performance.compression.level', { min: 1, max: 9 }),
-                    threshold: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.COMPRESSION_THRESHOLD || process.env.MORO_COMPRESSION_THRESHOLD || '') || schema_1.DEFAULT_CONFIG.performance.compression.threshold, 'performance.compression.threshold', { min: 0 }),
-                },
-                circuitBreaker: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.CIRCUIT_BREAKER_ENABLED || process.env.MORO_CIRCUIT_BREAKER_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.performance.circuitBreaker.enabled, 'performance.circuitBreaker.enabled'),
-                    failureThreshold: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.CIRCUIT_BREAKER_THRESHOLD ||
-                        process.env.MORO_CIRCUIT_BREAKER_THRESHOLD ||
-                        '') || schema_1.DEFAULT_CONFIG.performance.circuitBreaker.failureThreshold, 'performance.circuitBreaker.failureThreshold', { min: 1 }),
-                    resetTimeout: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.CIRCUIT_BREAKER_RESET || process.env.MORO_CIRCUIT_BREAKER_RESET || '') || schema_1.DEFAULT_CONFIG.performance.circuitBreaker.resetTimeout, 'performance.circuitBreaker.resetTimeout', { min: 1000 }),
-                    monitoringPeriod: (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.CIRCUIT_BREAKER_MONITOR || process.env.MORO_CIRCUIT_BREAKER_MONITOR || '') || schema_1.DEFAULT_CONFIG.performance.circuitBreaker.monitoringPeriod, 'performance.circuitBreaker.monitoringPeriod', { min: 1000 }),
-                },
-                clustering: {
-                    enabled: (0, validation_1.validateBoolean)((0, validation_1.coerceEnvValue)(process.env.CLUSTERING_ENABLED || process.env.MORO_CLUSTERING_ENABLED || '') ?? schema_1.DEFAULT_CONFIG.performance.clustering.enabled, 'performance.clustering.enabled'),
-                    workers: process.env.CLUSTER_WORKERS === 'auto' || process.env.MORO_CLUSTER_WORKERS === 'auto'
-                        ? 'auto'
-                        : (0, validation_1.validateNumber)((0, validation_1.coerceEnvValue)(process.env.CLUSTER_WORKERS || process.env.MORO_CLUSTER_WORKERS || '') || schema_1.DEFAULT_CONFIG.performance.clustering.workers, 'performance.clustering.workers', { min: 1 }),
-                },
-            },
-        };
-        logger.info('Configuration loaded and validated successfully with TypeScript');
-        logger.debug('Configuration summary:', JSON.stringify({
-            server: { port: config.server.port, environment: config.server.environment },
-            serviceDiscovery: {
-                enabled: config.serviceDiscovery.enabled,
-                type: config.serviceDiscovery.type,
-            },
-            modules: {
-                cache: config.modules.cache.enabled,
-                rateLimit: config.modules.rateLimit.enabled,
-                validation: config.modules.validation.enabled,
-            },
-        }));
-        return config;
-    }
-    catch (error) {
-        logger.error('❌ Configuration validation failed');
-        if (error instanceof validation_1.ConfigValidationError) {
-            logger.error(`Configuration error in '${error.field}': ${error.message}`);
-            logger.error(`  Value: ${JSON.stringify(error.value)}`);
-            // 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));
-        }
-        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');
-        process.exit(1);
-    }
-}
-//# sourceMappingURL=loader.js.map