@morojs/moro 1.4.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

@@ -1,5 +1,5 @@
-// TypeScript-based Configuration Validation
-// Simple validation functions that replace Zod for config system
+// Configuration Validation Functions
+// Validation for config system with simple TypeScript functions
 
 export class ConfigValidationError extends Error {
   constructor(
@@ -12,7 +12,7 @@ export class ConfigValidationError extends Error {
   }
 }
 
-// Type-safe validation functions
+// 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) {
@@ -76,7 +76,7 @@ export function validateEnum<T extends string>(
   return str as T;
 }
 
-export function validateArray(value: unknown, field = 'array'): unknown[] {
+export function validateStringArray(value: unknown, field = 'string array'): string[] {
   if (!Array.isArray(value)) {
     // Try to parse comma-separated string
     if (typeof value === 'string') {
@@ -87,12 +87,7 @@ export function validateArray(value: unknown, field = 'array'): unknown[] {
     }
     throw new ConfigValidationError(field, value, 'Must be an array or comma-separated string');
   }
-  return value;
-}
-
-export function validateStringArray(value: unknown, field = 'string array'): string[] {
-  const arr = validateArray(value, field);
-  return arr.map((item, index) => validateString(item, `${field}[${index}]`));
+  return value.map((item, index) => validateString(item, `${field}[${index}]`));
 }
 
 export function validateOptional<T>(

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/simple-docs.ts

@@ -132,7 +132,7 @@ export class SimpleDocsGenerator {
   <div class="container">
     <h1>${this.options.title}</h1>
     <p>${this.options.description}</p>
-    
+
     <div class="example">
       <strong>Interactive Swagger UI:</strong> <a href="${this.options.basePath}" target="_blank">${this.options.basePath}</a><br>
       <strong>OpenAPI JSON:</strong> <a href="${this.options.basePath}/openapi.json" target="_blank">${this.options.basePath}/openapi.json</a>
@@ -189,11 +189,11 @@ export class SimpleDocsGenerator {
         <span class="method ${route.method}">${route.method}</span>
         <span class="path">${route.path}</span>
       </div>
-      
+
       ${route.description ? `<div class="description">${route.description}</div>` : ''}
-      
+
       ${route.tags ? `<div class="tags">${route.tags.map(tag => `<span class="tag">${tag}</span>`).join('')}</div>` : ''}
-      
+
       ${this.generateValidationInfo(route)}
       ${this.generateAuthInfo(route)}
       ${this.generateRateLimitInfo(route)}
@@ -215,7 +215,7 @@ export class SimpleDocsGenerator {
     return `
     <div class="validation">
       <strong>Validation:</strong> ${validationTypes.join(', ')}
-      <br><small>Request will be validated with Zod schemas for type safety</small>
+      <br><small>Request will be validated with Validation schemas for type safety</small>
     </div>`;
   }
 

package/src/core/docs/zod-to-openapi.ts

@@ -1,22 +1,40 @@
 // Zod to OpenAPI Schema Converter
 // Transforms Zod schemas into OpenAPI 3.0 schema definitions
 
-import {
-  ZodSchema,
-  ZodType,
-  ZodObject,
-  ZodArray,
-  ZodString,
-  ZodNumber,
-  ZodBoolean,
-  ZodEnum,
-  ZodOptional,
-  ZodDefault,
-  ZodUnion,
-  ZodLiteral,
-} from 'zod';
 import { createFrameworkLogger } from '../logger';
 
+// Dynamic Zod imports (optional dependency)
+let ZodSchema: any,
+  ZodType: any,
+  ZodObject: any,
+  ZodArray: any,
+  ZodString: any,
+  ZodNumber: any,
+  ZodBoolean: any,
+  ZodEnum: any,
+  ZodOptional: any,
+  ZodDefault: any,
+  ZodUnion: any,
+  ZodLiteral: any;
+
+try {
+  const zod = require('zod');
+  ZodSchema = zod.ZodSchema;
+  ZodType = zod.ZodType;
+  ZodObject = zod.ZodObject;
+  ZodArray = zod.ZodArray;
+  ZodString = zod.ZodString;
+  ZodNumber = zod.ZodNumber;
+  ZodBoolean = zod.ZodBoolean;
+  ZodEnum = zod.ZodEnum;
+  ZodOptional = zod.ZodOptional;
+  ZodDefault = zod.ZodDefault;
+  ZodUnion = zod.ZodUnion;
+  ZodLiteral = zod.ZodLiteral;
+} catch {
+  // Zod not available - that's fine!
+}
+
 const logger = createFrameworkLogger('ZodToOpenAPI');
 
 // OpenAPI schema types
@@ -52,7 +70,12 @@ export interface ConversionOptions {
 }
 
 // Main conversion function
-export function zodToOpenAPI(schema: ZodSchema, options: ConversionOptions = {}): OpenAPISchema {
+export function zodToOpenAPI(schema: any, options: ConversionOptions = {}): OpenAPISchema {
+  // Check if Zod is available
+  if (!ZodSchema) {
+    throw new Error('Zod is not installed. Please install zod to use zodToOpenAPI function.');
+  }
+
   const opts = {
     includeExamples: true,
     includeDescriptions: true,
@@ -367,7 +390,7 @@ function convertZodDefault(def: any, options: ConversionOptions): OpenAPISchema
 
 // Convert ZodUnion
 function convertZodUnion(def: any, options: ConversionOptions): OpenAPISchema {
-  const schemas = def.options.map((option: ZodType) => convertZodType(option._def, options));
+  const schemas = def.options.map((option: any) => convertZodType(option._def, options));
 
   return {
     oneOf: schemas,
@@ -386,16 +409,23 @@ function convertZodLiteral(def: any, options: ConversionOptions): OpenAPISchema
 }
 
 // Helper functions
-function isOptionalType(type: ZodType): boolean {
+function isOptionalType(type: any): boolean {
   return (type._def as any).typeName === 'ZodOptional';
 }
 
-function hasDefault(type: ZodType): boolean {
+function hasDefault(type: any): boolean {
   return (type._def as any).typeName === 'ZodDefault';
 }
 
 // Generate example data from Zod schema
-export function generateExampleFromSchema(schema: ZodSchema): any {
+export function generateExampleFromSchema(schema: any): any {
+  // Check if Zod is available
+  if (!ZodSchema) {
+    throw new Error(
+      'Zod is not installed. Please install zod to use generateExampleFromSchema function.'
+    );
+  }
+
   try {
     return generateExample(schema._def);
   } catch (error) {
@@ -441,7 +471,7 @@ function generateExample(def: any): any {
         }
 
         for (const [key, value] of Object.entries(shape)) {
-          const zodType = value as ZodType;
+          const zodType = value as any;
           if (!isOptionalType(zodType)) {
             example[key] = generateExample(zodType._def);
           }