@morojs/moro 1.5.17 → 1.6.0

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 {

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';