@opra/mongodb 1.20.0 → 1.22.0

package/cjs/services/mongo-nested-service.js

@@ -1,913 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoNestedService = void 0;
-const objects_1 = require("@jsopen/objects");
-const common_1 = require("@opra/common");
-const valgen_1 = require("valgen");
-const mongo_adapter_js_1 = require("../adapter/mongo-adapter.js");
-const mongo_patch_generator_js_1 = require("../adapter/mongo-patch-generator.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 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 {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.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, this.scope).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 {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.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] == null || input[this.nestedKey] === ''
-                ? this._generateId(command)
-                : input[this.nestedKey];
-        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 {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 create operation result
-     * @throws {ResourceNotAvailableError} - If the parent document is not found.
-     */
-    async createOnly(documentId, input, options) {
-        const command = {
-            crud: 'create',
-            method: 'create',
-            byId: false,
-            documentId,
-            input,
-            options,
-        };
-        input[this.nestedKey] =
-            input[this.nestedKey] == null ||
-                input[this.nestedKey] === ''
-                ? this._generateId(command)
-                : input[this.nestedKey];
-        return this._executeCommand(command, () => this._create(command));
-    }
-    async _create(command) {
-        const inputCodec = this._getInputCodec('create');
-        const { documentId, options } = command;
-        const input = command.input;
-        (0, valgen_1.isNotNullish)(input, { label: 'input' });
-        (0, valgen_1.isNotNullish)(input[this.nestedKey], { label: `input.${this.nestedKey}` });
-        const document = inputCodec(input);
-        const docFilter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']);
-        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 common_1.ResourceNotAvailableError(this.getResourceName(), documentId);
-        }
-        return document;
-    }
-    /**
-     * Counts the number of documents in the collection that match the specified parentId and options.
-     *
-     * @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) {
-        const command = {
-            crud: 'read',
-            method: 'count',
-            byId: false,
-            documentId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getNestedFilter(command),
-                command.options?.filter,
-            ]);
-            command.options = { ...command.options, filter, documentFilter };
-            return this._count(command);
-        });
-    }
-    async _count(command) {
-        const { documentId, options } = command;
-        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options?.documentFilter,
-        ]);
-        const stages = [
-            { $match: matchFilter },
-            { $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 db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        const cursor = collection.aggregate(stages, {
-            ...(0, objects_1.omit)(options, ['documentFilter', 'skip', 'limit', 'filter']),
-            session: options?.session ?? this.getSession(),
-        });
-        try {
-            const n = await cursor.next();
-            return n?.['*'] || 0;
-        }
-        finally {
-            await cursor.close();
-        }
-    }
-    /**
-     * Deletes an element from an array within a document in the MongoDB collection.
-     *
-     * @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, nestedId, options) {
-        const command = {
-            crud: 'delete',
-            method: 'delete',
-            byId: true,
-            documentId,
-            nestedId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getNestedFilter(command),
-                command.options?.filter,
-            ]);
-            command.options = { ...command.options, filter, documentFilter };
-            return this._delete(command);
-        });
-    }
-    async _delete(command) {
-        const { documentId, nestedId, options } = command;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        (0, valgen_1.isNotNullish)(documentId, { label: 'nestedId' });
-        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options?.documentFilter,
-        ]);
-        const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]),
-            options?.filter,
-        ]) || {};
-        const update = {
-            $pull: { [this.fieldName]: pullFilter },
-        };
-        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;
-    }
-    /**
-     * Deletes multiple items from a collection based on the parent ID and optional 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) {
-        const command = {
-            crud: 'delete',
-            method: 'deleteMany',
-            byId: false,
-            documentId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getNestedFilter(command),
-                command.options?.filter,
-            ]);
-            command.options = { ...command.options, filter, documentFilter };
-            return this._deleteMany(command);
-        });
-    }
-    async _deleteMany(command) {
-        const { documentId, options } = command;
-        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options?.documentFilter,
-        ]);
-        // Count matching items, we will use this as result
-        const countCommand = {
-            crud: 'read',
-            method: 'count',
-            byId: false,
-            documentId,
-            options,
-        };
-        const matchCount = await this._count(countCommand);
-        const pullFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
-        const update = {
-            $pull: { [this.fieldName]: pullFilter },
-        };
-        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.
-     *
-     * @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, nestedId, options) {
-        const command = {
-            crud: 'read',
-            method: 'exists',
-            byId: true,
-            documentId,
-            nestedId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.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.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) {
-        const command = {
-            crud: 'read',
-            method: 'exists',
-            byId: false,
-            documentId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = await this._getDocumentFilter(command);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                documentFilter,
-                command.options?.filter,
-            ]);
-            const findCommand = command;
-            findCommand.options = {
-                ...command.options,
-                filter,
-                documentFilter,
-                projection: ['_id'],
-            };
-            return !!(await this._findOne(findCommand));
-        });
-    }
-    async findById(documentId, nestedId, options) {
-        const command = {
-            crud: 'read',
-            method: 'findById',
-            byId: true,
-            documentId,
-            nestedId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getNestedFilter(command),
-                command.options?.filter,
-            ]);
-            command.options = { ...command.options, filter, documentFilter };
-            return this._findById(command);
-        });
-    }
-    async _findById(command) {
-        const { documentId, nestedId, options } = command;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        (0, valgen_1.isNotNullish)(nestedId, { label: 'nestedId' });
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]),
-            options?.filter,
-        ]);
-        const findManyCommand = {
-            ...command,
-            options: {
-                ...options,
-                filter,
-                limit: 1,
-                skip: undefined,
-                sort: undefined,
-            },
-        };
-        const rows = await this._findMany(findManyCommand);
-        return rows?.[0];
-    }
-    async findOne(documentId, options) {
-        const command = {
-            crud: 'read',
-            method: 'findOne',
-            byId: false,
-            documentId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.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;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        const findManyCommand = {
-            ...command,
-            options: {
-                ...options,
-                limit: 1,
-            },
-        };
-        const rows = await this._findMany(findManyCommand);
-        return rows?.[0];
-    }
-    async findMany(documentId, options) {
-        const command = {
-            crud: 'read',
-            method: 'findMany',
-            byId: false,
-            documentId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = await this._getDocumentFilter(command);
-            const nestedFilter = await this._getNestedFilter(command);
-            command.options = {
-                ...command.options,
-                nestedFilter,
-                documentFilter,
-                limit: command.options?.limit || this.defaultLimit,
-            };
-            return this._findMany(command);
-        });
-    }
-    async _findMany(command) {
-        const { documentId, options } = command;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options?.documentFilter,
-        ]);
-        const limit = options?.limit || this.defaultLimit;
-        const stages = [
-            { $match: matchFilter },
-            { $unwind: { path: '$' + this.fieldName } },
-            { $replaceRoot: { newRoot: '$' + this.fieldName } },
-        ];
-        /** Pre-Stages */
-        if (options?.preStages)
-            stages.push(...options.preStages);
-        /** Filter */
-        if (options?.filter || options?.nestedFilter) {
-            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                options?.filter,
-                options.nestedFilter,
-            ]);
-            stages.push({ $match: optionsFilter });
-        }
-        /** Sort */
-        if (options?.sort) {
-            const sort = mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort);
-            if (sort)
-                stages.push({ $sort: sort });
-        }
-        /** Skip */
-        if (options?.skip)
-            stages.push({ $skip: options.skip });
-        /** Limit */
-        stages.push({ $limit: limit });
-        const dataType = this.dataType;
-        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options?.projection, this._dataTypeScope);
-        if (projection)
-            stages.push({ $project: projection });
-        /** Post-Stages */
-        if (options?.postStages)
-            stages.push(...options.postStages);
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        const cursor = collection.aggregate(stages, {
-            ...(0, objects_1.omit)(options, [
-                'documentFilter',
-                'nestedFilter',
-                'projection',
-                'sort',
-                'skip',
-                'limit',
-                'filter',
-            ]),
-            session: options?.session ?? this.getSession(),
-        });
-        try {
-            const outputCodec = this._getOutputCodec('find');
-            return (await cursor.toArray()).map((r) => outputCodec(r));
-        }
-        finally {
-            if (!cursor.closed)
-                await cursor.close();
-        }
-    }
-    async findManyWithCount(documentId, options) {
-        const command = {
-            crud: 'read',
-            method: 'findMany',
-            byId: false,
-            documentId,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = await this._getDocumentFilter(command);
-            const nestedFilter = await this._getNestedFilter(command);
-            command.options = {
-                ...command.options,
-                nestedFilter,
-                documentFilter,
-                limit: command.options?.limit || this.defaultLimit,
-            };
-            return this._findManyWithCount(command);
-        });
-    }
-    async _findManyWithCount(command) {
-        const { documentId, options } = command;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        const matchFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(documentId, ['_id']),
-            options?.documentFilter,
-        ]);
-        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' }],
-                },
-            },
-        ];
-        /** Pre-Stages */
-        if (options?.preStages)
-            dataStages.push(...options.preStages);
-        /** Filter */
-        if (options?.filter || options?.nestedFilter) {
-            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                options?.filter,
-                options?.nestedFilter,
-            ]);
-            dataStages.push({ $match: optionsFilter });
-        }
-        /** Sort */
-        if (options?.sort) {
-            const sort = mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort);
-            if (sort)
-                dataStages.push({ $sort: sort });
-        }
-        /** Skip */
-        if (options?.skip)
-            dataStages.push({ $skip: options.skip });
-        /** Limit */
-        dataStages.push({ $limit: limit });
-        /** Post-Stages */
-        if (options?.postStages)
-            dataStages.push(...options.postStages);
-        const dataType = this.dataType;
-        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options?.projection, this._dataTypeScope);
-        if (projection)
-            dataStages.push({ $project: projection });
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        const cursor = collection.aggregate(stages, {
-            ...(0, objects_1.omit)(options, [
-                'documentFilter',
-                'nestedFilter',
-                'projection',
-                'sort',
-                'skip',
-                'limit',
-                'filter',
-            ]),
-            session: options?.session ?? this.getSession(),
-        });
-        try {
-            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)
-                await cursor.close();
-        }
-    }
-    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;
-    }
-    async update(documentId, nestedId, input, options) {
-        const command = {
-            crud: 'update',
-            method: 'update',
-            byId: true,
-            documentId,
-            nestedId,
-            input,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.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 common_1.ResourceNotAvailableError(this.getResourceName() + '.' + this.nestedKey, documentId + '/' + nestedId);
-        });
-    }
-    /**
-     * Update an array element with new data. Returns 1 if document updated 0 otherwise.
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
-     * @param {MongoAdapter.AnyId} nestedId - The ID of the document to update.
-     * @param {MongoPatchDTO<T>} input - The partial input object containing the fields to update.
-     * @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 command = {
-            crud: 'update',
-            method: 'update',
-            byId: true,
-            documentId,
-            nestedId,
-            input,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getNestedFilter(command),
-                command.options?.filter,
-            ]);
-            command.options = {
-                ...command.options,
-                filter,
-                documentFilter,
-            };
-            return await this._updateOnly(command);
-        });
-    }
-    async _updateOnly(command) {
-        const { documentId, nestedId, options } = command;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        (0, valgen_1.isNotNullish)(nestedId, { label: 'nestedId' });
-        let filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(nestedId, [this.nestedKey]);
-        if (options?.filter)
-            filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([filter, options?.filter]);
-        const updateManyCommand = {
-            ...command,
-            options: {
-                ...command.options,
-                filter,
-            },
-        };
-        return await this._updateMany(updateManyCommand);
-    }
-    /**
-     * Updates multiple array elements in document
-     *
-     * @param {MongoAdapter.AnyId} documentId - The ID of the document to update.
-     * @param {MongoPatchDTO<T>} input - The updated data for the document(s).
-     * @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) {
-        const command = {
-            crud: 'update',
-            method: 'updateMany',
-            documentId,
-            byId: false,
-            input,
-            options,
-        };
-        return this._executeCommand(command, async () => {
-            const documentFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(command),
-            ]);
-            const filter = mongo_adapter_js_1.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;
-        (0, valgen_1.isNotNullish)(documentId, { label: 'documentId' });
-        const options = { ...command.options };
-        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, ['_id']),
-            options?.documentFilter,
-            { [this.fieldName]: { $exists: true } },
-        ]);
-        if (options?.filter) {
-            const elemMatch = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter], {
-                fieldPrefix: 'elem.',
-            });
-            options.arrayFilters = [elemMatch];
-        }
-        const patchGenerator = new mongo_patch_generator_js_1.MongoPatchGenerator();
-        const { update, arrayFilters } = patchGenerator.generatePatch(this.dataType, doc, {
-            currentPath: this.fieldName + (options?.filter ? '.$[elem]' : '.$[]'),
-        });
-        command.options = command.options || {};
-        if (arrayFilters) {
-            command.options.arrayFilters = command.options.arrayFilters || [];
-            command.options.arrayFilters.push(arrayFilters);
-        }
-        // 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 {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;
-    }
-    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;
-        }
-    }
-    async _beforeCreate(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command) {
-        // Do nothing
-    }
-    async _beforeUpdate(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command) {
-        // Do nothing
-    }
-    async _beforeUpdateMany(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command) {
-        // Do nothing
-    }
-    async _beforeDelete(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command) {
-        // Do nothing
-    }
-    async _beforeDeleteMany(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command) {
-        // Do nothing
-    }
-    async _afterCreate(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    result) {
-        // Do nothing
-    }
-    async _afterUpdate(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    result) {
-        // Do nothing
-    }
-    async _afterUpdateMany(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    affected) {
-        // Do nothing
-    }
-    async _afterDelete(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    affected) {
-        // Do nothing
-    }
-    async _afterDeleteMany(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    command, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    affected) {
-        // Do nothing
-    }
-}
-exports.MongoNestedService = MongoNestedService;