@morojs/moro 1.0.0

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

@@ -0,0 +1,292 @@
+// 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

@@ -0,0 +1,217 @@
+// 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

@@ -0,0 +1,211 @@
+// 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");
+  }
+}