@morojs/moro 1.0.0 → 1.0.1

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

@@ -1,6 +1,6 @@
 // Database MySQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from "../../../types/database";
-import { createFrameworkLogger } from "../../logger";
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface MySQLConfig {
   host?: string;
@@ -13,24 +13,24 @@ interface MySQLConfig {
 
 export class MySQLAdapter implements DatabaseAdapter {
   private pool: any;
-  private logger = createFrameworkLogger("MySQL");
+  private logger = createFrameworkLogger('MySQL');
 
   constructor(config: MySQLConfig) {
     try {
-      const mysql = require("mysql2/promise");
+      const mysql = require('mysql2/promise');
       this.pool = mysql.createPool({
-        host: config.host || "localhost",
+        host: config.host || 'localhost',
         port: config.port || 3306,
-        user: config.user || "root",
-        password: config.password || "",
-        database: config.database || "moro_app",
+        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",
+        'mysql2 package is required for MySQL adapter. Install it with: npm install mysql2'
       );
     }
   }
@@ -39,9 +39,9 @@ export class MySQLAdapter implements DatabaseAdapter {
     try {
       const connection = await this.pool.getConnection();
       connection.release();
-      this.logger.info("MySQL connection established", "Connection");
+      this.logger.info('MySQL connection established', 'Connection');
     } catch (error) {
-      this.logger.error("MySQL connection failed", "Connection", {
+      this.logger.error('MySQL connection failed', 'Connection', {
         error: error instanceof Error ? error.message : String(error),
       });
       throw error;
@@ -65,16 +65,15 @@ export class MySQLAdapter implements DatabaseAdapter {
   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 placeholders = keys.map(() => '?').join(', ');
 
-    const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
+    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],
-    );
+    const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE id = ?`, [
+      result.insertId,
+    ]);
 
     return insertedRecord!;
   }
@@ -82,14 +81,14 @@ export class MySQLAdapter implements DatabaseAdapter {
   async update<T = any>(
     table: string,
     data: Record<string, any>,
-    where: Record<string, any>,
+    where: Record<string, any>
   ): Promise<T> {
     const setClause = Object.keys(data)
-      .map((key) => `${key} = ?`)
-      .join(", ");
+      .map(key => `${key} = ?`)
+      .join(', ');
     const whereClause = Object.keys(where)
-      .map((key) => `${key} = ?`)
-      .join(" AND ");
+      .map(key => `${key} = ?`)
+      .join(' AND ');
 
     const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
     const params = [...Object.values(data), ...Object.values(where)];
@@ -99,7 +98,7 @@ export class MySQLAdapter implements DatabaseAdapter {
     // Return the updated record
     const updatedRecord = await this.queryOne<T>(
       `SELECT * FROM ${table} WHERE ${whereClause}`,
-      Object.values(where),
+      Object.values(where)
     );
 
     return updatedRecord!;
@@ -107,20 +106,15 @@ export class MySQLAdapter implements DatabaseAdapter {
 
   async delete(table: string, where: Record<string, any>): Promise<number> {
     const whereClause = Object.keys(where)
-      .map((key) => `${key} = ?`)
-      .join(" AND ");
+      .map(key => `${key} = ?`)
+      .join(' AND ');
     const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
 
-    const [result] = (await this.pool.execute(
-      sql,
-      Object.values(where),
-    )) as any;
+    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> {
+  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
     const connection = await this.pool.getConnection();
 
     try {
@@ -156,15 +150,14 @@ class MySQLTransaction implements DatabaseTransaction {
   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 placeholders = keys.map(() => '?').join(', ');
 
-    const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
+    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],
-    );
+    const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE id = ?`, [
+      result.insertId,
+    ]);
 
     return insertedRecord!;
   }
@@ -172,14 +165,14 @@ class MySQLTransaction implements DatabaseTransaction {
   async update<T = any>(
     table: string,
     data: Record<string, any>,
-    where: Record<string, any>,
+    where: Record<string, any>
   ): Promise<T> {
     const setClause = Object.keys(data)
-      .map((key) => `${key} = ?`)
-      .join(", ");
+      .map(key => `${key} = ?`)
+      .join(', ');
     const whereClause = Object.keys(where)
-      .map((key) => `${key} = ?`)
-      .join(" AND ");
+      .map(key => `${key} = ?`)
+      .join(' AND ');
 
     const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
     const params = [...Object.values(data), ...Object.values(where)];
@@ -188,7 +181,7 @@ class MySQLTransaction implements DatabaseTransaction {
 
     const updatedRecord = await this.queryOne<T>(
       `SELECT * FROM ${table} WHERE ${whereClause}`,
-      Object.values(where),
+      Object.values(where)
     );
 
     return updatedRecord!;
@@ -196,14 +189,11 @@ class MySQLTransaction implements DatabaseTransaction {
 
   async delete(table: string, where: Record<string, any>): Promise<number> {
     const whereClause = Object.keys(where)
-      .map((key) => `${key} = ?`)
-      .join(" AND ");
+      .map(key => `${key} = ?`)
+      .join(' AND ');
     const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
 
-    const [result] = (await this.connection.execute(
-      sql,
-      Object.values(where),
-    )) as any;
+    const [result] = (await this.connection.execute(sql, Object.values(where))) as any;
     return result.affectedRows;
   }
 

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

@@ -1,6 +1,6 @@
 // Database PostgreSQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from "../../../types/database";
-import { createFrameworkLogger } from "../../logger";
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface PostgreSQLConfig {
   host?: string;
@@ -14,31 +14,31 @@ interface PostgreSQLConfig {
 
 export class PostgreSQLAdapter implements DatabaseAdapter {
   private pool: any;
-  private logger = createFrameworkLogger("PostgreSQL");
+  private logger = createFrameworkLogger('PostgreSQL');
 
   constructor(config: PostgreSQLConfig) {
     try {
-      const { Pool } = require("pg");
+      const { Pool } = require('pg');
       this.pool = new Pool({
-        host: config.host || "localhost",
+        host: config.host || 'localhost',
         port: config.port || 5432,
-        user: config.user || "postgres",
-        password: config.password || "",
-        database: config.database || "moro_app",
+        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", {
+      this.pool.on('error', (err: Error) => {
+        this.logger.error('PostgreSQL pool error', 'Pool', {
           error: err.message,
         });
       });
 
-      this.logger.info("PostgreSQL adapter initialized", "PostgreSQL");
+      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",
+        'pg package is required for PostgreSQL adapter. Install it with: npm install pg'
       );
     }
   }
@@ -47,9 +47,9 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     try {
       const client = await this.pool.connect();
       client.release();
-      this.logger.info("PostgreSQL connection established", "Connection");
+      this.logger.info('PostgreSQL connection established', 'Connection');
     } catch (error) {
-      this.logger.error("PostgreSQL connection failed", "Connection", {
+      this.logger.error('PostgreSQL connection failed', 'Connection', {
         error: error instanceof Error ? error.message : String(error),
       });
       throw error;
@@ -73,9 +73,9 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   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 placeholders = keys.map((_, index) => `$${index + 1}`).join(', ');
 
-    const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;
+    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
     const result = await this.pool.query(sql, values);
 
     return result.rows[0] as T;
@@ -84,19 +84,17 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   async update<T = any>(
     table: string,
     data: Record<string, any>,
-    where: 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 setClause = dataKeys.map((key, index) => `${key} = $${index + 1}`).join(', ');
     const whereClause = whereKeys
       .map((key, index) => `${key} = $${dataKeys.length + index + 1}`)
-      .join(" AND ");
+      .join(' AND ');
 
     const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
     const params = [...dataValues, ...whereValues];
@@ -108,9 +106,7 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
   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 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);
@@ -118,21 +114,19 @@ export class PostgreSQLAdapter implements DatabaseAdapter {
     return result.rowCount || 0;
   }
 
-  async transaction<T>(
-    callback: (tx: DatabaseTransaction) => Promise<T>,
-  ): Promise<T> {
+  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
     const client = await this.pool.connect();
 
     try {
-      await client.query("BEGIN");
+      await client.query('BEGIN');
 
       const transaction = new PostgreSQLTransaction(client);
       const result = await callback(transaction);
 
-      await client.query("COMMIT");
+      await client.query('COMMIT');
       return result;
     } catch (error) {
-      await client.query("ROLLBACK");
+      await client.query('ROLLBACK');
       throw error;
     } finally {
       client.release();
@@ -156,9 +150,9 @@ class PostgreSQLTransaction implements DatabaseTransaction {
   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 placeholders = keys.map((_, index) => `$${index + 1}`).join(', ');
 
-    const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;
+    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
     const result = await this.client.query(sql, values);
 
     return result.rows[0] as T;
@@ -167,19 +161,17 @@ class PostgreSQLTransaction implements DatabaseTransaction {
   async update<T = any>(
     table: string,
     data: Record<string, any>,
-    where: 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 setClause = dataKeys.map((key, index) => `${key} = $${index + 1}`).join(', ');
     const whereClause = whereKeys
       .map((key, index) => `${key} = $${dataKeys.length + index + 1}`)
-      .join(" AND ");
+      .join(' AND ');
 
     const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
     const params = [...dataValues, ...whereValues];
@@ -191,9 +183,7 @@ class PostgreSQLTransaction implements DatabaseTransaction {
   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 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);
@@ -202,10 +192,10 @@ class PostgreSQLTransaction implements DatabaseTransaction {
   }
 
   async commit(): Promise<void> {
-    await this.client.query("COMMIT");
+    await this.client.query('COMMIT');
   }
 
   async rollback(): Promise<void> {
-    await this.client.query("ROLLBACK");
+    await this.client.query('ROLLBACK');
   }
 }

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

@@ -1,6 +1,6 @@
 // Database Redis Adapter
-import { DatabaseAdapter, DatabaseTransaction } from "../../../types/database";
-import { createFrameworkLogger } from "../../logger";
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface RedisConfig {
   host?: string;
@@ -20,13 +20,13 @@ interface RedisConfig {
 
 export class RedisAdapter implements DatabaseAdapter {
   private client: any;
-  private logger = createFrameworkLogger("Redis");
+  private logger = createFrameworkLogger('Redis');
   private keyPrefix: string;
 
   constructor(config: RedisConfig = {}) {
     try {
-      const Redis = require("ioredis");
-      this.keyPrefix = config.keyPrefix || "moro:";
+      const Redis = require('ioredis');
+      this.keyPrefix = config.keyPrefix || 'moro:';
 
       if (config.cluster) {
         // Redis Cluster
@@ -37,7 +37,7 @@ export class RedisAdapter implements DatabaseAdapter {
       } else {
         // Single Redis instance
         this.client = new Redis({
-          host: config.host || "localhost",
+          host: config.host || 'localhost',
           port: config.port || 6379,
           password: config.password,
           db: config.db || 0,
@@ -47,24 +47,24 @@ export class RedisAdapter implements DatabaseAdapter {
         });
       }
 
-      this.client.on("error", (err: Error) => {
-        this.logger.error("Redis client error", "Redis", {
+      this.client.on('error', (err: Error) => {
+        this.logger.error('Redis client error', 'Redis', {
           error: err.message,
         });
       });
 
-      this.client.on("connect", () => {
-        this.logger.info("Redis connected", "Connection");
+      this.client.on('connect', () => {
+        this.logger.info('Redis connected', 'Connection');
       });
 
-      this.client.on("disconnect", () => {
-        this.logger.warn("Redis disconnected", "Connection");
+      this.client.on('disconnect', () => {
+        this.logger.warn('Redis disconnected', 'Connection');
       });
 
-      this.logger.info("Redis adapter initialized", "Redis");
+      this.logger.info('Redis adapter initialized', 'Redis');
     } catch (error) {
       throw new Error(
-        "ioredis package is required for Redis adapter. Install it with: npm install ioredis",
+        'ioredis package is required for Redis adapter. Install it with: npm install ioredis'
       );
     }
   }
@@ -76,9 +76,9 @@ export class RedisAdapter implements DatabaseAdapter {
   async connect(): Promise<void> {
     try {
       await this.client.ping();
-      this.logger.info("Redis connection established", "Connection");
+      this.logger.info('Redis connection established', 'Connection');
     } catch (error) {
-      this.logger.error("Redis connection failed", "Connection", {
+      this.logger.error('Redis connection failed', 'Connection', {
         error: error instanceof Error ? error.message : String(error),
       });
       throw error;
@@ -97,11 +97,11 @@ export class RedisAdapter implements DatabaseAdapter {
 
       const values = await this.client.mget(keys);
       return values.map((value: string, index: number) => ({
-        key: keys[index].replace(this.keyPrefix, ""),
+        key: keys[index].replace(this.keyPrefix, ''),
         value: value ? JSON.parse(value) : null,
       }));
     } catch (error) {
-      this.logger.error("Redis query failed", "Query", {
+      this.logger.error('Redis query failed', 'Query', {
         pattern,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -114,7 +114,7 @@ export class RedisAdapter implements DatabaseAdapter {
       const value = await this.client.get(this.prefixKey(key));
       return value ? JSON.parse(value) : null;
     } catch (error) {
-      this.logger.error("Redis queryOne failed", "Query", {
+      this.logger.error('Redis queryOne failed', 'Query', {
         key,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -128,7 +128,7 @@ export class RedisAdapter implements DatabaseAdapter {
       await this.client.set(this.prefixKey(key), value);
       return data as T;
     } catch (error) {
-      this.logger.error("Redis insert failed", "Insert", {
+      this.logger.error('Redis insert failed', 'Insert', {
         key,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -139,7 +139,7 @@ export class RedisAdapter implements DatabaseAdapter {
   async update<T = any>(
     key: string,
     data: Record<string, any>,
-    _where?: Record<string, any>,
+    _where?: Record<string, any>
   ): Promise<T> {
     try {
       // For Redis, we'll merge with existing data if it exists
@@ -149,7 +149,7 @@ export class RedisAdapter implements DatabaseAdapter {
       await this.client.set(this.prefixKey(key), value);
       return merged as T;
     } catch (error) {
-      this.logger.error("Redis update failed", "Update", {
+      this.logger.error('Redis update failed', 'Update', {
         key,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -165,7 +165,7 @@ export class RedisAdapter implements DatabaseAdapter {
       const deletedCount = await this.client.del(...keys);
       return deletedCount;
     } catch (error) {
-      this.logger.error("Redis delete failed", "Delete", {
+      this.logger.error('Redis delete failed', 'Delete', {
         pattern,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -173,9 +173,7 @@ export class RedisAdapter implements DatabaseAdapter {
     }
   }
 
-  async transaction<T>(
-    callback: (tx: DatabaseTransaction) => Promise<T>,
-  ): Promise<T> {
+  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
     const multi = this.client.multi();
     const transaction = new RedisTransaction(multi, this.keyPrefix);
 
@@ -242,7 +240,7 @@ export class RedisAdapter implements DatabaseAdapter {
   }
 
   async lpush(list: string, ...values: any[]): Promise<number> {
-    const serialized = values.map((v) => JSON.stringify(v));
+    const serialized = values.map(v => JSON.stringify(v));
     return await this.client.lpush(this.prefixKey(list), ...serialized);
   }
 
@@ -260,13 +258,10 @@ export class RedisAdapter implements DatabaseAdapter {
     return await this.client.publish(channel, JSON.stringify(message));
   }
 
-  async subscribe(
-    channel: string,
-    callback: (message: any) => void,
-  ): Promise<void> {
+  async subscribe(channel: string, callback: (message: any) => void): Promise<void> {
     const subscriber = this.client.duplicate();
     subscriber.subscribe(channel);
-    subscriber.on("message", (_channel: string, message: string) => {
+    subscriber.on('message', (_channel: string, message: string) => {
       callback(JSON.parse(message));
     });
   }
@@ -279,7 +274,7 @@ export class RedisAdapter implements DatabaseAdapter {
 class RedisTransaction implements DatabaseTransaction {
   constructor(
     private multi: any,
-    private keyPrefix: string,
+    private keyPrefix: string
   ) {}
 
   private prefixKey(key: string): string {
@@ -290,13 +285,13 @@ class RedisTransaction implements DatabaseTransaction {
     // Note: Redis transactions can't perform read operations during MULTI
     // This is a limitation of Redis transactions
     throw new Error(
-      "Redis transactions cannot perform read operations. Use regular operations instead.",
+      'Redis transactions cannot perform read operations. Use regular operations instead.'
     );
   }
 
   async queryOne<T = any>(_key: string, _params?: any[]): Promise<T | null> {
     throw new Error(
-      "Redis transactions cannot perform read operations. Use regular operations instead.",
+      'Redis transactions cannot perform read operations. Use regular operations instead.'
     );
   }
 
@@ -309,7 +304,7 @@ class RedisTransaction implements DatabaseTransaction {
   async update<T = any>(
     key: string,
     data: Record<string, any>,
-    _where?: Record<string, any>,
+    _where?: Record<string, any>
   ): Promise<T> {
     const value = JSON.stringify(data);
     this.multi.set(this.prefixKey(key), value);