@morojs/moro 1.6.2 → 1.6.3

package/src/core/config/file-loader.ts

@@ -1,150 +0,0 @@
-// Configuration File Loader - Load moro.config.js/ts files
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { createRequire } from 'module';
-import { AppConfig } from './schema.js';
-import { createFrameworkLogger } from '../logger/index.js';
-
-const logger = createFrameworkLogger('ConfigFile');
-
-// Create require function for ESM to enable synchronous config loading
-// Use process.cwd() as base since we're loading with absolute paths anyway
-const moduleRequire = createRequire(join(process.cwd(), 'index.js'));
-
-/**
- * Supported configuration file names in order of preference
- */
-const CONFIG_FILES = ['moro.config.js', 'moro.config.ts'] as const;
-
-/**
- * Find and load configuration from moro.config.js (synchronously)
- * @param cwd Current working directory to search for config files
- * @returns Partial configuration object or null if no config file found
- */
-export function loadConfigFileSync(cwd: string = process.cwd()): Partial<AppConfig> | null {
-  const configFile = findConfigFile(cwd);
-
-  if (!configFile) {
-    logger.debug('No configuration file found');
-    return null;
-  }
-
-  logger.debug(`Loading configuration from: ${configFile}`);
-
-  try {
-    // Use createRequire to enable synchronous loading in ESM
-    // Clear the require cache to ensure fresh config on each load
-    delete moduleRequire.cache[moduleRequire.resolve(configFile)];
-
-    const configModule = moduleRequire(configFile);
-
-    // Handle ES module default export
-    const config = configModule.default || configModule;
-
-    if (!config || typeof config !== 'object') {
-      logger.warn(`Configuration file ${configFile} did not export a valid configuration object`);
-      return null;
-    }
-
-    logger.info(`Configuration loaded from: ${configFile}`);
-    return config;
-  } catch (error) {
-    logger.error(`Failed to load configuration file ${configFile}:`, String(error));
-    logger.warn('Falling back to environment variable configuration');
-    return null;
-  }
-}
-
-/**
- * Find and load configuration from moro.config.js or moro.config.ts (async)
- * @param cwd Current working directory to search for config files
- * @returns Partial configuration object or null if no config file found
- */
-export async function loadConfigFile(
-  cwd: string = process.cwd()
-): Promise<Partial<AppConfig> | null> {
-  const configFile = findConfigFile(cwd);
-
-  if (!configFile) {
-    logger.debug('No configuration file found');
-    return null;
-  }
-
-  logger.debug(`Loading configuration from: ${configFile}`);
-
-  try {
-    const config = await importConfigFile(configFile);
-
-    if (!config || typeof config !== 'object') {
-      logger.warn(`Configuration file ${configFile} did not export a valid configuration object`);
-      return null;
-    }
-
-    logger.info(`Configuration loaded from: ${configFile}`);
-    return config;
-  } catch (error) {
-    logger.error(`Failed to load configuration file ${configFile}:`, String(error));
-    logger.warn('Falling back to environment variable configuration');
-    return null;
-  }
-}
-
-/**
- * Find the first existing configuration file in the given directory
- */
-function findConfigFile(cwd: string): string | null {
-  for (const fileName of CONFIG_FILES) {
-    const filePath = join(cwd, fileName);
-    if (existsSync(filePath)) {
-      return filePath;
-    }
-  }
-  return null;
-}
-
-/**
- * Dynamically import a configuration file
- */
-async function importConfigFile(filePath: string): Promise<Partial<AppConfig> | null> {
-  const isTypeScript = filePath.endsWith('.ts');
-
-  if (isTypeScript) {
-    // For TypeScript files, we need to handle ts-node/tsx or similar
-    await setupTypeScriptLoader();
-  }
-
-  try {
-    // Use dynamic import to load the configuration
-    const configModule = await import(filePath);
-
-    // Handle both default export and module.exports
-    const config = configModule.default || configModule;
-
-    return config;
-  } catch (error) {
-    // If TypeScript loading fails, provide helpful error message
-    if (
-      isTypeScript &&
-      error instanceof Error &&
-      error.message.includes('Unknown file extension')
-    ) {
-      throw new Error(
-        `Failed to load TypeScript config file. Run your application with tsx or ts-node: "tsx your-app.ts" or "ts-node your-app.ts"`
-      );
-    }
-    throw error;
-  }
-}
-
-/**
- * Setup TypeScript loader for .ts config files
- * Note: This function is intentionally minimal because TypeScript config files
- * should be handled by the runtime environment (tsx, ts-node, etc.) when the
- * user runs their application, not by the framework itself.
- */
-async function setupTypeScriptLoader(): Promise<void> {
-  // No-op: TypeScript loading is handled by the runtime environment
-  // When users run `tsx moro.config.ts` or `ts-node moro.config.ts`,
-  // the TypeScript transpilation is already handled by those tools.
-  logger.debug('TypeScript config loading delegated to runtime environment');
-}

package/src/core/config/index.ts

@@ -1,109 +0,0 @@
-/**
- * Configuration System - Immutable Config with createApp Override Support
- *
- * This is the main entry point for the MoroJS configuration system.
- * It provides a clean, immutable configuration that is locked at createApp() time.
- *
- * Key Features:
- * - Immutable configuration after initialization
- * - Clear precedence: Env Vars > createApp Options > Config File > Defaults
- * - Type-safe validation
- * - Single source of truth
- */
-
-// Export types and core components
-export * from './schema.js';
-export * from './config-sources.js';
-export * from './config-validator.js';
-export * from './file-loader.js';
-
-// Export specific functions from config-manager to avoid conflicts
-export {
-  initializeAndLockConfig,
-  isConfigLocked,
-  resetConfigForTesting,
-} from './config-manager.js';
-
-// Export utilities for backward compatibility
-export * from './utils.js';
-
-import { MoroOptions } from '../../types/core.js';
-import { AppConfig } from '../../types/config.js';
-import { loadConfigFromAllSources } from './config-sources.js';
-import {
-  initializeAndLockConfig,
-  getGlobalConfig as getConfig,
-  isConfigLocked,
-  resetConfigForTesting,
-} from './config-manager.js';
-import { createFrameworkLogger } from '../logger/index.js';
-
-const logger = createFrameworkLogger('ConfigSystem');
-
-/**
- * Initialize configuration system with createApp options
- * This is the main entry point called by createApp()
- *
- * @param options - createApp options that can override config file and defaults
- * @returns Immutable, validated configuration object
- */
-export function initializeConfig(options?: MoroOptions): Readonly<AppConfig> {
-  if (isConfigLocked()) {
-    logger.debug('Configuration already locked, returning existing config');
-    return getConfig();
-  }
-
-  logger.debug('Initializing configuration system');
-
-  // Load configuration from all sources with proper precedence
-  const config = loadConfigFromAllSources(options);
-
-  // Lock the configuration to prevent further changes
-  initializeAndLockConfig(config);
-
-  logger.info(
-    `Configuration system initialized and locked: ${process.env.NODE_ENV || 'development'}:${config.server.port} (sources: env + file + options + defaults)`
-  );
-
-  return config;
-}
-
-/**
- * Load configuration without locking (for testing and utilities)
- * This maintains backward compatibility with existing code
- */
-export function loadConfig(): AppConfig {
-  return loadConfigFromAllSources();
-}
-
-/**
- * Load configuration with createApp options (for testing and utilities)
- * This maintains backward compatibility with existing code
- */
-export function loadConfigWithOptions(options: MoroOptions): AppConfig {
-  return loadConfigFromAllSources(options);
-}
-
-/**
- * Get the current global configuration
- * Alias for getGlobalConfig() for backward compatibility
- */
-export function getGlobalConfig(): Readonly<AppConfig> {
-  return getConfig();
-}
-
-/**
- * Check if configuration has been initialized and locked
- * Alias for isConfigLocked() for backward compatibility
- */
-export function isConfigInitialized(): boolean {
-  return isConfigLocked();
-}
-
-/**
- * Reset configuration state (for testing only)
- * @internal
- */
-export function resetConfig(): void {
-  resetConfigForTesting();
-}

package/src/core/config/schema.ts

@@ -1,164 +0,0 @@
-// Core Configuration Schema for Moro Framework
-
-import { AppConfig } from '../../types/config.js';
-
-// Minimal default configuration - performance-focused, most things opt-in
-export const DEFAULT_CONFIG: AppConfig = {
-  server: {
-    port: 3001,
-    host: 'localhost',
-    maxConnections: 1000,
-    timeout: 30000,
-    bodySizeLimit: '10mb',
-    useUWebSockets: false, // Opt-in for high performance
-    requestTracking: {
-      enabled: true, // Enable by default for debugging
-    },
-    requestLogging: {
-      enabled: true, // Enable by default - logs requests independently
-    },
-    errorBoundary: {
-      enabled: true, // Always enabled for safety
-    },
-  },
-  serviceDiscovery: {
-    enabled: false,
-    type: 'memory',
-    consulUrl: 'http://localhost:8500',
-    kubernetesNamespace: 'default',
-    healthCheckInterval: 30000,
-    retryAttempts: 3,
-  },
-  database: {},
-  modules: {
-    cache: {
-      enabled: false, // Opt-in for better performance
-      defaultTtl: 300,
-      maxSize: 1000,
-      strategy: 'lru',
-    },
-    rateLimit: {
-      enabled: false, // Opt-in to avoid unnecessary overhead
-      defaultRequests: 100,
-      defaultWindow: 60000,
-      skipSuccessfulRequests: false,
-      skipFailedRequests: false,
-    },
-    validation: {
-      enabled: false,
-      stripUnknown: true,
-      abortEarly: false,
-    },
-    autoDiscovery: {
-      enabled: true, // Enable by default for better DX
-      paths: ['./modules', './src/modules'],
-      patterns: ['**/*.module.{ts,js}', '**/index.{ts,js}', '**/*.config.{ts,js}'],
-      recursive: true,
-      loadingStrategy: 'eager',
-      watchForChanges: false, // Opt-in for development
-      ignorePatterns: ['**/*.test.{ts,js}', '**/*.spec.{ts,js}', '**/node_modules/**'],
-      loadOrder: 'dependency',
-      failOnError: false, // Graceful degradation
-      maxDepth: 5,
-    },
-  },
-  logging: {
-    level: 'info',
-    format: 'pretty',
-    enableColors: true,
-    enableTimestamp: true,
-    enableContext: true,
-    outputs: {
-      console: true,
-      file: {
-        enabled: false,
-        path: './logs/moro.log',
-        maxSize: '10MB',
-        maxFiles: 5,
-      },
-      webhook: {
-        enabled: false,
-        headers: {},
-      },
-    },
-  },
-  security: {
-    cors: {
-      enabled: false, // Opt-in for better performance
-      origin: '*',
-      methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
-      allowedHeaders: ['Content-Type', 'Authorization'],
-      credentials: false,
-    },
-    helmet: {
-      enabled: false, // Opt-in for better performance
-      contentSecurityPolicy: true,
-      hsts: true,
-      noSniff: true,
-      frameguard: true,
-    },
-    rateLimit: {
-      global: {
-        enabled: false,
-        requests: 1000,
-        window: 60000,
-      },
-    },
-  },
-  external: {},
-  performance: {
-    compression: {
-      enabled: false, // Opt-in to avoid overhead
-      level: 6,
-      threshold: 1024,
-    },
-    circuitBreaker: {
-      enabled: false, // Opt-in to avoid overhead
-      failureThreshold: 5,
-      resetTimeout: 60000,
-      monitoringPeriod: 10000,
-    },
-    clustering: {
-      enabled: false,
-      workers: 1,
-      memoryPerWorkerGB: undefined,
-    },
-  },
-  websocket: {
-    enabled: false, // Opt-in - user must explicitly enable WebSockets
-  },
-};
-
-// Schema validation is now handled by config-validator.ts
-// This export is kept for backward compatibility only
-// Note: For actual validation, use validateConfig() from config-validator.ts directly
-export const ConfigSchema = {
-  parse: (data: any): AppConfig => {
-    // Simple pass-through for backward compatibility
-    // Real validation happens in the config loading pipeline
-    return data as AppConfig;
-  },
-};
-
-// Re-export types for backward compatibility
-export type {
-  AppConfig,
-  ServerConfig,
-  ServiceDiscoveryConfig,
-  DatabaseConfig,
-  ModuleDefaultsConfig,
-  LoggingConfig,
-  SecurityConfig,
-  ExternalServicesConfig,
-  PerformanceConfig,
-} from '../../types/config.js';
-
-// For backward compatibility with modules that expect schema objects
-export const ServerConfigSchema = { parse: (data: any) => data };
-export const ServiceDiscoveryConfigSchema = { parse: (data: any) => data };
-export const DatabaseConfigSchema = { parse: (data: any) => data };
-export const ModuleDefaultsConfigSchema = { parse: (data: any) => data };
-export const LoggingConfigSchema = { parse: (data: any) => data };
-export const SecurityConfigSchema = { parse: (data: any) => data };
-export const ExternalServicesConfigSchema = { parse: (data: any) => data };
-export const PerformanceConfigSchema = { parse: (data: any) => data };

package/src/core/config/utils.ts

@@ -1,244 +0,0 @@
-// Configuration Utilities for Modules and Environment Handling
-import { AppConfig } from './schema.js';
-import { createFrameworkLogger } from '../logger/index.js';
-import { getGlobalConfig } from './config-manager.js';
-
-const logger = createFrameworkLogger('ConfigUtils');
-
-/**
- * Set the global configuration (deprecated - for backward compatibility only)
- * @deprecated Use the new immutable config system instead
- */
-export function setConfig(_config: AppConfig): void {
-  logger.warn(
-    'setConfig() is deprecated. Configuration is now immutable after createApp() initialization.'
-  );
-}
-
-/**
- * Get the global configuration
- * This now delegates to the new config manager
- */
-export function getConfig(): AppConfig {
-  return getGlobalConfig();
-}
-
-/**
- * Coerce environment variable string values to appropriate types
- */
-function coerceEnvironmentValue(value: string): any {
-  // Handle boolean values
-  if (value.toLowerCase() === 'true') return true;
-  if (value.toLowerCase() === 'false') return false;
-
-  // Handle numeric values
-  if (/^\d+$/.test(value)) {
-    const num = parseInt(value, 10);
-    return num;
-  }
-
-  if (/^\d+\.\d+$/.test(value)) {
-    const num = parseFloat(value);
-    return num;
-  }
-
-  // Handle JSON objects/arrays
-  if (
-    (value.startsWith('{') && value.endsWith('}')) ||
-    (value.startsWith('[') && value.endsWith(']'))
-  ) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      // If JSON parsing fails, return as string
-      return value;
-    }
-  }
-
-  // Return as string for all other cases
-  return value;
-}
-
-/**
- * Create module-specific configuration with environment override support
- * This now uses the new immutable config system
- */
-export function createModuleConfig<T>(
-  schema: { parse: (data: any) => T },
-  defaultConfig: Partial<T>,
-  envPrefix?: string
-): T {
-  // Try to get global config, but don't fail if not initialized
-  let globalConfig = {};
-  try {
-    globalConfig = getGlobalConfig();
-  } catch {
-    // Global config not initialized - use empty object (module config can still work independently)
-    logger.debug(
-      `Global config not available for module config with prefix ${envPrefix}, using defaults only`
-    );
-    globalConfig = {};
-  }
-
-  // Build environment configuration object with type coercion
-  const envConfig: Record<string, any> = {};
-
-  if (envPrefix) {
-    // Extract environment variables with the given prefix
-    Object.keys(process.env).forEach(key => {
-      if (key.startsWith(envPrefix)) {
-        const configKey = key
-          .substring(envPrefix.length)
-          .toLowerCase()
-          .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-
-        const envValue = process.env[key];
-        if (envValue !== undefined) {
-          // Attempt basic type coercion for common types
-          envConfig[configKey] = coerceEnvironmentValue(envValue);
-        }
-      }
-    });
-  }
-
-  // Merge default config, global defaults, and environment overrides
-  // Priority: environment variables > global config > default config
-  const mergedConfig = {
-    ...defaultConfig,
-    ...globalConfig, // Now uses the new immutable config system
-    ...envConfig,
-  };
-
-  try {
-    return schema.parse(mergedConfig);
-  } catch (error) {
-    logger.error(`Module configuration validation failed for prefix ${envPrefix}:`, String(error));
-    throw error;
-  }
-}
-
-/**
- * Get environment variable with type conversion
- */
-export function getEnvVar<T>(key: string, defaultValue: T, converter?: (value: string) => T): T {
-  const value = process.env[key];
-
-  if (value === undefined) {
-    return defaultValue;
-  }
-
-  if (converter) {
-    try {
-      return converter(value);
-    } catch (error) {
-      logger.warn(`Failed to convert environment variable ${key}:`, String(error));
-      return defaultValue;
-    }
-  }
-
-  // Default type conversions
-  if (typeof defaultValue === 'boolean') {
-    return (value.toLowerCase() === 'true') as T;
-  }
-
-  if (typeof defaultValue === 'number') {
-    const num = Number(value);
-    return (isNaN(num) ? defaultValue : num) as T;
-  }
-
-  return value as T;
-}
-
-/**
- * Parse comma-separated environment variable as array
- */
-export function getEnvArray(key: string, defaultValue: string[] = []): string[] {
-  const value = process.env[key];
-
-  if (!value) {
-    return defaultValue;
-  }
-
-  return value
-    .split(',')
-    .map(item => item.trim())
-    .filter(Boolean);
-}
-
-/**
- * Parse JSON environment variable safely
- */
-export function getEnvJson<T>(key: string, defaultValue: T): T {
-  const value = process.env[key];
-
-  if (!value) {
-    return defaultValue;
-  }
-
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    logger.warn(`Failed to parse JSON environment variable ${key}:`, String(error));
-    return defaultValue;
-  }
-}
-
-/**
- * Validate required environment variables
- */
-export function requireEnvVars(...keys: string[]): void {
-  const missing: string[] = [];
-
-  keys.forEach(key => {
-    if (!process.env[key]) {
-      missing.push(key);
-    }
-  });
-
-  if (missing.length > 0) {
-    throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
-  }
-}
-
-/**
- * Create environment variable name with prefix
- */
-export function envVar(prefix: string, name: string): string {
-  return `${prefix.toUpperCase()}_${name.toUpperCase()}`;
-}
-
-/**
- * Get configuration value with dot notation
- * This now delegates to the new config manager
- */
-export function getConfigValue(path: string): any {
-  const config = getGlobalConfig();
-
-  return path.split('.').reduce((obj, key) => {
-    return obj && obj[key] !== undefined ? obj[key] : undefined;
-  }, config as any);
-}
-
-/**
- * Check if we're in development environment
- * Now reads NODE_ENV directly for consistency with Node.js ecosystem
- */
-export function isDevelopment(): boolean {
-  return process.env.NODE_ENV === 'development';
-}
-
-/**
- * Check if we're in production environment
- * Now reads NODE_ENV directly for consistency with Node.js ecosystem
- */
-export function isProduction(): boolean {
-  return process.env.NODE_ENV === 'production';
-}
-
-/**
- * Check if we're in staging environment
- * Now reads NODE_ENV directly for consistency with Node.js ecosystem
- */
-export function isStaging(): boolean {
-  return process.env.NODE_ENV === 'staging';
-}