@morojs/moro 1.0.0

package/src/core/database/README.md

@@ -0,0 +1,228 @@
+# 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

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

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