@opra/mongodb 1.0.0-alpha.8 → 1.0.0-beta.1

package/esm/mongo-service.js

@@ -1,6 +1,7 @@
 import { DATATYPE_METADATA } from '@opra/common';
 import { ServiceBase } from '@opra/core';
 import { ObjectId } from 'mongodb';
+import { MongoAdapter } from './mongo-adapter.js';
 /**
  * Class representing a MongoDB service for interacting with a collection.
  * @extends ServiceBase
@@ -20,20 +21,33 @@ export class MongoService extends ServiceBase {
         this._outputCodecs = {};
         this._dataType_ = dataType;
         this.db = options?.db;
-        this.$documentFilter = this.$documentFilter || options?.documentFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
-        this.$collectionName = options?.collectionName;
-        if (!this.$collectionName) {
+        this.documentFilter = options?.documentFilter;
+        this.interceptor = options?.interceptor;
+        if (options?.collectionName)
+            this.collectionName = options?.collectionName;
+        else {
             if (typeof dataType === 'string')
-                this.$collectionName = dataType;
+                this.collectionName = dataType;
             if (typeof dataType === 'function') {
                 const metadata = Reflect.getMetadata(DATATYPE_METADATA, dataType);
                 if (metadata)
-                    this.$collectionName = metadata.name;
+                    this.collectionName = metadata.name;
             }
         }
-        this.$resourceName = options?.resourceName;
-        this.$idGenerator = options?.idGenerator;
+        this.resourceName = options?.resourceName;
+        this.idGenerator = options?.idGenerator;
+        this.onError = options?.onError;
+    }
+    for(context, overwriteProperties, overwriteContext) {
+        if (overwriteProperties?.documentFilter && this.documentFilter) {
+            overwriteProperties.documentFilter = [
+                ...(Array.isArray(this.documentFilter) ? this.documentFilter : [this.documentFilter]),
+                ...(Array.isArray(overwriteProperties?.documentFilter)
+                    ? overwriteProperties?.documentFilter
+                    : [overwriteProperties?.documentFilter]),
+            ];
+        }
+        return super.for(context, overwriteProperties, overwriteContext);
     }
     /**
      * Retrieves the collection name.
@@ -43,7 +57,7 @@ export class MongoService extends ServiceBase {
      * @throws {Error} If the collection name is not defined.
      */
     getCollectionName() {
-        const out = typeof this.$collectionName === 'function' ? this.$collectionName(this) : this.$collectionName;
+        const out = typeof this.collectionName === 'function' ? this.collectionName(this) : this.collectionName;
         if (out)
             return out;
         throw new Error('collectionName is not defined');
@@ -53,12 +67,10 @@ export class MongoService extends ServiceBase {
      *
      * @protected
      * @returns {string} The resource name.
-     * @throws {Error} If the collection name is not defined.
+     * @throws {Error} If the resource name is not defined.
      */
     getResourceName() {
-        const out = typeof this.$resourceName === 'function'
-            ? this.$resourceName(this)
-            : this.$resourceName || this.getCollectionName();
+        const out = typeof this.resourceName === 'function' ? this.resourceName(this) : this.resourceName || this.getCollectionName();
         if (out)
             return out;
         throw new Error('resourceName is not defined');
@@ -73,36 +85,6 @@ export class MongoService extends ServiceBase {
             this._dataType = this.context.document.node.getComplexType(this._dataType_);
         return this._dataType;
     }
-    /**
-     * Retrieves the codec for the specified operation.
-     *
-     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
-     */
-    getInputCodec(operation) {
-        let validator = this._inputCodecs[operation];
-        if (validator)
-            return validator;
-        const options = { projection: '*' };
-        if (operation === 'update')
-            options.partial = 'deep';
-        const dataType = this.dataType;
-        validator = dataType.generateCodec('decode', options);
-        this._inputCodecs[operation] = validator;
-        return validator;
-    }
-    /**
-     * Retrieves the codec.
-     */
-    getOutputCodec(operation) {
-        let validator = this._outputCodecs[operation];
-        if (validator)
-            return validator;
-        const options = { projection: '*', partial: 'deep' };
-        const dataType = this.dataType;
-        validator = dataType.generateCodec('decode', options);
-        this._outputCodecs[operation] = validator;
-        return validator;
-    }
     /**
      * Executes the provided function within a transaction.
      *
@@ -144,191 +126,6 @@ export class MongoService extends ServiceBase {
                 await session.endSession();
         }
     }
-    /**
-     * Gets the number of documents matching the filter.
-     *
-     * @param filter - The filter used to match documents.
-     * @param options - The options for counting documents.
-     * @protected
-     */
-    async _dbCountDocuments(filter, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            limit: undefined,
-            session: options?.session || this.getSession(),
-        };
-        return (await collection.countDocuments(filter || {}, options)) || 0;
-    }
-    /**
-     * Acquires a connection and performs Collection.deleteOne operation
-     *
-     * @param filter - The filter used to select the document to remove
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbDeleteOne(filter, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return await collection.deleteOne(filter || {}, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.deleteMany operation
-     *
-     * @param filter - The filter used to select the documents to remove
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbDeleteMany(filter, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return await collection.deleteMany(filter || {}, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.distinct operation
-     *
-     * @param field - Field of the document to find distinct values for
-     * @param filter - The filter for filtering the set of documents to which we apply the distinct filter.
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbDistinct(field, filter, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return await collection.distinct(field, filter || {}, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.aggregate operation
-     *
-     * @param pipeline - An array of aggregation pipelines to execute
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbAggregate(pipeline, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return await collection.aggregate(pipeline, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.findOne operation
-     *
-     * @param filter - Query for find Operation
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbFindOne(filter, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return (await collection.findOne(filter || {}, options));
-    }
-    /**
-     * Acquires a connection and performs Collection.find operation
-     *
-     * @param filter - The filter predicate. If unspecified,
-     * then all documents in the collection will match the predicate
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbFind(filter, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return collection.find(filter || {}, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.insertOne operation
-     *
-     * @param doc - The document to insert
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbInsertOne(doc, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return await collection.insertOne(doc, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.updateOne operation
-     *
-     * @param filter - The filter used to select the document to update
-     * @param update - The update operations to be applied to the document
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbUpdateOne(filter, update, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return collection.updateOne(filter || {}, update, options);
-    }
-    /**
-     * Acquires a connection and performs Collection.findOneAndUpdate operation
-     *
-     * @param filter - The filter used to select the document to update
-     * @param update - Update operations to be performed on the document
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbFindOneAndUpdate(filter, update, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        const opts = {
-            returnDocument: 'after',
-            includeResultMetadata: false,
-            ...options,
-            session: options?.session || this.getSession(),
-        };
-        return await collection.findOneAndUpdate(filter || {}, update, opts);
-    }
-    /**
-     * Acquires a connection and performs Collection.updateMany operation
-     *
-     * @param filter - The filter used to select the documents to update
-     * @param update - The update operations to be applied to the documents
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async _dbUpdateMany(filter, update, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession(),
-            upsert: false,
-        };
-        return await collection.updateMany(filter || {}, update, options);
-    }
     /**
      * Retrieves the database connection.
      *
@@ -367,8 +164,8 @@ export class MongoService extends ServiceBase {
      * @protected
      * @returns {MongoAdapter.AnyId} The generated ID.
      */
-    _generateId() {
-        return typeof this.$idGenerator === 'function' ? this.$idGenerator(this) : new ObjectId();
+    _generateId(command) {
+        return typeof this.idGenerator === 'function' ? this.idGenerator(command, this) : new ObjectId();
     }
     /**
      * Retrieves the common filter used for querying documents.
@@ -378,19 +175,62 @@ export class MongoService extends ServiceBase {
      * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
      * that resolves to the common filter, or undefined if not available.
      */
-    _getDocumentFilter(info) {
-        return typeof this.$documentFilter === 'function' ? this.$documentFilter(info, this) : this.$documentFilter;
-    }
-    async _intercept(callback, info) {
+    _getDocumentFilter(command) {
+        const commonFilter = Array.isArray(this.documentFilter) ? this.documentFilter : [this.documentFilter];
+        const mapped = commonFilter.map(f => (typeof f === 'function' ? f(command, this) : f));
+        return mapped.length > 1 ? MongoAdapter.prepareFilter(mapped) : mapped[0];
+    }
+    async _executeCommand(command, commandFn) {
+        let proto;
+        const next = async () => {
+            proto = proto ? Object.getPrototypeOf(proto) : this;
+            while (proto) {
+                if (proto.interceptor && Object.prototype.hasOwnProperty.call(proto, 'interceptor')) {
+                    return await proto.interceptor.call(this, next, command, this);
+                }
+                proto = Object.getPrototypeOf(proto);
+                if (!(proto instanceof MongoService))
+                    break;
+            }
+            return commandFn();
+        };
         try {
-            if (this.$interceptor)
-                return this.$interceptor(callback, info, this);
-            return callback();
+            return await next();
         }
         catch (e) {
-            Error.captureStackTrace(e, this._intercept);
-            await this.$onError?.(e, this);
+            Error.captureStackTrace(e, this._executeCommand);
+            await this.onError?.(e, this);
             throw e;
         }
     }
+    /**
+     * Retrieves the codec for the specified operation.
+     *
+     * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
+     */
+    _getInputCodec(operation) {
+        let validator = this._inputCodecs[operation];
+        if (validator)
+            return validator;
+        const options = { projection: '*' };
+        if (operation === 'update')
+            options.partial = 'deep';
+        const dataType = this.dataType;
+        validator = dataType.generateCodec('decode', options);
+        this._inputCodecs[operation] = validator;
+        return validator;
+    }
+    /**
+     * Retrieves the codec.
+     */
+    _getOutputCodec(operation) {
+        let validator = this._outputCodecs[operation];
+        if (validator)
+            return validator;
+        const options = { projection: '*', partial: 'deep' };
+        const dataType = this.dataType;
+        validator = dataType.generateCodec('decode', options);
+        this._outputCodecs[operation] = validator;
+        return validator;
+    }
 }

package/esm/mongo-singleton-service.js

@@ -1,4 +1,5 @@
 import { ResourceNotAvailableError } from '@opra/common';
+import omit from 'lodash.omit';
 import { ObjectId } from 'mongodb';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoEntityService } from './mongo-entity-service.js';
@@ -18,12 +19,12 @@ export class MongoSingletonService extends MongoEntityService {
      */
     constructor(dataType, options) {
         super(dataType, options);
-        this._id = this._id || options?._id || new ObjectId('655608925cad472b75fc6485');
+        this._id = options?._id || new ObjectId('655608925cad472b75fc6485');
     }
     /**
      * Asserts the existence of a resource based on the given options.
      *
-     * @param {MongoSingletonService.ExistsOptions<T>} [options]
+     * @param {MongoEntityService.ExistsOptions<T>} [options]
      * @returns {Promise<void>} A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} If the resource does not exist.
      */
@@ -31,127 +32,163 @@ export class MongoSingletonService extends MongoEntityService {
         if (!(await this.exists(options)))
             throw new ResourceNotAvailableError(this.getResourceName());
     }
+    async create(input, options) {
+        const command = {
+            crud: 'create',
+            method: 'create',
+            byId: false,
+            input,
+            options,
+        };
+        input._id = this._id;
+        return this._executeCommand(command, async () => {
+            const r = await this._create(command);
+            if (!command.options?.projection)
+                return r;
+            const findCommand = {
+                ...command,
+                crud: 'read',
+                byId: true,
+                documentId: r._id,
+                options: omit(options, 'filter'),
+            };
+            const out = await this._findById(findCommand);
+            if (out)
+                return out;
+        });
+    }
     /**
      * Creates the document in the database.
      *
-     * @param {PartialDTO<T>} input - The partial input to create the document with.
-     * @param {MongoSingletonService.CreateOptions} [options] - The options for creating the document.
-     * @return {Promise<PartialDTO<T>>} A promise that resolves to the partial output of the created document.
+     * @param {DTO<T>} input - The partial input to create the document with.
+     * @param {MongoEntityService.CreateOptions} [options] - The options for creating the document.
+     * @returns {Promise<MongoEntityService.CreateResult<T>>} A promise that resolves create operation result
      * @throws {Error} Throws an error if an unknown error occurs while creating the document.
      */
-    async create(input, options) {
-        input._id = this._id;
-        const info = {
+    async createOnly(input, options) {
+        const command = {
             crud: 'create',
-            method: 'create',
+            method: 'createOnly',
             byId: false,
-            documentId: this._id,
             input,
             options,
         };
-        return this._intercept(() => this._create(input, options), info);
+        input._id = this._id;
+        return this._executeCommand(command, () => this._create(command));
     }
     /**
      * Deletes a record from the database
      *
-     * @param {MongoSingletonService.DeleteOptions<T>} options - The options for deleting the record
+     * @param {MongoEntityService.DeleteOptions<T>} options - The options for deleting the record
      * @returns {Promise<number>} The number of records deleted
      */
     async delete(options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'delete',
             byId: true,
             documentId: this._id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._delete(this._id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._delete(command);
+        });
     }
     /**
      * Checks if the document exists in the database.
      *
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for finding the document.
      * @return {Promise<boolean>} - A promise that resolves to a boolean value indicating if the document exists.
      */
     async exists(options) {
-        return !!(await this.find({ ...options, projection: ['_id'], skip: undefined }));
+        const command = {
+            crud: 'read',
+            method: 'exists',
+            byId: true,
+            documentId: this._id,
+            options,
+        };
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const filter = MongoAdapter.prepareFilter([documentFilter, command.options?.filter]);
+            const findCommand = command;
+            findCommand.options = { ...command.options, filter, projection: ['_id'] };
+            return !!(await this._findById(findCommand));
+        });
     }
-    /**
-     * Fetches the document if it exists. Returns undefined if not found.
-     *
-     * @param {MongoSingletonService.FindOneOptions<T>} [options] - The options for finding the document.
-     * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
-     */
     async find(options) {
-        const info = {
+        const command = {
             crud: 'read',
-            method: 'findOne',
+            method: 'findById',
             byId: true,
             documentId: this._id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._findById(this._id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const documentFilter = await this._getDocumentFilter(command);
+            const filter = MongoAdapter.prepareFilter([documentFilter, command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._findById(command);
+        });
     }
-    /**
-     * Fetches the document from the Mongo collection service. Throws error if not found.
-     *
-     * @param {MongoSingletonService.FindOneOptions<T>} options - The options to customize the query.
-     * @return {Promise<PartialDTO<T>>} - A promise that resolves to the fetched document.
-     * @throws {ResourceNotAvailableError} - If the document is not found in the collection.
-     */
     async get(options) {
         const out = await this.find(options);
         if (!out)
             throw new ResourceNotAvailableError(this.getResourceName());
         return out;
     }
-    /**
-     * Updates a document in the MongoDB collection.
-     *
-     * @param {PatchDTO<T>} input - The partial input to update the document.
-     * @param {MongoSingletonService.UpdateOptions<T>} [options] - The update options.
-     *
-     * @return {Promise<number>} - A promise that resolves to the updated document or undefined if not found.
-     */
-    async updateOnly(input, options) {
-        const info = {
+    async update(input, options) {
+        const isUpdateFilter = Array.isArray(input) || !!Object.keys(input).find(x => x.startsWith('$'));
+        const command = {
             crud: 'update',
             method: 'update',
-            byId: true,
             documentId: this._id,
-            input,
+            byId: true,
+            input: isUpdateFilter ? undefined : input,
+            inputRaw: isUpdateFilter ? input : undefined,
             options,
         };
-        return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._updateOnly(this._id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            const matchCount = await this._updateOnly(command);
+            if (matchCount) {
+                const findCommand = {
+                    ...command,
+                    crud: 'read',
+                    byId: true,
+                    documentId: this._id,
+                    options: omit(options, ['filter', 'sort']),
+                };
+                const out = await this._findById(findCommand);
+                if (out)
+                    return out;
+            }
+        });
     }
     /**
      * Updates a document in the MongoDB collection.
      *
      * @param {PatchDTO<T>} input - The partial input to update the document.
-     * @param {MongoSingletonService.UpdateOptions<T>} [options] - The update options.
+     * @param {MongoEntityService.UpdateOneOptions<T>} [options] - The update options.
      *
-     * @return {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the updated document or undefined if not found.
+     * @return {Promise<number>} - A promise that resolves to the updated document or undefined if not found.
      */
-    async update(input, options) {
-        const info = {
+    async updateOnly(input, options) {
+        const command = {
             crud: 'update',
-            method: 'update',
-            byId: true,
+            method: 'updateOnly',
             documentId: this._id,
+            byId: true,
             input,
             options,
         };
-        return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
-            return this._update(this._id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._updateOnly(command);
+        });
     }
 }

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}