@morojs/moro 1.6.0 → 1.6.1

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

@@ -1,7 +1,6 @@
 // Database MongoDB Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface MongoDBConfig {
   url?: string;
@@ -12,16 +11,6 @@ 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;
@@ -36,43 +25,18 @@ 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 mongodbPath = resolveUserPackage('mongodb');
-      const mongodb = await import(mongodbPath);
-      const { MongoClient } = mongodb;
+      const { MongoClient } = require('mongodb');
 
       const url = config.url || this.buildConnectionString(config);
 
-      const clientOptions: any = {
+      this.client = new MongoClient(url, {
         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');
 
@@ -94,7 +58,6 @@ 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 });
@@ -108,13 +71,11 @@ 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);
 
@@ -141,7 +102,6 @@ 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 || {});
@@ -155,7 +115,6 @@ 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);
@@ -176,7 +135,6 @@ 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(
@@ -196,7 +154,6 @@ 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);
@@ -211,7 +168,6 @@ export class MongoDBAdapter implements DatabaseAdapter {
   }
 
   async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    await this.initPromise;
     const session = this.client.startSession();
 
     try {
@@ -226,26 +182,22 @@ 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,7 +1,6 @@
 // Database MySQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface MySQLConfig {
   host?: string;
@@ -10,35 +9,16 @@ 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 mysqlPath = resolveUserPackage('mysql2/promise');
-      const mysql = await import(mysqlPath);
-      this.pool = mysql.default.createPool({
+      const mysql = require('mysql2/promise');
+      this.pool = mysql.createPool({
         host: config.host || 'localhost',
         port: config.port || 3306,
         user: config.user || 'root',
@@ -47,7 +27,6 @@ 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(
@@ -57,7 +36,6 @@ export class MySQLAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
-    await this.initPromise;
     try {
       const connection = await this.pool.getConnection();
       connection.release();
@@ -71,12 +49,10 @@ 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[];
   }
@@ -87,7 +63,6 @@ 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(', ');
@@ -108,7 +83,6 @@ 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(', ');
@@ -131,7 +105,6 @@ 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 ');
@@ -142,7 +115,6 @@ 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,7 +1,6 @@
 // Database PostgreSQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface PostgreSQLConfig {
   host?: string;
@@ -10,33 +9,16 @@ interface PostgreSQLConfig {
   password?: string;
   database?: string;
   connectionLimit?: number;
-  ssl?:
-    | {
-        rejectUnauthorized?: boolean;
-        ca?: string;
-        cert?: string;
-        key?: string;
-        passphrase?: string;
-        servername?: string;
-        checkServerIdentity?: boolean;
-      }
-    | boolean;
+  ssl?: 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 pgPath = resolveUserPackage('pg');
-      const pg = await import(pgPath);
-      const { Pool } = pg.default;
+      const { Pool } = require('pg');
       this.pool = new Pool({
         host: config.host || 'localhost',
         port: config.port || 5432,
@@ -44,7 +26,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
         password: config.password || '',
         database: config.database || 'moro_app',
         max: config.connectionLimit || 10,
-        ssl: typeof config.ssl === 'object' ? { ...config.ssl } : config.ssl || false,
+        ssl: config.ssl || false,
       });
 
       this.pool.on('error', (err: Error) => {
@@ -62,7 +44,6 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
-    await this.initPromise;
     try {
       const client = await this.pool.connect();
       client.release();
@@ -76,12 +57,10 @@ 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[];
   }
@@ -92,7 +71,6 @@ 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(', ');
@@ -108,7 +86,6 @@ 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);
@@ -127,7 +104,6 @@ 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 ');
@@ -139,7 +115,6 @@ 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,7 +1,6 @@
 // Database Redis Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface RedisConfig {
   host?: string;
@@ -12,15 +11,6 @@ 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;
@@ -32,35 +22,21 @@ 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 ioredisPath = resolveUserPackage('ioredis');
-      const ioredis = await import(ioredisPath);
-      const Redis = ioredis.default;
+      const Redis = require('ioredis');
+      this.keyPrefix = config.keyPrefix || 'moro:';
 
       if (config.cluster) {
         // Redis Cluster
-        const clusterOptions: any = {
+        this.client = new Redis.Cluster(config.cluster.nodes, {
           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
-        const redisOptions: any = {
+        this.client = new Redis({
           host: config.host || 'localhost',
           port: config.port || 6379,
           password: config.password,
@@ -68,14 +44,7 @@ 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) => {
@@ -105,7 +74,6 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async connect(): Promise<void> {
-    await this.initPromise;
     try {
       await this.client.ping();
       this.logger.info('Redis connection established', 'Connection');
@@ -118,13 +86,11 @@ 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 [];
@@ -144,7 +110,6 @@ 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;
@@ -158,7 +123,6 @@ 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);
@@ -177,7 +141,6 @@ 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);
@@ -195,7 +158,6 @@ 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;
@@ -212,7 +174,6 @@ 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);
 
@@ -229,7 +190,6 @@ 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));
@@ -239,46 +199,38 @@ 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)) {
@@ -288,30 +240,25 @@ 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,7 +1,6 @@
 // Database SQLite Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface SQLiteConfig {
   filename?: string;
@@ -15,17 +14,10 @@ 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 sqlite3Path = resolveUserPackage('better-sqlite3');
-      const betterSqlite3 = await import(sqlite3Path);
-      const Database = betterSqlite3.default;
+      const Database = require('better-sqlite3');
       const filename = config.memory ? ':memory:' : config.filename || 'moro_app.db';
       this.db = new Database(filename, {
         readonly: config.readonly || false,
@@ -48,18 +40,15 @@ 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 || []);
@@ -74,7 +63,6 @@ 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 || []);
@@ -89,7 +77,6 @@ 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(', ');
@@ -120,7 +107,6 @@ 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(', ');
@@ -152,7 +138,6 @@ 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 ');
@@ -172,7 +157,6 @@ 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/index.js';
-export * from '../../types/database.js';
+export * from './adapters';
+export * from '../../types/database';