@opra/mongodb 1.0.0-alpha.9 → 1.0.0-beta.2

package/esm/mongo-entity-service.js

@@ -1,11 +1,11 @@
-import * as assert from 'node:assert';
 import { InternalServerError } from '@opra/common';
 import omit from 'lodash.omit';
+import { isNotNullish } from 'valgen';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoService } from './mongo-service.js';
 /**
  * @class MongoEntityService
- * @template T - The type of the documents in the collection.
+ * @template T - The type of the documents in the collection
  */
 export class MongoEntityService extends MongoService {
     /**
@@ -19,121 +19,155 @@ export class MongoEntityService extends MongoService {
         super(dataType, options);
     }
     /**
-     * Creates a new document in the MongoDB collection.
+     * Creates a new document in the MongoDB collection
      *
-     * @param {PartialDTO<T>} input
-     * @param {MongoEntityService.CreateOptions} options
+     * @param {MongoEntityService.CreateCommand} command
      * @protected
      */
-    async _create(input, options) {
-        const inputCodec = this.getInputCodec('create');
-        const doc = inputCodec(input);
-        assert.ok(doc._id, 'You must provide the "_id" field');
-        const r = await this._dbInsertOne(doc, options);
-        if (r.insertedId) {
-            if (!options)
-                return doc;
-            const out = await this._findById(doc._id, omit(options, 'filter'));
-            if (out)
-                return out;
-        }
+    async _create(command) {
+        const input = command.input;
+        isNotNullish(input, { label: 'input' });
+        isNotNullish(input._id, { label: 'input._id' });
+        const inputCodec = this._getInputCodec('create');
+        const document = inputCodec(input);
+        const { options } = command;
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const r = await collection.insertOne(document, {
+            ...options,
+            session: options?.session || this.getSession(),
+        });
         /* istanbul ignore next */
-        throw new InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
+        if (!r.insertedId) {
+            throw new InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
+        }
+        return document;
     }
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {MongoEntityService.CountOptions<T>} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
+     * @param {MongoEntityService.CountCommand<T>} command
+     * @protected
      */
-    async _count(options) {
+    async _count(command) {
+        const { options } = command;
         const filter = MongoAdapter.prepareFilter(options?.filter);
-        return this._dbCountDocuments(filter, omit(options, 'filter'));
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        return ((await collection.countDocuments(filter || {}, {
+            ...options,
+            limit: undefined,
+            session: options?.session || this.getSession(),
+        })) || 0);
     }
     /**
-     * Deletes a document from the collection.
+     * Deletes a document from the collection
      *
-     * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
-     * @param {MongoEntityService.DeleteOptions<T>} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param {MongoEntityService.DeleteCommand<T>} command
+     * @protected
      */
-    async _delete(id, options) {
-        assert.ok(id, 'You must provide an id');
-        const filter = MongoAdapter.prepareFilter([MongoAdapter.prepareKeyValues(id, ['_id']), options?.filter]);
-        const r = await this._dbDeleteOne(filter, options);
-        return r.deletedCount;
+    async _delete(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        const { options } = command;
+        const filter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(command.documentId, ['_id']),
+            options?.filter,
+        ]);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        return (await collection.deleteOne(filter || {}, {
+            ...options,
+            session: options?.session || this.getSession(),
+        })).deletedCount;
     }
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {MongoEntityService.DeleteManyOptions<T>} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param {MongoEntityService.DeleteCommand<T>} command
+     * @protected
      */
-    async _deleteMany(options) {
+    async _deleteMany(command) {
+        const { options } = command;
         const filter = MongoAdapter.prepareFilter(options?.filter);
-        const r = await this._dbDeleteMany(filter, omit(options, 'filter'));
-        return r.deletedCount;
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        return (await collection.deleteMany(filter || {}, {
+            ...options,
+            session: options?.session || this.getSession(),
+        })).deletedCount;
     }
     /**
-     * The distinct command returns a list of distinct values for the given key across a collection.
-     * @param {string} field
-     * @param {MongoEntityService.DistinctOptions<T>} options
+     * The distinct command returns a list of distinct values for the given key across a collection
+     *
+     * @param {MongoEntityService.DistinctCommand<T>} command
      * @protected
      */
-    async _distinct(field, options) {
+    async _distinct(command) {
+        const { options, field } = command;
         const filter = MongoAdapter.prepareFilter(options?.filter);
-        return await this._dbDistinct(field, filter, omit(options, 'filter'));
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        return await collection.distinct(field, filter || {}, {
+            ...options,
+            session: options?.session || this.getSession(),
+        });
     }
     /**
      * Finds a document by its ID.
      *
-     * @param {MongoAdapter.AnyId} id - The ID of the document.
-     * @param {MongoEntityService.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.
+     * @param { MongoEntityService.FindOneCommand<T>} command
      */
-    async _findById(id, options) {
-        const filter = MongoAdapter.prepareFilter([MongoAdapter.prepareKeyValues(id, ['_id']), options?.filter]);
-        const mongoOptions = {
-            ...options,
+    async _findById(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        const filter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(command.documentId, ['_id']),
+            command.options?.filter,
+        ]);
+        const { options } = command;
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const out = await collection.findOne(filter || {}, {
+            ...omit(options, 'filter'),
+            session: options?.session || this.getSession(),
             projection: MongoAdapter.prepareProjection(this.dataType, options?.projection),
             limit: undefined,
             skip: undefined,
             sort: undefined,
-        };
-        const out = await this._dbFindOne(filter, mongoOptions);
-        const outputCodec = this.getOutputCodec('find');
-        if (out)
+        });
+        if (out) {
+            const outputCodec = this._getOutputCodec('find');
             return outputCodec(out);
+        }
     }
     /**
      * Finds a document in the collection that matches the specified options.
      *
-     * @param {MongoEntityService.FindOneOptions} [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.
+     * @param {MongoEntityService.FindOneCommand<T>} command
      */
-    async _findOne(options) {
+    async _findOne(command) {
+        const { options } = command;
         const filter = MongoAdapter.prepareFilter(options?.filter);
-        const mongoOptions = {
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const out = await collection.findOne(filter || {}, {
             ...omit(options, 'filter'),
+            session: options?.session || this.getSession(),
             sort: options?.sort ? MongoAdapter.prepareSort(options.sort) : undefined,
             projection: MongoAdapter.prepareProjection(this.dataType, options?.projection),
             limit: undefined,
-        };
-        const out = await this._dbFindOne(filter, mongoOptions);
-        const outputCodec = this.getOutputCodec('find');
-        if (out)
+        });
+        if (out) {
+            const outputCodec = this._getOutputCodec('find');
             return outputCodec(out);
+        }
     }
     /**
-     * Finds multiple documents in the MongoDB collection.
+     * Finds multiple documents in the MongoDB collection
      *
-     * @param {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param {MongoEntityService.FindManyCommand<T>} command
      */
-    async _findMany(options) {
-        const mongoOptions = {
-            ...omit(options, ['projection', 'sort', 'skip', 'limit', 'filter']),
-        };
+    async _findMany(command) {
+        const { options } = command;
         const limit = options?.limit || 10;
         const stages = [];
         let filter;
@@ -153,11 +187,16 @@ export class MongoEntityService extends MongoService {
         const projection = MongoAdapter.prepareProjection(dataType, options?.projection);
         if (projection)
             stages.push({ $project: projection });
-        const cursor = await this._dbAggregate(stages, mongoOptions);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const cursor = collection.aggregate(stages, {
+            ...omit(options, ['projection', 'sort', 'skip', 'limit', 'filter']),
+            session: options?.session || this.getSession(),
+        });
         /** Execute db command */
         try {
             /** Fetch the cursor and decode the result objects */
-            const outputCodec = this.getOutputCodec('find');
+            const outputCodec = this._getOutputCodec('find');
             return (await cursor.toArray()).map((r) => outputCodec(r));
         }
         finally {
@@ -169,13 +208,10 @@ export class MongoEntityService extends MongoService {
      * Finds multiple documents in the collection and returns both records (max limit)
      * and total count that matched the given criteria
      *
-     * @param {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param {MongoEntityService.FindManyCommand<T>} command
      */
-    async _findManyWithCount(options) {
-        const mongoOptions = {
-            ...omit(options, ['projection', 'sort', 'skip', 'limit', 'filter']),
-        };
+    async _findManyWithCount(command) {
+        const { options } = command;
         const limit = options?.limit || 10;
         let filter;
         if (options?.filter)
@@ -207,11 +243,16 @@ export class MongoEntityService extends MongoService {
         const projection = MongoAdapter.prepareProjection(dataType, options?.projection);
         if (projection)
             dataStages.push({ $project: projection });
-        const outputCodec = this.getOutputCodec('find');
+        const outputCodec = this._getOutputCodec('find');
         /** Execute db command */
-        const cursor = await this._dbAggregate(stages, mongoOptions);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const cursor = collection.aggregate(stages, {
+            ...omit(options, ['projection', 'sort', 'skip', 'limit', 'filter']),
+            session: options?.session || this.getSession(),
+        });
+        /** Fetch the cursor and decode the result objects */
         try {
-            /** Fetch the cursor and decode the result objects */
             const facetResult = await cursor.toArray();
             return {
                 count: facetResult[0].count[0]?.totalMatches || 0,
@@ -224,59 +265,60 @@ export class MongoEntityService extends MongoService {
         }
     }
     /**
-     * Updates a document with the given id in the collection.
+     * Updates a document with the given id in the collection
      *
-     * @param {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 {MongoEntityService.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.
+     * @param {MongoEntityService.UpdateOneCommand<T>} command
      */
-    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) {
+    async _update(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        const { input, inputRaw, options } = command;
+        isNotNullish(input || inputRaw, { label: 'input' });
+        if (input && inputRaw) {
             throw new TypeError('You must pass one of MongoDB UpdateFilter or a partial document, not both');
         }
         let update;
-        if (isDocument) {
-            const inputCodec = this.getInputCodec('update');
+        if (input) {
+            const inputCodec = this._getInputCodec('update');
             const doc = inputCodec(input);
             delete doc._id;
             update = MongoAdapter.preparePatch(doc);
             update.$set = update.$set || {};
         }
         else
-            update = input;
-        const filter = MongoAdapter.prepareFilter([MongoAdapter.prepareKeyValues(id, ['_id']), options?.filter]);
-        const mongoOptions = {
+            update = inputRaw;
+        const filter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(command.documentId, ['_id']),
+            options?.filter,
+        ]);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        const out = await collection.findOneAndUpdate(filter || {}, update, {
+            upsert: undefined,
             ...options,
+            returnDocument: 'after',
             includeResultMetadata: false,
-            upsert: undefined,
+            session: options?.session || this.getSession(),
             projection: MongoAdapter.prepareProjection(this.dataType, options?.projection),
-        };
-        const out = await this._dbFindOneAndUpdate(filter, update, mongoOptions);
-        const outputCodec = this.getOutputCodec('update');
+        });
+        const outputCodec = this._getOutputCodec('update');
         if (out)
             return outputCodec(out);
     }
     /**
      * Updates a document in the collection with the specified ID.
      *
-     * @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 {MongoEntityService.UpdateOptions<T>} [options] - The options for updating the document.
-     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     * @param {MongoEntityService.UpdateOneCommand<T>} command
      */
-    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) {
+    async _updateOnly(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        const { input, inputRaw, options } = command;
+        isNotNullish(input || inputRaw, { label: 'input' });
+        if (input && inputRaw) {
             throw new TypeError('You must pass one of MongoDB UpdateFilter or a partial document, not both');
         }
         let update;
-        if (isDocument) {
-            const inputCodec = this.getInputCodec('update');
+        if (input) {
+            const inputCodec = this._getInputCodec('update');
             const doc = inputCodec(input);
             delete doc._id;
             update = MongoAdapter.preparePatch(doc);
@@ -284,33 +326,34 @@ export class MongoEntityService extends MongoService {
                 return 0;
         }
         else
-            update = input;
-        const filter = MongoAdapter.prepareFilter([MongoAdapter.prepareKeyValues(id, ['_id']), options?.filter]);
-        const mongoOptions = {
+            update = inputRaw;
+        const filter = MongoAdapter.prepareFilter([
+            MongoAdapter.prepareKeyValues(command.documentId, ['_id']),
+            options?.filter,
+        ]);
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        return (await collection.updateOne(filter || {}, update, {
             ...options,
-            includeResultMetadata: false,
+            session: options?.session || this.getSession(),
             upsert: undefined,
-            projection: MongoAdapter.prepareProjection(this.dataType, options?.projection),
-        };
-        const out = await this._dbUpdateOne(filter, update, mongoOptions);
-        return out.matchedCount;
+        })).matchedCount;
     }
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input to update the documents with.
-     * @param {MongoEntityService.UpdateManyOptions<T>} [options] - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     * @param {MongoEntityService.UpdateManyCommand<T>} command
      */
-    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) {
+    async _updateMany(command) {
+        isNotNullish(command.input, { label: 'input' });
+        const { input, inputRaw, options } = command;
+        isNotNullish(input || inputRaw, { label: 'input' });
+        if (input && inputRaw) {
             throw new TypeError('You must pass one of MongoDB UpdateFilter or a partial document, not both');
         }
         let update;
-        if (isDocument) {
-            const inputCodec = this.getInputCodec('update');
+        if (input) {
+            const inputCodec = this._getInputCodec('update');
             const doc = inputCodec(input);
             delete doc._id;
             update = MongoAdapter.preparePatch(doc);
@@ -318,13 +361,98 @@ export class MongoEntityService extends MongoService {
                 return 0;
         }
         else
-            update = input;
-        const mongoOptions = {
-            ...omit(options, 'filter'),
-            upsert: undefined,
-        };
+            update = inputRaw;
         const filter = MongoAdapter.prepareFilter(options?.filter);
-        const r = await this._dbUpdateMany(filter, update, mongoOptions);
-        return r.matchedCount;
+        const db = this.getDatabase();
+        const collection = await this.getCollection(db);
+        return (await collection.updateMany(filter || {}, update, {
+            ...omit(options, 'filter'),
+            session: options?.session || this.getSession(),
+            upsert: false,
+        })).matchedCount;
+    }
+    async _executeCommand(command, commandFn) {
+        try {
+            const result = await super._executeCommand(command, async () => {
+                /** Call before[X] hooks */
+                if (command.crud === 'create')
+                    await this._beforeCreate(command);
+                else if (command.crud === 'update' && command.byId) {
+                    await this._beforeUpdate(command);
+                }
+                else if (command.crud === 'update' && !command.byId) {
+                    await this._beforeUpdateMany(command);
+                }
+                else if (command.crud === 'delete' && command.byId) {
+                    await this._beforeDelete(command);
+                }
+                else if (command.crud === 'delete' && !command.byId) {
+                    await this._beforeDeleteMany(command);
+                }
+                /** Call command function */
+                return commandFn();
+            });
+            /** Call after[X] hooks */
+            if (command.crud === 'create')
+                await this._afterCreate(command, result);
+            else if (command.crud === 'update' && command.byId) {
+                await this._afterUpdate(command, result);
+            }
+            else if (command.crud === 'update' && !command.byId) {
+                await this._afterUpdateMany(command, result);
+            }
+            else if (command.crud === 'delete' && command.byId) {
+                await this._afterDelete(command, result);
+            }
+            else if (command.crud === 'delete' && !command.byId) {
+                await this._afterDeleteMany(command, result);
+            }
+            return result;
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._executeCommand);
+            await this.onError?.(e, this);
+            throw e;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeCreate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdateMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDelete(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDeleteMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterCreate(command, result) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterUpdate(command, result) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterUpdateMany(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDelete(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDeleteMany(command, affected) {
+        // Do nothing
     }
 }