@morojs/moro 1.6.2 → 1.6.3

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

@@ -1,226 +0,0 @@
-// Database PostgreSQL Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
-
-interface PostgreSQLConfig {
-  host?: string;
-  port?: number;
-  user?: string;
-  password?: string;
-  database?: string;
-  connectionLimit?: number;
-  ssl?:
-    | {
-        rejectUnauthorized?: boolean;
-        ca?: string;
-        cert?: string;
-        key?: string;
-        passphrase?: string;
-        servername?: string;
-        checkServerIdentity?: boolean;
-      }
-    | 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;
-      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: typeof config.ssl === 'object' ? { ...config.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> {
-    await this.initPromise;
-    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.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[];
-  }
-
-  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> {
-    await this.initPromise;
-    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> {
-    await this.initPromise;
-    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> {
-    await this.initPromise;
-    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> {
-    await this.initPromise;
-    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');
-  }
-}

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

@@ -1,379 +0,0 @@
-// Database Redis Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
-
-interface RedisConfig {
-  host?: string;
-  port?: number;
-  password?: string;
-  db?: number;
-  keyPrefix?: string;
-  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;
-    nodes: Array<{ host: string; port: number }>;
-  };
-}
-
-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;
-
-      if (config.cluster) {
-        // Redis Cluster
-        const clusterOptions: any = {
-          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 = {
-          host: config.host || 'localhost',
-          port: config.port || 6379,
-          password: config.password,
-          db: config.db || 0,
-          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) => {
-        this.logger.error('Redis client error', 'Redis', {
-          error: err.message,
-        });
-      });
-
-      this.client.on('connect', () => {
-        this.logger.info('Redis connected', 'Connection');
-      });
-
-      this.client.on('disconnect', () => {
-        this.logger.warn('Redis disconnected', 'Connection');
-      });
-
-      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'
-      );
-    }
-  }
-
-  private prefixKey(key: string): string {
-    return `${this.keyPrefix}${key}`;
-  }
-
-  async connect(): Promise<void> {
-    await this.initPromise;
-    try {
-      await this.client.ping();
-      this.logger.info('Redis connection established', 'Connection');
-    } catch (error) {
-      this.logger.error('Redis connection failed', 'Connection', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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 [];
-
-      const values = await this.client.mget(keys);
-      return values.map((value: string, index: number) => ({
-        key: keys[index].replace(this.keyPrefix, ''),
-        value: value ? JSON.parse(value) : null,
-      }));
-    } catch (error) {
-      this.logger.error('Redis query failed', 'Query', {
-        pattern,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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;
-    } catch (error) {
-      this.logger.error('Redis queryOne failed', 'Query', {
-        key,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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);
-      return data as T;
-    } catch (error) {
-      this.logger.error('Redis insert failed', 'Insert', {
-        key,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async update<T = any>(
-    key: string,
-    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);
-      const merged = existing ? { ...existing, ...data } : data;
-      const value = JSON.stringify(merged);
-      await this.client.set(this.prefixKey(key), value);
-      return merged as T;
-    } catch (error) {
-      this.logger.error('Redis update failed', 'Update', {
-        key,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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;
-
-      const deletedCount = await this.client.del(...keys);
-      return deletedCount;
-    } catch (error) {
-      this.logger.error('Redis delete failed', 'Delete', {
-        pattern,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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);
-
-    try {
-      const result = await callback(transaction);
-      await multi.exec();
-      return result;
-    } catch (error) {
-      // Redis doesn't have rollback, but we can discard the multi
-      multi.discard();
-      throw error;
-    }
-  }
-
-  // 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));
-    } else {
-      await this.client.set(prefixedKey, JSON.stringify(value));
-    }
-  }
-
-  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)) {
-      parsed[key] = JSON.parse(value as string);
-    }
-    return parsed;
-  }
-
-  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) => {
-      callback(JSON.parse(message));
-    });
-  }
-
-  getClient() {
-    return this.client;
-  }
-}
-
-class RedisTransaction implements DatabaseTransaction {
-  constructor(
-    private multi: any,
-    private keyPrefix: string
-  ) {}
-
-  private prefixKey(key: string): string {
-    return `${this.keyPrefix}${key}`;
-  }
-
-  async query<T = any>(pattern: string, _params?: any[]): Promise<T[]> {
-    // 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.'
-    );
-  }
-
-  async queryOne<T = any>(_key: string, _params?: any[]): Promise<T | null> {
-    throw new Error(
-      'Redis transactions cannot perform read operations. Use regular operations instead.'
-    );
-  }
-
-  async insert<T = any>(key: string, data: Record<string, any>): Promise<T> {
-    const value = JSON.stringify(data);
-    this.multi.set(this.prefixKey(key), value);
-    return data as T;
-  }
-
-  async update<T = any>(
-    key: string,
-    data: Record<string, any>,
-    _where?: Record<string, any>
-  ): Promise<T> {
-    const value = JSON.stringify(data);
-    this.multi.set(this.prefixKey(key), value);
-    return data as T;
-  }
-
-  async delete(pattern: string, _where?: Record<string, any>): Promise<number> {
-    this.multi.del(this.prefixKey(pattern));
-    return 1; // We can't know the actual count in a transaction
-  }
-
-  async commit(): Promise<void> {
-    await this.multi.exec();
-  }
-
-  async rollback(): Promise<void> {
-    this.multi.discard();
-  }
-}