@morojs/moro 1.3.0 → 1.5.0

package/src/core/config/schema.ts

@@ -1,283 +1,150 @@
 // Core Configuration Schema for Moro Framework
-import { z } from 'zod';
 
-// Server Configuration Schema
-const ServerConfigSchema = z.object({
-  port: z.coerce
-    .number()
-    .min(1, 'Port must be at least 1')
-    .max(65535, 'Port must be at most 65535')
-    .default(3001)
-    .describe('Server port to listen on'),
-
-  host: z.string().default('localhost').describe('Server host to bind to'),
-
-  environment: z
-    .enum(['development', 'staging', 'production'])
-    .default('development')
-    .describe('Application environment'),
-
-  maxConnections: z.coerce.number().min(1).default(1000).describe('Maximum concurrent connections'),
-
-  timeout: z.coerce.number().min(1000).default(30000).describe('Request timeout in milliseconds'),
-});
-
-// Service Discovery Configuration Schema
-const ServiceDiscoveryConfigSchema = z.object({
-  enabled: z.coerce.boolean().default(false).describe('Enable service discovery'),
-
-  type: z
-    .enum(['memory', 'consul', 'kubernetes'])
-    .default('memory')
-    .describe('Service discovery backend type'),
-
-  consulUrl: z
-    .string()
-    .url('Must be a valid URL')
-    .default('http://localhost:8500')
-    .describe('Consul server URL'),
-
-  kubernetesNamespace: z
-    .string()
-    .default('default')
-    .describe('Kubernetes namespace for service discovery'),
-
-  healthCheckInterval: z.coerce
-    .number()
-    .min(1000)
-    .default(30000)
-    .describe('Health check interval in milliseconds'),
-
-  retryAttempts: z.coerce
-    .number()
-    .min(0)
-    .default(3)
-    .describe('Number of retry attempts for failed health checks'),
-});
-
-// Database Configuration Schema
-const DatabaseConfigSchema = z.object({
-  url: z.string().optional().describe('Primary database connection URL'),
-
-  redis: z.object({
-    url: z.string().default('redis://localhost:6379').describe('Redis connection URL'),
-
-    maxRetries: z.coerce
-      .number()
-      .min(0)
-      .default(3)
-      .describe('Maximum Redis connection retry attempts'),
-
-    retryDelay: z.coerce
-      .number()
-      .min(100)
-      .default(1000)
-      .describe('Redis retry delay in milliseconds'),
-
-    keyPrefix: z.string().default('moro:').describe('Redis key prefix'),
-  }),
-
-  mysql: z
-    .object({
-      host: z.string().default('localhost'),
-      port: z.coerce.number().min(1).max(65535).default(3306),
-      database: z.string().optional(),
-      username: z.string().optional(),
-      password: z.string().optional(),
-      connectionLimit: z.coerce.number().min(1).default(10),
-      acquireTimeout: z.coerce.number().min(1000).default(60000),
-      timeout: z.coerce.number().min(1000).default(60000),
-    })
-    .optional(),
-});
-
-// Module Defaults Configuration Schema
-const ModuleDefaultsConfigSchema = z.object({
-  cache: z.object({
-    enabled: z.coerce.boolean().default(true).describe('Enable caching by default'),
-
-    defaultTtl: z.coerce.number().min(0).default(300).describe('Default cache TTL in seconds'),
-
-    maxSize: z.coerce.number().min(1).default(1000).describe('Maximum cache entries'),
-
-    strategy: z.enum(['lru', 'lfu', 'fifo']).default('lru').describe('Cache eviction strategy'),
-  }),
-
-  rateLimit: z.object({
-    enabled: z.coerce.boolean().default(true).describe('Enable rate limiting by default'),
-
-    defaultRequests: z.coerce.number().min(1).default(100).describe('Default requests per window'),
-
-    defaultWindow: z.coerce
-      .number()
-      .min(1000)
-      .default(60000)
-      .describe('Default rate limit window in milliseconds'),
-
-    skipSuccessfulRequests: z.coerce
-      .boolean()
-      .default(false)
-      .describe('Skip successful requests in rate limit counting'),
-
-    skipFailedRequests: z.coerce
-      .boolean()
-      .default(false)
-      .describe('Skip failed requests in rate limit counting'),
-  }),
-
-  validation: z.object({
-    enabled: z.coerce.boolean().default(true).describe('Enable validation by default'),
-
-    stripUnknown: z.coerce
-      .boolean()
-      .default(true)
-      .describe('Strip unknown properties from validated data'),
-
-    abortEarly: z.coerce.boolean().default(false).describe('Stop validation on first error'),
-  }),
-});
-
-// Logging Configuration Schema
-const LoggingConfigSchema = z.object({
-  level: z
-    .enum(['debug', 'info', 'warn', 'error', 'fatal'])
-    .default('info')
-    .describe('Minimum log level'),
-
-  format: z.enum(['pretty', 'json', 'compact']).default('pretty').describe('Log output format'),
-
-  enableColors: z.coerce.boolean().default(true).describe('Enable colored log output'),
-
-  enableTimestamp: z.coerce.boolean().default(true).describe('Include timestamp in logs'),
-
-  enableContext: z.coerce.boolean().default(true).describe('Include context information in logs'),
-
-  outputs: z.object({
-    console: z.coerce.boolean().default(true),
-    file: z.object({
-      enabled: z.coerce.boolean().default(false),
-      path: z.string().default('./logs/moro.log'),
-      maxSize: z.string().default('10MB'),
-      maxFiles: z.coerce.number().default(5),
-    }),
-    webhook: z.object({
-      enabled: z.coerce.boolean().default(false),
-      url: z.string().url().optional(),
-      headers: z.record(z.string(), z.string()).default({}),
-    }),
-  }),
-});
-
-// Security Configuration Schema
-const SecurityConfigSchema = z.object({
-  cors: z.object({
-    enabled: z.coerce.boolean().default(true),
-    origin: z.union([z.string(), z.array(z.string()), z.boolean()]).default('*'),
-    methods: z.array(z.string()).default(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS']),
-    allowedHeaders: z.array(z.string()).default(['Content-Type', 'Authorization']),
-    credentials: z.coerce.boolean().default(false),
-  }),
-
-  helmet: z.object({
-    enabled: z.coerce.boolean().default(true),
-    contentSecurityPolicy: z.coerce.boolean().default(true),
-    hsts: z.coerce.boolean().default(true),
-    noSniff: z.coerce.boolean().default(true),
-    frameguard: z.coerce.boolean().default(true),
-  }),
-
-  rateLimit: z.object({
-    global: z.object({
-      enabled: z.coerce.boolean().default(false),
-      requests: z.coerce.number().min(1).default(1000),
-      window: z.coerce.number().min(1000).default(60000),
-    }),
-  }),
-});
-
-// External Services Configuration Schema
-const ExternalServicesConfigSchema = z.object({
-  stripe: z
-    .object({
-      secretKey: z.string().optional(),
-      publishableKey: z.string().optional(),
-      webhookSecret: z.string().optional(),
-      apiVersion: z.string().default('2023-10-16'),
-    })
-    .optional(),
-
-  paypal: z
-    .object({
-      clientId: z.string().optional(),
-      clientSecret: z.string().optional(),
-      webhookId: z.string().optional(),
-      environment: z.enum(['sandbox', 'production']).default('sandbox'),
-    })
-    .optional(),
-
-  smtp: z
-    .object({
-      host: z.string().optional(),
-      port: z.coerce.number().min(1).max(65535).default(587),
-      secure: z.coerce.boolean().default(false),
-      username: z.string().optional(),
-      password: z.string().optional(),
-    })
-    .optional(),
-});
-
-// Performance Configuration Schema
-const PerformanceConfigSchema = z.object({
-  compression: z.object({
-    enabled: z.coerce.boolean().default(true),
-    level: z.coerce.number().min(1).max(9).default(6),
-    threshold: z.coerce.number().min(0).default(1024),
-  }),
-
-  circuitBreaker: z.object({
-    enabled: z.coerce.boolean().default(true),
-    failureThreshold: z.coerce.number().min(1).default(5),
-    resetTimeout: z.coerce.number().min(1000).default(60000),
-    monitoringPeriod: z.coerce.number().min(1000).default(10000),
-  }),
-
-  clustering: z.object({
-    enabled: z.coerce.boolean().default(false),
-    workers: z.union([z.coerce.number().min(1), z.literal('auto')]).default(1),
-  }),
-});
-
-// Main Configuration Schema
-export const ConfigSchema = z.object({
-  server: ServerConfigSchema,
-  serviceDiscovery: ServiceDiscoveryConfigSchema,
-  database: DatabaseConfigSchema,
-  modules: ModuleDefaultsConfigSchema,
-  logging: LoggingConfigSchema,
-  security: SecurityConfigSchema,
-  external: ExternalServicesConfigSchema,
-  performance: PerformanceConfigSchema,
-});
-
-// Inferred TypeScript types
-export type AppConfig = z.infer<typeof ConfigSchema>;
-export type ServerConfig = z.infer<typeof ServerConfigSchema>;
-export type ServiceDiscoveryConfig = z.infer<typeof ServiceDiscoveryConfigSchema>;
-export type DatabaseConfig = z.infer<typeof DatabaseConfigSchema>;
-export type ModuleDefaultsConfig = z.infer<typeof ModuleDefaultsConfigSchema>;
-export type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
-export type SecurityConfig = z.infer<typeof SecurityConfigSchema>;
-export type ExternalServicesConfig = z.infer<typeof ExternalServicesConfigSchema>;
-export type PerformanceConfig = z.infer<typeof PerformanceConfigSchema>;
+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,
+    },
+  },
+};
 
-// Export individual schemas for module-specific configuration
-export {
-  ServerConfigSchema,
-  ServiceDiscoveryConfigSchema,
-  DatabaseConfigSchema,
-  ModuleDefaultsConfigSchema,
-  LoggingConfigSchema,
-  SecurityConfigSchema,
-  ExternalServicesConfigSchema,
-  PerformanceConfigSchema,
+// 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,5 +1,4 @@
 // Configuration Utilities for Modules and Environment Handling
-import { z } from 'zod';
 import { AppConfig } from './schema';
 import { createFrameworkLogger } from '../logger';
 
@@ -66,7 +65,7 @@ function coerceEnvironmentValue(value: string): any {
  * Create module-specific configuration with environment override support
  */
 export function createModuleConfig<T>(
-  schema: z.ZodSchema<T>,
+  schema: { parse: (data: any) => T },
   defaultConfig: Partial<T>,
   envPrefix?: string
 ): T {

package/src/core/config/validation.ts

@@ -0,0 +1,140 @@
+// 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;
+}

package/src/core/docs/index.ts

@@ -1,5 +1,5 @@
 // Moro Framework Documentation System
-// Automatic API documentation generation from intelligent routes and Zod schemas
+// Automatic API documentation generation from intelligent routes and Validation schemas
 
 import { CompiledRoute } from '../routing';
 import { IntelligentRoutingManager } from '../routing/app-integration';

package/src/core/docs/openapi-generator.ts

@@ -2,7 +2,8 @@
 // Extracts route information from intelligent routing and generates OpenAPI 3.0 specs
 
 import { CompiledRoute, RouteSchema } from '../routing';
-import { zodToOpenAPI, generateExampleFromSchema, OpenAPISchema } from './zod-to-openapi';
+import { OpenAPISchema } from './zod-to-openapi';
+import { schemaToOpenAPI, generateExampleFromValidationSchema } from './schema-to-openapi';
 import { createFrameworkLogger } from '../logger';
 
 const logger = createFrameworkLogger('OpenAPIGenerator');
@@ -241,7 +242,7 @@ export class OpenAPIGenerator {
 
     // Path parameters
     if (route.validation?.params) {
-      const paramSchema = zodToOpenAPI(route.validation.params, this.options);
+      const paramSchema = schemaToOpenAPI(route.validation.params, this.options);
       if (paramSchema.properties) {
         for (const [name, schema] of Object.entries(paramSchema.properties)) {
           parameters.push({
@@ -258,7 +259,7 @@ export class OpenAPIGenerator {
 
     // Query parameters
     if (route.validation?.query) {
-      const querySchema = zodToOpenAPI(route.validation.query, this.options);
+      const querySchema = schemaToOpenAPI(route.validation.query, this.options);
       if (querySchema.properties) {
         for (const [name, schema] of Object.entries(querySchema.properties)) {
           const isRequired = querySchema.required?.includes(name) || false;
@@ -276,7 +277,7 @@ export class OpenAPIGenerator {
 
     // Header parameters
     if (route.validation?.headers) {
-      const headerSchema = zodToOpenAPI(route.validation.headers, this.options);
+      const headerSchema = schemaToOpenAPI(route.validation.headers, this.options);
       if (headerSchema.properties) {
         for (const [name, schema] of Object.entries(headerSchema.properties)) {
           const isRequired = headerSchema.required?.includes(name) || false;
@@ -309,9 +310,9 @@ export class OpenAPIGenerator {
       };
     }
 
-    const bodySchema = zodToOpenAPI(route.validation.body, this.options);
+    const bodySchema = schemaToOpenAPI(route.validation.body, this.options);
     const example = this.options.includeExamples
-      ? generateExampleFromSchema(route.validation.body)
+      ? generateExampleFromValidationSchema(route.validation.body)
       : undefined;
 
     return {