@morojs/moro 1.6.1 → 1.6.3

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

@@ -1,269 +0,0 @@
-// Database MongoDB Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
-
-interface MongoDBConfig {
-  url?: string;
-  host?: string;
-  port?: number;
-  username?: string;
-  password?: string;
-  database?: string;
-  authSource?: string;
-  ssl?: boolean;
-  replicaSet?: string;
-  maxPoolSize?: number;
-  minPoolSize?: number;
-}
-
-interface MongoDocument {
-  _id?: any;
-  [key: string]: any;
-}
-
-export class MongoDBAdapter implements DatabaseAdapter {
-  private client: any;
-  private db: any;
-  private logger = createFrameworkLogger('MongoDB');
-
-  constructor(config: MongoDBConfig) {
-    try {
-      const { MongoClient } = require('mongodb');
-
-      const url = config.url || this.buildConnectionString(config);
-
-      this.client = new MongoClient(url, {
-        maxPoolSize: config.maxPoolSize || 10,
-        minPoolSize: config.minPoolSize || 0,
-        ssl: config.ssl || false,
-      });
-
-      this.db = this.client.db(config.database || 'moro_app');
-
-      this.logger.info('MongoDB adapter initialized', 'MongoDB');
-    } catch (error) {
-      throw new Error(
-        'mongodb package is required for MongoDB adapter. Install it with: npm install mongodb'
-      );
-    }
-  }
-
-  private buildConnectionString(config: MongoDBConfig): string {
-    const host = config.host || 'localhost';
-    const port = config.port || 27017;
-    const auth = config.username && config.password ? `${config.username}:${config.password}@` : '';
-    const authSource = config.authSource ? `?authSource=${config.authSource}` : '';
-
-    return `mongodb://${auth}${host}:${port}/${config.database || 'moro_app'}${authSource}`;
-  }
-
-  async connect(): Promise<void> {
-    try {
-      await this.client.connect();
-      await this.client.db('admin').command({ ping: 1 });
-      this.logger.info('MongoDB connection established', 'Connection');
-    } catch (error) {
-      this.logger.error('MongoDB connection failed', 'Connection', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    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[]> {
-    try {
-      const coll = this.db.collection(collection);
-
-      if (pipeline && Array.isArray(pipeline)) {
-        // Aggregation pipeline
-        const cursor = coll.aggregate(pipeline);
-        return await cursor.toArray();
-      } else if (pipeline) {
-        // Find query
-        const cursor = coll.find(pipeline);
-        return await cursor.toArray();
-      } else {
-        // Find all
-        const cursor = coll.find({});
-        return await cursor.toArray();
-      }
-    } catch (error) {
-      this.logger.error('MongoDB query failed', 'Query', {
-        collection,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async queryOne<T = any>(collection: string, query?: any): Promise<T | null> {
-    try {
-      const coll = this.db.collection(collection);
-      return await coll.findOne(query || {});
-    } catch (error) {
-      this.logger.error('MongoDB queryOne failed', 'Query', {
-        collection,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async insert<T = any>(collection: string, data: Record<string, any>): Promise<T> {
-    try {
-      const coll = this.db.collection(collection);
-      const result = await coll.insertOne(data);
-
-      // Return the inserted document with _id
-      return { ...data, _id: result.insertedId } as T;
-    } catch (error) {
-      this.logger.error('MongoDB insert failed', 'Insert', {
-        collection,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async update<T = any>(
-    collection: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    try {
-      const coll = this.db.collection(collection);
-      const result = await coll.findOneAndUpdate(
-        where,
-        { $set: data },
-        { returnDocument: 'after' }
-      );
-
-      return result.value as T;
-    } catch (error) {
-      this.logger.error('MongoDB update failed', 'Update', {
-        collection,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async delete(collection: string, where: Record<string, any>): Promise<number> {
-    try {
-      const coll = this.db.collection(collection);
-      const result = await coll.deleteMany(where);
-      return result.deletedCount || 0;
-    } catch (error) {
-      this.logger.error('MongoDB delete failed', 'Delete', {
-        collection,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    const session = this.client.startSession();
-
-    try {
-      return await session.withTransaction(async () => {
-        const transaction = new MongoDBTransaction(this.db, session);
-        return await callback(transaction);
-      });
-    } finally {
-      await session.endSession();
-    }
-  }
-
-  // MongoDB-specific methods
-  async aggregate<T = any>(collection: string, pipeline: any[]): Promise<T[]> {
-    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> {
-    const coll = this.db.collection(collection);
-    return await coll.createIndex(index, options);
-  }
-
-  async dropIndex(collection: string, indexName: string): Promise<any> {
-    const coll = this.db.collection(collection);
-    return await coll.dropIndex(indexName);
-  }
-
-  async count(collection: string, query?: any): Promise<number> {
-    const coll = this.db.collection(collection);
-    return await coll.countDocuments(query || {});
-  }
-
-  getCollection(name: string) {
-    return this.db.collection(name);
-  }
-}
-
-class MongoDBTransaction implements DatabaseTransaction {
-  constructor(
-    private db: any,
-    private session: any
-  ) {}
-
-  async query<T = any>(collection: string, pipeline?: any[]): Promise<T[]> {
-    const coll = this.db.collection(collection);
-
-    if (pipeline && Array.isArray(pipeline)) {
-      const cursor = coll.aggregate(pipeline, { session: this.session });
-      return await cursor.toArray();
-    } else if (pipeline) {
-      const cursor = coll.find(pipeline, { session: this.session });
-      return await cursor.toArray();
-    } else {
-      const cursor = coll.find({}, { session: this.session });
-      return await cursor.toArray();
-    }
-  }
-
-  async queryOne<T = any>(collection: string, query?: any): Promise<T | null> {
-    const coll = this.db.collection(collection);
-    return await coll.findOne(query || {}, { session: this.session });
-  }
-
-  async insert<T = any>(collection: string, data: Record<string, any>): Promise<T> {
-    const coll = this.db.collection(collection);
-    const result = await coll.insertOne(data, { session: this.session });
-    return { ...data, _id: result.insertedId } as T;
-  }
-
-  async update<T = any>(
-    collection: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    const coll = this.db.collection(collection);
-    const result = await coll.findOneAndUpdate(
-      where,
-      { $set: data },
-      { returnDocument: 'after', session: this.session }
-    );
-    return result.value as T;
-  }
-
-  async delete(collection: string, where: Record<string, any>): Promise<number> {
-    const coll = this.db.collection(collection);
-    const result = await coll.deleteMany(where, { session: this.session });
-    return result.deletedCount || 0;
-  }
-
-  async commit(): Promise<void> {
-    await this.session.commitTransaction();
-  }
-
-  async rollback(): Promise<void> {
-    await this.session.abortTransaction();
-  }
-}

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

@@ -1,207 +0,0 @@
-// Database MySQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
-
-interface MySQLConfig {
-  host?: string;
-  port?: number;
-  user?: string;
-  password?: string;
-  database?: string;
-  connectionLimit?: number;
-}
-
-export class MySQLAdapter implements DatabaseAdapter {
-  private pool: any;
-  private logger = createFrameworkLogger('MySQL');
-
-  constructor(config: MySQLConfig) {
-    try {
-      const mysql = require('mysql2/promise');
-      this.pool = mysql.createPool({
-        host: config.host || 'localhost',
-        port: config.port || 3306,
-        user: config.user || 'root',
-        password: config.password || '',
-        database: config.database || 'moro_app',
-        waitForConnections: true,
-        connectionLimit: config.connectionLimit || 10,
-        queueLimit: 0,
-      });
-    } catch (error) {
-      throw new Error(
-        'mysql2 package is required for MySQL adapter. Install it with: npm install mysql2'
-      );
-    }
-  }
-
-  async connect(): Promise<void> {
-    try {
-      const connection = await this.pool.getConnection();
-      connection.release();
-      this.logger.info('MySQL connection established', 'Connection');
-    } catch (error) {
-      this.logger.error('MySQL connection failed', 'Connection', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    await this.pool.end();
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    const [rows] = await this.pool.execute(sql, params);
-    return rows as T[];
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    const results = await this.query<T>(sql, params);
-    return results.length > 0 ? results[0] : null;
-  }
-
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    const keys = Object.keys(data);
-    const values = Object.values(data);
-    const placeholders = keys.map(() => '?').join(', ');
-
-    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
-    const [result] = (await this.pool.execute(sql, values)) as any;
-
-    // Return the inserted record
-    const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE id = ?`, [
-      result.insertId,
-    ]);
-
-    return insertedRecord!;
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    const setClause = Object.keys(data)
-      .map(key => `${key} = ?`)
-      .join(', ');
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
-    const params = [...Object.values(data), ...Object.values(where)];
-
-    await this.pool.execute(sql, params);
-
-    // Return the updated record
-    const updatedRecord = await this.queryOne<T>(
-      `SELECT * FROM ${table} WHERE ${whereClause}`,
-      Object.values(where)
-    );
-
-    return updatedRecord!;
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-
-    const [result] = (await this.pool.execute(sql, Object.values(where))) as any;
-    return result.affectedRows;
-  }
-
-  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    const connection = await this.pool.getConnection();
-
-    try {
-      await connection.beginTransaction();
-
-      const transaction = new MySQLTransaction(connection);
-      const result = await callback(transaction);
-
-      await connection.commit();
-      return result;
-    } catch (error) {
-      await connection.rollback();
-      throw error;
-    } finally {
-      connection.release();
-    }
-  }
-}
-
-class MySQLTransaction implements DatabaseTransaction {
-  constructor(private connection: any) {}
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    const [rows] = await this.connection.execute(sql, params);
-    return rows as T[];
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    const results = await this.query<T>(sql, params);
-    return results.length > 0 ? results[0] : null;
-  }
-
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    const keys = Object.keys(data);
-    const values = Object.values(data);
-    const placeholders = keys.map(() => '?').join(', ');
-
-    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
-    const [result] = (await this.connection.execute(sql, values)) as any;
-
-    const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE id = ?`, [
-      result.insertId,
-    ]);
-
-    return insertedRecord!;
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    const setClause = Object.keys(data)
-      .map(key => `${key} = ?`)
-      .join(', ');
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
-    const params = [...Object.values(data), ...Object.values(where)];
-
-    await this.connection.execute(sql, params);
-
-    const updatedRecord = await this.queryOne<T>(
-      `SELECT * FROM ${table} WHERE ${whereClause}`,
-      Object.values(where)
-    );
-
-    return updatedRecord!;
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-
-    const [result] = (await this.connection.execute(sql, Object.values(where))) as any;
-    return result.affectedRows;
-  }
-
-  async commit(): Promise<void> {
-    await this.connection.commit();
-  }
-
-  async rollback(): Promise<void> {
-    await this.connection.rollback();
-  }
-}

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

@@ -1,201 +0,0 @@
-// Database PostgreSQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
-
-interface PostgreSQLConfig {
-  host?: string;
-  port?: number;
-  user?: string;
-  password?: string;
-  database?: string;
-  connectionLimit?: number;
-  ssl?: boolean;
-}
-
-export class PostgreSQLAdapter implements DatabaseAdapter {
-  private pool: any;
-  private logger = createFrameworkLogger('PostgreSQL');
-
-  constructor(config: PostgreSQLConfig) {
-    try {
-      const { Pool } = require('pg');
-      this.pool = new Pool({
-        host: config.host || 'localhost',
-        port: config.port || 5432,
-        user: config.user || 'postgres',
-        password: config.password || '',
-        database: config.database || 'moro_app',
-        max: config.connectionLimit || 10,
-        ssl: config.ssl || false,
-      });
-
-      this.pool.on('error', (err: Error) => {
-        this.logger.error('PostgreSQL pool error', 'Pool', {
-          error: err.message,
-        });
-      });
-
-      this.logger.info('PostgreSQL adapter initialized', 'PostgreSQL');
-    } catch (error) {
-      throw new Error(
-        'pg package is required for PostgreSQL adapter. Install it with: npm install pg'
-      );
-    }
-  }
-
-  async connect(): Promise<void> {
-    try {
-      const client = await this.pool.connect();
-      client.release();
-      this.logger.info('PostgreSQL connection established', 'Connection');
-    } catch (error) {
-      this.logger.error('PostgreSQL connection failed', 'Connection', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    await this.pool.end();
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    const result = await this.pool.query(sql, params);
-    return result.rows as T[];
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    const results = await this.query<T>(sql, params);
-    return results.length > 0 ? results[0] : null;
-  }
-
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    const keys = Object.keys(data);
-    const values = Object.values(data);
-    const placeholders = keys.map((_, index) => `$${index + 1}`).join(', ');
-
-    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
-    const result = await this.pool.query(sql, values);
-
-    return result.rows[0] as T;
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    const dataKeys = Object.keys(data);
-    const dataValues = Object.values(data);
-    const whereKeys = Object.keys(where);
-    const whereValues = Object.values(where);
-
-    const setClause = dataKeys.map((key, index) => `${key} = $${index + 1}`).join(', ');
-    const whereClause = whereKeys
-      .map((key, index) => `${key} = $${dataKeys.length + index + 1}`)
-      .join(' AND ');
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-    const params = [...dataValues, ...whereValues];
-
-    const result = await this.pool.query(sql, params);
-    return result.rows[0] as T;
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    const whereKeys = Object.keys(where);
-    const whereValues = Object.values(where);
-    const whereClause = whereKeys.map((key, index) => `${key} = $${index + 1}`).join(' AND ');
-
-    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-    const result = await this.pool.query(sql, whereValues);
-
-    return result.rowCount || 0;
-  }
-
-  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    const client = await this.pool.connect();
-
-    try {
-      await client.query('BEGIN');
-
-      const transaction = new PostgreSQLTransaction(client);
-      const result = await callback(transaction);
-
-      await client.query('COMMIT');
-      return result;
-    } catch (error) {
-      await client.query('ROLLBACK');
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-}
-
-class PostgreSQLTransaction implements DatabaseTransaction {
-  constructor(private client: any) {}
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    const result = await this.client.query(sql, params);
-    return result.rows as T[];
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    const results = await this.query<T>(sql, params);
-    return results.length > 0 ? results[0] : null;
-  }
-
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    const keys = Object.keys(data);
-    const values = Object.values(data);
-    const placeholders = keys.map((_, index) => `$${index + 1}`).join(', ');
-
-    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
-    const result = await this.client.query(sql, values);
-
-    return result.rows[0] as T;
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    const dataKeys = Object.keys(data);
-    const dataValues = Object.values(data);
-    const whereKeys = Object.keys(where);
-    const whereValues = Object.values(where);
-
-    const setClause = dataKeys.map((key, index) => `${key} = $${index + 1}`).join(', ');
-    const whereClause = whereKeys
-      .map((key, index) => `${key} = $${dataKeys.length + index + 1}`)
-      .join(' AND ');
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-    const params = [...dataValues, ...whereValues];
-
-    const result = await this.client.query(sql, params);
-    return result.rows[0] as T;
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    const whereKeys = Object.keys(where);
-    const whereValues = Object.values(where);
-    const whereClause = whereKeys.map((key, index) => `${key} = $${index + 1}`).join(' AND ');
-
-    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-    const result = await this.client.query(sql, whereValues);
-
-    return result.rowCount || 0;
-  }
-
-  async commit(): Promise<void> {
-    await this.client.query('COMMIT');
-  }
-
-  async rollback(): Promise<void> {
-    await this.client.query('ROLLBACK');
-  }
-}