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

package/esm/mongo-nested-service.js

@@ -1,5 +1,6 @@
 import { ComplexType, NotAcceptableError, ResourceNotAvailableError } from '@opra/common';
 import omit from 'lodash.omit';
+import { isNotNullish } from 'valgen';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoService } from './mongo-service.js';
 /**
@@ -21,7 +22,7 @@ export class MongoNestedService extends MongoService {
         this.fieldName = fieldName;
         this.nestedKey = options?.nestedKey || '_id';
         this.defaultLimit = options?.defaultLimit || 10;
-        this.$nestedFilter = options?.$nestedFilter;
+        this.nestedFilter = options?.nestedFilter;
     }
     /**
      * Retrieves the data type of the array field
@@ -50,51 +51,81 @@ export class MongoNestedService extends MongoService {
             throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + id);
         }
     }
+    async create(documentId, input, options) {
+        const command = {
+            crud: 'create',
+            method: 'create',
+            byId: false,
+            documentId,
+            input,
+            options,
+        };
+        input[this.nestedKey] = input[this.nestedKey] ?? this._generateId(command);
+        return this._executeCommand(command, async () => {
+            const r = await this._create(command);
+            if (!options?.projection)
+                return r;
+            const findCommand = {
+                crud: 'read',
+                method: 'findById',
+                byId: true,
+                documentId,
+                nestedId: r[this.nestedKey],
+                options: {
+                    ...options,
+                    sort: undefined,
+                    filter: undefined,
+                    skip: undefined,
+                },
+            };
+            const out = await this._findById(findCommand);
+            if (out)
+                return out;
+        });
+    }
     /**
      * Adds a single item into the array field.
      *
      * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
-     * @param {T} input - The item to be added to the array field.
+     * @param {DTO<T>} input - The item to be added to the array field.
      * @param {MongoNestedService.CreateOptions} [options] - Optional options for the create operation.
-     * @return {Promise<PartialDTO<T>>} - A promise that resolves with the partial output of the created item.
+     * @return {Promise<PartialDTO<T>>} - A promise that resolves create operation result
      * @throws {ResourceNotAvailableError} - If the parent document is not found.
      */
-    async create(documentId, input, options) {
-        const id = input._id || this._generateId();
-        if (id != null)
-            input._id = id;
-        const info = {
+    async createOnly(documentId, input, options) {
+        const command = {
             crud: 'create',
             method: 'create',
             byId: false,
             documentId,
-            nestedId: id,
             input,
             options,
         };
-        return this._intercept(() => this._create(documentId, input, options), info);
+        input[this.nestedKey] = input[this.nestedKey] ?? this._generateId(command);
+        return this._executeCommand(command, () => this._create(command));
     }
-    async _create(documentId, input, options) {
-        const inputCodec = this.getInputCodec('create');
-        const doc = inputCodec(input);
-        doc._id = doc._id || this._generateId();
+    async _create(command) {
+        const inputCodec = this._getInputCodec('create');
+        const { documentId, options } = command;
+        const input = command.input;
+        isNotNullish(input, { label: 'input' });
+        isNotNullish(input[this.nestedKey], { label: `input.${this.nestedKey}` });
+        const document = inputCodec(input);
         const docFilter = MongoAdapter.prepareKeyValues(documentId, ['_id']);
-        const r = await this._dbUpdateOne(docFilter, {
-            $push: { [this.fieldName]: doc },
-        }, options);
-        if (r.matchedCount) {
-            if (!options)
-                return doc;
-            const id = doc[this.nestedKey];
-            const out = await this._findById(documentId, id, {
-                ...options,
-                filter: undefined,
-                skip: undefined,
-            });
-            if (out)
-                return out;
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const update = {
+            $push: { [this.fieldName]: document },
+        };
+        const r = await collection.updateOne(docFilter, update, {
+            ...options,
+            session: options?.session || this.getSession(),
+            upsert: undefined,
+        });
+        if (!r.matchedCount) {
+            throw new ResourceNotAvailableError(this.getResourceName(), documentId);
         }
-        throw new ResourceNotAvailableError(this.getResourceName(), documentId);
+        return document;
     }
     /**
      * Counts the number of documents in the collection that match the specified parentId and options.
@@ -104,20 +135,22 @@ export class MongoNestedService extends MongoService {
      * @returns {Promise<number>} - A promise that resolves to the count of documents.
      */
     async count(documentId, options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'count',
             byId: false,
             documentId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._count(documentId, { ...options, filter, documentFilter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, documentFilter };
+            return this._count(command);
+        });
     }
-    async _count(documentId, options) {
+    async _count(command) {
+        const { documentId, options } = command;
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, ['_id']),
             options?.documentFilter,
@@ -132,13 +165,18 @@ export class MongoNestedService extends MongoService {
             stages.push({ $match: filter });
         }
         stages.push({ $count: '*' });
-        const r = await this._dbAggregate(stages, options);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const cursor = collection.aggregate(stages, {
+            ...omit(options, ['documentFilter', 'nestedFilter', 'projection', 'sort', 'skip', 'limit', 'filter', 'count']),
+            session: options?.session || this.getSession(),
+        });
         try {
-            const n = await r.next();
+            const n = await cursor.next();
             return n?.['*'] || 0;
         }
         finally {
-            await r.close();
+            await cursor.close();
         }
     }
     /**
@@ -150,7 +188,7 @@ export class MongoNestedService extends MongoService {
      * @return {Promise<number>} - A Promise that resolves to the number of elements deleted (1 if successful, 0 if not).
      */
     async delete(documentId, nestedId, options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'delete',
             byId: true,
@@ -158,21 +196,32 @@ export class MongoNestedService extends MongoService {
             nestedId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._delete(documentId, nestedId, { ...options, filter, documentFilter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, documentFilter };
+            return this._delete(command);
+        });
     }
-    async _delete(documentId, nestedId, options) {
+    async _delete(command) {
+        const { documentId, nestedId, options } = command;
+        isNotNullish(documentId, { label: 'documentId' });
+        isNotNullish(documentId, { label: 'nestedId' });
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, ['_id']),
             options?.documentFilter,
         ]);
         const pullFilter = MongoAdapter.prepareFilter([MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]), options?.filter]) || {};
-        const r = await this._dbUpdateOne(matchFilter, {
+        const update = {
             $pull: { [this.fieldName]: pullFilter },
-        }, options);
+        };
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const r = await collection.updateOne(matchFilter, update, {
+            ...options,
+            session: options?.session || this.getSession(),
+            upsert: undefined,
+        });
         return r.modifiedCount ? 1 : 0;
     }
     /**
@@ -183,33 +232,47 @@ export class MongoNestedService extends MongoService {
      * @returns {Promise<number>} - A Promise that resolves to the number of items deleted.
      */
     async deleteMany(documentId, options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'deleteMany',
             byId: false,
             documentId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._deleteMany(documentId, { ...options, filter, documentFilter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, documentFilter };
+            return this._deleteMany(command);
+        });
     }
-    async _deleteMany(documentId, options) {
+    async _deleteMany(command) {
+        const { documentId, options } = command;
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, ['_id']),
             options?.documentFilter,
         ]);
         // Count matching items, we will use this as result
-        const matchCount = await this.count(documentId, options);
+        const countCommand = {
+            crud: 'read',
+            method: 'count',
+            byId: false,
+            documentId,
+            options,
+        };
+        const matchCount = await this._count(countCommand);
         const pullFilter = MongoAdapter.prepareFilter(options?.filter) || {};
-        const r = await this._dbUpdateOne(matchFilter, {
+        const update = {
             $pull: { [this.fieldName]: pullFilter },
-        }, options);
-        if (r.matchedCount)
-            return matchCount;
-        return 0;
+        };
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        await collection.updateOne(matchFilter, update, {
+            ...options,
+            session: options?.session || this.getSession(),
+            upsert: undefined,
+        });
+        return matchCount;
     }
     /**
      * Checks if an array element with the given parentId and id exists.
@@ -220,28 +283,50 @@ export class MongoNestedService extends MongoService {
      * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating if the record exists or not.
      */
     async exists(documentId, nestedId, options) {
-        return !!(await this.findById(documentId, nestedId, { ...options, projection: ['_id'] }));
+        const command = {
+            crud: 'read',
+            method: 'exists',
+            byId: true,
+            documentId,
+            nestedId,
+            options,
+        };
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getNestedFilter(command),
+                documentFilter,
+                command.options?.filter,
+            ]);
+            command.options = { ...command.options, filter };
+            return !!(await this._findById(command));
+        });
     }
     /**
      * Checks if an object with the given arguments exists.
      *
      * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
-     * @param {MongoNestedService.ExistsOneOptions} [options] - The options for the query (optional).
+     * @param {MongoNestedService.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.
      */
     async existsOne(documentId, options) {
-        return !!(await this.findOne(documentId, { ...options, projection: ['_id'] }));
+        const command = {
+            crud: 'read',
+            method: 'exists',
+            byId: false,
+            documentId,
+            options,
+        };
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const filter = MongoAdapter.prepareFilter([documentFilter, command.options?.filter]);
+            const findCommand = command;
+            findCommand.options = { ...command.options, filter, documentFilter, projection: ['_id'] };
+            return !!(await this._findOne(findCommand));
+        });
     }
-    /**
-     * Finds an element in array field by its parent ID and ID.
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the document.
-     * @param {MongoAdapter.AnyId} nestedId - The ID of the document.
-     * @param {MongoNestedService.FindOneOptions<T>} [options] - The optional options for the operation.
-     * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
-     */
     async findById(documentId, nestedId, options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findById',
             byId: true,
@@ -249,95 +334,96 @@ export class MongoNestedService extends MongoService {
             nestedId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._findById(documentId, nestedId, { ...options, filter, documentFilter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, documentFilter };
+            return this._findById(command);
+        });
     }
-    async _findById(documentId, nestedId, options) {
+    async _findById(command) {
+        const { documentId, nestedId, options } = command;
+        isNotNullish(documentId, { label: 'documentId' });
+        isNotNullish(nestedId, { label: 'nestedId' });
         const filter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]),
             options?.filter,
         ]);
-        const rows = await this._findMany(documentId, {
-            ...options,
-            filter,
-            limit: 1,
-            skip: undefined,
-            sort: undefined,
-        });
+        const findManyCommand = {
+            ...command,
+            options: {
+                ...options,
+                filter,
+                limit: 1,
+                skip: undefined,
+                sort: undefined,
+            },
+        };
+        const rows = await this._findMany(findManyCommand);
         return rows?.[0];
     }
-    /**
-     * Finds the first array element that matches the given parentId.
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the document.
-     * @param {MongoNestedService.FindOneOptions<T>} [options] - Optional options to customize the query.
-     * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the first matching document, or `undefined` if no match is found.
-     */
     async findOne(documentId, options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findOne',
             byId: false,
             documentId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._findOne(documentId, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _findOne(documentId, options) {
-        const rows = await this._findMany(documentId, {
-            ...options,
-            limit: 1,
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, documentFilter };
+            return this._findOne(command);
         });
+    }
+    async _findOne(command) {
+        const { documentId, options } = command;
+        isNotNullish(documentId, { label: 'documentId' });
+        const findManyCommand = {
+            ...command,
+            options: {
+                ...options,
+                limit: 1,
+            },
+        };
+        const rows = await this._findMany(findManyCommand);
         return rows?.[0];
     }
-    /**
-     * Finds multiple elements in an array field.
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
-     * @param {MongoNestedService.FindManyOptions<T>} [options] - The options for finding the documents.
-     * @returns {Promise<PartialDTO<T>[]>} - The found documents.
-     */
     async findMany(documentId, options) {
-        const args = {
+        const command = {
             crud: 'read',
             method: 'findMany',
             byId: false,
             documentId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = await this._getDocumentFilter(args);
-            const nestedFilter = await this._getNestedFilter(args);
-            return this._findMany(documentId, {
-                ...options,
-                documentFilter,
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const nestedFilter = await this._getNestedFilter(command);
+            command.options = {
+                ...command.options,
                 nestedFilter,
-                limit: options?.limit || this.defaultLimit,
-            });
-        }, args);
+                documentFilter,
+                limit: command.options?.limit || this.defaultLimit,
+            };
+            return this._findMany(command);
+        });
     }
-    async _findMany(documentId, options) {
+    async _findMany(command) {
+        const { documentId, options } = command;
+        isNotNullish(documentId, { label: 'documentId' });
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options.documentFilter,
+            options?.documentFilter,
         ]);
-        const mongoOptions = {
-            ...omit(options, ['documentFilter', 'nestedFilter', 'projection', 'sort', 'skip', 'limit', 'filter', 'count']),
-        };
         const limit = options?.limit || this.defaultLimit;
         const stages = [
             { $match: matchFilter },
             { $unwind: { path: '$' + this.fieldName } },
             { $replaceRoot: { newRoot: '$' + this.fieldName } },
         ];
-        if (options?.filter || options.nestedFilter) {
+        if (options?.filter || options?.nestedFilter) {
             const optionsFilter = MongoAdapter.prepareFilter([options?.filter, options.nestedFilter]);
             stages.push({ $match: optionsFilter });
         }
@@ -353,51 +439,48 @@ export class MongoNestedService extends MongoService {
         const projection = MongoAdapter.prepareProjection(dataType, options?.projection);
         if (projection)
             stages.push({ $project: projection });
-        const cursor = await this._dbAggregate(stages, mongoOptions);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const cursor = collection.aggregate(stages, {
+            ...omit(options, ['documentFilter', 'nestedFilter', 'projection', 'sort', 'skip', 'limit', 'filter', 'count']),
+            session: options?.session || this.getSession(),
+        });
         try {
-            const outputCodec = this.getOutputCodec('find');
-            const out = await (await cursor.toArray()).map((r) => outputCodec(r));
-            return out;
+            const outputCodec = this._getOutputCodec('find');
+            return (await cursor.toArray()).map((r) => outputCodec(r));
         }
         finally {
             if (!cursor.closed)
                 await cursor.close();
         }
     }
-    /**
-     * Finds multiple elements in an array field.
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
-     * @param {MongoNestedService.FindManyOptions<T>} [options] - The options for finding the documents.
-     * @returns {Promise<PartialDTO<T>[]>} - The found documents.
-     */
     async findManyWithCount(documentId, options) {
-        const args = {
+        const command = {
             crud: 'read',
             method: 'findMany',
             byId: false,
             documentId,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = await this._getDocumentFilter(args);
-            const nestedFilter = await this._getNestedFilter(args);
-            return this._findManyWithCount(documentId, {
-                ...options,
-                documentFilter,
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const nestedFilter = await this._getNestedFilter(command);
+            command.options = {
+                ...command.options,
                 nestedFilter,
-                limit: options?.limit || this.defaultLimit,
-            });
-        }, args);
+                documentFilter,
+                limit: command.options?.limit || this.defaultLimit,
+            };
+            return this._findManyWithCount(command);
+        });
     }
-    async _findManyWithCount(documentId, options) {
+    async _findManyWithCount(command) {
+        const { documentId, options } = command;
+        isNotNullish(documentId, { label: 'documentId' });
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options.documentFilter,
+            options?.documentFilter,
         ]);
-        const mongoOptions = {
-            ...omit(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count']),
-        };
         const limit = options?.limit || this.defaultLimit;
         const dataStages = [];
         const stages = [
@@ -411,8 +494,8 @@ export class MongoNestedService extends MongoService {
                 },
             },
         ];
-        if (options?.filter || options.nestedFilter) {
-            const optionsFilter = MongoAdapter.prepareFilter([options?.filter, options.nestedFilter]);
+        if (options?.filter || options?.nestedFilter) {
+            const optionsFilter = MongoAdapter.prepareFilter([options?.filter, options?.nestedFilter]);
             dataStages.push({ $match: optionsFilter });
         }
         if (options?.skip)
@@ -427,12 +510,15 @@ export class MongoNestedService extends MongoService {
         const projection = MongoAdapter.prepareProjection(dataType, options?.projection);
         if (projection)
             dataStages.push({ $project: projection });
-        const cursor = await this._dbAggregate(stages, {
-            ...mongoOptions,
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const cursor = collection.aggregate(stages, {
+            ...omit(options, ['documentFilter', 'nestedFilter', 'projection', 'sort', 'skip', 'limit', 'filter', 'count']),
+            session: options?.session || this.getSession(),
         });
         try {
             const facetResult = await cursor.toArray();
-            const outputCodec = this.getOutputCodec('find');
+            const outputCodec = this._getOutputCodec('find');
             return {
                 count: facetResult[0].count[0].totalMatches || 0,
                 items: facetResult[0].data.map((r) => outputCodec(r)),
@@ -443,15 +529,6 @@ export class MongoNestedService extends MongoService {
                 await cursor.close();
         }
     }
-    /**
-     * Retrieves a specific item from the array of a document.
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the document.
-     * @param {MongoAdapter.AnyId} nestedId - The ID of the item.
-     * @param {MongoNestedService.FindOneOptions<T>} [options] - The options for finding the item.
-     * @returns {Promise<PartialDTO<T>>} - The item found.
-     * @throws {ResourceNotAvailableError} - If the item is not found.
-     */
     async get(documentId, nestedId, options) {
         const out = await this.findById(documentId, nestedId, options);
         if (!out) {
@@ -459,27 +536,40 @@ export class MongoNestedService extends MongoService {
         }
         return out;
     }
-    /**
-     * Updates an array element with new data and returns the updated element
-     *
-     * @param {AnyId} documentId - The ID of the document to update.
-     * @param {AnyId} nestedId - The ID of the item to update within the document.
-     * @param {PatchDTO<T>} input - The new data to update the item with.
-     * @param {MongoNestedService.UpdateOptions<T>} [options] - Additional update options.
-     * @returns {Promise<PartialDTO<T> | undefined>} The updated item or undefined if it does not exist.
-     * @throws {Error} If an error occurs while updating the item.
-     */
     async update(documentId, nestedId, input, options) {
-        const r = await this.updateOnly(documentId, nestedId, input, options);
-        if (!r)
-            return;
-        const out = await this._findById(documentId, nestedId, {
-            ...options,
-            sort: undefined,
+        const command = {
+            crud: 'update',
+            method: 'update',
+            byId: true,
+            documentId,
+            nestedId,
+            input,
+            options,
+        };
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = {
+                ...command.options,
+                filter,
+                documentFilter,
+            };
+            const matchCount = await this._updateOnly(command);
+            if (matchCount) {
+                const findCommand = {
+                    crud: 'read',
+                    method: 'findById',
+                    byId: true,
+                    documentId,
+                    nestedId,
+                    options: { ...options, sort: undefined },
+                };
+                const out = this._findById(findCommand);
+                if (out)
+                    return out;
+            }
+            throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + nestedId);
         });
-        if (out)
-            return out;
-        throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + nestedId);
     }
     /**
      * Update an array element with new data. Returns 1 if document updated 0 otherwise.
@@ -487,29 +577,45 @@ export class MongoNestedService extends MongoService {
      * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
      * @param {MongoAdapter.AnyId} nestedId - The ID of the document to update.
      * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
-     * @param {MongoNestedService.UpdateOptions<T>} [options] - Optional update options.
+     * @param {MongoNestedService.UpdateOneOptions<T>} [options] - Optional update options.
      * @returns {Promise<number>} - A promise that resolves to the number of elements updated.
      */
     async updateOnly(documentId, nestedId, input, options) {
-        const info = {
+        const command = {
             crud: 'update',
             method: 'update',
             byId: true,
             documentId,
             nestedId,
+            input,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._updateOnly(documentId, nestedId, input, { ...options, filter, documentFilter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = {
+                ...command.options,
+                filter,
+                documentFilter,
+            };
+            return await this._updateOnly(command);
+        });
     }
-    async _updateOnly(documentId, nestedId, input, options) {
+    async _updateOnly(command) {
+        const { documentId, nestedId, options } = command;
+        isNotNullish(documentId, { label: 'documentId' });
+        isNotNullish(nestedId, { label: 'nestedId' });
         let filter = MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]);
         if (options?.filter)
             filter = MongoAdapter.prepareFilter([filter, options?.filter]);
-        return await this._updateMany(documentId, input, { ...options, filter });
+        const updateManyCommand = {
+            ...command,
+            options: {
+                ...command.options,
+                filter,
+            },
+        };
+        return await this._updateMany(updateManyCommand);
     }
     /**
      * Updates multiple array elements in document
@@ -520,7 +626,7 @@ export class MongoNestedService extends MongoService {
      * @returns {Promise<number>} - A promise that resolves to the number of documents updated.
      */
     async updateMany(documentId, input, options) {
-        const info = {
+        const command = {
             crud: 'update',
             method: 'updateMany',
             documentId,
@@ -528,14 +634,18 @@ export class MongoNestedService extends MongoService {
             input,
             options,
         };
-        return this._intercept(async () => {
-            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
-            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
-            return this._updateMany(documentId, input, { ...options, filter, documentFilter });
-        }, info);
-    }
-    async _updateMany(documentId, input, options) {
-        const inputCodec = this.getInputCodec('update');
+        return this._executeCommand(command, async () => {
+            const documentFilter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command)]);
+            const filter = MongoAdapter.prepareFilter([await this._getNestedFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter, documentFilter };
+            return this._updateMany(command);
+        });
+    }
+    async _updateMany(command) {
+        const { documentId, input } = command;
+        isNotNullish(documentId, { label: 'documentId' });
+        const options = { ...command.options };
+        const inputCodec = this._getInputCodec('update');
         const doc = inputCodec(input);
         if (!Object.keys(doc).length)
             return 0;
@@ -546,26 +656,121 @@ export class MongoNestedService extends MongoService {
         ]);
         if (options?.filter) {
             const elemMatch = MongoAdapter.prepareFilter([options?.filter], { fieldPrefix: 'elem.' });
-            options = options || {};
             options.arrayFilters = [elemMatch];
         }
         const update = MongoAdapter.preparePatch(doc, {
             fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].'),
         });
-        const r = await this._dbUpdateOne(matchFilter, update, options);
-        if (options?.count)
-            return await this._count(documentId, options);
-        return r.modifiedCount || 0;
+        // Count matching items, we will use this as result
+        const count = await this._count({
+            crud: 'read',
+            method: 'count',
+            byId: false,
+            documentId,
+            options,
+        });
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        await collection.updateOne(matchFilter, update, {
+            ...options,
+            session: options?.session || this.getSession(),
+            upsert: undefined,
+        });
+        return count;
     }
     /**
      * Retrieves the common filter used for querying array elements.
      * This method is mostly used for security issues like securing multi-tenant applications.
      *
      * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
+     * @returns {MongoAdapter.FilterInput | Promise<MongoAdapter.FilterInput> | undefined} The common filter or a Promise
      * that resolves to the common filter, or undefined if not available.
      */
     _getNestedFilter(args) {
-        return typeof this.$nestedFilter === 'function' ? this.$nestedFilter(args, this) : this.$nestedFilter;
+        return typeof this.nestedFilter === 'function' ? this.nestedFilter(args, this) : this.nestedFilter;
+    }
+    async _executeCommand(command, commandFn) {
+        try {
+            const result = await super._executeCommand(command, async () => {
+                /** Call before[X] hooks */
+                if (command.crud === 'create')
+                    await this._beforeCreate(command);
+                else if (command.crud === 'update' && command.byId) {
+                    await this._beforeUpdate(command);
+                }
+                else if (command.crud === 'update' && !command.byId) {
+                    await this._beforeUpdateMany(command);
+                }
+                else if (command.crud === 'delete' && command.byId) {
+                    await this._beforeDelete(command);
+                }
+                else if (command.crud === 'delete' && !command.byId) {
+                    await this._beforeDeleteMany(command);
+                }
+                /** Call command function */
+                return commandFn();
+            });
+            /** Call after[X] hooks */
+            if (command.crud === 'create')
+                await this._afterCreate(command, result);
+            else if (command.crud === 'update' && command.byId) {
+                await this._afterUpdate(command, result);
+            }
+            else if (command.crud === 'update' && !command.byId) {
+                await this._afterUpdateMany(command, result);
+            }
+            else if (command.crud === 'delete' && command.byId) {
+                await this._afterDelete(command, result);
+            }
+            else if (command.crud === 'delete' && !command.byId) {
+                await this._afterDeleteMany(command, result);
+            }
+            return result;
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._executeCommand);
+            await this.onError?.(e, this);
+            throw e;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeCreate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdateMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDelete(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDeleteMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterCreate(command, result) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterUpdate(command, result) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterUpdateMany(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDelete(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDeleteMany(command, affected) {
+        // Do nothing
     }
 }