@morojs/moro 1.5.16 → 1.6.0

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

@@ -1,6 +1,7 @@
 // Database Redis Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
+import { createFrameworkLogger } from '../../logger/index.js';
+import { resolveUserPackage } from '../../utilities/package-utils.js';
 
 interface RedisConfig {
   host?: string;
@@ -31,11 +32,18 @@ export class RedisAdapter implements DatabaseAdapter {
   private client: any;
   private logger = createFrameworkLogger('Redis');
   private keyPrefix: string;
+  private initPromise: Promise<void>;
 
   constructor(config: RedisConfig = {}) {
+    this.keyPrefix = config.keyPrefix || 'moro:';
+    this.initPromise = this.initialize(config);
+  }
+
+  private async initialize(config: RedisConfig): Promise<void> {
     try {
-      const Redis = require('ioredis');
-      this.keyPrefix = config.keyPrefix || 'moro:';
+      const ioredisPath = resolveUserPackage('ioredis');
+      const ioredis = await import(ioredisPath);
+      const Redis = ioredis.default;
 
       if (config.cluster) {
         // Redis Cluster
@@ -97,6 +105,7 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     try {
       await this.client.ping();
       this.logger.info('Redis connection established', 'Connection');
@@ -109,11 +118,13 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async disconnect(): Promise<void> {
+    await this.initPromise;
     await this.client.quit();
   }
 
   // For Redis, we adapt the SQL-like interface to key-value operations
   async query<T = any>(pattern: string, _params?: any[]): Promise<T[]> {
+    await this.initPromise;
     try {
       const keys = await this.client.keys(this.prefixKey(pattern));
       if (keys.length === 0) return [];
@@ -133,6 +144,7 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async queryOne<T = any>(key: string, _params?: any[]): Promise<T | null> {
+    await this.initPromise;
     try {
       const value = await this.client.get(this.prefixKey(key));
       return value ? JSON.parse(value) : null;
@@ -146,6 +158,7 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async insert<T = any>(key: string, data: Record<string, any>): Promise<T> {
+    await this.initPromise;
     try {
       const value = JSON.stringify(data);
       await this.client.set(this.prefixKey(key), value);
@@ -164,6 +177,7 @@ export class RedisAdapter implements DatabaseAdapter {
     data: Record<string, any>,
     _where?: Record<string, any>
   ): Promise<T> {
+    await this.initPromise;
     try {
       // For Redis, we'll merge with existing data if it exists
       const existing = await this.queryOne(key);
@@ -181,6 +195,7 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async delete(pattern: string, _where?: Record<string, any>): Promise<number> {
+    await this.initPromise;
     try {
       const keys = await this.client.keys(this.prefixKey(pattern));
       if (keys.length === 0) return 0;
@@ -197,6 +212,7 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
+    await this.initPromise;
     const multi = this.client.multi();
     const transaction = new RedisTransaction(multi, this.keyPrefix);
 
@@ -213,6 +229,7 @@ export class RedisAdapter implements DatabaseAdapter {
 
   // Redis-specific methods
   async set(key: string, value: any, ttl?: number): Promise<void> {
+    await this.initPromise;
     const prefixedKey = this.prefixKey(key);
     if (ttl) {
       await this.client.setex(prefixedKey, ttl, JSON.stringify(value));
@@ -222,38 +239,46 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async get(key: string): Promise<any> {
+    await this.initPromise;
     const value = await this.client.get(this.prefixKey(key));
     return value ? JSON.parse(value) : null;
   }
 
   async exists(key: string): Promise<boolean> {
+    await this.initPromise;
     const result = await this.client.exists(this.prefixKey(key));
     return result === 1;
   }
 
   async expire(key: string, ttl: number): Promise<boolean> {
+    await this.initPromise;
     const result = await this.client.expire(this.prefixKey(key), ttl);
     return result === 1;
   }
 
   async incr(key: string): Promise<number> {
+    await this.initPromise;
     return await this.client.incr(this.prefixKey(key));
   }
 
   async decr(key: string): Promise<number> {
+    await this.initPromise;
     return await this.client.decr(this.prefixKey(key));
   }
 
   async hset(hash: string, field: string, value: any): Promise<void> {
+    await this.initPromise;
     await this.client.hset(this.prefixKey(hash), field, JSON.stringify(value));
   }
 
   async hget(hash: string, field: string): Promise<any> {
+    await this.initPromise;
     const value = await this.client.hget(this.prefixKey(hash), field);
     return value ? JSON.parse(value) : null;
   }
 
   async hgetall(hash: string): Promise<Record<string, any>> {
+    await this.initPromise;
     const result = await this.client.hgetall(this.prefixKey(hash));
     const parsed: Record<string, any> = {};
     for (const [key, value] of Object.entries(result)) {
@@ -263,25 +288,30 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async lpush(list: string, ...values: any[]): Promise<number> {
+    await this.initPromise;
     const serialized = values.map(v => JSON.stringify(v));
     return await this.client.lpush(this.prefixKey(list), ...serialized);
   }
 
   async rpop(list: string): Promise<any> {
+    await this.initPromise;
     const value = await this.client.rpop(this.prefixKey(list));
     return value ? JSON.parse(value) : null;
   }
 
   async lrange(list: string, start: number, stop: number): Promise<any[]> {
+    await this.initPromise;
     const values = await this.client.lrange(this.prefixKey(list), start, stop);
     return values.map((v: string) => JSON.parse(v));
   }
 
   async publish(channel: string, message: any): Promise<number> {
+    await this.initPromise;
     return await this.client.publish(channel, JSON.stringify(message));
   }
 
   async subscribe(channel: string, callback: (message: any) => void): Promise<void> {
+    await this.initPromise;
     const subscriber = this.client.duplicate();
     subscriber.subscribe(channel);
     subscriber.on('message', (_channel: string, message: string) => {

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

@@ -1,6 +1,7 @@
 // Database SQLite Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
+import { createFrameworkLogger } from '../../logger/index.js';
+import { resolveUserPackage } from '../../utilities/package-utils.js';
 
 interface SQLiteConfig {
   filename?: string;
@@ -14,10 +15,17 @@ interface SQLiteConfig {
 export class SQLiteAdapter implements DatabaseAdapter {
   private db: any;
   private logger = createFrameworkLogger('SQLite');
+  private initPromise: Promise<void>;
 
   constructor(config: SQLiteConfig = {}) {
+    this.initPromise = this.initialize(config);
+  }
+
+  private async initialize(config: SQLiteConfig): Promise<void> {
     try {
-      const Database = require('better-sqlite3');
+      const sqlite3Path = resolveUserPackage('better-sqlite3');
+      const betterSqlite3 = await import(sqlite3Path);
+      const Database = betterSqlite3.default;
       const filename = config.memory ? ':memory:' : config.filename || 'moro_app.db';
       this.db = new Database(filename, {
         readonly: config.readonly || false,
@@ -40,15 +48,18 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     // SQLite doesn't require explicit connection - it's handled in constructor
     this.logger.info('SQLite adapter ready', 'Connection');
   }
 
   async disconnect(): Promise<void> {
+    await this.initPromise;
     this.db.close();
   }
 
   async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
+    await this.initPromise;
     try {
       const stmt = this.db.prepare(sql);
       const results = stmt.all(params || []);
@@ -63,6 +74,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
+    await this.initPromise;
     try {
       const stmt = this.db.prepare(sql);
       const result = stmt.get(params || []);
@@ -77,6 +89,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
+    await this.initPromise;
     const keys = Object.keys(data);
     const values = Object.values(data);
     const placeholders = keys.map(() => '?').join(', ');
@@ -107,6 +120,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
     data: Record<string, any>,
     where: Record<string, any>
   ): Promise<T> {
+    await this.initPromise;
     const setClause = Object.keys(data)
       .map(key => `${key} = ?`)
       .join(', ');
@@ -138,6 +152,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   async delete(table: string, where: Record<string, any>): Promise<number> {
+    await this.initPromise;
     const whereClause = Object.keys(where)
       .map(key => `${key} = ?`)
       .join(' AND ');
@@ -157,6 +172,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
+    await this.initPromise;
     const transaction = this.db.transaction(async () => {
       const tx = new SQLiteTransaction(this.db);
       return await callback(tx);

package/src/core/database/index.ts

@@ -1,3 +1,3 @@
 // Database Module
-export * from './adapters';
-export * from '../../types/database';
+export * from './adapters/index.js';
+export * from '../../types/database.js';

package/src/core/docs/index.ts

@@ -1,17 +1,17 @@
 // Moro Framework Documentation System
 // Automatic API documentation generation from intelligent routes and Validation schemas
 
-import { CompiledRoute } from '../routing';
-import { IntelligentRoutingManager } from '../routing/app-integration';
+import { CompiledRoute } from '../routing/index.js';
+import { IntelligentRoutingManager } from '../routing/app-integration.js';
 import {
   OpenAPIGenerator,
   generateOpenAPIFromRoutes,
   GenerationOptions,
   OpenAPISpec,
   defaultSecuritySchemes,
-} from './openapi-generator';
-import { SwaggerUIMiddleware, SwaggerUIOptions, createDocsMiddleware } from './swagger-ui';
-import { createFrameworkLogger } from '../logger';
+} from './openapi-generator.js';
+import { SwaggerUIMiddleware, SwaggerUIOptions, createDocsMiddleware } from './swagger-ui.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('DocumentationSystem');
 
@@ -226,6 +226,6 @@ export function generateDocsFromIntelligentRoutes(
 }
 
 // Export all types and functions
-export * from './openapi-generator';
-export * from './swagger-ui';
-export * from './zod-to-openapi';
+export * from './openapi-generator.js';
+export * from './swagger-ui.js';
+export * from './zod-to-openapi.js';

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

@@ -1,10 +1,10 @@
 // OpenAPI Specification Generator for Moro Framework
 // Extracts route information from intelligent routing and generates OpenAPI 3.0 specs
 
-import { CompiledRoute, RouteSchema } from '../routing';
-import { OpenAPISchema } from './zod-to-openapi';
-import { schemaToOpenAPI, generateExampleFromValidationSchema } from './schema-to-openapi';
-import { createFrameworkLogger } from '../logger';
+import { CompiledRoute, RouteSchema } from '../routing/index.js';
+import { OpenAPISchema } from './zod-to-openapi.js';
+import { schemaToOpenAPI, generateExampleFromValidationSchema } from './schema-to-openapi.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('OpenAPIGenerator');
 

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

@@ -1,9 +1,9 @@
 // Universal Schema to OpenAPI Converter
 // Converts ValidationSchema (Zod, Joi, etc.) to OpenAPI 3.0 schema definitions
 
-import { ValidationSchema } from '../validation/schema-interface';
-import { OpenAPISchema } from './zod-to-openapi';
-import { createFrameworkLogger } from '../logger';
+import { ValidationSchema } from '../validation/schema-interface.js';
+import { OpenAPISchema, zodToOpenAPI, generateExampleFromSchema } from './zod-to-openapi.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('SchemaToOpenAPI');
 
@@ -32,8 +32,6 @@ export function schemaToOpenAPI(
   // If it's a Zod schema, use the existing zod converter
   if (isZodSchema(schema)) {
     try {
-      // Import zod converter dynamically
-      const { zodToOpenAPI } = require('./zod-to-openapi');
       return zodToOpenAPI(schema, options);
     } catch (error) {
       logger.warn('Zod converter not available, using fallback', String(error));
@@ -59,7 +57,6 @@ export function generateExampleFromValidationSchema(schema: ValidationSchema): a
   // If it's a Zod schema, use existing example generator
   if (isZodSchema(schema)) {
     try {
-      const { generateExampleFromSchema } = require('./zod-to-openapi');
       return generateExampleFromSchema(schema);
     } catch (error) {
       logger.warn('Zod example generator not available', String(error));

package/src/core/docs/simple-docs.ts

@@ -1,8 +1,8 @@
 // Simple Documentation Generator - Fallback for when Swagger UI has issues
 // Generates clean, readable API documentation from routes
 
-import { CompiledRoute, RouteSchema } from '../routing';
-import { createFrameworkLogger } from '../logger';
+import { CompiledRoute, RouteSchema } from '../routing/index.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('SimpleDocs');
 

package/src/core/docs/swagger-ui.ts

@@ -3,9 +3,10 @@
 
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { HttpRequest, HttpResponse } from '../http';
-import { OpenAPISpec } from './openapi-generator';
-import { createFrameworkLogger } from '../logger';
+import { createUserRequire } from '../utilities/package-utils.js';
+import { HttpRequest, HttpResponse } from '../http/index.js';
+import { OpenAPISpec } from './openapi-generator.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('SwaggerUI');
 
@@ -44,7 +45,9 @@ export class SwaggerUIMiddleware {
     };
 
     try {
-      // Find swagger-ui-dist assets
+      // Find swagger-ui-dist assets using ESM-compatible resolution
+      // Create a require function from the user's working directory to find their installed packages
+      const require = createUserRequire();
       this.swaggerUIAssetPath = require
         .resolve('swagger-ui-dist/package.json')
         .replace('/package.json', '');
@@ -119,37 +122,37 @@ export class SwaggerUIMiddleware {
     <h3>Failed to Load Swagger UI</h3>
     <div id="error-details"></div>
   </div>
-  
+
   <script src="${basePath}/swagger-ui-bundle.js" charset="UTF-8"></script>
   <script src="${basePath}/swagger-ui-standalone-preset.js" charset="UTF-8"></script>
   <script>
     console.log('Starting Swagger UI initialization...');
-    
+
     function showError(message, details) {
       console.error('Swagger UI Error:', message, details);
       document.getElementById('loading-message').style.display = 'none';
       document.getElementById('error-display').style.display = 'block';
-      document.getElementById('error-details').innerHTML = 
+      document.getElementById('error-details').innerHTML =
         '<p><strong>Error:</strong> ' + message + '</p>' +
         (details ? '<pre>' + JSON.stringify(details, null, 2) + '</pre>' : '');
     }
-    
+
     function initializeSwaggerUI() {
       console.log('Initializing Swagger UI...');
-      
+
       if (typeof SwaggerUIBundle === 'undefined') {
         showError('SwaggerUIBundle not loaded', { SwaggerUIBundle: typeof SwaggerUIBundle });
         return;
       }
-      
+
       if (typeof SwaggerUIStandalonePreset === 'undefined') {
         showError('SwaggerUIStandalonePreset not loaded', { SwaggerUIStandalonePreset: typeof SwaggerUIStandalonePreset });
         return;
       }
-      
+
       try {
         console.log('Creating SwaggerUIBundle...');
-        
+
         const ui = SwaggerUIBundle({
           url: '${basePath}/openapi.json',
           dom_id: '#swagger-ui',
@@ -173,10 +176,10 @@ export class SwaggerUIMiddleware {
             showError('Swagger UI initialization failed', error);
           }
         });
-        
+
         window.ui = ui;
         console.log('SwaggerUIBundle created successfully');
-        
+
         // Hide loading message after timeout if onComplete doesn't fire
         setTimeout(function() {
           var loadingEl = document.getElementById('loading-message');
@@ -185,7 +188,7 @@ export class SwaggerUIMiddleware {
             loadingEl.style.display = 'none';
           }
         }, 5000);
-        
+
       } catch (error) {
         console.error('Error creating SwaggerUIBundle:', error);
         showError('Failed to create SwaggerUIBundle', {
@@ -194,7 +197,7 @@ export class SwaggerUIMiddleware {
         });
       }
     }
-    
+
     // Initialize when DOM is ready and scripts are loaded
     if (document.readyState === 'loading') {
       document.addEventListener('DOMContentLoaded', function() {

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

@@ -1,41 +1,39 @@
 // Zod to OpenAPI Schema Converter
 // Transforms Zod schemas into OpenAPI 3.0 schema definitions
 
-import { createFrameworkLogger } from '../logger';
+import { createFrameworkLogger } from '../logger/index.js';
+import { createUserRequire, isPackageAvailable } from '../utilities/package-utils.js';
+
+const logger = createFrameworkLogger('ZodToOpenAPI');
 
 // 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!
-}
+let zodModule: any = null;
+let zodLoadAttempted = false;
 
-const logger = createFrameworkLogger('ZodToOpenAPI');
+// Lazy synchronous initialization for Zod
+function loadZodSync() {
+  if (zodLoadAttempted) {
+    return zodModule;
+  }
+
+  zodLoadAttempted = true;
+
+  try {
+    if (!isPackageAvailable('zod')) {
+      zodModule = null;
+      return zodModule;
+    }
+
+    // Use synchronous require for immediate availability
+    const userRequire = createUserRequire();
+    zodModule = userRequire('zod');
+  } catch {
+    // Zod not available - that's fine!
+    zodModule = null;
+  }
+
+  return zodModule;
+}
 
 // OpenAPI schema types
 export interface OpenAPISchema {
@@ -72,7 +70,8 @@ export interface ConversionOptions {
 // Main conversion function
 export function zodToOpenAPI(schema: any, options: ConversionOptions = {}): OpenAPISchema {
   // Check if Zod is available
-  if (!ZodSchema) {
+  const zod = loadZodSync();
+  if (!zod) {
     throw new Error('Zod is not installed. Please install zod to use zodToOpenAPI function.');
   }
 
@@ -420,7 +419,8 @@ function hasDefault(type: any): boolean {
 // Generate example data from Zod schema
 export function generateExampleFromSchema(schema: any): any {
   // Check if Zod is available
-  if (!ZodSchema) {
+  const zod = loadZodSync();
+  if (!zod) {
     throw new Error(
       'Zod is not installed. Please install zod to use generateExampleFromSchema function.'
     );

package/src/core/events/event-bus.ts

@@ -8,8 +8,8 @@ import {
   GlobalEventBus,
   EventMetrics,
   EventHandler,
-} from '../../types/events';
-import { createFrameworkLogger } from '../logger';
+} from '../../types/events.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 export class MoroEventBus implements GlobalEventBus {
   private emitter = new EventEmitter();

package/src/core/events/index.ts

@@ -1,5 +1,5 @@
 // Event System - Centralized Exports
-export { MoroEventBus } from './event-bus';
+export { MoroEventBus } from './event-bus.js';
 export type {
   EventContext,
   EventPayload,
@@ -9,4 +9,4 @@ export type {
   EventMetrics,
   SystemEvents,
   EventHandler,
-} from '../../types/events';
+} from '../../types/events.js';