@opra/mongodb 0.33.13 → 1.0.0-alpha.10

package/cjs/{mongo-array-service.js → mongo-nested-service.js}

@@ -1,86 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoArrayService = void 0;
+exports.MongoNestedService = void 0;
 const tslib_1 = require("tslib");
-const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
-const mongodb_1 = require("mongodb");
 const common_1 = require("@opra/common");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
 const mongo_adapter_js_1 = require("./mongo-adapter.js");
 const mongo_service_js_1 = require("./mongo-service.js");
 /**
  * A class that provides methods to perform operations on an array field in a MongoDB collection.
+ * @class MongoNestedService
  * @template T The type of the array item.
  */
-class MongoArrayService extends mongo_service_js_1.MongoService {
+class MongoNestedService extends mongo_service_js_1.MongoService {
     /**
      * Constructs a new instance
      *
      * @param {Type | string} dataType - The data type of the array elements.
      * @param {string} fieldName - The name of the field in the document representing the array.
-     * @param {MongoArrayService.Options} [options] - The options for the array service.
+     * @param {MongoNestedService.Options} [options] - The options for the array service.
      * @constructor
      */
     constructor(dataType, fieldName, options) {
         super(dataType, options);
         this.fieldName = fieldName;
+        this.nestedKey = options?.nestedKey || '_id';
         this.defaultLimit = options?.defaultLimit || 10;
-        this.collectionKey = options?.collectionKey || '_id';
-        this.arrayKey = options?.arrayKey || '_id';
-        this.$documentFilter = options?.documentFilter;
-        this.$arrayFilter = options?.arrayFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
+        this.$nestedFilter = options?.$nestedFilter;
+    }
+    /**
+     * Retrieves the data type of the array field
+     *
+     * @returns {ComplexType} The complex data type of the field.
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType() {
+        const t = super.dataType.getField(this.fieldName).type;
+        if (!(t instanceof common_1.ComplexType))
+            throw new common_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        return t;
     }
     /**
      * Asserts whether a resource with the specified parentId and id exists.
      * Throws a ResourceNotFoundError if the resource does not exist.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The ID of the resource.
-     * @param {MongoArrayService.ExistsOptions} [options] - Optional parameters for checking resource existence.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
+     * @param {MongoAdapter.AnyId} id - The ID of the resource.
+     * @param {MongoNestedService.ExistsOptions<T>} [options] - Optional parameters for checking resource existence.
      * @return {Promise<void>} - A promise that resolves with no value upon success.
      * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
     async assert(documentId, id, options) {
-        if (!(await this.exists(documentId, id, options)))
-            throw new common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
+        if (!(await this.exists(documentId, id, options))) {
+            throw new common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + id);
+        }
     }
     /**
      * Adds a single item into the array field.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
      * @param {T} input - The item to be added to the array field.
-     * @param {MongoArrayService.CreateOptions} [options] - Optional options for the create operation.
+     * @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.
      * @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 = {
             crud: 'create',
             method: 'create',
             byId: false,
             documentId,
-            itemId: input._id,
+            nestedId: id,
             input,
-            options
+            options,
         };
         return this._intercept(() => this._create(documentId, input, options), info);
     }
     async _create(documentId, input, options) {
-        const encode = this.getEncoder('create');
-        const doc = encode(input, { coerce: true });
+        const inputCodec = this.getInputCodec('create');
+        const doc = inputCodec(input);
         doc._id = doc._id || this._generateId();
-        const docFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
-        const r = await this.__updateOne(docFilter, {
-            $push: { [this.fieldName]: doc }
+        const docFilter = mongo_adapter_js_1.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.arrayKey];
+            const id = doc[this.nestedKey];
             const out = await this._findById(documentId, id, {
                 ...options,
                 filter: undefined,
-                skip: undefined
+                skip: undefined,
             });
             if (out)
                 return out;
@@ -90,9 +103,8 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
     /**
      * Counts the number of documents in the collection that match the specified parentId and options.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {object} options - Optional parameters for counting.
-     * @param {object} options.filter - The filter object to apply to the count operation.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
+     * @param {MongoNestedService.CountOptions<T>} [options] - Optional parameters for counting.
      * @returns {Promise<number>} - A promise that resolves to the count of documents.
      */
     async count(documentId, options) {
@@ -101,35 +113,30 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
             method: 'count',
             byId: false,
             documentId,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
             return this._count(documentId, { ...options, filter, documentFilter });
         }, info);
     }
     async _count(documentId, options) {
         const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
+            options?.documentFilter,
         ]);
         const stages = [
             { $match: matchFilter },
-            { $unwind: { path: "$" + this.fieldName } },
-            { $replaceRoot: { newRoot: "$" + this.fieldName } }
+            { $unwind: { path: '$' + this.fieldName } },
+            { $replaceRoot: { newRoot: '$' + this.fieldName } },
         ];
         if (options?.filter) {
             const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
             stages.push({ $match: filter });
         }
         stages.push({ $count: '*' });
-        const r = await this.__aggregate(stages, options);
+        const r = await this._dbAggregate(stages, options);
         try {
             const n = await r.next();
             return n?.['*'] || 0;
@@ -141,50 +148,42 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
     /**
      * Deletes an element from an array within a document in the MongoDB collection.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The ID of the element to delete from the array.
-     * @param {MongoArrayService.DeleteOptions<T>} [options] - Additional options for the delete operation.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
+     * @param {MongoAdapter.AnyId} nestedId - The ID of the element to delete from the nested array.
+     * @param {MongoNestedService.DeleteOptions<T>} [options] - Additional options for the delete operation.
      * @return {Promise<number>} - A Promise that resolves to the number of elements deleted (1 if successful, 0 if not).
      */
-    async delete(documentId, id, options) {
+    async delete(documentId, nestedId, options) {
         const info = {
             crud: 'delete',
             method: 'delete',
             byId: true,
             documentId,
-            itemId: id,
-            options
+            nestedId,
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._delete(documentId, id, { ...options, filter, documentFilter });
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
+            return this._delete(documentId, nestedId, { ...options, filter, documentFilter });
         }, info);
     }
-    async _delete(documentId, id, options) {
+    async _delete(documentId, nestedId, options) {
         const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
+            options?.documentFilter,
         ]);
-        const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
-            options?.filter
-        ]) || {};
-        const r = await this.__updateOne(matchFilter, {
-            $pull: { [this.fieldName]: pullFilter }
+        const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([mongo_adapter_js_1.MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]), options?.filter]) || {};
+        const r = await this._dbUpdateOne(matchFilter, {
+            $pull: { [this.fieldName]: pullFilter },
         }, options);
         return r.modifiedCount ? 1 : 0;
     }
     /**
      * Deletes multiple items from a collection based on the parent ID and optional filter.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {MongoArrayService.DeleteManyOptions<T>} options - Optional options to specify a filter.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
+     * @param {MongoNestedService.DeleteManyOptions<T>} [options] - Optional options to specify a filter.
      * @returns {Promise<number>} - A Promise that resolves to the number of items deleted.
      */
     async deleteMany(documentId, options) {
@@ -193,92 +192,92 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
             method: 'deleteMany',
             byId: false,
             documentId,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
             return this._deleteMany(documentId, { ...options, filter, documentFilter });
         }, info);
     }
     async _deleteMany(documentId, options) {
         const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options?.documentFilter
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
+            options?.documentFilter,
         ]);
         // Count matching items, we will use this as result
         const matchCount = await this.count(documentId, options);
         const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
-        const r = await this.__updateOne(matchFilter, {
-            $pull: { [this.fieldName]: pullFilter }
+        const r = await this._dbUpdateOne(matchFilter, {
+            $pull: { [this.fieldName]: pullFilter },
         }, options);
-        if (r.modifiedCount)
+        if (r.matchedCount)
             return matchCount;
         return 0;
     }
     /**
      * Checks if an array element with the given parentId and id exists.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The id of the record.
-     * @param {MongoArrayService.ExistsOptions} [options] - The options for the exists method.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
+     * @param {MongoAdapter.AnyId} nestedId - The id of the record.
+     * @param {MongoNestedService.ExistsOptions<T>} [options] - The options for the exists method.
      * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating if the record exists or not.
      */
-    async exists(documentId, id, options) {
-        return !!(await this.findById(documentId, id, { ...options, pick: ['_id'], omit: undefined, include: undefined }));
+    async exists(documentId, nestedId, options) {
+        return !!(await this.findById(documentId, nestedId, { ...options, projection: ['_id'] }));
+    }
+    /**
+     * 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).
+     * @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'] }));
     }
     /**
      * Finds an element in array field by its parent ID and ID.
      *
-     * @param {AnyId} documentId - The ID of the document.
-     * @param {AnyId} id - The ID of the document.
-     * @param {MongoArrayService.FindOneOptions} [options] - The optional options for the operation.
+     * @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, id, options) {
+    async findById(documentId, nestedId, options) {
         const info = {
             crud: 'read',
             method: 'findById',
             byId: true,
             documentId,
-            itemId: id,
-            options
+            nestedId,
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._findById(documentId, id, { ...options, filter, documentFilter });
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
+            return this._findById(documentId, nestedId, { ...options, filter, documentFilter });
         }, info);
     }
-    async _findById(documentId, id, options) {
+    async _findById(documentId, nestedId, options) {
         const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
-            options?.filter
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]),
+            options?.filter,
         ]);
         const rows = await this._findMany(documentId, {
             ...options,
             filter,
             limit: 1,
             skip: undefined,
-            sort: undefined
+            sort: undefined,
         });
         return rows?.[0];
     }
     /**
      * Finds the first array element that matches the given parentId.
      *
-     * @param {AnyId} documentId - The ID of the document.
-     * @param {MongoArrayService.FindOneOptions} [options] - Optional options to customize the query.
+     * @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) {
@@ -287,31 +286,26 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
             method: 'findOne',
             byId: false,
             documentId,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.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
+            limit: 1,
         });
         return rows?.[0];
     }
     /**
      * Finds multiple elements in an array field.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {MongoArrayService.FindManyOptions<T>} [options] - The options for finding the documents.
+     * @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) {
@@ -320,43 +314,109 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
             method: 'findMany',
             byId: false,
             documentId,
-            options
+            options,
         };
         return this._intercept(async () => {
             const documentFilter = await this._getDocumentFilter(args);
-            const arrayFilter = await this._getArrayFilter(args);
-            return this._findMany(documentId, { ...options, documentFilter, arrayFilter });
+            const nestedFilter = await this._getNestedFilter(args);
+            return this._findMany(documentId, {
+                ...options,
+                documentFilter,
+                nestedFilter,
+                limit: options?.limit || this.defaultLimit,
+            });
         }, args);
     }
     async _findMany(documentId, options) {
         const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            options.documentFilter
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
+            options.documentFilter,
         ]);
         const mongoOptions = {
-            ...(0, lodash_omit_1.default)(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
+            ...(0, lodash_omit_1.default)(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 } }
+            { $unwind: { path: '$' + this.fieldName } },
+            { $replaceRoot: { newRoot: '$' + this.fieldName } },
         ];
-        let dataStages = stages;
-        if (options?.count) {
-            dataStages = [];
-            stages.push({
+        if (options?.filter || options.nestedFilter) {
+            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, options.nestedFilter]);
+            stages.push({ $match: optionsFilter });
+        }
+        if (options?.skip)
+            stages.push({ $skip: options.skip });
+        if (options?.sort) {
+            const sort = mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort);
+            if (sort)
+                stages.push({ $sort: sort });
+        }
+        stages.push({ $limit: limit });
+        const dataType = this.dataType;
+        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options?.projection);
+        if (projection)
+            stages.push({ $project: projection });
+        const cursor = await this._dbAggregate(stages, mongoOptions);
+        try {
+            const outputCodec = this.getOutputCodec('find');
+            const out = await (await cursor.toArray()).map((r) => outputCodec(r));
+            return out;
+        }
+        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 = {
+            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,
+                nestedFilter,
+                limit: options?.limit || this.defaultLimit,
+            });
+        }, args);
+    }
+    async _findManyWithCount(documentId, options) {
+        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
+            options.documentFilter,
+        ]);
+        const mongoOptions = {
+            ...(0, lodash_omit_1.default)(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count']),
+        };
+        const limit = options?.limit || this.defaultLimit;
+        const dataStages = [];
+        const stages = [
+            { $match: matchFilter },
+            { $unwind: { path: '$' + this.fieldName } },
+            { $replaceRoot: { newRoot: '$' + this.fieldName } },
+            {
                 $facet: {
                     data: dataStages,
-                    count: [{ $count: 'totalMatches' }]
-                }
-            });
-        }
-        if (options?.filter || options.arrayFilter) {
-            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                options?.filter,
-                options.arrayFilter
-            ]);
+                    count: [{ $count: 'totalMatches' }],
+                },
+            },
+        ];
+        if (options?.filter || options.nestedFilter) {
+            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, options.nestedFilter]);
             dataStages.push({ $match: optionsFilter });
         }
         if (options?.skip)
@@ -367,22 +427,20 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
                 dataStages.push({ $sort: sort });
         }
         dataStages.push({ $limit: limit });
-        const dataType = this.getDataType();
-        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options);
+        const dataType = this.dataType;
+        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options?.projection);
         if (projection)
             dataStages.push({ $project: projection });
-        const decode = this.getDecoder();
-        const cursor = await this.__aggregate(stages, {
-            ...mongoOptions
+        const cursor = await this._dbAggregate(stages, {
+            ...mongoOptions,
         });
         try {
-            if (options?.count) {
-                const facetResult = await cursor.toArray();
-                this.context.response.totalMatches = facetResult[0].count[0].totalMatches || 0;
-                return facetResult[0].data.map((r) => decode(r, { coerce: true }));
-            }
-            else
-                return await cursor.toArray();
+            const facetResult = await cursor.toArray();
+            const outputCodec = this.getOutputCodec('find');
+            return {
+                count: facetResult[0].count[0].totalMatches || 0,
+                items: facetResult[0].data.map((r) => outputCodec(r)),
+            };
         }
         finally {
             if (!cursor.closed)
@@ -392,68 +450,67 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
     /**
      * Retrieves a specific item from the array of a document.
      *
-     * @param {AnyId} documentId - The ID of the document.
-     * @param {AnyId} id - The ID of the item.
-     * @param {MongoArrayService.FindOneOptions<T>} [options] - The options for finding the item.
+     * @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, id, options) {
-        const out = await this.findById(documentId, id, options);
-        if (!out)
-            throw new common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
+    async get(documentId, nestedId, options) {
+        const out = await this.findById(documentId, nestedId, options);
+        if (!out) {
+            throw new common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + nestedId);
+        }
         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} id - The ID of the item to update within the document.
+     * @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 {MongoArrayService.UpdateOptions<T>} [options] - Additional update options.
+     * @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, id, input, options) {
-        const r = await this.updateOnly(documentId, id, input, options);
+    async update(documentId, nestedId, input, options) {
+        const r = await this.updateOnly(documentId, nestedId, input, options);
         if (!r)
             return;
-        const out = await this._findById(documentId, id, options);
+        const out = await this._findById(documentId, nestedId, {
+            ...options,
+            sort: undefined,
+        });
         if (out)
             return out;
-        throw new common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
+        throw new common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + nestedId);
     }
     /**
      * Update an array element with new data. Returns 1 if document updated 0 otherwise.
      *
-     * @param {AnyId} documentId - The ID of the parent document.
-     * @param {AnyId} id - The ID of the document to update.
+     * @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 {MongoArrayService.UpdateOptions<T>} [options] - Optional update options.
+     * @param {MongoNestedService.UpdateOptions<T>} [options] - Optional update options.
      * @returns {Promise<number>} - A promise that resolves to the number of elements updated.
      */
-    async updateOnly(documentId, id, input, options) {
+    async updateOnly(documentId, nestedId, input, options) {
         const info = {
             crud: 'update',
             method: 'update',
             byId: true,
             documentId,
-            itemId: id,
-            options
+            nestedId,
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
-            return this._updateOnly(documentId, id, input, { ...options, filter, documentFilter });
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
+            return this._updateOnly(documentId, nestedId, input, { ...options, filter, documentFilter });
         }, info);
     }
-    async _updateOnly(documentId, id, input, options) {
-        let filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
+    async _updateOnly(documentId, nestedId, input, options) {
+        let filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]);
         if (options?.filter)
             filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([filter, options?.filter]);
         return await this._updateMany(documentId, input, { ...options, filter });
@@ -461,9 +518,9 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
     /**
      * Updates multiple array elements in document
      *
-     * @param {AnyId} documentId - The ID of the document to update.
+     * @param {MongoAdapter.AnyId} documentId - The ID of the document to update.
      * @param {PatchDTO<T>} input - The updated data for the document(s).
-     * @param {MongoArrayService.UpdateManyOptions<T>} [options] - Additional options for the update operation.
+     * @param {MongoNestedService.UpdateManyOptions<T>} [options] - Additional options for the update operation.
      * @returns {Promise<number>} - A promise that resolves to the number of documents updated.
      */
     async updateMany(documentId, input, options) {
@@ -473,28 +530,23 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
             documentId,
             byId: false,
             input,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info)
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getArrayFilter(info),
-                options?.filter
-            ]);
+            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getDocumentFilter(info)]);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([await this._getNestedFilter(info), options?.filter]);
             return this._updateMany(documentId, input, { ...options, filter, documentFilter });
         }, info);
     }
     async _updateMany(documentId, input, options) {
-        const encode = this.getEncoder('update');
-        const doc = encode(input, { coerce: true });
+        const inputCodec = this.getInputCodec('update');
+        const doc = inputCodec(input);
         if (!Object.keys(doc).length)
             return 0;
         const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
             options?.documentFilter,
-            { [this.fieldName]: { $exists: true } }
+            { [this.fieldName]: { $exists: true } },
         ]);
         if (options?.filter) {
             const elemMatch = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter], { fieldPrefix: 'elem.' });
@@ -502,50 +554,12 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
             options.arrayFilters = [elemMatch];
         }
         const update = mongo_adapter_js_1.MongoAdapter.preparePatch(doc, {
-            fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].')
+            fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].'),
         });
-        const r = await this.__updateOne(matchFilter, update, options);
-        if (!options?.count)
-            return r.modifiedCount;
-        return r.modifiedCount
-            // Count matching items that fits filter criteria
-            ? await this._count(documentId, options)
-            : 0;
-    }
-    /**
-     * Retrieves the data type of the array field
-     *
-     * @returns {ComplexType} The complex data type of the field.
-     * @throws {NotAcceptableError} If the data type is not a ComplexType.
-     */
-    getDataType() {
-        const t = super.getDataType()
-            .getField(this.fieldName).type;
-        if (!(t instanceof common_1.ComplexType))
-            throw new common_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
-        return t;
-    }
-    /**
-     * Generates an ID.
-     *
-     * @protected
-     * @returns {AnyId} The generated ID.
-     */
-    _generateId() {
-        return typeof this.$idGenerator === 'function' ?
-            this.$idGenerator(this) : new mongodb_1.ObjectId();
-    }
-    /**
-     * Retrieves the common filter used for querying documents.
-     * 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
-     * that resolves to the common filter, or undefined if not available.
-     */
-    _getDocumentFilter(args) {
-        return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(args, this) : this.$documentFilter;
+        const r = await this._dbUpdateOne(matchFilter, update, options);
+        if (options?.count)
+            return await this._count(documentId, options);
+        return r.modifiedCount || 0;
     }
     /**
      * Retrieves the common filter used for querying array elements.
@@ -555,14 +569,8 @@ class MongoArrayService extends mongo_service_js_1.MongoService {
      * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
      * that resolves to the common filter, or undefined if not available.
      */
-    _getArrayFilter(args) {
-        return typeof this.$arrayFilter === 'function' ?
-            this.$arrayFilter(args, this) : this.$arrayFilter;
-    }
-    async _intercept(callback, args) {
-        if (this.$interceptor)
-            return this.$interceptor(callback, args, this);
-        return callback();
+    _getNestedFilter(args) {
+        return typeof this.$nestedFilter === 'function' ? this.$nestedFilter(args, this) : this.$nestedFilter;
     }
 }
-exports.MongoArrayService = MongoArrayService;
+exports.MongoNestedService = MongoNestedService;