@morojs/moro 1.6.1 → 1.6.3

package/src/core/config/schema.ts

@@ -1,150 +0,0 @@
-// Core Configuration Schema for Moro Framework
-
-import { AppConfig } from '../../types/config';
-
-// Default configuration values
-export const DEFAULT_CONFIG: AppConfig = {
-  server: {
-    port: 3001,
-    host: 'localhost',
-    environment: 'development',
-    maxConnections: 1000,
-    timeout: 30000,
-  },
-  serviceDiscovery: {
-    enabled: false,
-    type: 'memory',
-    consulUrl: 'http://localhost:8500',
-    kubernetesNamespace: 'default',
-    healthCheckInterval: 30000,
-    retryAttempts: 3,
-  },
-  database: {
-    redis: {
-      url: 'redis://localhost:6379',
-      maxRetries: 3,
-      retryDelay: 1000,
-      keyPrefix: 'moro:',
-    },
-  },
-  modules: {
-    cache: {
-      enabled: true,
-      defaultTtl: 300,
-      maxSize: 1000,
-      strategy: 'lru',
-    },
-    rateLimit: {
-      enabled: true,
-      defaultRequests: 100,
-      defaultWindow: 60000,
-      skipSuccessfulRequests: false,
-      skipFailedRequests: false,
-    },
-    validation: {
-      enabled: true,
-      stripUnknown: true,
-      abortEarly: false,
-    },
-  },
-  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: true,
-      origin: '*',
-      methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
-      allowedHeaders: ['Content-Type', 'Authorization'],
-      credentials: false,
-    },
-    helmet: {
-      enabled: true,
-      contentSecurityPolicy: true,
-      hsts: true,
-      noSniff: true,
-      frameguard: true,
-    },
-    rateLimit: {
-      global: {
-        enabled: false,
-        requests: 1000,
-        window: 60000,
-      },
-    },
-  },
-  external: {
-    stripe: {
-      apiVersion: '2023-10-16',
-    },
-    paypal: {
-      environment: 'sandbox',
-    },
-    smtp: {
-      port: 587,
-      secure: false,
-    },
-  },
-  performance: {
-    compression: {
-      enabled: true,
-      level: 6,
-      threshold: 1024,
-    },
-    circuitBreaker: {
-      enabled: true,
-      failureThreshold: 5,
-      resetTimeout: 60000,
-      monitoringPeriod: 10000,
-    },
-    clustering: {
-      enabled: false,
-      workers: 1,
-    },
-  },
-};
-
-// Simple compatibility export - just return the config as-is
-export const ConfigSchema = {
-  parse: (data: any): AppConfig => data as AppConfig,
-};
-
-// Re-export types for backward compatibility
-export type {
-  AppConfig,
-  ServerConfig,
-  ServiceDiscoveryConfig,
-  DatabaseConfig,
-  ModuleDefaultsConfig,
-  LoggingConfig,
-  SecurityConfig,
-  ExternalServicesConfig,
-  PerformanceConfig,
-} from '../../types/config';
-
-// 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,251 +0,0 @@
-// Configuration Utilities for Modules and Environment Handling
-import { AppConfig } from './schema';
-import { createFrameworkLogger } from '../logger';
-
-const logger = createFrameworkLogger('ConfigUtils');
-
-// Global configuration store
-let appConfig: AppConfig | null = null;
-
-/**
- * Set the global configuration (used by framework initialization)
- */
-export function setConfig(config: AppConfig): void {
-  appConfig = config;
-  logger.debug('Global configuration updated');
-}
-
-/**
- * Get the global configuration
- */
-export function getConfig(): AppConfig {
-  if (!appConfig) {
-    throw new Error('Configuration not initialized. Call loadConfig() first.');
-  }
-  return appConfig;
-}
-
-/**
- * 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
- */
-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 {
-    const { getGlobalConfig } = require('./index');
-    globalConfig = getGlobalConfig();
-  } catch {
-    // Global config not initialized - use empty object (module config can still work independently)
-    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 actually using global config!
-    ...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
- */
-export function getConfigValue(path: string): any {
-  const config = getConfig();
-
-  return path.split('.').reduce((obj, key) => {
-    return obj && obj[key] !== undefined ? obj[key] : undefined;
-  }, config as any);
-}
-
-/**
- * Check if we're in development environment
- */
-export function isDevelopment(): boolean {
-  try {
-    return getConfig().server.environment === 'development';
-  } catch {
-    return process.env.NODE_ENV === 'development';
-  }
-}
-
-/**
- * Check if we're in production environment
- */
-export function isProduction(): boolean {
-  try {
-    return getConfig().server.environment === 'production';
-  } catch {
-    return process.env.NODE_ENV === 'production';
-  }
-}
-
-/**
- * Check if we're in staging environment
- */
-export function isStaging(): boolean {
-  try {
-    return getConfig().server.environment === 'staging';
-  } catch {
-    return process.env.NODE_ENV === 'staging';
-  }
-}

package/src/core/config/validation.ts

@@ -1,140 +0,0 @@
-// Configuration Validation Functions
-// Validation for config system with simple TypeScript functions
-
-export class ConfigValidationError extends Error {
-  constructor(
-    public field: string,
-    public value: unknown,
-    message: string
-  ) {
-    super(`Configuration validation failed for '${field}': ${message}`);
-    this.name = 'ConfigValidationError';
-  }
-}
-
-// Type-safe validation functions for configuration
-export function validatePort(value: unknown, field = 'port'): number {
-  const num = Number(value);
-  if (isNaN(num) || num < 1 || num > 65535) {
-    throw new ConfigValidationError(field, value, 'Must be a number between 1 and 65535');
-  }
-  return num;
-}
-
-export function validateBoolean(value: unknown, field = 'boolean'): boolean {
-  if (value === 'true' || value === true) return true;
-  if (value === 'false' || value === false) return false;
-  if (value === '1' || value === 1) return true;
-  if (value === '0' || value === 0) return false;
-  throw new ConfigValidationError(field, value, 'Must be a boolean (true/false) or numeric (1/0)');
-}
-
-export function validateNumber(
-  value: unknown,
-  field = 'number',
-  options: { min?: number; max?: number } = {}
-): number {
-  const num = Number(value);
-  if (isNaN(num)) {
-    throw new ConfigValidationError(field, value, 'Must be a valid number');
-  }
-  if (options.min !== undefined && num < options.min) {
-    throw new ConfigValidationError(field, value, `Must be at least ${options.min}`);
-  }
-  if (options.max !== undefined && num > options.max) {
-    throw new ConfigValidationError(field, value, `Must be at most ${options.max}`);
-  }
-  return num;
-}
-
-export function validateString(value: unknown, field = 'string'): string {
-  if (typeof value !== 'string') {
-    throw new ConfigValidationError(field, value, 'Must be a string');
-  }
-  return value;
-}
-
-export function validateUrl(value: unknown, field = 'url'): string {
-  const str = validateString(value, field);
-  try {
-    new URL(str);
-    return str;
-  } catch {
-    throw new ConfigValidationError(field, value, 'Must be a valid URL');
-  }
-}
-
-export function validateEnum<T extends string>(
-  value: unknown,
-  validValues: readonly T[],
-  field = 'enum'
-): T {
-  const str = validateString(value, field);
-  if (!validValues.includes(str as T)) {
-    throw new ConfigValidationError(field, value, `Must be one of: ${validValues.join(', ')}`);
-  }
-  return str as T;
-}
-
-export function validateStringArray(value: unknown, field = 'string array'): string[] {
-  if (!Array.isArray(value)) {
-    // Try to parse comma-separated string
-    if (typeof value === 'string') {
-      return value
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0);
-    }
-    throw new ConfigValidationError(field, value, 'Must be an array or comma-separated string');
-  }
-  return value.map((item, index) => validateString(item, `${field}[${index}]`));
-}
-
-export function validateOptional<T>(
-  value: unknown,
-  validator: (value: unknown, field: string) => T,
-  field: string
-): T | undefined {
-  if (value === undefined || value === null || value === '') {
-    return undefined;
-  }
-  return validator(value, field);
-}
-
-// Coercion helpers for environment variables
-export function coerceEnvValue(value: string): unknown {
-  // Handle common patterns in environment variables
-
-  // Null/undefined
-  if (value === '' || value === 'null' || value === 'undefined') {
-    return undefined;
-  }
-
-  // Boolean
-  if (value === 'true' || value === 'false') {
-    return value === 'true';
-  }
-
-  // Number (but not if it starts with 0 - could be port, zip code, etc.)
-  if (/^-?\d+(\.\d+)?$/.test(value) && !value.startsWith('0')) {
-    const num = Number(value);
-    if (!isNaN(num)) {
-      return num;
-    }
-  }
-
-  // JSON (for complex objects/arrays)
-  if (
-    (value.startsWith('{') && value.endsWith('}')) ||
-    (value.startsWith('[') && value.endsWith(']'))
-  ) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      // Not valid JSON, treat as string
-    }
-  }
-
-  // Return as string for all other cases
-  return value;
-}