@opra/mongodb 0.33.13 → 1.0.0-alpha.10

package/esm/mongo-service.js

@@ -1,67 +1,107 @@
 import { DATATYPE_METADATA } from '@opra/common';
-import { ApiService } from '@opra/core';
+import { ServiceBase } from '@opra/core';
+import { ObjectId } from 'mongodb';
 /**
  * Class representing a MongoDB service for interacting with a collection.
- * @extends ApiService
+ * @extends ServiceBase
  * @template T - The type of the documents in the collection.
  */
-export class MongoService extends ApiService {
+export class MongoService extends ServiceBase {
     /**
      * Constructs a new instance
      *
-     * @param dataType - The data type of the array elements.
-     * @param [options] - The options for the array service.
+     * @param dataType - The data type of the returning results
+     * @param [options] - The options for the service
      * @constructor
      */
     constructor(dataType, options) {
         super();
-        this._encoders = {};
-        this._dataType = dataType;
+        this._inputCodecs = {};
+        this._outputCodecs = {};
+        this._dataType_ = dataType;
         this.db = options?.db;
-        this.collectionName = options?.collectionName;
-        if (!this.collectionName) {
+        this.$documentFilter = this.$documentFilter || options?.documentFilter;
+        this.$interceptor = this.$interceptor || options?.interceptor;
+        this.$collectionName = options?.collectionName;
+        if (!this.$collectionName) {
             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.$resourceName = options?.resourceName;
         this.$idGenerator = options?.idGenerator;
     }
     /**
-     * Retrieves the data type of the document
+     * Retrieves the collection name.
+     *
+     * @protected
+     * @returns The collection name.
+     * @throws {Error} If the collection name is not defined.
+     */
+    getCollectionName() {
+        const out = typeof this.$collectionName === 'function' ? this.$collectionName(this) : this.$collectionName;
+        if (out)
+            return out;
+        throw new Error('collectionName is not defined');
+    }
+    /**
+     * Retrieves the resource name.
+     *
+     * @protected
+     * @returns {string} The resource name.
+     * @throws {Error} If the resource name is not defined.
+     */
+    getResourceName() {
+        const out = typeof this.$resourceName === 'function'
+            ? this.$resourceName(this)
+            : this.$resourceName || this.getCollectionName();
+        if (out)
+            return out;
+        throw new Error('resourceName is not defined');
+    }
+    /**
+     * Retrieves the OPRA data type
      *
      * @throws {NotAcceptableError} If the data type is not a ComplexType.
      */
-    getDataType() {
-        return this.context.api.getComplexType(this._dataType);
+    get dataType() {
+        if (!this._dataType)
+            this._dataType = this.context.document.node.getComplexType(this._dataType_);
+        return this._dataType;
     }
     /**
-     * Retrieves the encoder for the specified operation.
+     * Retrieves the codec for the specified operation.
      *
      * @param operation - The operation to retrieve the encoder for. Valid values are 'create' and 'update'.
      */
-    getEncoder(operation) {
-        let encoder = this._encoders[operation];
-        if (encoder)
-            return encoder;
-        encoder = this._generateEncoder(operation);
-        this._encoders[operation] = encoder;
-        return encoder;
+    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 decoder.
+     * Retrieves the codec.
      */
-    getDecoder() {
-        let decoder = this._decoder;
-        if (decoder)
-            return decoder;
-        decoder = this._generateDecoder();
-        this._decoder = decoder;
-        return decoder;
+    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.
@@ -74,7 +114,7 @@ export class MongoService extends ApiService {
         if (session)
             return callback(session);
         // Backup old session property
-        const hasOldSession = this.hasOwnProperty('session');
+        const hasOldSession = Object.prototype.hasOwnProperty.call(this, 'session');
         const oldSessionGetter = hasOldSession ? this.session : undefined;
         const db = this.getDatabase();
         const client = db.client;
@@ -104,30 +144,6 @@ export class MongoService extends ApiService {
                 await session.endSession();
         }
     }
-    /**
-     * 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 - The document to insert
-     * @param options - Optional settings for the command
-     * @protected
-     */
-    async __insertOne(doc, options) {
-        const db = this.getDatabase();
-        const collection = await this.getCollection(db);
-        options = {
-            ...options,
-            session: options?.session || this.getSession()
-        };
-        try {
-            return await collection.insertOne(doc, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
-    }
     /**
      * Gets the number of documents matching the filter.
      *
@@ -135,188 +151,156 @@ export class MongoService extends ApiService {
      * @param options - The options for counting documents.
      * @protected
      */
-    async __countDocuments(filter, options) {
+    async _dbCountDocuments(filter, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
             limit: undefined,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.countDocuments(filter || {}, options) || 0;
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return (await collection.countDocuments(filter || {}, options)) || 0;
     }
     /**
-     * Delete a document from a collection
+     * 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 __deleteOne(filter, options) {
+    async _dbDeleteOne(filter, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.deleteOne(filter || {}, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return await collection.deleteOne(filter || {}, options);
     }
     /**
-     * Delete multiple documents from a collection
+     * 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 __deleteMany(filter, options) {
+    async _dbDeleteMany(filter, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.deleteMany(filter || {}, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return await collection.deleteMany(filter || {}, options);
     }
     /**
-     * Gets the number of documents matching the filter.
+     * 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 __distinct(field, filter, options) {
+    async _dbDistinct(field, filter, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.distinct(field, filter || {}, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return await collection.distinct(field, filter || {}, options);
     }
     /**
-     * Execute an aggregation framework pipeline against the collection, needs MongoDB \>= 2.2
+     * 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 __aggregate(pipeline, options) {
+    async _dbAggregate(pipeline, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.aggregate(pipeline, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return await collection.aggregate(pipeline, options);
     }
     /**
-     * Fetches the first document that matches the filter
+     * Acquires a connection and performs Collection.findOne operation
      *
      * @param filter - Query for find Operation
      * @param options - Optional settings for the command
      * @protected
      */
-    async __findOne(filter, options) {
+    async _dbFindOne(filter, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.findOne(filter || {}, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return (await collection.findOne(filter || {}, options));
     }
     /**
-     * Creates a cursor for a filter that can be used to iterate over results from MongoDB
+     * 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 __find(filter, options) {
+    async _dbFind(filter, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
-            session: options?.session || this.getSession()
+            session: options?.session || this.getSession(),
         };
-        try {
-            return collection.find(filter || {}, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        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);
     }
     /**
-     * Update a single document in a collection
+     * 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 __updateOne(filter, update, options) {
+    async _dbUpdateOne(filter, update, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.getSession(),
         };
-        try {
-            return collection.updateOne(filter || {}, update, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return collection.updateOne(filter || {}, update, options);
     }
     /**
-     * Find a document and update it in one atomic operation. Requires a write lock for the duration of the operation.
+     * 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 __findOneAndUpdate(filter, update, options) {
+    async _dbFindOneAndUpdate(filter, update, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         const opts = {
@@ -325,37 +309,25 @@ export class MongoService extends ApiService {
             ...options,
             session: options?.session || this.getSession(),
         };
-        try {
-            return await collection.findOneAndUpdate(filter || {}, update, opts);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return await collection.findOneAndUpdate(filter || {}, update, opts);
     }
     /**
-     * Update multiple documents in a collection
+     * 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 __updateMany(filter, update, options) {
+    async _dbUpdateMany(filter, update, options) {
         const db = this.getDatabase();
         const collection = await this.getCollection(db);
         options = {
             ...options,
             session: options?.session || this.getSession(),
-            upsert: false
+            upsert: false,
         };
-        try {
-            return await collection.updateMany(filter || {}, update, options);
-        }
-        catch (e) {
-            await this.$onError?.(e, this);
-            throw e;
-        }
+        return await collection.updateMany(filter || {}, update, options);
     }
     /**
      * Retrieves the database connection.
@@ -365,9 +337,7 @@ export class MongoService extends ApiService {
      * @throws {Error} If the context or database is not set.
      */
     getDatabase() {
-        const db = typeof this.db === 'function'
-            ? this.db(this)
-            : this.db;
+        const db = typeof this.db === 'function' ? this.db(this) : this.db;
         if (!db)
             throw new Error(`Database not set!`);
         return db;
@@ -380,9 +350,7 @@ export class MongoService extends ApiService {
      * @throws {Error} If the context or database is not set.
      */
     getSession() {
-        return typeof this.session === 'function'
-            ? this.session(this)
-            : this.session;
+        return typeof this.session === 'function' ? this.session(this) : this.session;
     }
     /**
      * Retrieves a MongoDB collection from the given database.
@@ -394,59 +362,35 @@ export class MongoService extends ApiService {
         return db.collection(this.getCollectionName());
     }
     /**
-     * Retrieves the collection name.
+     * Generates an ID.
      *
      * @protected
-     * @returns The collection name.
-     * @throws {Error} If the collection name is not defined.
+     * @returns {MongoAdapter.AnyId} The generated ID.
      */
-    getCollectionName() {
-        const out = typeof this.collectionName === 'function'
-            ? this.collectionName(this)
-            : this.collectionName;
-        if (out)
-            return out;
-        throw new Error('collectionName is not defined');
+    _generateId() {
+        return typeof this.$idGenerator === 'function' ? this.$idGenerator(this) : new ObjectId();
     }
     /**
-     * Retrieves the resource name.
+     * Retrieves the common filter used for querying documents.
+     * This method is mostly used for security issues like securing multi-tenant applications.
      *
      * @protected
-     * @returns {string} The resource name.
-     * @throws {Error} If the collection name is not defined.
+     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
+     * that resolves to the common filter, or undefined if not available.
      */
-    getResourceName() {
-        const out = typeof this.resourceName === 'function'
-            ? this.resourceName(this)
-            : this.resourceName || this.getCollectionName();
-        if (out)
-            return out;
-        throw new Error('resourceName is not defined');
+    _getDocumentFilter(info) {
+        return typeof this.$documentFilter === 'function' ? this.$documentFilter(info, this) : this.$documentFilter;
     }
-    /**
-     * Generates an encoder for the specified operation.
-     *
-     * @param operation - The operation to generate the encoder for. Must be either 'create' or 'update'.
-     * @protected
-     * @returns - The generated encoder for the specified operation.
-     */
-    _generateEncoder(operation) {
-        const dataType = this.getDataType();
-        const options = {};
-        if (operation === 'update') {
-            options.omit = ['_id'];
-            options.partial = true;
+    async _intercept(callback, info) {
+        try {
+            if (this.$interceptor)
+                return this.$interceptor(callback, info, this);
+            return callback();
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this._intercept);
+            await this.$onError?.(e, this);
+            throw e;
         }
-        return dataType.generateCodec('encode', options);
-    }
-    /**
-     * Generates an encoder for the specified operation.
-     *
-     * @protected
-     * @returns - The generated encoder for the specified operation.
-     */
-    _generateDecoder() {
-        const dataType = this.getDataType();
-        return dataType.generateCodec('decode', { partial: true });
     }
 }