@opra/mongodb 1.0.0-alpha.9 → 1.0.0-beta.2

package/package.json

@@ -1,49 +1,43 @@
 {
   "name": "@opra/mongodb",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0-beta.2",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/panates/opra.git",
-    "directory": "packages/mongodb"
-  },
-  "scripts": {
-    "compile": "tsc",
-    "prebuild": "npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json",
-    "postbuild": "cp README.md package.json ../../LICENSE ../../build/mongodb && cp ../../package.cjs.json ../../build/mongodb/cjs/package.json",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "test": "jest --passWithNoTests",
-    "cover": "jest --passWithNoTests --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
-    "clean:dist": "rimraf ../../build/mongodb",
-    "clean:cover": "rimraf ../../coverage/mongodb"
-  },
   "dependencies": {
     "lodash.omit": "^4.5.0",
-    "putil-isplainobject": "^1.1.5"
-  },
-  "devDependencies": {
-    "@faker-js/faker": "^8.4.1",
-    "mongodb": "^6.8.0",
-    "ts-gems": "^3.4.0"
+    "putil-isplainobject": "^1.1.5",
+    "tslib": "^2.7.0",
+    "valgen": "^5.9.0"
   },
   "peerDependencies": {
-    "@opra/common": "^1.0.0-alpha.9",
-    "@opra/core": "^1.0.0-alpha.9",
+    "@opra/common": "^1.0.0-beta.2",
+    "@opra/core": "^1.0.0-beta.2",
     "mongodb": ">= 6.0.0"
   },
   "type": "module",
-  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "main": "./cjs/index.js",
+  "module": "./esm/index.js",
   "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/mongodb"
+  },
   "engines": {
     "node": ">=16.0",
     "npm": ">=7.0.0"
@@ -61,4 +55,4 @@
     "mongodb",
     "adapter"
   ]
-}
+}

package/types/adapter-utils/prepare-filter.d.ts

@@ -9,6 +9,6 @@ import type { MongoAdapter } from '../mongo-adapter.js';
  *
  * @returns {mongodb.Filter<any>} - The prepared MongoDB filter.
  */
-export default function prepareFilter(filters: MongoAdapter.FilterInput | MongoAdapter.FilterInput[], options?: {
+export default function prepareFilter<T = any>(filters: MongoAdapter.FilterInput<T> | MongoAdapter.FilterInput<T>[], options?: {
     fieldPrefix?: string;
-}): mongodb.Filter<any>;
+}): mongodb.Filter<T>;

package/types/adapter-utils/prepare-projection.d.ts

@@ -1,4 +1,4 @@
 import { ComplexType, FieldsProjection } from '@opra/common';
-import mongodb, { Document } from 'mongodb';
+import mongodb, { type Document } from 'mongodb';
 export default function prepareProjection(dataType: ComplexType, projection?: string | string[] | Document): mongodb.Document | undefined;
 export declare function prepare(dataType: ComplexType, target: mongodb.Document, projection?: FieldsProjection): void;

package/types/index.d.cts

@@ -0,0 +1,6 @@
+export * from './mongo-adapter.js';
+export * from './mongo-collection-service.js';
+export * from './mongo-entity-service.js';
+export * from './mongo-nested-service.js';
+export * from './mongo-service.js';
+export * from './mongo-singleton-service.js';

package/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from './mongo-adapter.js';
 export * from './mongo-collection-service.js';
+export * from './mongo-entity-service.js';
 export * from './mongo-nested-service.js';
 export * from './mongo-service.js';
 export * from './mongo-singleton-service.js';

package/types/mongo-adapter.d.ts

@@ -8,7 +8,7 @@ import _prepareProjection from './adapter-utils/prepare-projection.js';
 import _prepareSort from './adapter-utils/prepare-sort.js';
 export declare namespace MongoAdapter {
     type AnyId = string | number | ObjectId;
-    type FilterInput = OpraFilter.Expression | mongodb.Filter<any> | string | undefined;
+    type FilterInput<T = any> = OpraFilter.Expression | mongodb.Filter<T> | string | undefined;
     type WithTransactionCallback = (session: ClientSession) => any;
     const prepareFilter: typeof _prepareFilter;
     const prepareKeyValues: typeof _prepareKeyValues;

package/types/mongo-collection-service.d.ts

@@ -1,8 +1,7 @@
-import mongodb, { UpdateFilter } from 'mongodb';
-import { PartialDTO, PatchDTO, Type } from 'ts-gems';
+import mongodb, { type UpdateFilter } from 'mongodb';
+import type { PartialDTO, PatchDTO, RequiredSome, Type } from 'ts-gems';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoEntityService } from './mongo-entity-service.js';
-import { MongoService } from './mongo-service.js';
 /**
  *
  * @namespace MongoCollectionService
@@ -17,28 +16,6 @@ export declare namespace MongoCollectionService {
     interface Options extends MongoEntityService.Options {
         defaultLimit?: number;
     }
-    interface CreateOptions extends MongoEntityService.CreateOptions {
-    }
-    interface CountOptions<T> extends MongoEntityService.CountOptions<T> {
-    }
-    interface DeleteOptions<T> extends MongoEntityService.DeleteOptions<T> {
-    }
-    interface DeleteManyOptions<T> extends MongoEntityService.DeleteManyOptions<T> {
-    }
-    interface DistinctOptions<T> extends MongoEntityService.DistinctOptions<T> {
-    }
-    interface ExistsOptions<T> extends MongoService.ExistsOptions<T> {
-    }
-    interface ExistsOneOptions<T> extends MongoService.ExistsOneOptions<T> {
-    }
-    interface FindOneOptions<T> extends MongoEntityService.FindOneOptions<T> {
-    }
-    interface FindManyOptions<T> extends MongoEntityService.FindManyOptions<T> {
-    }
-    interface UpdateOptions<T> extends MongoEntityService.UpdateOptions<T> {
-    }
-    interface UpdateManyOptions<T> extends MongoEntityService.UpdateManyOptions<T> {
-    }
 }
 /**
  * @class MongoCollectionService
@@ -64,140 +41,143 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
      * Throws a ResourceNotFoundError if the resource does not exist.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the resource to assert.
-     * @param {MongoCollectionService.ExistsOptions<T>} [options] - Optional options for checking the existence.
+     * @param {MongoEntityService.ExistsOptions<T>} [options] - Optional options for checking the existence.
      * @returns {Promise<void>} - A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
-    assert(id: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOptions<T>): Promise<void>;
+    assert(id: MongoAdapter.AnyId, options?: MongoEntityService.ExistsOptions<T>): Promise<void>;
     /**
      * Creates a new document in the MongoDB collection.
      * Interceptors will be called before performing db operation
      *
      * @param {PartialDTO<T>} input - The input data for creating the document.
-     * @param {MongoCollectionService.CreateOptions} [options] - The options for creating the document.
+     * @param {MongoEntityService.CreateOptions} [options] - The options for creating the document.
      * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created document.
      * @throws {Error} if an unknown error occurs while creating the document.
      */
-    create(input: PartialDTO<T>, options?: MongoCollectionService.CreateOptions): Promise<PartialDTO<T>>;
+    create(input: PartialDTO<T>, options: RequiredSome<MongoEntityService.CreateOptions, 'projection'>): Promise<PartialDTO<T>>;
+    create(input: PartialDTO<T>, options?: MongoEntityService.CreateOptions): Promise<T>;
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {MongoCollectionService.CountOptions<T>} options - The options for the count operation.
+     * @param {MongoEntityService.CountOptions<T>} options - The options for the count operation.
      * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
      */
-    count(options?: MongoCollectionService.CountOptions<T>): Promise<number>;
+    count(options?: MongoEntityService.CountOptions<T>): Promise<number>;
     /**
      * Deletes a document from the collection.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
-     * @param {MongoCollectionService.DeleteOptions<T>} [options] - Optional delete options.
+     * @param {MongoEntityService.DeleteOptions<T>} [options] - Optional delete options.
      * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
      */
-    delete(id: MongoAdapter.AnyId, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
+    delete(id: MongoAdapter.AnyId, options?: MongoEntityService.DeleteOptions<T>): Promise<number>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {MongoCollectionService.DeleteManyOptions<T>} options - The options for the delete operation.
+     * @param {MongoEntityService.DeleteManyOptions<T>} options - The options for the delete operation.
      * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
      */
-    deleteMany(options?: MongoCollectionService.DeleteManyOptions<T>): Promise<number>;
+    deleteMany(options?: MongoEntityService.DeleteManyOptions<T>): Promise<number>;
     /**
      * The distinct command returns a list of distinct values for the given key across a collection.
      * @param {string} field
-     * @param {MongoCollectionService.DistinctOptions<T>} [options]
+     * @param {MongoEntityService.DistinctOptions<T>} [options]
      * @protected
      */
-    distinct(field: string, options?: MongoCollectionService.DistinctOptions<T>): Promise<any[]>;
+    distinct(field: string, options?: MongoEntityService.DistinctOptions<T>): Promise<any[]>;
     /**
      * Checks if an object with the given id exists.
      *
      * @param {MongoAdapter.AnyId} id - The id of the object to check.
-     * @param {MongoCollectionService.ExistsOptions<T>} [options] - The options for the query (optional).
+     * @param {MongoEntityService.ExistsOptions<T>} [options] - The options for the query (optional).
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
      */
-    exists(id: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOptions<T>): Promise<boolean>;
+    exists(id: MongoAdapter.AnyId, options?: MongoEntityService.ExistsOptions<T>): Promise<boolean>;
     /**
      * Checks if an object with the given arguments exists.
      *
-     * @param {MongoCollectionService.ExistsOneOptions} [options] - The options for the query (optional).
+     * @param {MongoEntityService.ExistsOptions} [options] - The options for the query (optional).
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
      */
-    existsOne(options?: MongoCollectionService.ExistsOneOptions<T>): Promise<boolean>;
+    existsOne(options?: MongoEntityService.ExistsOptions<T>): Promise<boolean>;
     /**
      * Finds a document by its ID.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document.
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the find query.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for the find query.
      * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
      */
-    findById(id: MongoAdapter.AnyId, options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    findById(id: MongoAdapter.AnyId, options: RequiredSome<MongoEntityService.FindOneOptions<T>, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    findById(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<T | undefined>;
     /**
      * Finds a document in the collection that matches the specified options.
      *
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the query.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for the query.
      * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
      */
-    findOne(options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    findOne(options: RequiredSome<MongoEntityService.FindOneOptions<T>, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    findOne(options?: MongoEntityService.FindOneOptions<T>): Promise<T | undefined>;
     /**
      * Finds multiple documents in the MongoDB collection.
      *
-     * @param {MongoCollectionService.FindManyOptions<T>} options - The options for the find operation.
+     * @param {MongoEntityService.FindManyOptions<T>} options - The options for the find operation.
      * @return A Promise that resolves to an array of partial outputs of type T.
      */
-    findMany(options?: MongoCollectionService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
+    findMany(options: RequiredSome<MongoEntityService.FindManyOptions<T>, 'projection'>): Promise<PartialDTO<T>[]>;
+    findMany(options?: MongoEntityService.FindManyOptions<T>): Promise<T[]>;
     /**
      * Finds multiple documents in the collection and returns both records (max limit)
      * and total count that matched the given criteria
      *
-     * @param {MongoCollectionService.FindManyOptions<T>} [options] - The options for the find operation.
+     * @param {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
      * @return A Promise that resolves to an array of partial outputs of type T.
      */
-    findManyWithCount(options?: MongoCollectionService.FindManyOptions<T>): Promise<{
+    findManyWithCount(options: RequiredSome<MongoEntityService.FindManyOptions<T>, 'projection'>): Promise<{
         count: number;
         items: PartialDTO<T>[];
     }>;
+    findManyWithCount(options?: MongoEntityService.FindManyOptions<T>): Promise<{
+        count: number;
+        items: T[];
+    }>;
     /**
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to retrieve.
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
      * @returns {Promise<PartialDTO<T>>} - A promise that resolves to the retrieved document,
      *    or rejects with a ResourceNotFoundError if the document does not exist.
      * @throws {ResourceNotAvailableError} - If the document with the specified ID does not exist.
      */
-    get(id: MongoAdapter.AnyId, options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T>>;
+    get(id: MongoAdapter.AnyId, options: RequiredSome<MongoEntityService.FindOneOptions<T>, 'projection'>): Promise<PartialDTO<T>>;
+    get(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<T>;
     /**
      * Updates a document with the given id in the collection.
      *
      * @param {MongoAdapter.AnyId} id - The id of the document to update.
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input object containing the fields to update.
-     * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for the update operation.
+     * @param {MongoEntityService.UpdateOneOptions<T>} [options] - The options for the update operation.
      * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
      * undefined if the document was not found.
      */
-    update(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
+    update(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options: RequiredSome<MongoEntityService.UpdateOneOptions<T>, 'projection'>): Promise<PartialDTO<T> | undefined>;
+    update(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoEntityService.UpdateOneOptions<T>): Promise<T | undefined>;
     /**
      * Updates a document in the collection with the specified ID.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to update.
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input data to update the document with.
-     * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for updating the document.
+     * @param {MongoEntityService.UpdateOneOptions<T>} [options] - The options for updating the document.
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
-    updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<number>;
+    updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoEntityService.UpdateOneOptions<T>): Promise<number>;
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input to update the documents with.
-     * @param {MongoCollectionService.UpdateManyOptions<T>} options - The options for updating the documents.
+     * @param {MongoEntityService.UpdateManyOptions<T>} options - The options for updating the documents.
      * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
      */
-    updateMany(input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
-    /**
-     * Generates an ID.
-     *
-     * @protected
-     * @returns {MongoAdapter.AnyId} The generated ID.
-     */
-    protected _generateId(): MongoAdapter.AnyId;
+    updateMany(input: PatchDTO<T> | UpdateFilter<T>, options?: MongoEntityService.UpdateManyOptions<T>): Promise<number>;
 }

package/types/mongo-entity-service.d.ts

@@ -1,6 +1,5 @@
 import mongodb from 'mongodb';
-import { PartialDTO, PatchDTO, Type } from 'ts-gems';
-import { MongoAdapter } from './mongo-adapter.js';
+import type { PartialDTO, PatchDTO, StrictOmit, Type } from 'ts-gems';
 import { MongoService } from './mongo-service.js';
 /**
  *
@@ -27,18 +26,62 @@ export declare namespace MongoEntityService {
     }
     interface DistinctOptions<T> extends MongoService.DistinctOptions<T> {
     }
+    interface ExistsOptions<T> extends MongoService.ExistsOptions<T> {
+    }
     interface FindOneOptions<T> extends MongoService.FindOneOptions<T> {
     }
     interface FindManyOptions<T> extends MongoService.FindManyOptions<T> {
     }
-    interface UpdateOptions<T> extends MongoService.UpdateOptions<T> {
+    interface UpdateOneOptions<T> extends MongoService.UpdateOneOptions<T> {
     }
     interface UpdateManyOptions<T> extends MongoService.UpdateManyOptions<T> {
     }
+    interface CreateCommand<T> extends StrictOmit<CommandInfo, 'documentId' | 'nestedId' | 'input'> {
+        crud: 'create';
+        input: PartialDTO<T>;
+        options?: CreateOptions;
+    }
+    interface CountCommand<T> extends StrictOmit<CommandInfo, 'documentId' | 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: CountOptions<T>;
+    }
+    interface DeleteCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'delete';
+        options?: DeleteOptions<T>;
+    }
+    interface DistinctCommand<T> extends StrictOmit<CommandInfo, 'documentId' | 'nestedId' | 'input'> {
+        crud: 'read';
+        field: string;
+        options?: DistinctOptions<T>;
+    }
+    interface ExistsCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: ExistsOptions<T>;
+    }
+    interface FindOneCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: FindOneOptions<T>;
+    }
+    interface FindManyCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: FindManyOptions<T>;
+    }
+    interface UpdateOneCommand<T> extends StrictOmit<CommandInfo, 'nestedId'> {
+        crud: 'update';
+        input?: PatchDTO<T>;
+        inputRaw?: mongodb.UpdateFilter<T>;
+        options?: UpdateOneOptions<T>;
+    }
+    interface UpdateManyCommand<T> extends StrictOmit<CommandInfo, 'nestedId'> {
+        crud: 'update';
+        input?: PatchDTO<T>;
+        inputRaw?: mongodb.UpdateFilter<T>;
+        options?: UpdateManyOptions<T>;
+    }
 }
 /**
  * @class MongoEntityService
- * @template T - The type of the documents in the collection.
+ * @template T - The type of the documents in the collection
  */
 export declare class MongoEntityService<T extends mongodb.Document> extends MongoService<T> {
     /**
@@ -50,100 +93,95 @@ export declare class MongoEntityService<T extends mongodb.Document> extends Mong
      */
     constructor(dataType: Type | string, options?: MongoEntityService.Options);
     /**
-     * Creates a new document in the MongoDB collection.
+     * Creates a new document in the MongoDB collection
      *
-     * @param {PartialDTO<T>} input
-     * @param {MongoEntityService.CreateOptions} options
+     * @param {MongoEntityService.CreateCommand} command
      * @protected
      */
-    protected _create(input: PartialDTO<T>, options?: MongoEntityService.CreateOptions): Promise<PartialDTO<T>>;
+    protected _create(command: MongoEntityService.CreateCommand<T>): Promise<T>;
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {MongoEntityService.CountOptions<T>} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
+     * @param {MongoEntityService.CountCommand<T>} command
+     * @protected
      */
-    protected _count(options?: MongoEntityService.CountOptions<T>): Promise<number>;
+    protected _count(command: MongoEntityService.CountCommand<T>): Promise<number>;
     /**
-     * Deletes a document from the collection.
+     * Deletes a document from the collection
      *
-     * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
-     * @param {MongoEntityService.DeleteOptions<T>} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param {MongoEntityService.DeleteCommand<T>} command
+     * @protected
      */
-    protected _delete(id: MongoAdapter.AnyId, options?: MongoEntityService.DeleteOptions<T>): Promise<number>;
+    protected _delete(command: MongoEntityService.DeleteCommand<T>): Promise<number>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {MongoEntityService.DeleteManyOptions<T>} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param {MongoEntityService.DeleteCommand<T>} command
+     * @protected
      */
-    protected _deleteMany(options?: MongoEntityService.DeleteManyOptions<T>): Promise<number>;
+    protected _deleteMany(command: MongoEntityService.DeleteCommand<T>): Promise<number>;
     /**
-     * The distinct command returns a list of distinct values for the given key across a collection.
-     * @param {string} field
-     * @param {MongoEntityService.DistinctOptions<T>} options
+     * The distinct command returns a list of distinct values for the given key across a collection
+     *
+     * @param {MongoEntityService.DistinctCommand<T>} command
      * @protected
      */
-    protected _distinct(field: string, options?: MongoEntityService.DistinctOptions<T>): Promise<any[]>;
+    protected _distinct(command: MongoEntityService.DistinctCommand<T>): Promise<any[]>;
     /**
      * Finds a document by its ID.
      *
-     * @param {MongoAdapter.AnyId} id - The ID of the document.
-     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for the find query.
-     * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
+     * @param { MongoEntityService.FindOneCommand<T>} command
      */
-    protected _findById(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _findById(command: MongoEntityService.FindOneCommand<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds a document in the collection that matches the specified options.
      *
-     * @param {MongoEntityService.FindOneOptions} [options] - The options for the query.
-     * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
+     * @param {MongoEntityService.FindOneCommand<T>} command
      */
-    protected _findOne(options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _findOne(command: MongoEntityService.FindOneCommand<T>): Promise<PartialDTO<T> | undefined>;
     /**
-     * Finds multiple documents in the MongoDB collection.
+     * Finds multiple documents in the MongoDB collection
      *
-     * @param {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param {MongoEntityService.FindManyCommand<T>} command
      */
-    protected _findMany(options?: MongoEntityService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
+    protected _findMany(command: MongoEntityService.FindManyCommand<T>): Promise<PartialDTO<T>[]>;
     /**
      * Finds multiple documents in the collection and returns both records (max limit)
      * and total count that matched the given criteria
      *
-     * @param {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param {MongoEntityService.FindManyCommand<T>} command
      */
-    protected _findManyWithCount(options?: MongoEntityService.FindManyOptions<T>): Promise<{
+    protected _findManyWithCount(command: MongoEntityService.FindManyCommand<T>): Promise<{
         count: number;
         items: PartialDTO<T>[];
     }>;
     /**
-     * Updates a document with the given id in the collection.
+     * Updates a document with the given id in the collection
      *
-     * @param {AnyId} id - The id of the document to update.
-     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input object containing the fields to update.
-     * @param {MongoEntityService.UpdateOptions<T>} [options] - The options for the update operation.
-     * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
-     * undefined if the document was not found.
+     * @param {MongoEntityService.UpdateOneCommand<T>} command
      */
-    protected _update(id: MongoAdapter.AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _update(command: MongoEntityService.UpdateOneCommand<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Updates a document in the collection with the specified ID.
      *
-     * @param {MongoAdapter.AnyId} id - The ID of the document to update.
-     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input data to update the document with.
-     * @param {MongoEntityService.UpdateOptions<T>} [options] - The options for updating the document.
-     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     * @param {MongoEntityService.UpdateOneCommand<T>} command
      */
-    protected _updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateOptions<T>): Promise<number>;
+    protected _updateOnly(command: MongoEntityService.UpdateOneCommand<T>): Promise<number>;
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input to update the documents with.
-     * @param {MongoEntityService.UpdateManyOptions<T>} [options] - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     * @param {MongoEntityService.UpdateManyCommand<T>} command
      */
-    protected _updateMany(input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateManyOptions<T>): Promise<number>;
+    protected _updateMany(command: MongoEntityService.UpdateManyCommand<T>): Promise<number>;
+    protected _executeCommand(command: MongoEntityService.CommandInfo, commandFn: () => any): Promise<any>;
+    protected _beforeCreate(command: MongoEntityService.CreateCommand<T>): Promise<void>;
+    protected _beforeUpdate(command: MongoEntityService.UpdateOneCommand<T>): Promise<void>;
+    protected _beforeUpdateMany(command: MongoEntityService.UpdateManyCommand<T>): Promise<void>;
+    protected _beforeDelete(command: MongoEntityService.DeleteCommand<T>): Promise<void>;
+    protected _beforeDeleteMany(command: MongoEntityService.DeleteCommand<T>): Promise<void>;
+    protected _afterCreate(command: MongoEntityService.CreateCommand<T>, result: PartialDTO<T>): Promise<void>;
+    protected _afterUpdate(command: MongoEntityService.UpdateOneCommand<T>, result?: PartialDTO<T>): Promise<void>;
+    protected _afterUpdateMany(command: MongoEntityService.UpdateManyCommand<T>, affected: number): Promise<void>;
+    protected _afterDelete(command: MongoEntityService.DeleteCommand<T>, affected: number): Promise<void>;
+    protected _afterDeleteMany(command: MongoEntityService.DeleteCommand<T>, affected: number): Promise<void>;
 }