@morojs/moro 1.0.0 → 1.0.1

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

@@ -1,6 +1,6 @@
 // Database Drizzle ORM Adapter
-import { DatabaseAdapter, DatabaseTransaction } from "../../../types/database";
-import { createFrameworkLogger } from "../../logger";
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface DrizzleConfig {
   database: any; // Drizzle database instance
@@ -11,22 +11,22 @@ interface DrizzleConfig {
 export class DrizzleAdapter implements DatabaseAdapter {
   private db: any;
   private schema: any;
-  private logger = createFrameworkLogger("Drizzle");
+  private logger = createFrameworkLogger('Drizzle');
 
   constructor(config: DrizzleConfig) {
     try {
       if (!config.database) {
-        throw new Error("Drizzle database instance is required");
+        throw new Error('Drizzle database instance is required');
       }
 
       this.db = config.database;
       this.schema = config.schema;
 
-      this.logger.info("Drizzle ORM adapter initialized", "Drizzle");
+      this.logger.info('Drizzle ORM adapter initialized', 'Drizzle');
     } catch (error) {
-      this.logger.error("Drizzle ORM initialization failed", "Drizzle");
+      this.logger.error('Drizzle ORM initialization failed', 'Drizzle');
       throw new Error(
-        "Drizzle ORM configuration error. Ensure you have a valid Drizzle database instance.",
+        'Drizzle ORM configuration error. Ensure you have a valid Drizzle database instance.'
       );
     }
   }
@@ -34,13 +34,13 @@ export class DrizzleAdapter implements DatabaseAdapter {
   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");
+    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");
+    this.logger.info('Drizzle ORM adapter disconnected', 'Connection');
   }
 
   // Raw SQL query support
@@ -60,7 +60,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
         return [result];
       }
     } catch (error) {
-      this.logger.error("Drizzle query failed", "Query", {
+      this.logger.error('Drizzle query failed', 'Query', {
         sql,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -78,23 +78,20 @@ export class DrizzleAdapter implements DatabaseAdapter {
     try {
       if (this.schema && this.schema[table]) {
         // Use schema-based insert
-        const result = await this.db
-          .insert(this.schema[table])
-          .values(data)
-          .returning();
+        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 placeholders = keys.map((_, i) => `$${i + 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.query<T>(sql, values);
         return result[0];
       }
     } catch (error) {
-      this.logger.error("Drizzle insert failed", "Insert", {
+      this.logger.error('Drizzle insert failed', 'Insert', {
         table,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -105,20 +102,19 @@ export class DrizzleAdapter implements DatabaseAdapter {
   async update<T = any>(
     table: string,
     data: Record<string, any>,
-    where: 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");
+          const { eq, and } = require('drizzle-orm');
 
           // Build where conditions
           const conditions = Object.entries(where).map(([key, value]) =>
-            eq(this.schema[table][key], value),
+            eq(this.schema[table][key], value)
           );
-          const whereClause =
-            conditions.length === 1 ? conditions[0] : and(...conditions);
+          const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
 
           const result = await this.db
             .update(this.schema[table])
@@ -131,10 +127,10 @@ export class DrizzleAdapter implements DatabaseAdapter {
           // Fallback to raw SQL if drizzle-orm is not available
           const setClause = Object.keys(data)
             .map((key, i) => `${key} = $${i + 1}`)
-            .join(", ");
+            .join(', ');
           const whereClause = Object.keys(where)
             .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-            .join(" AND ");
+            .join(' AND ');
 
           const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
           const params = [...Object.values(data), ...Object.values(where)];
@@ -145,10 +141,10 @@ export class DrizzleAdapter implements DatabaseAdapter {
         // Fallback to raw SQL
         const setClause = Object.keys(data)
           .map((key, i) => `${key} = $${i + 1}`)
-          .join(", ");
+          .join(', ');
         const whereClause = Object.keys(where)
           .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-          .join(" AND ");
+          .join(' AND ');
 
         const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
         const params = [...Object.values(data), ...Object.values(where)];
@@ -156,7 +152,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
         return result[0];
       }
     } catch (error) {
-      this.logger.error("Drizzle update failed", "Update", {
+      this.logger.error('Drizzle update failed', 'Update', {
         table,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -169,29 +165,23 @@ export class DrizzleAdapter implements DatabaseAdapter {
       if (this.schema && this.schema[table]) {
         // Use schema-based delete
         try {
-          const { eq, and } = require("drizzle-orm");
+          const { eq, and } = require('drizzle-orm');
 
           const conditions = Object.entries(where).map(([key, value]) =>
-            eq(this.schema[table][key], value),
+            eq(this.schema[table][key], value)
           );
-          const whereClause =
-            conditions.length === 1 ? conditions[0] : and(...conditions);
+          const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
 
-          const result = await this.db
-            .delete(this.schema[table])
-            .where(whereClause);
+          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
+            (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 ");
+            .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
@@ -200,13 +190,13 @@ export class DrizzleAdapter implements DatabaseAdapter {
         // Fallback to raw SQL
         const whereClause = Object.keys(where)
           .map((key, i) => `${key} = $${i + 1}`)
-          .join(" AND ");
+          .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", {
+      this.logger.error('Drizzle delete failed', 'Delete', {
         table,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -214,9 +204,7 @@ export class DrizzleAdapter implements DatabaseAdapter {
     }
   }
 
-  async transaction<T>(
-    callback: (tx: DatabaseTransaction) => Promise<T>,
-  ): Promise<T> {
+  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);
@@ -274,7 +262,7 @@ class DrizzleTransaction implements DatabaseTransaction {
   constructor(
     private tx: any,
     private schema: any,
-    private logger: any,
+    private logger: any
   ) {}
 
   async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
@@ -291,7 +279,7 @@ class DrizzleTransaction implements DatabaseTransaction {
         return [result];
       }
     } catch (error) {
-      this.logger.error("Drizzle transaction query failed", "Query", {
+      this.logger.error('Drizzle transaction query failed', 'Query', {
         sql,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -306,17 +294,14 @@ class DrizzleTransaction implements DatabaseTransaction {
 
   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();
+      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 placeholders = keys.map((_, i) => `$${i + 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.query<T>(sql, values);
       return result[0];
     }
@@ -325,17 +310,16 @@ class DrizzleTransaction implements DatabaseTransaction {
   async update<T = any>(
     table: string,
     data: Record<string, any>,
-    where: Record<string, any>,
+    where: Record<string, any>
   ): Promise<T> {
     if (this.schema && this.schema[table]) {
       try {
-        const { eq, and } = require("drizzle-orm");
+        const { eq, and } = require('drizzle-orm');
 
         const conditions = Object.entries(where).map(([key, value]) =>
-          eq(this.schema[table][key], value),
+          eq(this.schema[table][key], value)
         );
-        const whereClause =
-          conditions.length === 1 ? conditions[0] : and(...conditions);
+        const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
 
         const result = await this.tx
           .update(this.schema[table])
@@ -348,10 +332,10 @@ class DrizzleTransaction implements DatabaseTransaction {
         // Fallback to raw SQL
         const setClause = Object.keys(data)
           .map((key, i) => `${key} = $${i + 1}`)
-          .join(", ");
+          .join(', ');
         const whereClause = Object.keys(where)
           .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-          .join(" AND ");
+          .join(' AND ');
 
         const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
         const params = [...Object.values(data), ...Object.values(where)];
@@ -361,10 +345,10 @@ class DrizzleTransaction implements DatabaseTransaction {
     } else {
       const setClause = Object.keys(data)
         .map((key, i) => `${key} = $${i + 1}`)
-        .join(", ");
+        .join(', ');
       const whereClause = Object.keys(where)
         .map((key, i) => `${key} = $${Object.keys(data).length + i + 1}`)
-        .join(" AND ");
+        .join(' AND ');
 
       const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause} RETURNING *`;
       const params = [...Object.values(data), ...Object.values(where)];
@@ -376,29 +360,23 @@ class DrizzleTransaction implements DatabaseTransaction {
   async delete(table: string, where: Record<string, any>): Promise<number> {
     if (this.schema && this.schema[table]) {
       try {
-        const { eq, and } = require("drizzle-orm");
+        const { eq, and } = require('drizzle-orm');
 
         const conditions = Object.entries(where).map(([key, value]) =>
-          eq(this.schema[table][key], value),
+          eq(this.schema[table][key], value)
         );
-        const whereClause =
-          conditions.length === 1 ? conditions[0] : and(...conditions);
+        const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
 
-        const result = await this.tx
-          .delete(this.schema[table])
-          .where(whereClause);
+        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
+          (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 ");
+          .join(' AND ');
         const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
         await this.query(sql, Object.values(where));
         return 1; // Can't determine exact count
@@ -406,7 +384,7 @@ class DrizzleTransaction implements DatabaseTransaction {
     } else {
       const whereClause = Object.keys(where)
         .map((key, i) => `${key} = $${i + 1}`)
-        .join(" AND ");
+        .join(' AND ');
       const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
       await this.query(sql, Object.values(where));
       return 1; // Can't determine exact count
@@ -420,6 +398,6 @@ class DrizzleTransaction implements DatabaseTransaction {
 
   async rollback(): Promise<void> {
     // Drizzle transactions will auto-rollback on error
-    throw new Error("Transaction rollback");
+    throw new Error('Transaction rollback');
   }
 }

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

@@ -1,45 +1,42 @@
 // 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";
+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";
+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 {
+export function createDatabaseAdapter(type: string, options: any = {}): DatabaseAdapter {
   switch (type.toLowerCase()) {
-    case "mysql":
+    case 'mysql':
       return new MySQLAdapter(options);
-    case "postgresql":
-    case "postgres":
-    case "pg":
+    case 'postgresql':
+    case 'postgres':
+    case 'pg':
       return new PostgreSQLAdapter(options);
-    case "sqlite":
-    case "sqlite3":
+    case 'sqlite':
+    case 'sqlite3':
       return new SQLiteAdapter(options);
-    case "mongodb":
-    case "mongo":
+    case 'mongodb':
+    case 'mongo':
       return new MongoDBAdapter(options);
-    case "redis":
+    case 'redis':
       return new RedisAdapter(options);
-    case "drizzle":
-    case "orm":
+    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`,
+        `Unknown database adapter type: ${type}. Available types: mysql, postgresql, sqlite, mongodb, redis, drizzle`
       );
   }
 }

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

@@ -1,6 +1,6 @@
 // Database MongoDB Adapter
-import { DatabaseAdapter, DatabaseTransaction } from "../../../types/database";
-import { createFrameworkLogger } from "../../logger";
+import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database';
+import { createFrameworkLogger } from '../../logger';
 
 interface MongoDBConfig {
   url?: string;
@@ -24,11 +24,11 @@ interface MongoDocument {
 export class MongoDBAdapter implements DatabaseAdapter {
   private client: any;
   private db: any;
-  private logger = createFrameworkLogger("MongoDB");
+  private logger = createFrameworkLogger('MongoDB');
 
   constructor(config: MongoDBConfig) {
     try {
-      const { MongoClient } = require("mongodb");
+      const { MongoClient } = require('mongodb');
 
       const url = config.url || this.buildConnectionString(config);
 
@@ -38,37 +38,32 @@ export class MongoDBAdapter implements DatabaseAdapter {
         ssl: config.ssl || false,
       });
 
-      this.db = this.client.db(config.database || "moro_app");
+      this.db = this.client.db(config.database || 'moro_app');
 
-      this.logger.info("MongoDB adapter initialized", "MongoDB");
+      this.logger.info('MongoDB adapter initialized', 'MongoDB');
     } catch (error) {
       throw new Error(
-        "mongodb package is required for MongoDB adapter. Install it with: npm install mongodb",
+        'mongodb package is required for MongoDB adapter. Install it with: npm install mongodb'
       );
     }
   }
 
   private buildConnectionString(config: MongoDBConfig): string {
-    const host = config.host || "localhost";
+    const host = config.host || 'localhost';
     const port = config.port || 27017;
-    const auth =
-      config.username && config.password
-        ? `${config.username}:${config.password}@`
-        : "";
-    const authSource = config.authSource
-      ? `?authSource=${config.authSource}`
-      : "";
-
-    return `mongodb://${auth}${host}:${port}/${config.database || "moro_app"}${authSource}`;
+    const auth = config.username && config.password ? `${config.username}:${config.password}@` : '';
+    const authSource = config.authSource ? `?authSource=${config.authSource}` : '';
+
+    return `mongodb://${auth}${host}:${port}/${config.database || 'moro_app'}${authSource}`;
   }
 
   async connect(): Promise<void> {
     try {
       await this.client.connect();
-      await this.client.db("admin").command({ ping: 1 });
-      this.logger.info("MongoDB connection established", "Connection");
+      await this.client.db('admin').command({ ping: 1 });
+      this.logger.info('MongoDB connection established', 'Connection');
     } catch (error) {
-      this.logger.error("MongoDB connection failed", "Connection", {
+      this.logger.error('MongoDB connection failed', 'Connection', {
         error: error instanceof Error ? error.message : String(error),
       });
       throw error;
@@ -98,7 +93,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
         return await cursor.toArray();
       }
     } catch (error) {
-      this.logger.error("MongoDB query failed", "Query", {
+      this.logger.error('MongoDB query failed', 'Query', {
         collection,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -111,7 +106,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
       const coll = this.db.collection(collection);
       return await coll.findOne(query || {});
     } catch (error) {
-      this.logger.error("MongoDB queryOne failed", "Query", {
+      this.logger.error('MongoDB queryOne failed', 'Query', {
         collection,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -119,10 +114,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
     }
   }
 
-  async insert<T = any>(
-    collection: string,
-    data: Record<string, any>,
-  ): Promise<T> {
+  async insert<T = any>(collection: string, data: Record<string, any>): Promise<T> {
     try {
       const coll = this.db.collection(collection);
       const result = await coll.insertOne(data);
@@ -130,7 +122,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
       // Return the inserted document with _id
       return { ...data, _id: result.insertedId } as T;
     } catch (error) {
-      this.logger.error("MongoDB insert failed", "Insert", {
+      this.logger.error('MongoDB insert failed', 'Insert', {
         collection,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -141,19 +133,19 @@ export class MongoDBAdapter implements DatabaseAdapter {
   async update<T = any>(
     collection: string,
     data: Record<string, any>,
-    where: Record<string, any>,
+    where: Record<string, any>
   ): Promise<T> {
     try {
       const coll = this.db.collection(collection);
       const result = await coll.findOneAndUpdate(
         where,
         { $set: data },
-        { returnDocument: "after" },
+        { returnDocument: 'after' }
       );
 
       return result.value as T;
     } catch (error) {
-      this.logger.error("MongoDB update failed", "Update", {
+      this.logger.error('MongoDB update failed', 'Update', {
         collection,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -161,16 +153,13 @@ export class MongoDBAdapter implements DatabaseAdapter {
     }
   }
 
-  async delete(
-    collection: string,
-    where: Record<string, any>,
-  ): Promise<number> {
+  async delete(collection: string, where: Record<string, any>): Promise<number> {
     try {
       const coll = this.db.collection(collection);
       const result = await coll.deleteMany(where);
       return result.deletedCount || 0;
     } catch (error) {
-      this.logger.error("MongoDB delete failed", "Delete", {
+      this.logger.error('MongoDB delete failed', 'Delete', {
         collection,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -178,9 +167,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
     }
   }
 
-  async transaction<T>(
-    callback: (tx: DatabaseTransaction) => Promise<T>,
-  ): Promise<T> {
+  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
     const session = this.client.startSession();
 
     try {
@@ -200,11 +187,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
     return await cursor.toArray();
   }
 
-  async createIndex(
-    collection: string,
-    index: any,
-    options?: any,
-  ): Promise<string> {
+  async createIndex(collection: string, index: any, options?: any): Promise<string> {
     const coll = this.db.collection(collection);
     return await coll.createIndex(index, options);
   }
@@ -227,7 +210,7 @@ export class MongoDBAdapter implements DatabaseAdapter {
 class MongoDBTransaction implements DatabaseTransaction {
   constructor(
     private db: any,
-    private session: any,
+    private session: any
   ) {}
 
   async query<T = any>(collection: string, pipeline?: any[]): Promise<T[]> {
@@ -250,10 +233,7 @@ class MongoDBTransaction implements DatabaseTransaction {
     return await coll.findOne(query || {}, { session: this.session });
   }
 
-  async insert<T = any>(
-    collection: string,
-    data: Record<string, any>,
-  ): Promise<T> {
+  async insert<T = any>(collection: string, data: Record<string, any>): Promise<T> {
     const coll = this.db.collection(collection);
     const result = await coll.insertOne(data, { session: this.session });
     return { ...data, _id: result.insertedId } as T;
@@ -262,21 +242,18 @@ class MongoDBTransaction implements DatabaseTransaction {
   async update<T = any>(
     collection: string,
     data: Record<string, any>,
-    where: Record<string, any>,
+    where: Record<string, any>
   ): Promise<T> {
     const coll = this.db.collection(collection);
     const result = await coll.findOneAndUpdate(
       where,
       { $set: data },
-      { returnDocument: "after", session: this.session },
+      { returnDocument: 'after', session: this.session }
     );
     return result.value as T;
   }
 
-  async delete(
-    collection: string,
-    where: Record<string, any>,
-  ): Promise<number> {
+  async delete(collection: string, where: Record<string, any>): Promise<number> {
     const coll = this.db.collection(collection);
     const result = await coll.deleteMany(where, { session: this.session });
     return result.deletedCount || 0;