@opra/mongodb 0.33.13 → 1.0.0-alpha.2

package/esm/mongo-collection-service.js

@@ -1,13 +1,12 @@
-import omit from 'lodash.omit';
 import { ObjectId } from 'mongodb';
-import { InternalServerError, ResourceNotAvailableError } from '@opra/common';
+import { ResourceNotAvailableError } from '@opra/common';
 import { MongoAdapter } from './mongo-adapter.js';
-import { MongoService } from './mongo-service.js';
+import { MongoEntityService } from './mongo-entity-service.js';
 /**
  * @class MongoCollectionService
  * @template T - The type of the documents in the collection.
  */
-export class MongoCollectionService extends MongoService {
+export class MongoCollectionService extends MongoEntityService {
     /**
      * Constructs a new instance
      *
@@ -17,17 +16,14 @@ export class MongoCollectionService extends MongoService {
      */
     constructor(dataType, options) {
         super(dataType, options);
-        this.collectionKey = this.collectionKey || options?.collectionKey || '_id';
         this.defaultLimit = this.defaultLimit || options?.defaultLimit || 10;
-        this.$documentFilter = this.$documentFilter || options?.documentFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
     }
     /**
      * Asserts the existence of a resource with the given ID.
      * Throws a ResourceNotFoundError if the resource does not exist.
      *
-     * @param {AnyId} id - The ID of the resource to assert.
-     * @param {MongoCollectionService.ExistsOptions} [options] - Optional options for checking the existence.
+     * @param {MongoAdapter.AnyId} id - The ID of the resource to assert.
+     * @param {MongoCollectionService.ExistsOptions<T>} [options] - Optional options for checking the existence.
      * @returns {Promise<void>} - A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
@@ -37,42 +33,27 @@ export class MongoCollectionService extends MongoService {
     }
     /**
      * Creates a new document in the MongoDB collection.
+     * Interceptors will be called before performing db operation
      *
-     * @param {DTO<T>} input - The input data for creating the document.
+     * @param {PartialDTO<T>} input - The input data for creating the document.
      * @param {MongoCollectionService.CreateOptions} [options] - The options for creating the document.
      * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created document.
      * @throws {Error} if an unknown error occurs while creating the document.
      */
     async create(input, options) {
+        const id = input._id || this._generateId();
+        if (id != null)
+            input._id = id;
         const info = {
             crud: 'create',
             method: 'create',
             byId: false,
-            documentId: input._id,
+            documentId: id,
             input,
-            options
+            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();
-        const r = await this.__insertOne(doc, options);
-        if (r.insertedId) {
-            if (!options)
-                return doc;
-            const out = await this._findById(doc._id, {
-                ...options,
-                filter: undefined,
-                skip: undefined
-            });
-            if (out)
-                return out;
-        }
-        /* istanbul ignore next */
-        throw new InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
-    }
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
@@ -84,24 +65,17 @@ export class MongoCollectionService extends MongoService {
             crud: 'read',
             method: 'count',
             byId: false,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._count({ ...options, filter });
         }, info);
     }
-    async _count(options) {
-        const filter = MongoAdapter.prepareFilter(options?.filter);
-        return this.__countDocuments(filter, omit(options, 'filter'));
-    }
     /**
      * Deletes a document from the collection.
      *
-     * @param {AnyId} id - The ID of the document to delete.
+     * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
      * @param {MongoCollectionService.DeleteOptions<T>} [options] - Optional delete options.
      * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
      */
@@ -109,26 +83,15 @@ export class MongoCollectionService extends MongoService {
         const info = {
             crud: 'delete',
             method: 'delete',
-            byId: false,
+            byId: true,
             documentId: id,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._delete(id, { ...options, filter });
         }, info);
     }
-    async _delete(id, options) {
-        const filter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter
-        ]);
-        const r = await this.__deleteOne(filter, options);
-        return r.deletedCount;
-    }
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
@@ -140,49 +103,40 @@ export class MongoCollectionService extends MongoService {
             crud: 'delete',
             method: 'deleteMany',
             byId: false,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter,
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._deleteMany({ ...options, filter });
         }, info);
     }
-    async _deleteMany(options) {
-        const filter = MongoAdapter.prepareFilter(options?.filter);
-        const r = await this.__deleteMany(filter, omit(options, 'filter'));
-        return r.deletedCount;
-    }
+    /**
+     * The distinct command returns a list of distinct values for the given key across a collection.
+     * @param {string} field
+     * @param {MongoCollectionService.DistinctOptions<T>} [options]
+     * @protected
+     */
     async distinct(field, options) {
         const info = {
             crud: 'read',
             method: 'distinct',
             byId: true,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter,
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._distinct(field, { ...options, filter });
         }, info);
     }
-    async _distinct(field, options) {
-        const filter = MongoAdapter.prepareFilter(options?.filter);
-        return await this.__distinct(field, filter, omit(options, 'filter'));
-    }
     /**
      * 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 query (optional).
+     * @param {MongoAdapter.AnyId} id - The id of the object to check.
+     * @param {MongoCollectionService.ExistsOptions<T>} [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) {
-        return !!(await this.findById(id, { ...options, pick: ['_id'], omit: undefined, include: undefined }));
+        return !!(await this.findById(id, { ...options, projection: ['_id'] }));
     }
     /**
      * Checks if an object with the given arguments exists.
@@ -191,13 +145,13 @@ export class MongoCollectionService extends MongoService {
      * @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 }));
+        return !!(await this.findOne({ ...options, projection: ['_id'] }));
     }
     /**
      * Finds a document by its ID.
      *
-     * @param {AnyId} id - The ID of the document.
-     * @param {MongoCollectionService.FindOneOptions} [options] - The options for the find query.
+     * @param {MongoAdapter.AnyId} id - The ID of the document.
+     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the find query.
      * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
      */
     async findById(id, options) {
@@ -206,37 +160,18 @@ export class MongoCollectionService extends MongoService {
             method: 'findById',
             byId: true,
             documentId: id,
-            options
+            options,
         };
         return this._intercept(async () => {
             const documentFilter = await this._getDocumentFilter(info);
-            const filter = MongoAdapter.prepareFilter([
-                documentFilter,
-                options?.filter,
-            ]);
+            const filter = MongoAdapter.prepareFilter([documentFilter, options?.filter]);
             return this._findById(id, { ...options, filter });
         }, info);
     }
-    async _findById(id, options) {
-        const filter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter
-        ]);
-        const mongoOptions = {
-            ...options,
-            limit: undefined,
-            skip: undefined,
-            sort: undefined,
-            projection: 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.
      *
-     * @param {MongoCollectionService.FindOneOptions} options - The options for the query.
+     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the query.
      * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
      */
     async findOne(options) {
@@ -244,41 +179,17 @@ export class MongoCollectionService extends MongoService {
             crud: 'read',
             method: 'findOne',
             byId: false,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter,
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._findOne({ ...options, filter });
         }, info);
     }
-    async _findOne(options) {
-        const filter = MongoAdapter.prepareFilter(options?.filter);
-        const mongoOptions = {
-            ...options,
-            sort: options?.sort ? MongoAdapter.prepareSort(options.sort) : undefined,
-            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
-            limit: undefined
-        };
-        const decode = this.getDecoder();
-        const out = await this.__findOne(filter, mongoOptions);
-        return out ? decode(out, { coerce: true }) : undefined;
-    }
     /**
      * Finds multiple documents in the MongoDB collection.
      *
-     * @param options - The options for the find operation.
-     *  - pick: string[] - An array of fields to include in the returned documents.
-     *  - include: string[] - An array of fields to include in the returned documents.
-     *  - omit: string[] - An array of fields to exclude from the returned documents.
-     *  - sort: Record<string, number> - The sorting criteria.
-     *  - skip: number - The number of documents to skip.
-     *  - limit: number - The maximum number of documents to return.
-     *  - filter: FilterQuery<T> - The filter conditions to apply to the find operation.
-     *  - count: boolean - If set to true, returns the total count of matching documents.
-     *
+     * @param {MongoCollectionService.FindManyOptions<T>} options - The options for the find operation.
      * @return A Promise that resolves to an array of partial outputs of type T.
      */
     async findMany(options) {
@@ -286,76 +197,37 @@ export class MongoCollectionService extends MongoService {
             crud: 'read',
             method: 'findMany',
             byId: false,
-            options
+            options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter,
-            ]);
-            return this._findMany({ ...options, filter });
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._findMany({ ...options, filter, limit: options?.limit || this.defaultLimit });
         }, info);
     }
-    async _findMany(options) {
-        const mongoOptions = {
-            ...omit(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
+    /**
+     * Finds multiple documents in the collection and returns both records (max limit)
+     * and total count that matched the given criteria
+     *
+     * @param {MongoCollectionService.FindManyOptions<T>} [options] - The options for the find operation.
+     * @return A Promise that resolves to an array of partial outputs of type T.
+     */
+    async findManyWithCount(options) {
+        const info = {
+            crud: 'read',
+            method: 'findManyWithCount',
+            byId: false,
+            options,
         };
-        const limit = options?.limit || this.defaultLimit;
-        const stages = [];
-        let filter;
-        if (options?.filter)
-            filter = MongoAdapter.prepareFilter(options?.filter);
-        let dataStages = stages;
-        if (options?.count) {
-            dataStages = [];
-            const count = [];
-            if (filter)
-                count.push({ $match: filter });
-            count.push({ $count: 'totalMatches' });
-            stages.push({
-                $facet: {
-                    data: dataStages,
-                    count,
-                }
-            });
-        }
-        if (filter)
-            dataStages.push({ $match: filter });
-        if (options?.skip)
-            dataStages.push({ $skip: options.skip });
-        if (options?.sort) {
-            const sort = MongoAdapter.prepareSort(options.sort);
-            if (sort)
-                dataStages.push({ $sort: sort });
-        }
-        dataStages.push({ $limit: limit });
-        const dataType = this.getDataType();
-        const projection = MongoAdapter.prepareProjection(dataType, options);
-        if (projection)
-            dataStages.push({ $project: projection });
-        const decode = this.getDecoder();
-        const cursor = await this.__aggregate(stages, {
-            ...mongoOptions
-        });
-        try {
-            if (options?.count) {
-                const facetResult = await cursor.toArray();
-                this.context.response.totalMatches = facetResult[0].count[0].totalMatches || 0;
-                return facetResult[0].data.map((r) => decode(r, { coerce: true }));
-            }
-            else
-                return await cursor.toArray();
-        }
-        finally {
-            if (!cursor.closed)
-                await cursor.close();
-        }
+        return this._intercept(async () => {
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._findManyWithCount({ ...options, filter, limit: options?.limit || this.defaultLimit });
+        }, info);
     }
     /**
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
-     * @param {*} id - The ID of the document to retrieve.
-     * @param {MongoCollectionService.FindOneOptions} [options] - Optional options for the findOne operation.
+     * @param {MongoAdapter.AnyId} id - The ID of the document to retrieve.
+     * @param {MongoCollectionService.FindOneOptions<T>} [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 {ResourceNotAvailableError} - If the document with the specified ID does not exist.
@@ -369,8 +241,8 @@ export class MongoCollectionService extends MongoService {
     /**
      * Updates a document with the given id in the collection.
      *
-     * @param {any} id - The id of the document to update.
-     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
+     * @param {MongoAdapter.AnyId} id - The id of the document to update.
+     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input object containing the fields to update.
      * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for the update operation.
      * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
      * undefined if the document was not found.
@@ -385,49 +257,16 @@ export class MongoCollectionService extends MongoService {
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._update(id, input, { ...options, filter });
         }, info);
     }
-    async _update(id, input, options) {
-        const isUpdateFilter = Array.isArray(input) ||
-            !!Object.keys(input).find(x => x.startsWith('$'));
-        const isDocument = !Array.isArray(input) &&
-            !!Object.keys(input).find(x => !x.startsWith('$'));
-        if (isUpdateFilter && isDocument)
-            throw new TypeError('You must pass one of MongoDB UpdateFilter or a partial document, not both');
-        let update;
-        if (isDocument) {
-            const encode = this.getEncoder('update');
-            const doc = encode(input, { coerce: true });
-            update = MongoAdapter.preparePatch(doc);
-            update.$set = update.$set || {};
-        }
-        else
-            update = input;
-        const filter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter
-        ]);
-        const mongoOptions = {
-            ...options,
-            includeResultMetadata: false,
-            upsert: undefined,
-            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
-        };
-        const decode = this.getDecoder();
-        const out = await this.__findOneAndUpdate(filter, update, mongoOptions);
-        return out ? decode(out, { coerce: true }) : undefined;
-    }
     /**
      * Updates a document in the collection with the specified ID.
      *
-     * @param {any} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {MongoCollectionService.UpdateOptions<T>} options - The options for updating the document.
+     * @param {MongoAdapter.AnyId} id - The ID of the document to update.
+     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input data to update the document with.
+     * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for updating the document.
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
     async updateOnly(id, input, options) {
@@ -440,47 +279,14 @@ export class MongoCollectionService extends MongoService {
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._updateOnly(id, input, { ...options, filter });
         }, info);
     }
-    async _updateOnly(id, input, options) {
-        const isUpdateFilter = Array.isArray(input) ||
-            !!Object.keys(input).find(x => x.startsWith('$'));
-        const isDocument = !Array.isArray(input) &&
-            !!Object.keys(input).find(x => !x.startsWith('$'));
-        if (isUpdateFilter && isDocument)
-            throw new TypeError('You must pass one of MongoDB UpdateFilter or a partial document, not both');
-        let update;
-        if (isDocument) {
-            const encode = this.getEncoder('update');
-            const doc = encode(input, { coerce: true });
-            update = MongoAdapter.preparePatch(doc);
-            if (!Object.keys(doc).length)
-                return 0;
-        }
-        else
-            update = input;
-        const filter = MongoAdapter.prepareFilter([
-            MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
-            options?.filter
-        ]);
-        const mongoOptions = {
-            ...options,
-            includeResultMetadata: false,
-            upsert: undefined,
-            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
-        };
-        const out = await this.__updateOne(filter, update, mongoOptions);
-        return out.matchedCount;
-    }
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
+     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input to update the documents with.
      * @param {MongoCollectionService.UpdateManyOptions<T>} options - The options for updating the documents.
      * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
      */
@@ -493,63 +299,17 @@ export class MongoCollectionService extends MongoService {
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
             return this._updateMany(input, { ...options, filter });
         }, info);
     }
-    async _updateMany(input, options) {
-        const isUpdateFilter = Array.isArray(input) ||
-            !!Object.keys(input).find(x => x.startsWith('$'));
-        const isDocument = !Array.isArray(input) &&
-            !!Object.keys(input).find(x => !x.startsWith('$'));
-        if (isUpdateFilter && isDocument)
-            throw new TypeError('You must pass one of MongoDB UpdateFilter or a partial document, not both');
-        let update;
-        if (isDocument) {
-            const encode = this.getEncoder('update');
-            const doc = encode(input, { coerce: true });
-            update = MongoAdapter.preparePatch(doc);
-            if (!Object.keys(doc).length)
-                return 0;
-        }
-        else
-            update = input;
-        const mongoOptions = {
-            ...omit(options, 'filter'),
-            upsert: undefined
-        };
-        const filter = MongoAdapter.prepareFilter(options?.filter);
-        const r = await this.__updateMany(filter, update, mongoOptions);
-        return r.matchedCount;
-    }
     /**
      * Generates an ID.
      *
      * @protected
-     * @returns {AnyId} The generated ID.
+     * @returns {MongoAdapter.AnyId} The generated ID.
      */
     _generateId() {
-        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(args) {
-        return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(args, this) : this.$documentFilter;
-    }
-    async _intercept(callback, args) {
-        if (this.$interceptor)
-            return this.$interceptor(callback, args, this);
-        return callback();
+        return typeof this.$idGenerator === 'function' ? this.$idGenerator(this) : new ObjectId();
     }
 }