@morojs/moro 1.6.1 → 1.6.2

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

@@ -1,6 +1,7 @@
 // Database PostgreSQL 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 PostgreSQLConfig {
   host?: string;
@@ -9,16 +10,33 @@ interface PostgreSQLConfig {
   password?: string;
   database?: string;
   connectionLimit?: number;
-  ssl?: boolean;
+  ssl?:
+    | {
+        rejectUnauthorized?: boolean;
+        ca?: string;
+        cert?: string;
+        key?: string;
+        passphrase?: string;
+        servername?: string;
+        checkServerIdentity?: boolean;
+      }
+    | boolean;
 }
 
 export class PostgreSQLAdapter implements DatabaseAdapter {
   private pool: any;
   private logger = createFrameworkLogger('PostgreSQL');
+  private initPromise: Promise<void>;
 
   constructor(config: PostgreSQLConfig) {
+    this.initPromise = this.initialize(config);
+  }
+
+  private async initialize(config: PostgreSQLConfig): Promise<void> {
     try {
-      const { Pool } = require('pg');
+      const pgPath = resolveUserPackage('pg');
+      const pg = await import(pgPath);
+      const { Pool } = pg.default;
       this.pool = new Pool({
         host: config.host || 'localhost',
         port: config.port || 5432,
@@ -26,7 +44,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
         password: config.password || '',
         database: config.database || 'moro_app',
         max: config.connectionLimit || 10,
-        ssl: config.ssl || false,
+        ssl: typeof config.ssl === 'object' ? { ...config.ssl } : config.ssl || false,
       });
 
       this.pool.on('error', (err: Error) => {
@@ -44,6 +62,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     try {
       const client = await this.pool.connect();
       client.release();
@@ -57,10 +76,12 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   }
 
   async disconnect(): Promise<void> {
+    await this.initPromise;
     await this.pool.end();
   }
 
   async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
+    await this.initPromise;
     const result = await this.pool.query(sql, params);
     return result.rows as T[];
   }
@@ -71,6 +92,7 @@ export class PostgreSQLAdapter 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((_, index) => `$${index + 1}`).join(', ');
@@ -86,6 +108,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     data: Record<string, any>,
     where: Record<string, any>
   ): Promise<T> {
+    await this.initPromise;
     const dataKeys = Object.keys(data);
     const dataValues = Object.values(data);
     const whereKeys = Object.keys(where);
@@ -104,6 +127,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   }
 
   async delete(table: string, where: Record<string, any>): Promise<number> {
+    await this.initPromise;
     const whereKeys = Object.keys(where);
     const whereValues = Object.values(where);
     const whereClause = whereKeys.map((key, index) => `${key} = $${index + 1}`).join(' AND ');
@@ -115,6 +139,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   }
 
   async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
+    await this.initPromise;
     const client = await this.pool.connect();
 
     try {

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;
@@ -11,6 +12,15 @@ interface RedisConfig {
   maxRetriesPerRequest?: number;
   retryDelayOnFailover?: number;
   lazyConnect?: boolean;
+  tls?: {
+    rejectUnauthorized?: boolean;
+    ca?: string;
+    cert?: string;
+    key?: string;
+    passphrase?: string;
+    servername?: string;
+    checkServerIdentity?: boolean;
+  };
   cluster?: {
     enableReadyCheck?: boolean;
     redisOptions?: any;
@@ -22,21 +32,35 @@ 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
-        this.client = new Redis.Cluster(config.cluster.nodes, {
+        const clusterOptions: any = {
           enableReadyCheck: config.cluster.enableReadyCheck || false,
           redisOptions: config.cluster.redisOptions || {},
-        });
+        };
+
+        // Add TLS options to cluster configuration
+        if (config.tls) {
+          clusterOptions.redisOptions.tls = { ...config.tls };
+        }
+
+        this.client = new Redis.Cluster(config.cluster.nodes, clusterOptions);
       } else {
         // Single Redis instance
-        this.client = new Redis({
+        const redisOptions: any = {
           host: config.host || 'localhost',
           port: config.port || 6379,
           password: config.password,
@@ -44,7 +68,14 @@ export class RedisAdapter implements DatabaseAdapter {
           maxRetriesPerRequest: config.maxRetriesPerRequest || 3,
           retryDelayOnFailover: config.retryDelayOnFailover || 100,
           lazyConnect: config.lazyConnect || true,
-        });
+        };
+
+        // Add TLS options if provided
+        if (config.tls) {
+          redisOptions.tls = { ...config.tls };
+        }
+
+        this.client = new Redis(redisOptions);
       }
 
       this.client.on('error', (err: Error) => {
@@ -74,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');
@@ -86,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 [];
@@ -110,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;
@@ -123,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);
@@ -141,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);
@@ -158,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;
@@ -174,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);
 
@@ -190,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));
@@ -199,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)) {
@@ -240,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() {