@opra/mongodb 0.32.6 → 0.33.0

package/esm/mongo-array-service.js

@@ -1,6 +1,6 @@
 import omit from 'lodash.omit';
 import { ObjectId } from 'mongodb';
-import { ComplexType, NotAcceptableError, ResourceNotFoundError } from '@opra/common';
+import { ComplexType, NotAcceptableError, ResourceNotAvailableError } from '@opra/common';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoService } from './mongo-service.js';
 /**
@@ -34,11 +34,11 @@ export class MongoArrayService extends MongoService {
      * @param {AnyId} id - The ID of the resource.
      * @param {MongoArrayService.ExistsOptions} [options] - Optional parameters for checking resource existence.
      * @return {Promise<void>} - A promise that resolves with no value upon success.
-     * @throws {ResourceNotFoundError} - If the resource does not exist.
+     * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
     async assert(documentId, id, options) {
         if (!(await this.exists(documentId, id, options)))
-            throw new ResourceNotFoundError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
+            throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
     }
     /**
      * Adds a single item into the array field.
@@ -47,18 +47,20 @@ export class MongoArrayService extends MongoService {
      * @param {T} input - The item to be added to the array field.
      * @param {MongoArrayService.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 {ResourceNotFoundError} - If the parent document is not found.
+     * @throws {ResourceNotAvailableError} - If the parent document is not found.
      */
     async create(documentId, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.create(documentId, input, { ...options, __interceptor__: true }), {
-                crud: 'create',
-                method: 'create',
-                documentId,
-                itemId: input._id,
-                input,
-                options
-            }, this);
+        const info = {
+            crud: 'create',
+            method: 'create',
+            documentId,
+            itemId: input._id,
+            input,
+            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 });
         doc._id = doc._id || this._generateId();
@@ -66,18 +68,19 @@ export class MongoArrayService extends MongoService {
         const r = await this.__updateOne(docFilter, {
             $push: { [this.fieldName]: doc }
         }, options);
-        if (r.modifiedCount) {
+        if (r.matchedCount) {
             if (!options)
                 return doc;
-            try {
-                return this.get(documentId, doc[this.arrayKey], { ...options, filter: undefined, skip: undefined });
-            }
-            catch (e) {
-                Error.captureStackTrace(e);
-                throw e;
-            }
+            const id = doc[this.arrayKey];
+            const out = await this._findById(documentId, id, {
+                ...options,
+                filter: undefined,
+                skip: undefined
+            });
+            if (out)
+                return out;
         }
-        throw new ResourceNotFoundError(this.getResourceName(), documentId);
+        throw new ResourceNotAvailableError(this.getResourceName(), documentId);
     }
     /**
      * Counts the number of documents in the collection that match the specified parentId and options.
@@ -88,26 +91,36 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<number>} - A promise that resolves to the count of documents.
      */
     async count(documentId, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.count(documentId, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'count',
-                documentId,
-                options
-            }, this);
+        const info = {
+            crud: 'read',
+            method: 'count',
+            documentId,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(info),
+                options?.filter
+            ]);
+            return this._count(documentId, { ...options, filter, documentFilter });
+        }, info);
+    }
+    async _count(documentId, options) {
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            await this._getDocumentFilter()
+            options?.documentFilter
         ]);
         const stages = [
             { $match: matchFilter },
             { $unwind: { path: "$" + this.fieldName } },
             { $replaceRoot: { newRoot: "$" + this.fieldName } }
         ];
-        const contextArrayFilter = await this._getArrayFilter();
-        if (options?.filter || contextArrayFilter) {
-            const optionsFilter = MongoAdapter.prepareFilter([options?.filter, contextArrayFilter]);
-            stages.push({ $match: optionsFilter });
+        if (options?.filter) {
+            const filter = MongoAdapter.prepareFilter(options?.filter);
+            stages.push({ $match: filter });
         }
         stages.push({ $count: '*' });
         const r = await this.__aggregate(stages, options);
@@ -128,22 +141,32 @@ export class MongoArrayService extends MongoService {
      * @return {Promise<number>} - A Promise that resolves to the number of elements deleted (1 if successful, 0 if not).
      */
     async delete(documentId, id, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.delete(documentId, id, { ...options, __interceptor__: true }), {
-                crud: 'delete',
-                method: 'delete',
-                documentId,
-                itemId: id,
-                options
-            }, this);
+        const info = {
+            crud: 'delete',
+            method: 'delete',
+            documentId,
+            itemId: id,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(info),
+                options?.filter
+            ]);
+            return this._delete(documentId, id, { ...options, filter, documentFilter });
+        }, info);
+    }
+    async _delete(documentId, id, options) {
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            await this._getDocumentFilter()
+            options?.documentFilter
         ]);
         const pullFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
-            options?.filter,
-            await this._getArrayFilter()
+            options?.filter
         ]) || {};
         const r = await this.__updateOne(matchFilter, {
             $pull: { [this.fieldName]: pullFilter }
@@ -158,23 +181,31 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<number>} - A Promise that resolves to the number of items deleted.
      */
     async deleteMany(documentId, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.deleteMany(documentId, { ...options, __interceptor__: true }), {
-                crud: 'delete',
-                method: 'deleteMany',
-                documentId,
-                options
-            }, this);
+        const info = {
+            crud: 'delete',
+            method: 'deleteMany',
+            documentId,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(info),
+                options?.filter
+            ]);
+            return this._deleteMany(documentId, { ...options, filter, documentFilter });
+        }, info);
+    }
+    async _deleteMany(documentId, options) {
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            await this._getDocumentFilter()
+            options?.documentFilter
         ]);
         // Count matching items, we will use this as result
         const matchCount = await this.count(documentId, options);
-        const pullFilter = MongoAdapter.prepareFilter([
-            options?.filter,
-            await this._getArrayFilter()
-        ]) || {};
+        const pullFilter = MongoAdapter.prepareFilter(options?.filter) || {};
         const r = await this.__updateOne(matchFilter, {
             $pull: { [this.fieldName]: pullFilter }
         }, options);
@@ -191,15 +222,7 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating if the record exists or not.
      */
     async exists(documentId, id, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.exists(documentId, id, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'exists',
-                documentId,
-                itemId: id,
-                options
-            }, this);
-        return !!(await this.findById(documentId, id, { ...options, pick: ['_id'] }));
+        return !!(await this.findById(documentId, id, { ...options, pick: ['_id'], omit: undefined, include: undefined }));
     }
     /**
      * Finds an element in array field by its parent ID and ID.
@@ -210,19 +233,37 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
      */
     async findById(documentId, id, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.findOne(documentId, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'findById',
-                documentId,
-                itemId: id,
-                options
-            }, this);
+        const info = {
+            crud: 'read',
+            method: 'findById',
+            documentId,
+            itemId: id,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(info),
+                options?.filter
+            ]);
+            return this._findById(documentId, id, { ...options, filter, documentFilter });
+        }, info);
+    }
+    async _findById(documentId, id, options) {
         const filter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
             options?.filter
         ]);
-        return await this.findOne(documentId, { ...options, filter });
+        const rows = await this._findMany(documentId, {
+            ...options,
+            filter,
+            limit: 1,
+            skip: undefined,
+            sort: undefined
+        });
+        return rows?.[0];
     }
     /**
      * Finds the first array element that matches the given parentId.
@@ -232,14 +273,25 @@ export class MongoArrayService extends MongoService {
      * @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) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.findOne(documentId, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'findOne',
-                documentId,
-                options
-            }, this);
-        const rows = await this.findMany(documentId, {
+        const info = {
+            crud: 'read',
+            method: 'findOne',
+            documentId,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(info),
+                options?.filter
+            ]);
+            return this._findOne(documentId, { ...options, filter, documentFilter });
+        }, info);
+    }
+    async _findOne(documentId, options) {
+        const rows = await this._findMany(documentId, {
             ...options,
             limit: 1
         });
@@ -253,16 +305,22 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<PartialDTO<T>[]>} - The found documents.
      */
     async findMany(documentId, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.findMany(documentId, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'findMany',
-                documentId,
-                options
-            }, this);
+        const args = {
+            crud: 'read',
+            method: 'findMany',
+            documentId,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = await this._getDocumentFilter(args);
+            const arrayFilter = await this._getArrayFilter(args);
+            return this._findMany(documentId, { ...options, documentFilter, arrayFilter });
+        }, args);
+    }
+    async _findMany(documentId, options) {
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            await this._getDocumentFilter()
+            options.documentFilter
         ]);
         const mongoOptions = {
             ...omit(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
@@ -283,11 +341,10 @@ export class MongoArrayService extends MongoService {
                 }
             });
         }
-        const contextArrayFilter = await this._getArrayFilter();
-        if (options?.filter || contextArrayFilter) {
+        if (options?.filter || options.arrayFilter) {
             const optionsFilter = MongoAdapter.prepareFilter([
                 options?.filter,
-                contextArrayFilter
+                options.arrayFilter
             ]);
             dataStages.push({ $match: optionsFilter });
         }
@@ -328,12 +385,12 @@ export class MongoArrayService extends MongoService {
      * @param {AnyId} id - The ID of the item.
      * @param {MongoArrayService.FindOneOptions<T>} [options] - The options for finding the item.
      * @returns {Promise<PartialDTO<T>>} - The item found.
-     * @throws {ResourceNotFoundError} - If the item is not 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 ResourceNotFoundError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
+            throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
         return out;
     }
     /**
@@ -347,24 +404,13 @@ export class MongoArrayService extends MongoService {
      * @throws {Error} If an error occurs while updating the item.
      */
     async update(documentId, id, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.update(documentId, id, input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'update',
-                documentId,
-                itemId: id,
-                options
-            }, this);
         const r = await this.updateOnly(documentId, id, input, options);
         if (!r)
             return;
-        try {
-            return await this.findById(documentId, id, options);
-        }
-        catch (e) {
-            Error.captureStackTrace(e);
-            throw e;
-        }
+        const out = await this._findById(documentId, id, options);
+        if (out)
+            return out;
+        throw new ResourceNotAvailableError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
     }
     /**
      * Update an array element with new data. Returns 1 if document updated 0 otherwise.
@@ -376,19 +422,29 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<number>} - A promise that resolves to the number of elements updated.
      */
     async updateOnly(documentId, id, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.updateOnly(documentId, id, input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'updateOnly',
-                documentId,
-                itemId: id,
-                input,
-                options
-            }, this);
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId,
+            itemId: id,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(info),
+                options?.filter
+            ]);
+            return this._updateOnly(documentId, id, input, { ...options, filter, documentFilter });
+        }, info);
+    }
+    async _updateOnly(documentId, id, input, options) {
         let filter = MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
         if (options?.filter)
             filter = MongoAdapter.prepareFilter([filter, options?.filter]);
-        return await this.updateMany(documentId, input, { ...options, filter });
+        return await this._updateMany(documentId, input, { ...options, filter });
     }
     /**
      * Updates multiple array elements in document
@@ -399,56 +455,48 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<number>} - A promise that resolves to the number of documents updated.
      */
     async updateMany(documentId, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.updateMany(documentId, input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'updateMany',
-                documentId,
-                input,
-                options
-            }, this);
+        const info = {
+            crud: 'update',
+            method: 'updateMany',
+            documentId,
+            input,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info)
+            ]);
+            const filter = MongoAdapter.prepareFilter([
+                await this._getArrayFilter(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 });
         if (!Object.keys(doc).length)
             return 0;
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
-            await this._getDocumentFilter(),
+            options?.documentFilter,
             { [this.fieldName]: { $exists: true } }
         ]);
-        const contextArrayFilter = await this._getArrayFilter();
-        if (options?.filter || contextArrayFilter) {
-            const elemMatch = MongoAdapter.prepareFilter([options?.filter, contextArrayFilter], { fieldPrefix: 'elem.' });
+        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 || contextArrayFilter) ? '.$[elem].' : '.$[].')
+            fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].')
         });
         const r = await this.__updateOne(matchFilter, update, options);
-        return r.modifiedCount;
-    }
-    /**
-     * Updates multiple elements and returns the count of elements that were updated.
-     *
-     * @param {AnyId} documentId - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial document to update with.
-     * @param {MongoArrayService.UpdateManyOptions<T>} [options] - The options for updating multiple documents.
-     * @return {Promise<number>} A promise that resolves to the number of elements updated.
-     */
-    async updateManyReturnCount(documentId, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.updateManyReturnCount(documentId, input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'updateManyReturnCount',
-                documentId,
-                input,
-                options
-            }, this);
-        const r = await this.updateMany(documentId, input, options);
-        return r
+        if (!options?.count)
+            return r.modifiedCount;
+        return r.modifiedCount
             // Count matching items that fits filter criteria
-            ? await this.count(documentId, options)
+            ? await this._count(documentId, options)
             : 0;
     }
     /**
@@ -482,9 +530,9 @@ export class MongoArrayService extends MongoService {
      * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
      * that resolves to the common filter, or undefined if not available.
      */
-    _getDocumentFilter() {
+    _getDocumentFilter(args) {
         return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(this) : this.$documentFilter;
+            this.$documentFilter(args, this) : this.$documentFilter;
     }
     /**
      * Retrieves the common filter used for querying array elements.
@@ -494,8 +542,13 @@ export class MongoArrayService extends MongoService {
      * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
      * that resolves to the common filter, or undefined if not available.
      */
-    _getArrayFilter() {
+    _getArrayFilter(args) {
         return typeof this.$arrayFilter === 'function' ?
-            this.$arrayFilter(this) : this.$arrayFilter;
+            this.$arrayFilter(args, this) : this.$arrayFilter;
+    }
+    async _intercept(callback, args) {
+        if (this.$interceptor)
+            return this.$interceptor(callback, args, this);
+        return callback();
     }
 }