@morojs/moro 1.5.16 → 1.6.0

package/src/core/config/config-validator.ts

@@ -5,8 +5,8 @@
  * simple TypeScript functions that match the type definitions exactly.
  */
 
-import { AppConfig } from '../../types/config';
-import { createFrameworkLogger } from '../logger';
+import { AppConfig } from '../../types/config.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('ConfigValidator');
 
@@ -75,7 +75,7 @@ function validateServerConfig(config: any, path: string) {
     );
   }
 
-  return {
+  const result: any = {
     port: validatePort(config.port, `${path}.port`),
     host: validateString(config.host, `${path}.host`),
     maxConnections: validateNumber(config.maxConnections, `${path}.maxConnections`, { min: 1 }),
@@ -88,6 +88,41 @@ function validateServerConfig(config: any, path: string) {
       enabled: validateBoolean(config.errorBoundary?.enabled, `${path}.errorBoundary.enabled`),
     },
   };
+
+  // Optional uWebSockets configuration
+  if (config.useUWebSockets !== undefined) {
+    result.useUWebSockets = validateBoolean(config.useUWebSockets, `${path}.useUWebSockets`);
+  }
+
+  // Optional SSL configuration
+  if (config.ssl !== undefined) {
+    result.ssl = validateSSLConfig(config.ssl, `${path}.ssl`);
+  }
+
+  return result;
+}
+
+/**
+ * Validate SSL configuration
+ */
+function validateSSLConfig(config: any, path: string) {
+  if (!config || typeof config !== 'object') {
+    throw new ConfigValidationError(path, config, 'object', 'SSL configuration must be an object');
+  }
+
+  const result: any = {};
+
+  if (config.key_file_name !== undefined) {
+    result.key_file_name = validateString(config.key_file_name, `${path}.key_file_name`);
+  }
+  if (config.cert_file_name !== undefined) {
+    result.cert_file_name = validateString(config.cert_file_name, `${path}.cert_file_name`);
+  }
+  if (config.passphrase !== undefined) {
+    result.passphrase = validateString(config.passphrase, `${path}.passphrase`);
+  }
+
+  return result;
 }
 
 /**

package/src/core/config/file-loader.ts

@@ -1,11 +1,16 @@
 // Configuration File Loader - Load moro.config.js/ts files
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { AppConfig } from './schema';
-import { createFrameworkLogger } from '../logger';
+import { createRequire } from 'module';
+import { AppConfig } from './schema.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('ConfigFile');
 
+// Create require function for ESM to enable synchronous config loading
+// Use process.cwd() as base since we're loading with absolute paths anyway
+const moduleRequire = createRequire(join(process.cwd(), 'index.js'));
+
 /**
  * Supported configuration file names in order of preference
  */
@@ -23,55 +28,23 @@ export function loadConfigFileSync(cwd: string = process.cwd()): Partial<AppConf
     logger.debug('No configuration file found');
     return null;
   }
-  // Handle TypeScript files by trying dynamic import (works with tsx/ts-node runtimes)
-  if (configFile.endsWith('.ts')) {
-    logger.debug('Found TypeScript config file, attempting to load with dynamic import');
-    try {
-      // When running under tsx/ts-node, dynamic imports work synchronously for TypeScript
-      // We can use require() with the current environment that already has TypeScript support
-      const config = require(configFile);
-      const configData = config.default || config;
-
-      if (!configData || typeof configData !== 'object') {
-        logger.warn(`Configuration file ${configFile} did not export a valid configuration object`);
-        return null;
-      }
-
-      logger.info(`TypeScript configuration loaded from: ${configFile}`);
-      return configData;
-    } catch (error) {
-      logger.debug(
-        'TypeScript config loading failed in sync mode, this is expected if not running with tsx/ts-node'
-      );
-      logger.debug('Error details:', String(error));
-      return null;
-    }
-  }
-
-  // Only .js files use the standard synchronous loading
-  if (!configFile.endsWith('.js')) {
-    logger.debug(
-      'Found config file with unsupported extension. Only .js and .ts files are supported.'
-    );
-    return null;
-  }
 
   logger.debug(`Loading configuration from: ${configFile}`);
 
   try {
-    // Clear module cache to ensure fresh load
-    delete require.cache[require.resolve(configFile)];
+    // Use createRequire to enable synchronous loading in ESM
+    // Clear the require cache to ensure fresh config on each load
+    delete moduleRequire.cache[moduleRequire.resolve(configFile)];
 
-    const config = require(configFile);
-    const configData = config.default || config;
+    const config = moduleRequire(configFile);
 
-    if (!configData || typeof configData !== 'object') {
+    if (!config || typeof config !== 'object') {
       logger.warn(`Configuration file ${configFile} did not export a valid configuration object`);
       return null;
     }
 
     logger.info(`Configuration loaded from: ${configFile}`);
-    return configData;
+    return config;
   } catch (error) {
     logger.error(`Failed to load configuration file ${configFile}:`, String(error));
     logger.warn('Falling back to environment variable configuration');

package/src/core/config/index.ts

@@ -12,27 +12,31 @@
  */
 
 // Export types and core components
-export * from './schema';
-export * from './config-sources';
-export * from './config-validator';
-export * from './file-loader';
+export * from './schema.js';
+export * from './config-sources.js';
+export * from './config-validator.js';
+export * from './file-loader.js';
 
 // Export specific functions from config-manager to avoid conflicts
-export { initializeAndLockConfig, isConfigLocked, resetConfigForTesting } from './config-manager';
+export {
+  initializeAndLockConfig,
+  isConfigLocked,
+  resetConfigForTesting,
+} from './config-manager.js';
 
 // Export utilities for backward compatibility
-export * from './utils';
+export * from './utils.js';
 
-import { MoroOptions } from '../../types/core';
-import { AppConfig } from '../../types/config';
-import { loadConfigFromAllSources } from './config-sources';
+import { MoroOptions } from '../../types/core.js';
+import { AppConfig } from '../../types/config.js';
+import { loadConfigFromAllSources } from './config-sources.js';
 import {
   initializeAndLockConfig,
   getGlobalConfig as getConfig,
   isConfigLocked,
   resetConfigForTesting,
-} from './config-manager';
-import { createFrameworkLogger } from '../logger';
+} from './config-manager.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('ConfigSystem');
 

package/src/core/config/schema.ts

@@ -1,6 +1,6 @@
 // Core Configuration Schema for Moro Framework
 
-import { AppConfig } from '../../types/config';
+import { AppConfig } from '../../types/config.js';
 
 // Minimal default configuration - performance-focused, most things opt-in
 export const DEFAULT_CONFIG: AppConfig = {
@@ -10,6 +10,7 @@ export const DEFAULT_CONFIG: AppConfig = {
     maxConnections: 1000,
     timeout: 30000,
     bodySizeLimit: '10mb',
+    useUWebSockets: false, // Opt-in for ultra-high performance
     requestTracking: {
       enabled: true, // Enable by default for debugging
     },
@@ -147,7 +148,7 @@ export type {
   SecurityConfig,
   ExternalServicesConfig,
   PerformanceConfig,
-} from '../../types/config';
+} from '../../types/config.js';
 
 // For backward compatibility with modules that expect schema objects
 export const ServerConfigSchema = { parse: (data: any) => data };

package/src/core/config/utils.ts

@@ -1,7 +1,7 @@
 // Configuration Utilities for Modules and Environment Handling
-import { AppConfig } from './schema';
-import { createFrameworkLogger } from '../logger';
-import { getGlobalConfig } from './config-manager';
+import { AppConfig } from './schema.js';
+import { createFrameworkLogger } from '../logger/index.js';
+import { getGlobalConfig } from './config-manager.js';
 
 const logger = createFrameworkLogger('ConfigUtils');
 

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

@@ -1,6 +1,18 @@
 // Database Drizzle ORM 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';
+
+// 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;
+}
 
 interface DrizzleConfig {
   database: any; // Drizzle database instance
@@ -108,7 +120,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
       if (this.schema && this.schema[table]) {
         // Use schema-based update
         try {
-          const { eq, and } = require('drizzle-orm');
+          const { eq, and } = await getDrizzleOrm();
 
           // Build where conditions
           const conditions = Object.entries(where).map(([key, value]) =>
@@ -165,7 +177,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
       if (this.schema && this.schema[table]) {
         // Use schema-based delete
         try {
-          const { eq, and } = require('drizzle-orm');
+          const { eq, and } = await getDrizzleOrm();
 
           const conditions = Object.entries(where).map(([key, value]) =>
             eq(this.schema[table][key], value)
@@ -314,7 +326,7 @@ class DrizzleTransaction implements DatabaseTransaction {
   ): Promise<T> {
     if (this.schema && this.schema[table]) {
       try {
-        const { eq, and } = require('drizzle-orm');
+        const { eq, and } = await getDrizzleOrm();
 
         const conditions = Object.entries(where).map(([key, value]) =>
           eq(this.schema[table][key], value)
@@ -360,7 +372,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 } = require('drizzle-orm');
+        const { eq, and } = await getDrizzleOrm();
 
         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';
-export { PostgreSQLAdapter } from './postgresql';
-export { SQLiteAdapter } from './sqlite';
-export { MongoDBAdapter } from './mongodb';
-export { RedisAdapter } from './redis';
-export { DrizzleAdapter } from './drizzle';
+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';
 
-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';
+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';
 
 // Adapter factory function for auto-loading
 export function createDatabaseAdapter(type: string, options: any = {}): DatabaseAdapter {

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

@@ -1,6 +1,7 @@
 // Database MongoDB 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 MongoDBConfig {
   url?: string;
@@ -35,10 +36,17 @@ export class MongoDBAdapter implements DatabaseAdapter {
   private client: any;
   private db: any;
   private logger = createFrameworkLogger('MongoDB');
+  private initPromise: Promise<void>;
 
   constructor(config: MongoDBConfig) {
+    this.initPromise = this.initialize(config);
+  }
+
+  private async initialize(config: MongoDBConfig): Promise<void> {
     try {
-      const { MongoClient } = require('mongodb');
+      const mongodbPath = resolveUserPackage('mongodb');
+      const mongodb = await import(mongodbPath);
+      const { MongoClient } = mongodb;
 
       const url = config.url || this.buildConnectionString(config);
 
@@ -86,6 +94,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     try {
       await this.client.connect();
       await this.client.db('admin').command({ ping: 1 });
@@ -99,11 +108,13 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async disconnect(): Promise<void> {
+    await this.initPromise;
     await this.client.close();
   }
 
   // For MongoDB, we'll treat "sql" as collection name and "params" as query/pipeline
   async query<T = any>(collection: string, pipeline?: any[]): Promise<T[]> {
+    await this.initPromise;
     try {
       const coll = this.db.collection(collection);
 
@@ -130,6 +141,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async queryOne<T = any>(collection: string, query?: any): Promise<T | null> {
+    await this.initPromise;
     try {
       const coll = this.db.collection(collection);
       return await coll.findOne(query || {});
@@ -143,6 +155,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async insert<T = any>(collection: string, data: Record<string, any>): Promise<T> {
+    await this.initPromise;
     try {
       const coll = this.db.collection(collection);
       const result = await coll.insertOne(data);
@@ -163,6 +176,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
     data: Record<string, any>,
     where: Record<string, any>
   ): Promise<T> {
+    await this.initPromise;
     try {
       const coll = this.db.collection(collection);
       const result = await coll.findOneAndUpdate(
@@ -182,6 +196,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async delete(collection: string, where: Record<string, any>): Promise<number> {
+    await this.initPromise;
     try {
       const coll = this.db.collection(collection);
       const result = await coll.deleteMany(where);
@@ -196,6 +211,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
+    await this.initPromise;
     const session = this.client.startSession();
 
     try {
@@ -210,22 +226,26 @@ export class MongoDBAdapter implements DatabaseAdapter {
 
   // MongoDB-specific methods
   async aggregate<T = any>(collection: string, pipeline: any[]): Promise<T[]> {
+    await this.initPromise;
     const coll = this.db.collection(collection);
     const cursor = coll.aggregate(pipeline);
     return await cursor.toArray();
   }
 
   async createIndex(collection: string, index: any, options?: any): Promise<string> {
+    await this.initPromise;
     const coll = this.db.collection(collection);
     return await coll.createIndex(index, options);
   }
 
   async dropIndex(collection: string, indexName: string): Promise<any> {
+    await this.initPromise;
     const coll = this.db.collection(collection);
     return await coll.dropIndex(indexName);
   }
 
   async count(collection: string, query?: any): Promise<number> {
+    await this.initPromise;
     const coll = this.db.collection(collection);
     return await coll.countDocuments(query || {});
   }

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

@@ -1,6 +1,7 @@
 // Database MySQL 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 MySQLConfig {
   host?: string;
@@ -27,11 +28,17 @@ interface MySQLConfig {
 export class MySQLAdapter implements DatabaseAdapter {
   private pool: any;
   private logger = createFrameworkLogger('MySQL');
+  private initPromise: Promise<void>;
 
   constructor(config: MySQLConfig) {
+    this.initPromise = this.initialize(config);
+  }
+
+  private async initialize(config: MySQLConfig): Promise<void> {
     try {
-      const mysql = require('mysql2/promise');
-      this.pool = mysql.createPool({
+      const mysqlPath = resolveUserPackage('mysql2/promise');
+      const mysql = await import(mysqlPath);
+      this.pool = mysql.default.createPool({
         host: config.host || 'localhost',
         port: config.port || 3306,
         user: config.user || 'root',
@@ -50,6 +57,7 @@ export class MySQLAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     try {
       const connection = await this.pool.getConnection();
       connection.release();
@@ -63,10 +71,12 @@ export class MySQLAdapter 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 [rows] = await this.pool.execute(sql, params);
     return rows as T[];
   }
@@ -77,6 +87,7 @@ export class MySQLAdapter 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(', ');
@@ -97,6 +108,7 @@ export class MySQLAdapter implements DatabaseAdapter {
     data: Record<string, any>,
     where: Record<string, any>
   ): Promise<T> {
+    await this.initPromise;
     const setClause = Object.keys(data)
       .map(key => `${key} = ?`)
       .join(', ');
@@ -119,6 +131,7 @@ export class MySQLAdapter 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 ');
@@ -129,6 +142,7 @@ export class MySQLAdapter implements DatabaseAdapter {
   }
 
   async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
+    await this.initPromise;
     const connection = await this.pool.getConnection();
 
     try {

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;
@@ -25,10 +26,17 @@ interface PostgreSQLConfig {
 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,
@@ -54,6 +62,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     try {
       const client = await this.pool.connect();
       client.release();
@@ -67,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[];
   }
@@ -81,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(', ');
@@ -96,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);
@@ -114,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 ');
@@ -125,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 {