@zakodium/adonis-mongodb 0.18.1 → 0.20.0

package/src/Database/Connection.ts

@@ -1,21 +1,23 @@
 import { EventEmitter } from 'node:events';
 
 import { Exception } from '@poppinss/utils';
-import {
-  MongoClient,
+import type {
   Db,
   Collection,
   ClientSession,
   Document,
   TransactionOptions,
 } from 'mongodb';
+import { MongoClient } from 'mongodb';
 
-import { LoggerContract } from '@ioc:Adonis/Core/Logger';
+import type { LoggerContract } from '@ioc:Adonis/Core/Logger';
 import type {
   MongodbConnectionConfig,
   ConnectionContract,
 } from '@ioc:Zakodium/Mongodb/Database';
 
+import { TransactionEventEmitter } from './TransactionEventEmitter';
+
 enum ConnectionStatus {
   CONNECTED = 'CONNECTED',
   DISCONNECTED = 'DISCONNECTED',
@@ -45,7 +47,7 @@ export declare interface Connection {
   ): this;
 }
 
-// eslint-disable-next-line unicorn/prefer-event-target, @typescript-eslint/no-unsafe-declaration-merging
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class Connection extends EventEmitter implements ConnectionContract {
   public readonly client: MongoClient;
   public readonly name: string;
@@ -131,17 +133,51 @@ export class Connection extends EventEmitter implements ConnectionContract {
   }
 
   public async transaction<TResult>(
-    handler: (session: ClientSession, db: Db) => Promise<TResult>,
+    handler: (
+      session: ClientSession,
+      db: Db,
+      transactionEventEmitter: TransactionEventEmitter,
+    ) => Promise<TResult>,
     options?: TransactionOptions,
   ): Promise<TResult> {
     const db = await this._ensureDb();
-    let result: TResult;
-    await this.client.withSession(async (session) => {
-      return session.withTransaction(async (session) => {
-        result = await handler(session, db);
-      }, options);
-    });
-    // @ts-expect-error The `await` ensures `result` has a value.
-    return result;
+
+    let session: ClientSession;
+    const emitter = new TransactionEventEmitter();
+
+    return this.client
+      .withSession((_session) =>
+        _session.withTransaction(async (_session) => {
+          session = _session;
+          return handler(session, db, emitter);
+        }, options),
+      )
+      .then(
+        (result) => {
+          // https://github.com/mongodb/node-mongodb-native/blob/v6.7.0/src/transactions.ts#L147
+          // https://github.com/mongodb/node-mongodb-native/blob/v6.7.0/src/transactions.ts#L54
+          // session.transaction.isCommitted is not a sufficient indicator,
+          // because it's true if transaction commits or aborts.
+          const isCommitted = session.transaction.isCommitted;
+          const isAborted =
+            // https://github.com/mongodb/node-mongodb-native/blob/v6.7.0/src/transactions.ts#L11
+            Reflect.get(session.transaction, 'state') === 'TRANSACTION_ABORTED';
+
+          emitter.emit(
+            isCommitted && isAborted ? 'abort' : 'commit',
+            session,
+            db,
+          );
+
+          return result;
+          // If an error occurs in this scope,
+          // it will not be caught by this then's error handler, but by the caller's catch.
+          // This is what we want, as an error in this scope should not trigger the abort event.
+        },
+        (error) => {
+          emitter.emit('abort', session, db, error);
+          throw error;
+        },
+      );
   }
 }

package/src/Database/ConnectionManager.ts

@@ -1,6 +1,6 @@
 import { Exception } from '@poppinss/utils';
 
-import { LoggerContract } from '@ioc:Adonis/Core/Logger';
+import type { LoggerContract } from '@ioc:Adonis/Core/Logger';
 import type {
   ConnectionContract,
   ConnectionManagerContract,
@@ -78,6 +78,8 @@ export class ConnectionManager implements ConnectionManagerContract {
 
   public connect(connectionName: string): void {
     const connection = this.validateConnection(connectionName);
+    // Connection error is handled by the `error` event listener.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     connection.connection.connect();
   }
 

package/src/Database/Database.ts

@@ -1,6 +1,6 @@
-import { ClientSession, Db, TransactionOptions } from 'mongodb';
+import type { ClientSession, Db, TransactionOptions } from 'mongodb';
 
-import { LoggerContract } from '@ioc:Adonis/Core/Logger';
+import type { LoggerContract } from '@ioc:Adonis/Core/Logger';
 import type {
   ConnectionContract,
   ConnectionManagerContract,

package/src/Database/TransactionEventEmitter.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'node:events';
+
+import type { ClientSession, Db } from 'mongodb';
+
+export interface TransactionEvents {
+  commit: [session: ClientSession, db: Db];
+  abort: [session: ClientSession, db: Db, error?: Error];
+}
+
+export class TransactionEventEmitter extends EventEmitter<TransactionEvents> {}

package/src/Migration.ts

@@ -1,10 +1,10 @@
-import { Logger } from '@poppinss/cliui/build/src/Logger';
-import {
-  CreateIndexesOptions,
+import type { Logger } from '@poppinss/cliui/build/src/Logger';
+import type {
   ClientSession,
+  CreateIndexesOptions,
   Db,
-  IndexSpecification,
   DropIndexesOptions,
+  IndexSpecification,
 } from 'mongodb';
 
 import type {
@@ -13,12 +13,18 @@ import type {
 } from '@ioc:Zakodium/Mongodb/Database';
 
 enum MigrationType {
+  DropCollection = 'DropCollection',
   CreateCollection = 'CreateCollection',
   DropIndex = 'DropIndex',
   CreateIndex = 'CreateIndex',
   Custom = 'Custom',
 }
 
+interface DropCollectionOperation {
+  type: MigrationType.DropCollection;
+  collectionName: string;
+}
+
 interface CreateCollectionOperation {
   type: MigrationType.CreateCollection;
   collectionName: string;
@@ -44,6 +50,7 @@ interface CustomOperation {
 }
 
 type MigrationOperation =
+  | DropCollectionOperation
   | CreateCollectionOperation
   | DropIndexOperation
   | CreateIndexOperation
@@ -68,6 +75,13 @@ export default function createMigration(Database: DatabaseContract): any {
       }
     }
 
+    public dropCollection(collectionName: string): void {
+      this.$operations.push({
+        type: MigrationType.DropCollection,
+        collectionName,
+      });
+    }
+
     public createCollection(collectionName: string): void {
       this.$operations.push({
         type: MigrationType.CreateCollection,
@@ -114,6 +128,7 @@ export default function createMigration(Database: DatabaseContract): any {
       await this._dropIndexes(session);
       await this._createIndexes(session);
       await this._executeDeferred(session);
+      await this._dropCollections();
     }
 
     private async _listCollections() {
@@ -128,6 +143,14 @@ export default function createMigration(Database: DatabaseContract): any {
       return this.$collectionList;
     }
 
+    private async _dropCollections(): Promise<void> {
+      const db = await this.$connection.database();
+      for (const op of this.$operations.filter(isDropCollection)) {
+        this.$logger.info(`Dropping collection ${op.collectionName}`);
+        await db.dropCollection(op.collectionName);
+      }
+    }
+
     private async _createCollections(session: ClientSession): Promise<void> {
       const db = await this.$connection.database();
       for (const op of this.$operations.filter(isCreateCollection)) {
@@ -179,6 +202,12 @@ export default function createMigration(Database: DatabaseContract): any {
   return Migration;
 }
 
+function isDropCollection(
+  op: MigrationOperation,
+): op is DropCollectionOperation {
+  return op.type === MigrationType.DropCollection;
+}
+
 function isCreateCollection(
   op: MigrationOperation,
 ): op is CreateCollectionOperation {

package/src/Model/Model.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert';
 
 import { defineStaticProperty, Exception } from '@poppinss/utils';
 import { cloneDeep, isEqual, pickBy, snakeCase } from 'lodash';
-import {
+import type {
   BulkWriteOptions,
   ClientSession,
   Collection,
@@ -19,18 +19,18 @@ import {
 } from 'mongodb';
 import pluralize from 'pluralize';
 
-import { DatabaseContract } from '@ioc:Zakodium/Mongodb/Database';
-import {
-  MongodbDocument,
-  QueryContract,
-  NoExtraProperties,
-  ModelAttributes,
+import type { DatabaseContract } from '@ioc:Zakodium/Mongodb/Database';
+import type {
+  ComputedOptions,
+  FieldOptions,
+  ForbiddenQueryOptions,
   ModelAdapterOptions,
+  ModelAttributes,
   ModelDocumentOptions,
-  FieldOptions,
+  MongodbDocument,
+  NoExtraProperties,
+  QueryContract,
   QuerySortObject,
-  ForbiddenQueryOptions,
-  ComputedOptions,
 } from '@ioc:Zakodium/Mongodb/Odm';
 
 import { proxyHandler } from './proxyHandler';
@@ -200,7 +200,9 @@ class Query<ModelType extends typeof BaseModel>
   public async explain(verbosity?: ExplainVerbosityLike): Promise<Document> {
     const collection = await this.ModelConstructor.getCollection();
     const driverOptions = this.getDriverOptions();
-    return collection.find(this.filter, driverOptions).explain(verbosity);
+    return collection
+      .find(this.filter, driverOptions)
+      .explain(verbosity as ExplainVerbosityLike);
   }
 
   public async *[Symbol.asyncIterator](): AsyncIterableIterator<
@@ -239,10 +241,6 @@ function ensureSort(options?: FindOptions): void {
   };
 }
 
-function hasOwn(object: unknown, key: string): boolean {
-  return Object.prototype.hasOwnProperty.call(object, key);
-}
-
 interface DataToSet {
   [key: string]: unknown;
   createdAt: Date;
@@ -358,7 +356,7 @@ export class BaseModel {
      * Define the property when not defined on self. This makes sure that all
      * subclasses boot on their own.
      */
-    if (!hasOwn(this, 'booted')) {
+    if (!Object.hasOwn(this, 'booted')) {
       this.booted = false;
     }
 
@@ -775,7 +773,7 @@ export class BaseModel {
 }
 
 export class BaseAutoIncrementModel extends BaseModel {
-  public readonly _id: number;
+  declare public readonly _id: number;
 
   public async save(
     options?: ModelDocumentOptions<InsertOneOptions>,

package/src/Model/proxyHandler.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { BaseModel } from './Model';
+import type { BaseModel } from './Model';
 
 export const proxyHandler: ProxyHandler<any> = {
   get(target: any, prop: string | symbol, receiver: any) {

package/src/Odm/decorators.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ComputedDecorator,
   ComputedOptions,
   FieldDecorator,