@morojs/moro 1.6.1 → 1.6.2

package/src/core/config/utils.ts

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

package/src/core/database/README.md

@@ -7,16 +7,19 @@ 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`
@@ -24,11 +27,13 @@ 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`
@@ -36,6 +41,7 @@ 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`
@@ -43,7 +49,7 @@ The MoroJS database module provides a pluggable adapter system for different dat
 ## Factory Pattern (Recommended)
 
 ```typescript
-import { createDatabaseAdapter } from 'moro';
+import { createDatabaseAdapter } from '@morojs/moro';
 
 // SQL Databases
 const mysql = createDatabaseAdapter('mysql', {
@@ -52,7 +58,7 @@ const mysql = createDatabaseAdapter('mysql', {
   user: 'root',
   password: 'password',
   database: 'my_app',
-  connectionLimit: 10
+  connectionLimit: 10,
 });
 
 const postgres = createDatabaseAdapter('postgresql', {
@@ -62,12 +68,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
@@ -76,34 +82,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 'moro';
+} from '@morojs/moro';
 
 // SQL
 const mysql = new MySQLAdapter({ host: 'localhost', ... });
@@ -151,7 +157,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;
@@ -161,6 +167,7 @@ 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]);
@@ -171,6 +178,7 @@ 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
@@ -179,12 +187,13 @@ 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
@@ -197,6 +206,7 @@ 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));
@@ -213,7 +223,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
@@ -225,4 +235,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,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;
@@ -11,6 +12,16 @@ interface MongoDBConfig {
   database?: string;
   authSource?: string;
   ssl?: boolean;
+  tls?: {
+    ca?: string;
+    cert?: string;
+    key?: string;
+    passphrase?: string;
+    insecure?: boolean;
+    allowInvalidCertificates?: boolean;
+    allowInvalidHostnames?: boolean;
+    checkServerIdentity?: boolean;
+  };
   replicaSet?: string;
   maxPoolSize?: number;
   minPoolSize?: number;
@@ -25,18 +36,43 @@ 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);
 
-      this.client = new MongoClient(url, {
+      const clientOptions: any = {
         maxPoolSize: config.maxPoolSize || 10,
         minPoolSize: config.minPoolSize || 0,
         ssl: config.ssl || false,
-      });
+      };
+
+      // Add TLS options if provided
+      if (config.tls) {
+        clientOptions.tls = true;
+        if (config.tls.ca) clientOptions.tlsCAFile = config.tls.ca;
+        if (config.tls.cert) clientOptions.tlsCertificateFile = config.tls.cert;
+        if (config.tls.key) clientOptions.tlsCertificateKeyFile = config.tls.key;
+        if (config.tls.passphrase)
+          clientOptions.tlsCertificateKeyFilePassword = config.tls.passphrase;
+        if (config.tls.insecure) clientOptions.tlsInsecure = config.tls.insecure;
+        if (config.tls.allowInvalidCertificates)
+          clientOptions.tlsAllowInvalidCertificates = config.tls.allowInvalidCertificates;
+        if (config.tls.allowInvalidHostnames)
+          clientOptions.tlsAllowInvalidHostnames = config.tls.allowInvalidHostnames;
+        if (config.tls.checkServerIdentity === false) clientOptions.checkServerIdentity = false;
+      }
+
+      this.client = new MongoClient(url, clientOptions);
 
       this.db = this.client.db(config.database || 'moro_app');
 
@@ -58,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 });
@@ -71,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);
 
@@ -102,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 || {});
@@ -115,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);
@@ -135,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(
@@ -154,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);
@@ -168,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 {
@@ -182,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;
@@ -9,16 +10,35 @@ interface MySQLConfig {
   password?: string;
   database?: string;
   connectionLimit?: number;
+  ssl?:
+    | {
+        rejectUnauthorized?: boolean;
+        ca?: string;
+        cert?: string;
+        key?: string;
+        passphrase?: string;
+        servername?: string;
+        checkServerIdentity?: boolean;
+        ciphers?: string;
+        secureProtocol?: string;
+      }
+    | boolean;
 }
 
 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',
@@ -27,6 +47,7 @@ export class MySQLAdapter implements DatabaseAdapter {
         waitForConnections: true,
         connectionLimit: config.connectionLimit || 10,
         queueLimit: 0,
+        ssl: typeof config.ssl === 'object' ? { ...config.ssl } : config.ssl || false,
       });
     } catch (error) {
       throw new Error(
@@ -36,6 +57,7 @@ export class MySQLAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
+    await this.initPromise;
     try {
       const connection = await this.pool.getConnection();
       connection.release();
@@ -49,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[];
   }
@@ -63,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(', ');
@@ -83,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(', ');
@@ -105,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 ');
@@ -115,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 {