@opra/mongodb 0.31.13 → 0.32.0

package/cjs/mongo-collection-service.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoCollectionService = void 0;
 const tslib_1 = require("tslib");
 const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const mongodb_1 = require("mongodb");
 const common_1 = require("@opra/common");
 const mongo_adapter_js_1 = require("./mongo-adapter.js");
 const mongo_service_js_1 = require("./mongo-service.js");
@@ -13,112 +14,232 @@ const mongo_service_js_1 = require("./mongo-service.js");
 class MongoCollectionService extends mongo_service_js_1.MongoService {
     constructor(dataType, options) {
         super(dataType, options);
+        this._encoders = {};
         this.defaultLimit = options?.defaultLimit || 10;
-        this.keyFields = options?.keyField ?
-            (Array.isArray(options.keyField) ? options.keyField : [options.keyField]) : undefined;
-    }
-    async create(doc, options) {
-        const r = await this._rawInsertOne(doc, options);
-        if (r.insertedId) {
-            const out = await this.get(r.insertedId, options);
-            if (out)
-                return out;
-        }
+        this.collectionKey = options?.collectionKey || '_id';
+    }
+    /**
+     * Checks if document exists. Throws error if not.
+     *
+     * @param id
+     */
+    async assert(id) {
+        if (!(await this.exists(id)))
+            throw new common_1.ResourceNotFoundError(this.resourceName || this.getCollectionName(), id);
+    }
+    /**
+     * Inserts a single document into MongoDB
+     *
+     * @param input
+     * @param options
+     */
+    async create(input, options) {
+        const encode = this._getEncoder('create');
+        const doc = encode(input);
+        doc._id = doc._id || this._generateId();
+        const r = await this.__insertOne(doc, options);
+        if (r.insertedId)
+            return doc;
         /* istanbul ignore next */
         throw new Error('Unknown error while creating document');
     }
+    /**
+     * Gets the number of documents matching the filter.
+     *
+     * @param options
+     */
     async count(options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
-        return this._rawCountDocuments(filter, (0, lodash_omit_1.default)(options, 'filter'));
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
+        return this.__countDocuments(filter, (0, lodash_omit_1.default)(options, 'filter'));
     }
+    /**
+     * Delete a document from a collection
+     *
+     * @param id
+     * @param options
+     */
     async delete(id, options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, this.keyFields);
-        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        const r = await this._rawDeleteOne(filter, options);
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
+            options?.filter
+        ]);
+        const r = await this.__deleteOne(filter, options);
         return r.deletedCount;
     }
+    /**
+     * Delete multiple documents from a collection
+     *
+     * @param options
+     */
     async deleteMany(options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
-        const r = await this._rawDeleteMany(filter, (0, lodash_omit_1.default)(options, 'filter'));
+        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;
     }
+    /**
+     * Checks if document exists.
+     * Returns true if document exists, false otherwise
+     *
+     * @param id
+     */
+    async exists(id) {
+        return !!(await this.findById(id, { pick: ['_id'] }));
+    }
+    /**
+     * Fetches the first document matches by id.
+     *
+     * @param id
+     * @param options
+     */
+    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 });
+    }
+    /**
+     * Fetches the first document that matches the filter.
+     * Returns undefined if not found.
+     *
+     * @param options
+     */
+    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,
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
+            limit: undefined
+        };
+        const out = await this.__findOne(filter, mongoOptions);
+        return out || undefined;
+    }
+    /**
+     * Fetches all document that matches the filter
+     *
+     * @param options
+     */
+    async findMany(options) {
+        const mongoOptions = {
+            ...(0, lodash_omit_1.default)(options, ['pick', 'include', 'omit', 'sort', 'skip', 'limit', 'filter', 'count'])
+        };
+        const limit = options?.limit || this.defaultLimit;
+        const stages = [];
+        let dataStages = stages;
+        if (options?.count) {
+            dataStages = [];
+            stages.push({
+                $facet: {
+                    data: dataStages,
+                    count: [{ $count: 'totalMatches' }]
+                }
+            });
+        }
+        if (options?.filter) {
+            const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
+            dataStages.push({ $match: optionsFilter });
+        }
+        if (options?.skip)
+            dataStages.push({ $skip: options.skip });
+        if (options?.sort) {
+            const sort = mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort);
+            if (sort)
+                dataStages.push({ $sort: sort });
+        }
+        dataStages.push({ $limit: limit });
+        const dataType = this.getDataType();
+        const projection = mongo_adapter_js_1.MongoAdapter.prepareProjection(dataType, options);
+        if (projection)
+            dataStages.push({ $project: projection });
+        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;
+            }
+            else
+                return await cursor.toArray();
+        }
+        finally {
+            if (!cursor.closed)
+                await cursor.close();
+        }
+    }
+    /**
+     * Fetches the first Document that matches the id. Throws error undefined if not found.
+     *
+     * @param id
+     * @param options
+     */
     async get(id, options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, this.keyFields);
-        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        const out = await this.findOne({ ...options, filter });
+        const out = await this.findById(id, options);
         if (!out)
             throw new common_1.ResourceNotFoundError(this.resourceName || this.getCollectionName(), id);
         return out;
     }
-    async findOne(options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
+    /**
+     * Updates a single document.
+     * Returns updated document
+     *
+     * @param id
+     * @param input
+     * @param options
+     */
+    async update(id, input, options) {
+        const encode = this._getEncoder('update');
+        const doc = encode(input);
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
+            options?.filter
+        ]);
+        const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
         const mongoOptions = {
-            ...(0, lodash_omit_1.default)(options, ['sort', 'skip', 'limit', 'filter']),
+            ...options,
+            includeResultMetadata: false,
+            upsert: undefined,
             projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
         };
-        const out = await this._rawFindOne(filter, mongoOptions);
-        if (out) {
-            if (this.transformData)
-                return this.transformData(out);
-            return out;
-        }
+        const out = await this.__findOneAndUpdate(filter, patch, mongoOptions);
+        return out || undefined;
     }
-    async findMany(options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
-        const [items, count] = await Promise.all([
-            // Promise that returns items
-            Promise.resolve().then(async () => {
-                const cursor = await this._rawFind(filter, {
-                    ...(0, lodash_omit_1.default)(options, 'filter'),
-                    sort: options?.sort ? mongo_adapter_js_1.MongoAdapter.prepareSort(options.sort) : undefined,
-                    projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options)
-                });
-                try {
-                    const out = [];
-                    let obj;
-                    while (out.length < this.defaultLimit && (obj = await cursor.next())) {
-                        const v = this.transformData ? this.transformData(obj) : obj;
-                        if (v)
-                            out.push(obj);
-                    }
-                    return out;
-                }
-                finally {
-                    await cursor.close();
-                }
-            }),
-            // Promise that returns count
-            (options?.count ? this.count(options) : Promise.resolve()),
+    /**
+     * Updates a single document
+     * Returns number of updated documents
+     *
+     * @param id
+     * @param input
+     * @param options
+     */
+    async updateOnly(id, input, options) {
+        const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter([
+            mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, [this.collectionKey]),
+            options?.filter
         ]);
-        if (options?.count)
-            this.context.response.totalMatches = count || 0;
-        return items;
-    }
-    async update(id, doc, options) {
-        const filter = mongo_adapter_js_1.MongoAdapter.prepareKeyValues(id, this.keyFields);
-        const optionsFilter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        // Prevent updating _id field
-        delete doc._id;
+        const encode = this._getEncoder('update');
+        const doc = encode(input);
         const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
-        patch.$set = patch.$set || {};
         const mongoOptions = {
             ...options,
-            upsert: undefined
+            includeResultMetadata: false,
+            upsert: undefined,
+            projection: mongo_adapter_js_1.MongoAdapter.prepareProjection(this.getDataType(), options),
         };
-        const r = await this._rawUpdateOne(filter, patch, mongoOptions);
-        if (r.upsertedCount)
-            return await this.get(r.upsertedId, options);
-        return await this.get(id, options);
-    }
-    async updateMany(doc, options) {
-        // Prevent updating _id field
-        delete doc._id;
+        const out = await this.__updateOne(filter, patch, mongoOptions);
+        return out.modifiedCount;
+    }
+    /**
+     *  Update multiple documents in a collection
+     *
+     * @param input
+     * @param options
+     */
+    async updateMany(input, options) {
+        const encode = this._getEncoder('update');
+        const doc = encode(input);
         const patch = mongo_adapter_js_1.MongoAdapter.preparePatch(doc);
         patch.$set = patch.$set || {};
         const mongoOptions = {
@@ -126,8 +247,49 @@ class MongoCollectionService extends mongo_service_js_1.MongoService {
             upsert: undefined
         };
         const filter = mongo_adapter_js_1.MongoAdapter.prepareFilter(options?.filter) || {};
-        const r = await this._rawUpdateMany(filter, patch, mongoOptions);
+        const r = await this.__updateMany(filter, patch, mongoOptions);
         return r.matchedCount;
     }
+    /**
+     * Generates Id value
+     *
+     * @protected
+     */
+    _generateId() {
+        return new mongodb_1.ObjectId();
+    }
+    /**
+     * Generates a new Validator  for encoding or returns from cache if already generated before
+     * @param operation
+     * @protected
+     */
+    _getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        encoder = this._generateEncoder(operation);
+        this._encoders[operation] = encoder;
+        return encoder;
+    }
+    /**
+     * Generates a new Valgen Validator for encode operation
+     *
+     * @param operation
+     * @protected
+     */
+    _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;
+    }
 }
 exports.MongoCollectionService = MongoCollectionService;

package/cjs/mongo-service.js

@@ -20,10 +20,22 @@ class MongoService extends core_1.ApiService {
         }
         this.resourceName = options?.resourceName || this.collectionName;
     }
+    getDataType() {
+        return this.context.api.getComplexType(this._dataType);
+    }
     forContext(arg0, attributes) {
         return super.forContext(arg0, attributes);
     }
-    async _rawInsertOne(doc, options) {
+    /**
+     * 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
+     * can be overridden by setting the **forceServerObjectId** flag.
+     *
+     * @param doc
+     * @param options
+     * @protected
+     */
+    async __insertOne(doc, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -38,7 +50,14 @@ class MongoService extends core_1.ApiService {
             throw e;
         }
     }
-    async _rawCountDocuments(filter, options) {
+    /**
+     * Gets the number of documents matching the filter.
+     *
+     * @param filter
+     * @param options
+     * @protected
+     */
+    async __countDocuments(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -54,7 +73,13 @@ class MongoService extends core_1.ApiService {
             throw e;
         }
     }
-    async _rawDeleteOne(filter, options) {
+    /**
+     * Delete a document from a collection
+     *
+     * @param filter - The filter used to select the document to remove
+     * @param options - Optional settings for the command
+     */
+    async __deleteOne(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -69,7 +94,14 @@ class MongoService extends core_1.ApiService {
             throw e;
         }
     }
-    async _rawDeleteMany(filter, options) {
+    /**
+     * Delete multiple documents from a collection
+     *
+     * @param filter
+     * @param options
+     * @protected
+     */
+    async __deleteMany(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -84,7 +116,36 @@ class MongoService extends core_1.ApiService {
             throw e;
         }
     }
-    async _rawFindOne(filter, options) {
+    /**
+     * Create a new Change Stream, watching for new changes (insertions, updates, replacements, deletions, and invalidations) in this collection.
+     *
+     * @param pipeline
+     * @param options
+     * @protected
+     */
+    async __aggregate(pipeline, options) {
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
+        options = {
+            ...options,
+            session: options?.session || this.session
+        };
+        try {
+            return await collection.aggregate(pipeline, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    /**
+     * Fetches the first document that matches the filter
+     *
+     * @param filter
+     * @param options
+     * @protected
+     */
+    async __findOne(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -99,7 +160,14 @@ class MongoService extends core_1.ApiService {
             throw e;
         }
     }
-    async _rawFind(filter, options) {
+    /**
+     * Creates a cursor for a filter that can be used to iterate over results from MongoDB
+     *
+     * @param filter
+     * @param options
+     * @protected
+     */
+    async __find(filter, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -114,22 +182,63 @@ class MongoService extends core_1.ApiService {
             throw e;
         }
     }
-    async _rawUpdateOne(filter, doc, options) {
+    /**
+     * Update a single document in a collection
+     *
+     * @param filter
+     * @param update
+     * @param options
+     * @protected
+     */
+    async __updateOne(filter, update, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
+            session: this.session,
+            ...options
+        };
+        try {
+            return collection.updateOne(filter, update, options);
+        }
+        catch (e) {
+            await this._onError(e);
+            throw e;
+        }
+    }
+    /**
+     * Find a document and update it in one atomic operation. Requires a write lock for the duration of the operation.
+     *
+     * @param filter
+     * @param doc
+     * @param options
+     * @protected
+     */
+    async __findOneAndUpdate(filter, doc, options) {
+        const db = await this.getDatabase();
+        const collection = await this.getCollection(db);
+        const opts = {
+            returnDocument: 'after',
+            session: this.session,
+            includeResultMetadata: false,
             ...options,
-            session: options?.session || this.session
         };
         try {
-            return await collection.updateOne(filter, doc, options);
+            return await collection.findOneAndUpdate(filter, doc, opts);
         }
         catch (e) {
             await this._onError(e);
             throw e;
         }
     }
-    async _rawUpdateMany(filter, doc, options) {
+    /**
+     * Update multiple documents in a collection
+     *
+     * @param filter
+     * @param doc
+     * @param options
+     * @protected
+     */
+    async __updateMany(filter, doc, options) {
         const db = await this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
@@ -156,9 +265,6 @@ class MongoService extends core_1.ApiService {
             throw new Error(`Database not set!`);
         return this.db;
     }
-    getDataType() {
-        return this.context.api.getComplexType(this._dataType);
-    }
     async getCollection(db) {
         return db.collection(this.getCollectionName());
     }