@morojs/moro 1.6.0 → 1.6.1

package/src/core/config/schema.ts

@@ -1,22 +1,15 @@
 // Core Configuration Schema for Moro Framework
 
-import { AppConfig } from '../../types/config.js';
+import { AppConfig } from '../../types/config';
 
-// Minimal default configuration - performance-focused, most things opt-in
+// Default configuration values
 export const DEFAULT_CONFIG: AppConfig = {
   server: {
     port: 3001,
     host: 'localhost',
+    environment: 'development',
     maxConnections: 1000,
     timeout: 30000,
-    bodySizeLimit: '10mb',
-    useUWebSockets: false, // Opt-in for ultra-high performance
-    requestTracking: {
-      enabled: true, // Enable by default for debugging
-    },
-    errorBoundary: {
-      enabled: true, // Always enabled for safety
-    },
   },
   serviceDiscovery: {
     enabled: false,
@@ -26,38 +19,33 @@ export const DEFAULT_CONFIG: AppConfig = {
     healthCheckInterval: 30000,
     retryAttempts: 3,
   },
-  database: {},
+  database: {
+    redis: {
+      url: 'redis://localhost:6379',
+      maxRetries: 3,
+      retryDelay: 1000,
+      keyPrefix: 'moro:',
+    },
+  },
   modules: {
     cache: {
-      enabled: false, // Opt-in for better performance
+      enabled: true,
       defaultTtl: 300,
       maxSize: 1000,
       strategy: 'lru',
     },
     rateLimit: {
-      enabled: false, // Opt-in to avoid unnecessary overhead
+      enabled: true,
       defaultRequests: 100,
       defaultWindow: 60000,
       skipSuccessfulRequests: false,
       skipFailedRequests: false,
     },
     validation: {
-      enabled: false,
+      enabled: true,
       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',
@@ -81,14 +69,14 @@ export const DEFAULT_CONFIG: AppConfig = {
   },
   security: {
     cors: {
-      enabled: false, // Opt-in for better performance
+      enabled: true,
       origin: '*',
       methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
       allowedHeaders: ['Content-Type', 'Authorization'],
       credentials: false,
     },
     helmet: {
-      enabled: false, // Opt-in for better performance
+      enabled: true,
       contentSecurityPolicy: true,
       hsts: true,
       noSniff: true,
@@ -102,15 +90,26 @@ export const DEFAULT_CONFIG: AppConfig = {
       },
     },
   },
-  external: {},
+  external: {
+    stripe: {
+      apiVersion: '2023-10-16',
+    },
+    paypal: {
+      environment: 'sandbox',
+    },
+    smtp: {
+      port: 587,
+      secure: false,
+    },
+  },
   performance: {
     compression: {
-      enabled: false, // Opt-in to avoid overhead
+      enabled: true,
       level: 6,
       threshold: 1024,
     },
     circuitBreaker: {
-      enabled: false, // Opt-in to avoid overhead
+      enabled: true,
       failureThreshold: 5,
       resetTimeout: 60000,
       monitoringPeriod: 10000,
@@ -118,23 +117,13 @@ export const DEFAULT_CONFIG: AppConfig = {
     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
+// Simple compatibility export - just return the config as-is
 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;
-  },
+  parse: (data: any): AppConfig => data as AppConfig,
 };
 
 // Re-export types for backward compatibility
@@ -148,7 +137,7 @@ export type {
   SecurityConfig,
   ExternalServicesConfig,
   PerformanceConfig,
-} from '../../types/config.js';
+} from '../../types/config';
 
 // For backward compatibility with modules that expect schema objects
 export const ServerConfigSchema = { parse: (data: any) => data };

package/src/core/config/utils.ts

@@ -1,26 +1,28 @@
 // Configuration Utilities for Modules and Environment Handling
-import { AppConfig } from './schema.js';
-import { createFrameworkLogger } from '../logger/index.js';
-import { getGlobalConfig } from './config-manager.js';
+import { AppConfig } from './schema';
+import { createFrameworkLogger } from '../logger';
 
 const logger = createFrameworkLogger('ConfigUtils');
 
+// Global configuration store
+let appConfig: AppConfig | null = null;
+
 /**
- * Set the global configuration (deprecated - for backward compatibility only)
- * @deprecated Use the new immutable config system instead
+ * Set the global configuration (used by framework initialization)
  */
-export function setConfig(_config: AppConfig): void {
-  logger.warn(
-    'setConfig() is deprecated. Configuration is now immutable after createApp() initialization.'
-  );
+export function setConfig(config: AppConfig): void {
+  appConfig = config;
+  logger.debug('Global configuration updated');
 }
 
 /**
  * Get the global configuration
- * This now delegates to the new config manager
  */
 export function getConfig(): AppConfig {
-  return getGlobalConfig();
+  if (!appConfig) {
+    throw new Error('Configuration not initialized. Call loadConfig() first.');
+  }
+  return appConfig;
 }
 
 /**
@@ -61,7 +63,6 @@ function coerceEnvironmentValue(value: string): any {
 
 /**
  * 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 },
@@ -71,12 +72,10 @@ export function createModuleConfig<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)
-    logger.debug(
-      `Global config not available for module config with prefix ${envPrefix}, using defaults only`
-    );
     globalConfig = {};
   }
 
@@ -105,7 +104,7 @@ export function createModuleConfig<T>(
   // Priority: environment variables > global config > default config
   const mergedConfig = {
     ...defaultConfig,
-    ...globalConfig, // Now uses the new immutable config system
+    ...globalConfig, // Now actually using global config!
     ...envConfig,
   };
 
@@ -209,10 +208,9 @@ export function envVar(prefix: string, name: string): string {
 
 /**
  * Get configuration value with dot notation
- * This now delegates to the new config manager
  */
 export function getConfigValue(path: string): any {
-  const config = getGlobalConfig();
+  const config = getConfig();
 
   return path.split('.').reduce((obj, key) => {
     return obj && obj[key] !== undefined ? obj[key] : undefined;
@@ -221,24 +219,33 @@ export function getConfigValue(path: string): 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';
+  try {
+    return getConfig().server.environment === 'development';
+  } catch {
+    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';
+  try {
+    return getConfig().server.environment === 'production';
+  } catch {
+    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';
+  try {
+    return getConfig().server.environment === 'staging';
+  } catch {
+    return process.env.NODE_ENV === 'staging';
+  }
 }

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/database/README.md

@@ -7,19 +7,16 @@ The MoroJS database module provides a pluggable adapter system for different dat
 ### SQL Databases
 
 #### MySQL Adapter
-
 - **Package Required**: `mysql2`
 - **Usage**: Production-ready with connection pooling
 - **Type**: `mysql`
 
-#### PostgreSQL Adapter
-
+#### PostgreSQL Adapter  
 - **Package Required**: `pg` and `@types/pg`
 - **Usage**: Full PostgreSQL feature support
 - **Type**: `postgresql`, `postgres`, or `pg`
 
 #### SQLite Adapter
-
 - **Package Required**: `better-sqlite3`
 - **Usage**: Lightweight, file-based database
 - **Type**: `sqlite` or `sqlite3`
@@ -27,13 +24,11 @@ The MoroJS database module provides a pluggable adapter system for different dat
 ### NoSQL Databases
 
 #### MongoDB Adapter
-
 - **Package Required**: `mongodb`
 - **Usage**: Document database with aggregation support
 - **Type**: `mongodb` or `mongo`
 
 #### Redis Adapter
-
 - **Package Required**: `ioredis`
 - **Usage**: In-memory key-value store with pub/sub
 - **Type**: `redis`
@@ -41,7 +36,6 @@ The MoroJS database module provides a pluggable adapter system for different dat
 ### ORM
 
 #### Drizzle Adapter
-
 - **Package Required**: `drizzle-orm` + database driver
 - **Usage**: Type-safe ORM with schema validation
 - **Type**: `drizzle` or `orm`
@@ -49,7 +43,7 @@ The MoroJS database module provides a pluggable adapter system for different dat
 ## Factory Pattern (Recommended)
 
 ```typescript
-import { createDatabaseAdapter } from '@morojs/moro';
+import { createDatabaseAdapter } from 'moro';
 
 // SQL Databases
 const mysql = createDatabaseAdapter('mysql', {
@@ -58,7 +52,7 @@ const mysql = createDatabaseAdapter('mysql', {
   user: 'root',
   password: 'password',
   database: 'my_app',
-  connectionLimit: 10,
+  connectionLimit: 10
 });
 
 const postgres = createDatabaseAdapter('postgresql', {
@@ -68,12 +62,12 @@ const postgres = createDatabaseAdapter('postgresql', {
   password: 'password',
   database: 'my_app',
   connectionLimit: 10,
-  ssl: false,
+  ssl: false
 });
 
 const sqlite = createDatabaseAdapter('sqlite', {
   filename: 'app.db',
-  memory: false,
+  memory: false
 });
 
 // NoSQL Databases
@@ -82,34 +76,34 @@ const mongodb = createDatabaseAdapter('mongodb', {
   port: 27017,
   database: 'my_app',
   username: 'user',
-  password: 'password',
+  password: 'password'
 });
 
 const redis = createDatabaseAdapter('redis', {
   host: 'localhost',
   port: 6379,
   password: 'password',
-  keyPrefix: 'myapp:',
+  keyPrefix: 'myapp:'
 });
 
 // ORM
 const drizzle = createDatabaseAdapter('drizzle', {
   database: drizzleInstance,
-  schema: schemaObject,
+  schema: schemaObject
 });
 ```
 
 ## Direct Instantiation
 
 ```typescript
-import {
-  MySQLAdapter,
-  PostgreSQLAdapter,
+import { 
+  MySQLAdapter, 
+  PostgreSQLAdapter, 
   SQLiteAdapter,
   MongoDBAdapter,
   RedisAdapter,
   DrizzleAdapter
-} from '@morojs/moro';
+} from 'moro';
 
 // SQL
 const mysql = new MySQLAdapter({ host: 'localhost', ... });
@@ -157,7 +151,7 @@ const updated = await db.update('users', { name: 'Jane' }, { id: 1 });
 const deleted = await db.delete('users', { id: 1 });
 
 // Transactions
-const result = await db.transaction(async tx => {
+const result = await db.transaction(async (tx) => {
   const user = await tx.insert('users', userData);
   await tx.insert('profiles', { user_id: user.id, ...profileData });
   return user;
@@ -167,7 +161,6 @@ const result = await db.transaction(async tx => {
 ## Usage Examples
 
 ### SQL Operations
-
 ```typescript
 // Standard CRUD operations work across all SQL adapters
 const users = await db.query('SELECT * FROM users WHERE age > ?', [18]);
@@ -178,7 +171,6 @@ const deleted = await db.delete('users', { id: 1 });
 ```
 
 ### MongoDB Operations
-
 ```typescript
 // MongoDB uses collections instead of tables
 const users = await mongoDb.query('users'); // Get all
@@ -187,13 +179,12 @@ const user = await mongoDb.queryOne('users', { email: 'john@example.com' });
 
 // MongoDB-specific methods
 const stats = await mongoDb.aggregate('users', [
-  { $group: { _id: null, avgAge: { $avg: '$age' } } },
+  { $group: { _id: null, avgAge: { $avg: '$age' } } }
 ]);
 await mongoDb.createIndex('users', { email: 1 }, { unique: true });
 ```
 
 ### Redis Operations
-
 ```typescript
 // Key-value operations
 await redisDb.set('user:123', userData, 3600); // with TTL
@@ -206,7 +197,6 @@ await redisDb.publish('notifications', message);
 ```
 
 ### Drizzle ORM Operations
-
 ```typescript
 // Type-safe queries (requires schema setup)
 const users = await drizzleDb.select('users').where(eq(schema.users.age, 25));
@@ -223,7 +213,7 @@ Choose and install the appropriate database package:
 ```bash
 # SQL Databases
 npm install mysql2                    # MySQL
-npm install pg @types/pg             # PostgreSQL
+npm install pg @types/pg             # PostgreSQL  
 npm install better-sqlite3           # SQLite
 
 # NoSQL Databases
@@ -235,4 +225,4 @@ npm install drizzle-orm              # Drizzle ORM
 # Plus the appropriate driver (mysql2, pg, better-sqlite3, etc.)
 ```
 
-The adapters will gracefully handle missing packages with helpful error messages.
+The adapters will gracefully handle missing packages with helpful error messages. 

package/src/core/database/adapters/drizzle.ts

@@ -1,18 +1,6 @@
 // Database Drizzle ORM Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
-
-// Cache the drizzle-orm module
-let drizzleOrm: any = null;
-async function getDrizzleOrm() {
-  if (!drizzleOrm) {
-    const drizzlePath = resolveUserPackage('drizzle-orm');
-    const module = await import(drizzlePath);
-    drizzleOrm = module;
-  }
-  return drizzleOrm;
-}
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface DrizzleConfig {
   database: any; // Drizzle database instance
@@ -120,7 +108,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
       if (this.schema && this.schema[table]) {
         // Use schema-based update
         try {
-          const { eq, and } = await getDrizzleOrm();
+          const { eq, and } = require('drizzle-orm');
 
           // Build where conditions
           const conditions = Object.entries(where).map(([key, value]) =>
@@ -177,7 +165,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
       if (this.schema && this.schema[table]) {
         // Use schema-based delete
         try {
-          const { eq, and } = await getDrizzleOrm();
+          const { eq, and } = require('drizzle-orm');
 
           const conditions = Object.entries(where).map(([key, value]) =>
             eq(this.schema[table][key], value)
@@ -326,7 +314,7 @@ class DrizzleTransaction implements DatabaseTransaction {
   ): Promise<T> {
     if (this.schema && this.schema[table]) {
       try {
-        const { eq, and } = await getDrizzleOrm();
+        const { eq, and } = require('drizzle-orm');
 
         const conditions = Object.entries(where).map(([key, value]) =>
           eq(this.schema[table][key], value)
@@ -372,7 +360,7 @@ class DrizzleTransaction implements DatabaseTransaction {
   async delete(table: string, where: Record<string, any>): Promise<number> {
     if (this.schema && this.schema[table]) {
       try {
-        const { eq, and } = await getDrizzleOrm();
+        const { eq, and } = require('drizzle-orm');
 
         const conditions = Object.entries(where).map(([key, value]) =>
           eq(this.schema[table][key], value)

package/src/core/database/adapters/index.ts

@@ -1,18 +1,18 @@
 // Database Adapters
-export { MySQLAdapter } from './mysql.js';
-export { PostgreSQLAdapter } from './postgresql.js';
-export { SQLiteAdapter } from './sqlite.js';
-export { MongoDBAdapter } from './mongodb.js';
-export { RedisAdapter } from './redis.js';
-export { DrizzleAdapter } from './drizzle.js';
+export { MySQLAdapter } from './mysql';
+export { PostgreSQLAdapter } from './postgresql';
+export { SQLiteAdapter } from './sqlite';
+export { MongoDBAdapter } from './mongodb';
+export { RedisAdapter } from './redis';
+export { DrizzleAdapter } from './drizzle';
 
-import { MySQLAdapter } from './mysql.js';
-import { PostgreSQLAdapter } from './postgresql.js';
-import { SQLiteAdapter } from './sqlite.js';
-import { MongoDBAdapter } from './mongodb.js';
-import { RedisAdapter } from './redis.js';
-import { DrizzleAdapter } from './drizzle.js';
-import { DatabaseAdapter } from '../../../types/database.js';
+import { MySQLAdapter } from './mysql';
+import { PostgreSQLAdapter } from './postgresql';
+import { SQLiteAdapter } from './sqlite';
+import { MongoDBAdapter } from './mongodb';
+import { RedisAdapter } from './redis';
+import { DrizzleAdapter } from './drizzle';
+import { DatabaseAdapter } from '../../../types/database';
 
 // Adapter factory function for auto-loading
 export function createDatabaseAdapter(type: string, options: any = {}): DatabaseAdapter {