@opra/mongodb 0.32.3 → 0.32.4

package/esm/mongo-array-service.js

@@ -8,25 +8,23 @@ import { MongoService } from './mongo-service.js';
  * @template T The type of the array item.
  */
 export class MongoArrayService extends 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.
+     * @constructor
+     */
     constructor(dataType, fieldName, options) {
         super(dataType, options);
         this.fieldName = fieldName;
         this.defaultLimit = options?.defaultLimit || 10;
         this.collectionKey = options?.collectionKey || '_id';
         this.arrayKey = options?.arrayKey || '_id';
-    }
-    /**
-     * 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 ComplexType))
-            throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
-        return t;
+        this.$documentFilter = options?.documentFilter;
+        this.$arrayFilter = options?.arrayFilter;
+        this.$interceptor = this.$interceptor || options?.interceptor;
     }
     /**
      * Asserts whether a resource with the specified parentId and id exists.
@@ -34,12 +32,13 @@ export class MongoArrayService extends MongoService {
      *
      * @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.
      * @return {Promise<void>} - A promise that resolves with no value upon success.
      * @throws {ResourceNotFoundError} - If the resource does not exist.
      */
-    async assert(documentId, id) {
-        if (!(await this.exists(documentId, id)))
-            throw new ResourceNotFoundError((this.resourceName || this.getCollectionName()) + '.' + this.arrayKey, documentId + '/' + id);
+    async assert(documentId, id, options) {
+        if (!(await this.exists(documentId, id, options)))
+            throw new ResourceNotFoundError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
     }
     /**
      * Adds a single item into the array field.
@@ -47,13 +46,22 @@ export class MongoArrayService extends MongoService {
      * @param {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.
-     * @return {Promise<PartialOutput<T>>} - A promise that resolves with the partial output of the created item.
+     * @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.
      */
     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 encode = this.getEncoder('create');
         const doc = encode(input);
-        doc[this.arrayKey] = doc[this.arrayKey] || this._generateId();
+        doc._id = doc._id || this._generateId();
         const docFilter = MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
         const r = await this.__updateOne(docFilter, {
             $push: { [this.fieldName]: doc }
@@ -69,7 +77,7 @@ export class MongoArrayService extends MongoService {
                 throw e;
             }
         }
-        throw new ResourceNotFoundError(this.resourceName || this.getCollectionName(), documentId);
+        throw new ResourceNotFoundError(this.getResourceName(), documentId);
     }
     /**
      * Counts the number of documents in the collection that match the specified parentId and options.
@@ -80,14 +88,25 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<number>} - A promise that resolves to the count of documents.
      */
     async count(documentId, options) {
-        const matchFilter = MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
+        if (this.$interceptor && !options?.__interceptor__)
+            return this.$interceptor(() => this.count(documentId, { ...options, __interceptor__: true }), {
+                crud: 'read',
+                method: 'count',
+                documentId,
+                options
+            }, this);
+        const matchFilter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
+            await this._getDocumentFilter()
+        ]);
         const stages = [
             { $match: matchFilter },
             { $unwind: { path: "$" + this.fieldName } },
             { $replaceRoot: { newRoot: "$" + this.fieldName } }
         ];
-        if (options?.filter) {
-            const optionsFilter = MongoAdapter.prepareFilter(options.filter);
+        const contextArrayFilter = await this._getArrayFilter();
+        if (options?.filter || contextArrayFilter) {
+            const optionsFilter = MongoAdapter.prepareFilter([options?.filter, contextArrayFilter]);
             stages.push({ $match: optionsFilter });
         }
         stages.push({ $count: '*' });
@@ -109,11 +128,23 @@ 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) {
-        const matchFilter = MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
+        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 matchFilter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
+            await this._getDocumentFilter()
+        ]);
         const pullFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
-            options?.filter
-        ]);
+            options?.filter,
+            await this._getArrayFilter()
+        ]) || {};
         const r = await this.__updateOne(matchFilter, {
             $pull: { [this.fieldName]: pullFilter }
         }, options);
@@ -127,11 +158,24 @@ export class MongoArrayService extends MongoService {
      * @returns {Promise<number>} - A Promise that resolves to the number of items deleted.
      */
     async deleteMany(documentId, options) {
-        const docFilter = MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
+        if (this.$interceptor && !options?.__interceptor__)
+            return this.$interceptor(() => this.deleteMany(documentId, { ...options, __interceptor__: true }), {
+                crud: 'delete',
+                method: 'deleteMany',
+                documentId,
+                options
+            }, this);
+        const matchFilter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
+            await this._getDocumentFilter()
+        ]);
         // Count matching items, we will use this as result
         const matchCount = await this.count(documentId, options);
-        const pullFilter = MongoAdapter.prepareFilter(options?.filter) || {};
-        const r = await this.__updateOne(docFilter, {
+        const pullFilter = MongoAdapter.prepareFilter([
+            options?.filter,
+            await this._getArrayFilter()
+        ]) || {};
+        const r = await this.__updateOne(matchFilter, {
             $pull: { [this.fieldName]: pullFilter }
         }, options);
         if (r.modifiedCount)
@@ -143,10 +187,19 @@ export class MongoArrayService extends MongoService {
      *
      * @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.
      * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating if the record exists or not.
      */
-    async exists(documentId, id) {
-        return !!(await this.findById(documentId, id, { pick: ['_id'] }));
+    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'] }));
     }
     /**
      * Finds an element in array field by its parent ID and ID.
@@ -154,12 +207,21 @@ export class MongoArrayService extends MongoService {
      * @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.
-     * @returns {Promise<PartialOutput<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
+     * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
      */
     async findById(documentId, id, options) {
-        let filter = MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
-        if (options?.filter)
-            filter = MongoAdapter.prepareFilter([filter, options?.filter]);
+        if (this.$interceptor && !options?.__interceptor__)
+            return this.$interceptor(() => this.findOne(documentId, { ...options, __interceptor__: true }), {
+                crud: 'read',
+                method: 'findById',
+                documentId,
+                itemId: id,
+                options
+            }, this);
+        const filter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(id, [this.arrayKey]),
+            options?.filter
+        ]);
         return await this.findOne(documentId, { ...options, filter });
     }
     /**
@@ -167,9 +229,16 @@ export class MongoArrayService extends MongoService {
      *
      * @param {AnyId} documentId - The ID of the document.
      * @param {MongoArrayService.FindOneOptions} [options] - Optional options to customize the query.
-     * @returns {Promise<PartialOutput<T> | undefined>} A promise that resolves to the first matching document, or `undefined` if no match is found.
+     * @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, {
             ...options,
             limit: 1
@@ -181,10 +250,20 @@ export class MongoArrayService extends MongoService {
      *
      * @param {AnyId} documentId - The ID of the parent document.
      * @param {MongoArrayService.FindManyOptions<T>} [options] - The options for finding the documents.
-     * @returns {Promise<PartialOutput<T>[] | undefined>} - The found documents.
+     * @returns {Promise<PartialDTO<T>[]>} - The found documents.
      */
     async findMany(documentId, options) {
-        const matchFilter = MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]);
+        if (this.$interceptor && !options?.__interceptor__)
+            return this.$interceptor(() => this.findMany(documentId, { ...options, __interceptor__: true }), {
+                crud: 'read',
+                method: 'findMany',
+                documentId,
+                options
+            }, this);
+        const matchFilter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
+            await this._getDocumentFilter()
+        ]);
         const mongoOptions = {
             ...omit(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
         };
@@ -204,8 +283,12 @@ export class MongoArrayService extends MongoService {
                 }
             });
         }
-        if (options?.filter) {
-            const optionsFilter = MongoAdapter.prepareFilter(options?.filter);
+        const contextArrayFilter = await this._getArrayFilter();
+        if (options?.filter || contextArrayFilter) {
+            const optionsFilter = MongoAdapter.prepareFilter([
+                options?.filter,
+                contextArrayFilter
+            ]);
             dataStages.push({ $match: optionsFilter });
         }
         if (options?.skip)
@@ -244,13 +327,13 @@ export class MongoArrayService extends MongoService {
      * @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.
-     * @returns {Promise<PartialOutput<T>>} - The item found.
+     * @returns {Promise<PartialDTO<T>>} - The item found.
      * @throws {ResourceNotFoundError} - 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.resourceName || this.getCollectionName()) + '.' + this.arrayKey, documentId + '/' + id);
+            throw new ResourceNotFoundError(this.getResourceName() + '.' + this.arrayKey, documentId + '/' + id);
         return out;
     }
     /**
@@ -258,13 +341,23 @@ export class MongoArrayService extends MongoService {
      *
      * @param {AnyId} documentId - The ID of the document to update.
      * @param {AnyId} id - The ID of the item to update within the document.
-     * @param {PartialInput<T>} input - The new data to update the item with.
+     * @param {PatchDTO<T>} input - The new data to update the item with.
      * @param {MongoArrayService.UpdateOptions<T>} [options] - Additional update options.
-     * @returns {Promise<PartialOutput<T> | undefined>} The updated item or undefined if it does not exist.
+     * @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) {
-        await this.updateOnly(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);
         }
@@ -278,40 +371,59 @@ export class MongoArrayService extends MongoService {
      *
      * @param {AnyId} documentId - The ID of the parent document.
      * @param {AnyId} id - The ID of the document to update.
-     * @param {PartialInput<T>} doc - The partial input object containing the fields to update.
+     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
      * @param {MongoArrayService.UpdateOptions<T>} [options] - Optional update options.
      * @returns {Promise<number>} - A promise that resolves to the number of elements updated.
      */
-    async updateOnly(documentId, id, doc, options) {
+    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);
         let filter = MongoAdapter.prepareKeyValues(id, [this.arrayKey]);
         if (options?.filter)
             filter = MongoAdapter.prepareFilter([filter, options?.filter]);
-        return await this.updateMany(documentId, doc, { ...options, filter });
+        return await this.updateMany(documentId, input, { ...options, filter });
     }
     /**
      * Updates multiple array elements in document
      *
      * @param {AnyId} documentId - The ID of the document to update.
-     * @param {PartialInput<T>} input - The updated data for the document(s).
+     * @param {PatchDTO<T>} input - The updated data for the document(s).
      * @param {MongoArrayService.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) {
+        if (this.$interceptor && !options?.__interceptor__)
+            return this.$interceptor(() => this.updateMany(documentId, input, { ...options, __interceptor__: true }), {
+                crud: 'update',
+                method: 'updateMany',
+                documentId,
+                input,
+                options
+            }, this);
         const encode = this.getEncoder('update');
         const doc = encode(input);
         if (!Object.keys(doc).length)
             return 0;
         const matchFilter = MongoAdapter.prepareFilter([
             MongoAdapter.prepareKeyValues(documentId, [this.collectionKey]),
+            await this._getDocumentFilter(),
             { [this.fieldName]: { $exists: true } }
         ]);
-        if (options?.filter) {
-            const elemMatch = MongoAdapter.prepareFilter(options?.filter, { fieldPrefix: 'elem.' });
+        const contextArrayFilter = await this._getArrayFilter();
+        if (options?.filter || contextArrayFilter) {
+            const elemMatch = MongoAdapter.prepareFilter([options?.filter, contextArrayFilter], { fieldPrefix: 'elem.' });
             options = options || {};
             options.arrayFilters = [elemMatch];
         }
         const update = MongoAdapter.preparePatch(doc, {
-            fieldPrefix: this.fieldName + (options?.filter ? '.$[elem].' : '.$[].')
+            fieldPrefix: this.fieldName + ((options?.filter || contextArrayFilter) ? '.$[elem].' : '.$[].')
         });
         const r = await this.__updateOne(matchFilter, update, options);
         return r.modifiedCount;
@@ -320,24 +432,70 @@ export class MongoArrayService extends MongoService {
      * Updates multiple elements and returns the count of elements that were updated.
      *
      * @param {AnyId} documentId - The ID of the document to update.
-     * @param {PartialInput<T>} doc - The partial document to update with.
+     * @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, doc, options) {
-        const r = await this.updateMany(documentId, doc, options);
+    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
             // Count matching items that fits filter criteria
             ? await this.count(documentId, options)
             : 0;
     }
     /**
-     * Generates a new id for new inserting Document.
+     * 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 ComplexType))
+            throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        return t;
+    }
+    /**
+     * Generates an ID.
      *
      * @protected
-     * @returns {AnyId} A new instance of AnyId.
+     * @returns {AnyId} The generated ID.
      */
     _generateId() {
-        return new ObjectId();
+        return typeof this.$idGenerator === 'function' ?
+            this.$idGenerator(this) : new 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() {
+        return typeof this.$documentFilter === 'function' ?
+            this.$documentFilter(this) : this.$documentFilter;
+    }
+    /**
+     * Retrieves the common filter used for querying array elements.
+     * This method is mostly used for security issues like securing multi-tenant applications.
+     *
+     * @protected
+     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
+     * that resolves to the common filter, or undefined if not available.
+     */
+    _getArrayFilter() {
+        return typeof this.$arrayFilter === 'function' ?
+            this.$arrayFilter(this) : this.$arrayFilter;
     }
 }