@morojs/moro 1.6.1 → 1.6.3

package/src/core/database/README.md

@@ -1,228 +0,0 @@
-# Database Adapters
-
-The MoroJS database module provides a pluggable adapter system for different database backends, similar to the middleware adapter pattern.
-
-## Available Adapters
-
-### SQL Databases
-
-#### MySQL Adapter
-- **Package Required**: `mysql2`
-- **Usage**: Production-ready with connection pooling
-- **Type**: `mysql`
-
-#### PostgreSQL Adapter  
-- **Package Required**: `pg` and `@types/pg`
-- **Usage**: Full PostgreSQL feature support
-- **Type**: `postgresql`, `postgres`, or `pg`
-
-#### SQLite Adapter
-- **Package Required**: `better-sqlite3`
-- **Usage**: Lightweight, file-based database
-- **Type**: `sqlite` or `sqlite3`
-
-### NoSQL Databases
-
-#### MongoDB Adapter
-- **Package Required**: `mongodb`
-- **Usage**: Document database with aggregation support
-- **Type**: `mongodb` or `mongo`
-
-#### Redis Adapter
-- **Package Required**: `ioredis`
-- **Usage**: In-memory key-value store with pub/sub
-- **Type**: `redis`
-
-### ORM
-
-#### Drizzle Adapter
-- **Package Required**: `drizzle-orm` + database driver
-- **Usage**: Type-safe ORM with schema validation
-- **Type**: `drizzle` or `orm`
-
-## Factory Pattern (Recommended)
-
-```typescript
-import { createDatabaseAdapter } from 'moro';
-
-// SQL Databases
-const mysql = createDatabaseAdapter('mysql', {
-  host: 'localhost',
-  port: 3306,
-  user: 'root',
-  password: 'password',
-  database: 'my_app',
-  connectionLimit: 10
-});
-
-const postgres = createDatabaseAdapter('postgresql', {
-  host: 'localhost',
-  port: 5432,
-  user: 'postgres',
-  password: 'password',
-  database: 'my_app',
-  connectionLimit: 10,
-  ssl: false
-});
-
-const sqlite = createDatabaseAdapter('sqlite', {
-  filename: 'app.db',
-  memory: false
-});
-
-// NoSQL Databases
-const mongodb = createDatabaseAdapter('mongodb', {
-  host: 'localhost',
-  port: 27017,
-  database: 'my_app',
-  username: 'user',
-  password: 'password'
-});
-
-const redis = createDatabaseAdapter('redis', {
-  host: 'localhost',
-  port: 6379,
-  password: 'password',
-  keyPrefix: 'myapp:'
-});
-
-// ORM
-const drizzle = createDatabaseAdapter('drizzle', {
-  database: drizzleInstance,
-  schema: schemaObject
-});
-```
-
-## Direct Instantiation
-
-```typescript
-import { 
-  MySQLAdapter, 
-  PostgreSQLAdapter, 
-  SQLiteAdapter,
-  MongoDBAdapter,
-  RedisAdapter,
-  DrizzleAdapter
-} from 'moro';
-
-// SQL
-const mysql = new MySQLAdapter({ host: 'localhost', ... });
-const postgres = new PostgreSQLAdapter({ host: 'localhost', ... });
-const sqlite = new SQLiteAdapter({ filename: 'app.db' });
-
-// NoSQL
-const mongodb = new MongoDBAdapter({ host: 'localhost', ... });
-const redis = new RedisAdapter({ host: 'localhost', ... });
-
-// ORM
-const drizzle = new DrizzleAdapter({ database: drizzleInstance, schema });
-```
-
-## Common Interface
-
-All adapters implement the same `DatabaseAdapter` interface:
-
-```typescript
-interface DatabaseAdapter {
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  query<T>(sql: string, params?: any[]): Promise<T[]>;
-  queryOne<T>(sql: string, params?: any[]): Promise<T | null>;
-  insert<T>(table: string, data: Record<string, any>): Promise<T>;
-  update<T>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<T>;
-  delete(table: string, where: Record<string, any>): Promise<number>;
-  transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T>;
-}
-```
-
-## Usage Example
-
-```typescript
-// Initialize
-await db.connect();
-
-// Basic operations
-const users = await db.query('SELECT * FROM users');
-const user = await db.queryOne('SELECT * FROM users WHERE id = ?', [1]);
-
-// ORM-like helpers
-const newUser = await db.insert('users', { name: 'John', email: 'john@example.com' });
-const updated = await db.update('users', { name: 'Jane' }, { id: 1 });
-const deleted = await db.delete('users', { id: 1 });
-
-// Transactions
-const result = await db.transaction(async (tx) => {
-  const user = await tx.insert('users', userData);
-  await tx.insert('profiles', { user_id: user.id, ...profileData });
-  return user;
-});
-```
-
-## Usage Examples
-
-### SQL Operations
-```typescript
-// Standard CRUD operations work across all SQL adapters
-const users = await db.query('SELECT * FROM users WHERE age > ?', [18]);
-const user = await db.queryOne('SELECT * FROM users WHERE id = ?', [1]);
-const newUser = await db.insert('users', { name: 'John', email: 'john@example.com' });
-const updated = await db.update('users', { name: 'Jane' }, { id: 1 });
-const deleted = await db.delete('users', { id: 1 });
-```
-
-### MongoDB Operations
-```typescript
-// MongoDB uses collections instead of tables
-const users = await mongoDb.query('users'); // Get all
-const users = await mongoDb.query('users', { age: { $gte: 18 } }); // Query
-const user = await mongoDb.queryOne('users', { email: 'john@example.com' });
-
-// MongoDB-specific methods
-const stats = await mongoDb.aggregate('users', [
-  { $group: { _id: null, avgAge: { $avg: '$age' } } }
-]);
-await mongoDb.createIndex('users', { email: 1 }, { unique: true });
-```
-
-### Redis Operations
-```typescript
-// Key-value operations
-await redisDb.set('user:123', userData, 3600); // with TTL
-const user = await redisDb.get('user:123');
-
-// Redis-specific methods
-await redisDb.incr('page:views');
-await redisDb.lpush('tasks', taskData);
-await redisDb.publish('notifications', message);
-```
-
-### Drizzle ORM Operations
-```typescript
-// Type-safe queries (requires schema setup)
-const users = await drizzleDb.select('users').where(eq(schema.users.age, 25));
-const newUser = await drizzleDb.insertInto('users').values(userData).returning();
-
-// Raw SQL fallback
-const users = await drizzleDb.query('SELECT * FROM users WHERE age > ?', [18]);
-```
-
-## Installation
-
-Choose and install the appropriate database package:
-
-```bash
-# SQL Databases
-npm install mysql2                    # MySQL
-npm install pg @types/pg             # PostgreSQL  
-npm install better-sqlite3           # SQLite
-
-# NoSQL Databases
-npm install mongodb                  # MongoDB
-npm install ioredis                  # Redis
-
-# ORM
-npm install drizzle-orm              # Drizzle ORM
-# Plus the appropriate driver (mysql2, pg, better-sqlite3, etc.)
-```
-
-The adapters will gracefully handle missing packages with helpful error messages. 

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

@@ -1,403 +0,0 @@
-// Database Drizzle ORM Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
-import { createFrameworkLogger } from '../../logger';
-
-interface DrizzleConfig {
-  database: any; // Drizzle database instance
-  schema?: any; // Optional schema for additional type safety
-  logger?: boolean;
-}
-
-export class DrizzleAdapter implements DatabaseAdapter {
-  private db: any;
-  private schema: any;
-  private logger = createFrameworkLogger('Drizzle');
-
-  constructor(config: DrizzleConfig) {
-    try {
-      if (!config.database) {
-        throw new Error('Drizzle database instance is required');
-      }
-
-      this.db = config.database;
-      this.schema = config.schema;
-
-      this.logger.info('Drizzle ORM adapter initialized', 'Drizzle');
-    } catch (error) {
-      this.logger.error('Drizzle ORM initialization failed', 'Drizzle');
-      throw new Error(
-        'Drizzle ORM configuration error. Ensure you have a valid Drizzle database instance.'
-      );
-    }
-  }
-
-  async connect(): Promise<void> {
-    // Drizzle doesn't have an explicit connect method
-    // Connection is handled by the underlying driver
-    this.logger.info('Drizzle ORM adapter ready', 'Connection');
-  }
-
-  async disconnect(): Promise<void> {
-    // Drizzle doesn't have an explicit disconnect method
-    // This would be handled by the underlying driver
-    this.logger.info('Drizzle ORM adapter disconnected', 'Connection');
-  }
-
-  // Raw SQL query support
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    try {
-      // Using Drizzle's execute method for raw SQL
-      const result = await this.db.execute(sql, params);
-
-      // Handle different result formats from different drivers
-      if (Array.isArray(result)) {
-        return result;
-      } else if (result.rows) {
-        return result.rows;
-      } else if (result.recordset) {
-        return result.recordset;
-      } else {
-        return [result];
-      }
-    } catch (error) {
-      this.logger.error('Drizzle 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> {
-    const results = await this.query<T>(sql, params);
-    return results.length > 0 ? results[0] : null;
-  }
-
-  // ORM-style operations (requires schema)
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    try {
-      if (this.schema && this.schema[table]) {
-        // Use schema-based insert
-        const result = await this.db.insert(this.schema[table]).values(data).returning();
-        return result[0] as T;
-      } else {
-        // Fallback to raw SQL
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
-
-        const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
-        const result = await this.query<T>(sql, values);
-        return result[0];
-      }
-    } catch (error) {
-      this.logger.error('Drizzle 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> {
-    try {
-      if (this.schema && this.schema[table]) {
-        // Use schema-based update
-        try {
-          const { eq, and } = require('drizzle-orm');
-
-          // Build where conditions
-          const conditions = Object.entries(where).map(([key, value]) =>
-            eq(this.schema[table][key], value)
-          );
-          const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
-
-          const result = await this.db
-            .update(this.schema[table])
-            .set(data)
-            .where(whereClause)
-            .returning();
-
-          return result[0] as T;
-        } catch (importError) {
-          // Fallback to raw SQL if drizzle-orm is not available
-          const setClause = Object.keys(data)
-            .map((key, i) => `${key} = $${i + 1}`)
-            .join(', ');
-          const whereClause = Object.keys(where)
-            .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-            .join(' AND ');
-
-          const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-          const params = [...Object.values(data), ...Object.values(where)];
-          const result = await this.query<T>(sql, params);
-          return result[0];
-        }
-      } else {
-        // Fallback to raw SQL
-        const setClause = Object.keys(data)
-          .map((key, i) => `${key} = $${i + 1}`)
-          .join(', ');
-        const whereClause = Object.keys(where)
-          .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-          .join(' AND ');
-
-        const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-        const params = [...Object.values(data), ...Object.values(where)];
-        const result = await this.query<T>(sql, params);
-        return result[0];
-      }
-    } catch (error) {
-      this.logger.error('Drizzle update failed', 'Update', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    try {
-      if (this.schema && this.schema[table]) {
-        // Use schema-based delete
-        try {
-          const { eq, and } = require('drizzle-orm');
-
-          const conditions = Object.entries(where).map(([key, value]) =>
-            eq(this.schema[table][key], value)
-          );
-          const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
-
-          const result = await this.db.delete(this.schema[table]).where(whereClause);
-
-          return (
-            (result as any).changes || (result as any).rowCount || (result as any).affectedRows || 0
-          );
-        } catch (importError) {
-          // Fallback to raw SQL if drizzle-orm is not available
-          const whereClause = Object.keys(where)
-            .map((key, i) => `${key} = $${i + 1}`)
-            .join(' AND ');
-          const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-          await this.query(sql, Object.values(where));
-          return 1; // Can't determine exact count without result metadata
-        }
-      } else {
-        // Fallback to raw SQL
-        const whereClause = Object.keys(where)
-          .map((key, i) => `${key} = $${i + 1}`)
-          .join(' AND ');
-        const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-        await this.query(sql, Object.values(where));
-        return 1; // Can't determine exact count without result metadata
-      }
-    } catch (error) {
-      this.logger.error('Drizzle delete failed', 'Delete', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    return await this.db.transaction(async (tx: any) => {
-      const transaction = new DrizzleTransaction(tx, this.schema, this.logger);
-      return await callback(transaction);
-    });
-  }
-
-  // Drizzle-specific methods
-  select(table?: string) {
-    if (table && this.schema && this.schema[table]) {
-      return this.db.select().from(this.schema[table]);
-    }
-    return this.db.select();
-  }
-
-  insertInto(table: string) {
-    if (this.schema && this.schema[table]) {
-      return this.db.insert(this.schema[table]);
-    }
-    throw new Error(`Table ${table} not found in schema`);
-  }
-
-  updateTable(table: string) {
-    if (this.schema && this.schema[table]) {
-      return this.db.update(this.schema[table]);
-    }
-    throw new Error(`Table ${table} not found in schema`);
-  }
-
-  deleteFrom(table: string) {
-    if (this.schema && this.schema[table]) {
-      return this.db.delete(this.schema[table]);
-    }
-    throw new Error(`Table ${table} not found in schema`);
-  }
-
-  getSchema() {
-    return this.schema;
-  }
-
-  getDb() {
-    return this.db;
-  }
-
-  // Schema introspection helpers
-  getTableNames(): string[] {
-    return this.schema ? Object.keys(this.schema) : [];
-  }
-
-  hasTable(tableName: string): boolean {
-    return this.schema ? !!this.schema[tableName] : false;
-  }
-}
-
-class DrizzleTransaction implements DatabaseTransaction {
-  constructor(
-    private tx: any,
-    private schema: any,
-    private logger: any
-  ) {}
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    try {
-      const result = await this.tx.execute(sql, params);
-
-      if (Array.isArray(result)) {
-        return result;
-      } else if (result.rows) {
-        return result.rows;
-      } else if (result.recordset) {
-        return result.recordset;
-      } else {
-        return [result];
-      }
-    } catch (error) {
-      this.logger.error('Drizzle transaction 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> {
-    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> {
-    if (this.schema && this.schema[table]) {
-      const result = await this.tx.insert(this.schema[table]).values(data).returning();
-      return result[0] as T;
-    } else {
-      const keys = Object.keys(data);
-      const values = Object.values(data);
-      const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
-
-      const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
-      const result = await this.query<T>(sql, values);
-      return result[0];
-    }
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    if (this.schema && this.schema[table]) {
-      try {
-        const { eq, and } = require('drizzle-orm');
-
-        const conditions = Object.entries(where).map(([key, value]) =>
-          eq(this.schema[table][key], value)
-        );
-        const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
-
-        const result = await this.tx
-          .update(this.schema[table])
-          .set(data)
-          .where(whereClause)
-          .returning();
-
-        return result[0] as T;
-      } catch (importError) {
-        // Fallback to raw SQL
-        const setClause = Object.keys(data)
-          .map((key, i) => `${key} = $${i + 1}`)
-          .join(', ');
-        const whereClause = Object.keys(where)
-          .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-          .join(' AND ');
-
-        const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-        const params = [...Object.values(data), ...Object.values(where)];
-        const result = await this.query<T>(sql, params);
-        return result[0];
-      }
-    } else {
-      const setClause = Object.keys(data)
-        .map((key, i) => `${key} = $${i + 1}`)
-        .join(', ');
-      const whereClause = Object.keys(where)
-        .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-        .join(' AND ');
-
-      const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-      const params = [...Object.values(data), ...Object.values(where)];
-      const result = await this.query<T>(sql, params);
-      return result[0];
-    }
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    if (this.schema && this.schema[table]) {
-      try {
-        const { eq, and } = require('drizzle-orm');
-
-        const conditions = Object.entries(where).map(([key, value]) =>
-          eq(this.schema[table][key], value)
-        );
-        const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
-
-        const result = await this.tx.delete(this.schema[table]).where(whereClause);
-
-        return (
-          (result as any).changes || (result as any).rowCount || (result as any).affectedRows || 0
-        );
-      } catch (importError) {
-        // Fallback to raw SQL
-        const whereClause = Object.keys(where)
-          .map((key, i) => `${key} = $${i + 1}`)
-          .join(' AND ');
-        const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-        await this.query(sql, Object.values(where));
-        return 1; // Can't determine exact count
-      }
-    } else {
-      const whereClause = Object.keys(where)
-        .map((key, i) => `${key} = $${i + 1}`)
-        .join(' AND ');
-      const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-      await this.query(sql, Object.values(where));
-      return 1; // Can't determine exact count
-    }
-  }
-
-  async commit(): Promise<void> {
-    // Drizzle transactions are auto-committed
-    // This is just for interface compatibility
-  }
-
-  async rollback(): Promise<void> {
-    // Drizzle transactions will auto-rollback on error
-    throw new Error('Transaction rollback');
-  }
-}

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

@@ -1,42 +0,0 @@
-// Database Adapters
-export { MySQLAdapter } from './mysql';
-export { PostgreSQLAdapter } from './postgresql';
-export { SQLiteAdapter } from './sqlite';
-export { MongoDBAdapter } from './mongodb';
-export { RedisAdapter } from './redis';
-export { DrizzleAdapter } from './drizzle';
-
-import { MySQLAdapter } from './mysql';
-import { PostgreSQLAdapter } from './postgresql';
-import { SQLiteAdapter } from './sqlite';
-import { MongoDBAdapter } from './mongodb';
-import { RedisAdapter } from './redis';
-import { DrizzleAdapter } from './drizzle';
-import { DatabaseAdapter } from '../../../types/database';
-
-// Adapter factory function for auto-loading
-export function createDatabaseAdapter(type: string, options: any = {}): DatabaseAdapter {
-  switch (type.toLowerCase()) {
-    case 'mysql':
-      return new MySQLAdapter(options);
-    case 'postgresql':
-    case 'postgres':
-    case 'pg':
-      return new PostgreSQLAdapter(options);
-    case 'sqlite':
-    case 'sqlite3':
-      return new SQLiteAdapter(options);
-    case 'mongodb':
-    case 'mongo':
-      return new MongoDBAdapter(options);
-    case 'redis':
-      return new RedisAdapter(options);
-    case 'drizzle':
-    case 'orm':
-      return new DrizzleAdapter(options);
-    default:
-      throw new Error(
-        `Unknown database adapter type: ${type}. Available types: mysql, postgresql, sqlite, mongodb, redis, drizzle`
-      );
-  }
-}