@morojs/moro 1.6.1 → 1.6.3

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

@@ -1,326 +0,0 @@
-// Database Redis Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
-
-interface RedisConfig {
-  host?: string;
-  port?: number;
-  password?: string;
-  db?: number;
-  keyPrefix?: string;
-  maxRetriesPerRequest?: number;
-  retryDelayOnFailover?: number;
-  lazyConnect?: 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;
-
-  constructor(config: RedisConfig = {}) {
-    try {
-      const Redis = require('ioredis');
-      this.keyPrefix = config.keyPrefix || 'moro:';
-
-      if (config.cluster) {
-        // Redis Cluster
-        this.client = new Redis.Cluster(config.cluster.nodes, {
-          enableReadyCheck: config.cluster.enableReadyCheck || false,
-          redisOptions: config.cluster.redisOptions || {},
-        });
-      } else {
-        // Single Redis instance
-        this.client = new Redis({
-          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,
-        });
-      }
-
-      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> {
-    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.client.quit();
-  }
-
-  // For Redis, we adapt the SQL-like interface to key-value operations
-  async query<T = any>(pattern: string, _params?: any[]): Promise<T[]> {
-    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> {
-    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> {
-    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> {
-    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> {
-    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> {
-    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> {
-    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> {
-    const value = await this.client.get(this.prefixKey(key));
-    return value ? JSON.parse(value) : null;
-  }
-
-  async exists(key: string): Promise<boolean> {
-    const result = await this.client.exists(this.prefixKey(key));
-    return result === 1;
-  }
-
-  async expire(key: string, ttl: number): Promise<boolean> {
-    const result = await this.client.expire(this.prefixKey(key), ttl);
-    return result === 1;
-  }
-
-  async incr(key: string): Promise<number> {
-    return await this.client.incr(this.prefixKey(key));
-  }
-
-  async decr(key: string): Promise<number> {
-    return await this.client.decr(this.prefixKey(key));
-  }
-
-  async hset(hash: string, field: string, value: any): Promise<void> {
-    await this.client.hset(this.prefixKey(hash), field, JSON.stringify(value));
-  }
-
-  async hget(hash: string, field: string): Promise<any> {
-    const value = await this.client.hget(this.prefixKey(hash), field);
-    return value ? JSON.parse(value) : null;
-  }
-
-  async hgetall(hash: string): Promise<Record<string, any>> {
-    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> {
-    const serialized = values.map(v => JSON.stringify(v));
-    return await this.client.lpush(this.prefixKey(list), ...serialized);
-  }
-
-  async rpop(list: string): Promise<any> {
-    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[]> {
-    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> {
-    return await this.client.publish(channel, JSON.stringify(message));
-  }
-
-  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) => {
-      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();
-  }
-}

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

@@ -1,247 +0,0 @@
-// Database SQLite Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
-
-interface SQLiteConfig {
-  filename?: string;
-  memory?: boolean;
-  readonly?: boolean;
-  fileMustExist?: boolean;
-  timeout?: number;
-  verbose?: boolean;
-}
-
-export class SQLiteAdapter implements DatabaseAdapter {
-  private db: any;
-  private logger = createFrameworkLogger('SQLite');
-
-  constructor(config: SQLiteConfig = {}) {
-    try {
-      const Database = require('better-sqlite3');
-      const filename = config.memory ? ':memory:' : config.filename || 'moro_app.db';
-      this.db = new Database(filename, {
-        readonly: config.readonly || false,
-        fileMustExist: config.fileMustExist || false,
-        timeout: config.timeout || 5000,
-        verbose: config.verbose ? this.logger.debug.bind(this.logger) : undefined,
-      });
-
-      // Enable foreign keys
-      this.db.pragma('foreign_keys = ON');
-
-      this.logger.info('SQLite connection established', 'Connection', {
-        filename,
-      });
-    } catch (error) {
-      throw new Error(
-        'better-sqlite3 package is required for SQLite adapter. Install it with: npm install better-sqlite3'
-      );
-    }
-  }
-
-  async connect(): Promise<void> {
-    // SQLite doesn't require explicit connection - it's handled in constructor
-    this.logger.info('SQLite adapter ready', 'Connection');
-  }
-
-  async disconnect(): Promise<void> {
-    this.db.close();
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    try {
-      const stmt = this.db.prepare(sql);
-      const results = stmt.all(params || []);
-      return results as T[];
-    } catch (error) {
-      this.logger.error('SQLite query failed', 'Query', {
-        sql,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    try {
-      const stmt = this.db.prepare(sql);
-      const result = stmt.get(params || []);
-      return (result as T) || null;
-    } catch (error) {
-      this.logger.error('SQLite queryOne failed', 'Query', {
-        sql,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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})`;
-
-    try {
-      const stmt = this.db.prepare(sql);
-      const info = stmt.run(values);
-
-      // Return the inserted record
-      const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE rowid = ?`, [
-        info.lastInsertRowid,
-      ]);
-
-      return insertedRecord!;
-    } catch (error) {
-      this.logger.error('SQLite insert failed', 'Insert', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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)];
-
-    try {
-      const stmt = this.db.prepare(sql);
-      stmt.run(params);
-
-      // Return the updated record
-      const updatedRecord = await this.queryOne<T>(
-        `SELECT * FROM ${table} WHERE ${whereClause}`,
-        Object.values(where)
-      );
-
-      return updatedRecord!;
-    } catch (error) {
-      this.logger.error('SQLite update failed', 'Update', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  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}`;
-
-    try {
-      const stmt = this.db.prepare(sql);
-      const info = stmt.run(Object.values(where));
-      return info.changes;
-    } catch (error) {
-      this.logger.error('SQLite delete failed', 'Delete', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    const transaction = this.db.transaction(async () => {
-      const tx = new SQLiteTransaction(this.db);
-      return await callback(tx);
-    });
-
-    return transaction();
-  }
-}
-
-class SQLiteTransaction implements DatabaseTransaction {
-  constructor(private db: any) {}
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    const stmt = this.db.prepare(sql);
-    const results = stmt.all(params || []);
-    return results as T[];
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    const stmt = this.db.prepare(sql);
-    const result = stmt.get(params || []);
-    return (result as T) || 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 stmt = this.db.prepare(sql);
-    const info = stmt.run(values);
-
-    const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE rowid = ?`, [
-      info.lastInsertRowid,
-    ]);
-
-    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)];
-
-    const stmt = this.db.prepare(sql);
-    stmt.run(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 stmt = this.db.prepare(sql);
-    const info = stmt.run(Object.values(where));
-    return info.changes;
-  }
-
-  async commit(): Promise<void> {
-    // SQLite transactions are handled automatically by better-sqlite3
-    // This is just for interface compatibility
-  }
-
-  async rollback(): Promise<void> {
-    // SQLite transactions are handled automatically by better-sqlite3
-    // This is just for interface compatibility
-    throw new Error('Transaction rollback');
-  }
-}

package/src/core/database/index.ts

@@ -1,3 +0,0 @@
-// Database Module
-export * from './adapters';
-export * from '../../types/database';