@opra/mongodb 0.32.6 → 0.33.1

package/cjs/mongo-collection-service.js

@@ -33,11 +33,11 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @param {AnyId} id - The ID of the resource to assert.
      * @param {MongoCollectionService.ExistsOptions} [options] - Optional options for checking the existence.
      * @returns {Promise<void>} - A Promise that resolves when the resource exists.
-     * @throws {ResourceNotFoundError} - If the resource does not exist.
+     * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
     async assert(id, options) {
         if (!(await this.exists(id, options)))
-            throw new common_1.ResourceNotFoundError(this.getResourceName(), id);
+            throw new common_1.ResourceNotAvailableError(this.getResourceName(), id);
     }
     /**
      * Creates a new document in the MongoDB collection.
@@ -48,14 +48,16 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @throws {Error} if an unknown error occurs while creating the document.
      */
     async create(input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.create(input, { ...options, __interceptor__: true }), {
-                crud: 'create',
-                method: 'create',
-                documentId: input._id,
-                input,
-                options
-            }, this);
+        const info = {
+            crud: 'create',
+            method: 'create',
+            documentId: input._id,
+            input,
+            options
+        };
+        return this._intercept(() => this._create(input, options), info);
+    }
+    async _create(input, options) {
         const encode = this.getEncoder('create');
         const doc = encode(input, { coerce: true });
         doc._id = doc._id || this._generateId();
@@ -63,16 +65,16 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
         if (r.insertedId) {
             if (!options)
                 return doc;
-            try {
-                return this.get(doc._id, options);
-            }
-            catch (e) {
-                Error.captureStackTrace(e);
-                throw e;
-            }
+            const out = await this._findById(doc._id, {
+                ...options,
+                filter: undefined,
+                skip: undefined
+            });
+            if (out)
+                return out;
         }
         /* istanbul ignore next */
-        throw new Error('Unknown error while creating document');
+        throw new common_1.InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
     }
     /**
      * Returns the count of documents in the collection based on the provided options.
@@ -81,13 +83,21 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
      */
     async count(options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.count({ ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'count',
-                options
-            }, this);
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, await this._getDocumentFilter()]);
+        const info = {
+            crud: 'read',
+            method: 'count',
+            options
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter
+            ]);
+            return this._count({ ...options, filter });
+        }, info);
+    }
+    async _count(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
         return this.__countDocuments(filter, (0, lodash_omit_1.default)(options, 'filter'));
     }
     /**
@@ -98,17 +108,24 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
      */
     async delete(id, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.delete(id, { ...options, __interceptor__: true }), {
-                crud: 'delete',
-                method: 'delete',
-                documentId: id,
-                options
-            }, this);
+        const info = {
+            crud: 'delete',
+            method: 'delete',
+            documentId: id,
+            options
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter
+            ]);
+            return this._delete(id, { ...options, filter });
+        }, info);
+    }
+    async _delete(id, options) {
         const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
             mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter,
-            await this._getDocumentFilter(),
+            options?.filter
         ]);
         const r = await this.__deleteOne(filter, options);
         return r.deletedCount;
@@ -120,13 +137,21 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
      */
     async deleteMany(options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.deleteMany({ ...options, __interceptor__: true }), {
-                crud: 'delete',
-                method: 'deleteMany',
-                options
-            }, this);
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, await this._getDocumentFilter()]);
+        const info = {
+            crud: 'delete',
+            method: 'delete',
+            options
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter,
+            ]);
+            return this._deleteMany({ ...options, filter });
+        }, info);
+    }
+    async _deleteMany(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
         const r = await this.__deleteMany(filter, (0, lodash_omit_1.default)(options, 'filter'));
         return r.deletedCount;
     }
@@ -134,18 +159,20 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * Checks if an object with the given id exists.
      *
      * @param {AnyId} id - The id of the object to check.
-     * @param {MongoCollectionService.ExistsOptions} [options] - The options for the aggregation query (optional).
+     * @param {MongoCollectionService.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 exists(id, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.exists(id, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'exists',
-                documentId: id,
-                options
-            }, this);
-        return !!(await this.findById(id, { ...options, pick: ['_id'] }));
+        return !!(await this.findById(id, { ...options, pick: ['_id'], omit: undefined, include: undefined }));
+    }
+    /**
+     * Checks if an object with the given arguments exists.
+     *
+     * @param {MongoCollectionService.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(options) {
+        return !!(await this.findOne({ ...options, pick: ['_id'], omit: undefined, include: undefined }));
     }
     /**
      * Finds a document by its ID.
@@ -155,18 +182,36 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
      */
     async findById(id, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.findById(id, { ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'findById',
-                documentId: id,
-                options
-            }, this);
+        const info = {
+            crud: 'read',
+            method: 'findById',
+            documentId: id,
+            options
+        };
+        return this._intercept(async () => {
+            const documentFilter = await this._getDocumentFilter(info);
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                documentFilter,
+                options?.filter,
+            ]);
+            return this._findById(id, { ...options, filter });
+        }, info);
+    }
+    async _findById(id, options) {
         const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
             mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
             options?.filter
         ]);
-        return await this.findOne({ ...options, filter });
+        const mongoOptions = {
+            ...options,
+            limit: undefined,
+            skip: undefined,
+            sort: undefined,
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
+        };
+        const decode = this.getDecoder();
+        const out = await this.__findOne(filter, mongoOptions);
+        return out ? decode(out, { coerce: true }) : undefined;
     }
     /**
      * Finds a document in the collection that matches the specified options.
@@ -175,13 +220,21 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
      */
     async findOne(options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.findOne({ ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'findOne',
-                options
-            }, this);
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, await this._getDocumentFilter()]);
+        const info = {
+            crud: 'read',
+            method: 'findOne',
+            options
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter,
+            ]);
+            return this._findOne({ ...options, filter });
+        }, info);
+    }
+    async _findOne(options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
         const mongoOptions = {
             ...options,
             sort: options?.sort ? mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort) : undefined,
@@ -208,12 +261,20 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return A Promise that resolves to an array of partial outputs of type T.
      */
     async findMany(options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.findMany({ ...options, __interceptor__: true }), {
-                crud: 'read',
-                method: 'findMany',
-                options
-            }, this);
+        const info = {
+            crud: 'read',
+            method: 'findMany',
+            options
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter,
+            ]);
+            return this._findMany({ ...options, filter });
+        }, info);
+    }
+    async _findMany(options) {
         const mongoOptions = {
             ...(0, lodash_omit_1.default)(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
         };
@@ -229,10 +290,9 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
                 }
             });
         }
-        const contextFilter = await this._getDocumentFilter();
-        if (options?.filter || contextFilter) {
-            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, contextFilter]);
-            dataStages.push({ $match: optionsFilter });
+        if (options?.filter) {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
+            dataStages.push({ $match: filter });
         }
         if (options?.skip)
             dataStages.push({ $skip: options.skip });
@@ -271,12 +331,12 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @param {MongoCollectionService.FindOneOptions} [options] - Optional options for the findOne operation.
      * @returns {Promise<PartialDTO<T>>} - A promise that resolves to the retrieved document,
      *    or rejects with a ResourceNotFoundError if the document does not exist.
-     * @throws {ResourceNotFoundError} - If the document with the specified ID does not exist.
+     * @throws {ResourceNotAvailableError} - If the document with the specified ID does not exist.
      */
     async get(id, options) {
         const out = await this.findById(id, options);
         if (!out)
-            throw new common_1.ResourceNotFoundError(this.getResourceName(), id);
+            throw new common_1.ResourceNotAvailableError(this.getResourceName(), id);
         return out;
     }
     /**
@@ -289,14 +349,22 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * undefined if the document was not found.
      */
     async update(id, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.update(id, input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'update',
-                documentId: id,
-                input,
-                options,
-            }, this);
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId: id,
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter
+            ]);
+            return this._update(id, input, { ...options, filter });
+        }, info);
+    }
+    async _update(id, input, options) {
         const encode = this.getEncoder('update');
         const doc = encode(input, { coerce: true });
         const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
@@ -308,8 +376,7 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
         };
         const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
             mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter,
-            await this._getDocumentFilter()
+            options?.filter
         ]);
         const decode = this.getDecoder();
         const out = await this.__findOneAndUpdate(filter, patch, mongoOptions);
@@ -324,18 +391,25 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
     async updateOnly(id, input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.updateOnly(id, input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'updateOnly',
-                documentId: id,
-                input,
-                options,
-            }, this);
+        const info = {
+            crud: 'update',
+            method: 'update',
+            documentId: id,
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter
+            ]);
+            return this._updateOnly(id, input, { ...options, filter });
+        }, info);
+    }
+    async _updateOnly(id, input, options) {
         const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
             mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter,
-            await this._getDocumentFilter()
+            options?.filter
         ]);
         const encode = this.getEncoder('update');
         const doc = encode(input, { coerce: true });
@@ -359,13 +433,21 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
      * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
      */
     async updateMany(input, options) {
-        if (this.$interceptor && !options?.__interceptor__)
-            return this.$interceptor(() => this.updateMany(input, { ...options, __interceptor__: true }), {
-                crud: 'update',
-                method: 'updateMany',
-                input,
-                options,
-            }, this);
+        const info = {
+            crud: 'update',
+            method: 'updateMany',
+            input,
+            options,
+        };
+        return this._intercept(async () => {
+            const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+                await this._getDocumentFilter(info),
+                options?.filter
+            ]);
+            return this._updateMany(input, { ...options, filter });
+        }, info);
+    }
+    async _updateMany(input, options) {
         const encode = this.getEncoder('update');
         const doc = encode(input, { coerce: true });
         if (!Object.keys(doc).length)
@@ -376,7 +458,7 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
             ...(0, lodash_omit_1.default)(options, 'filter'),
             upsert: undefined
         };
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([options?.filter, await this._getDocumentFilter()]);
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
         const r = await this.__updateMany(filter, patch, mongoOptions);
         return r.matchedCount;
     }
@@ -398,9 +480,14 @@ class MongoCollectionService 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.
      */
-    _getDocumentFilter() {
+    _getDocumentFilter(args) {
         return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(this) : this.$documentFilter;
+            this.$documentFilter(args, this) : this.$documentFilter;
+    }
+    async _intercept(callback, args) {
+        if (this.$interceptor)
+            return this.$interceptor(callback, args, this);
+        return callback();
     }
 }
 exports.MongoCollectionService = MongoCollectionService;

package/cjs/mongo-service.js

@@ -47,7 +47,7 @@ class MongoService extends core_1.ApiService {
      * Retrieves the encoder for the specified operation.
      *
      * @param {String} operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
-     * @returns {vg.ObjectValidator<T>} - The encoder for the specified operation.
+     * @returns {IsObject.Validator<T>} - The encoder for the specified operation.
      */
     getEncoder(operation) {
         let encoder = this._encoders[operation];
@@ -60,7 +60,7 @@ class MongoService extends core_1.ApiService {
     /**
      * Retrieves the decoder.
      *
-     * @returns {vg.ObjectValidator<T>} - The encoder for the specified operation.
+     * @returns {IsObject.Validator<T>} - The encoder for the specified operation.
      */
     getDecoder() {
         let decoder = this._decoder;
@@ -70,6 +70,48 @@ class MongoService extends core_1.ApiService {
         this._decoder = decoder;
         return decoder;
     }
+    /**
+     * Executes the provided function within a transaction.
+     *
+     * @param {WithTransactionCallback} callback - The function to be executed within the transaction.
+     * @param {TransactionOptions} [options] - Optional options for the transaction.
+     * @returns {Promise<any>} - A promise that resolves with the result of the function execution within the transaction.
+     */
+    async withTransaction(callback, options) {
+        let session = this.getSession();
+        if (session)
+            return callback(session);
+        // Backup old session property
+        const hasOldSession = this.hasOwnProperty('session');
+        const oldSessionGetter = hasOldSession ? this.session : undefined;
+        const db = this.getDatabase();
+        const client = db.client;
+        session = client.startSession();
+        this.session = session;
+        const oldInTransaction = session.inTransaction();
+        try {
+            if (!oldInTransaction)
+                session.startTransaction(options);
+            const out = await callback(session);
+            if (!oldInTransaction)
+                await session.commitTransaction();
+            return out;
+        }
+        catch (e) {
+            if (!oldInTransaction)
+                await session.abortTransaction();
+            throw e;
+        }
+        finally {
+            // Restore old session property
+            if (hasOldSession) {
+                this.session = oldSessionGetter;
+                await session.endSession();
+            }
+            else
+                delete this.session;
+        }
+    }
     /**
      * Inserts a single document into MongoDB. If documents passed in do not contain the **_id** field,
      * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
@@ -379,59 +421,31 @@ class MongoService extends core_1.ApiService {
             return out;
         throw new Error('resourceName is not defined');
     }
-    /**
-     * Compares the current instance with the provided attributes and returns true if they match, false otherwise.
-     * This method is protected and should only be called by subclasses.
-     *
-     * @param {MongoService<any>} service - The service instance to compare.
-     * @param {RequestContext} context - The request context.
-     * @param {Object} attributes - Optional attributes object for comparison.
-     * @return {boolean} - True if the instance matches the provided attributes, false otherwise.
-     * @protected
-     */
-    _instanceCompare(service, context, attributes) {
-        return super._instanceCompare(service, context, attributes) &&
-            (!attributes?.db ||
-                (typeof service.db === 'object' && service.db === attributes.db) ||
-                (typeof service.db === 'function' && service.getDatabase() === attributes.db)) &&
-            (!attributes?.session ||
-                (typeof service.session === 'object' && service.session === attributes?.session) ||
-                (typeof service.session === 'function' && service.getSession() === attributes?.session));
-    }
     /**
      * Generates an encoder for the specified operation.
      *
      * @param {string} operation - The operation to generate the encoder for. Must be either 'create' or 'update'.
      * @protected
-     * @returns {vg.Validator} - The generated encoder for the specified operation.
+     * @returns {IsObject.Validator} - The generated encoder for the specified operation.
      */
     _generateEncoder(operation) {
-        let encoder = this._encoders[operation];
-        if (encoder)
-            return encoder;
         const dataType = this.getDataType();
         const options = {};
         if (operation === 'update') {
             options.omit = ['_id'];
             options.partial = true;
         }
-        encoder = dataType.generateCodec('encode', options);
-        this._encoders[operation] = encoder;
-        return encoder;
+        return dataType.generateCodec('encode', options);
     }
     /**
      * Generates an encoder for the specified operation.
      *
      * @protected
-     * @returns {vg.Validator} - The generated encoder for the specified operation.
+     * @returns {IsObject.Validator} - The generated encoder for the specified operation.
      */
     _generateDecoder() {
-        let decoder = this._decoder;
-        if (decoder)
-            return decoder;
         const dataType = this.getDataType();
-        decoder = this._decoder = dataType.generateCodec('decode', { partial: true });
-        return decoder;
+        return dataType.generateCodec('decode', { partial: true });
     }
 }
 exports.MongoService = MongoService;