@opra/mongodb 1.0.0-alpha.17 → 1.0.0-alpha.19

package/esm/mongo-service.js

@@ -20,20 +20,20 @@ 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;
+        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.$idGenerator = options?.idGenerator;
+        this.resourceName = options?.resourceName;
+        this.idGenerator = options?.idGenerator;
     }
     /**
      * Retrieves the collection name.
@@ -43,7 +43,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');
@@ -56,9 +56,7 @@ export class MongoService extends ServiceBase {
      * @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');
@@ -367,8 +365,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,18 +376,29 @@ 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;
+    _getDocumentFilter(command) {
+        return typeof this.documentFilter === 'function' ? this.documentFilter(command, this) : this.documentFilter;
     }
-    async _intercept(callback, info) {
+    async _executeCommand(command, commandFn) {
+        let proto;
+        const next = async () => {
+            proto = proto ? Object.getPrototypeOf(proto) : this;
+            while (proto) {
+                if (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;
         }
     }

package/esm/mongo-singleton-service.js

@@ -23,7 +23,7 @@ export class MongoSingletonService extends MongoEntityService {
     /**
      * 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.
      */
@@ -35,72 +35,88 @@ export class MongoSingletonService extends MongoEntityService {
      * 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.
+     * @param {MongoEntityService.CreateOptions} [options] - The options for creating the document.
      * @return {Promise<PartialDTO<T>>} A promise that resolves to the partial output of the created document.
      * @throws {Error} Throws an error if an unknown error occurs while creating the document.
      */
     async create(input, options) {
-        input._id = this._id;
-        const info = {
+        const command = {
             crud: 'create',
             method: 'create',
             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.
+     * @param {MongoEntityService.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.
+     * @param {MongoEntityService.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.
      */
@@ -114,44 +130,48 @@ export class MongoSingletonService extends MongoEntityService {
      * 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<number>} - A promise that resolves to the updated document or undefined if not found.
+     * @return {Promise<PartialDTO<T> | undefined>} - 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 };
+            return this._update(command);
+        });
     }
     /**
      * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/mongodb",
-  "version": "1.0.0-alpha.17",
+  "version": "1.0.0-alpha.19",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -28,7 +28,8 @@
   },
   "dependencies": {
     "lodash.omit": "^4.5.0",
-    "putil-isplainobject": "^1.1.5"
+    "putil-isplainobject": "^1.1.5",
+    "valgen": "^5.6.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
@@ -36,8 +37,8 @@
     "ts-gems": "^3.4.0"
   },
   "peerDependencies": {
-    "@opra/common": "^1.0.0-alpha.17",
-    "@opra/core": "^1.0.0-alpha.17",
+    "@opra/common": "^1.0.0-alpha.19",
+    "@opra/core": "^1.0.0-alpha.19",
     "mongodb": ">= 6.0.0"
   },
   "type": "module",

package/types/mongo-collection-service.d.ts

@@ -2,7 +2,6 @@ import mongodb, { UpdateFilter } from 'mongodb';
 import { PartialDTO, PatchDTO, Type } from 'ts-gems';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoEntityService } from './mongo-entity-service.js';
-import { MongoService } from './mongo-service.js';
 /**
  *
  * @namespace MongoCollectionService
@@ -17,28 +16,6 @@ export declare namespace MongoCollectionService {
     interface Options extends MongoEntityService.Options {
         defaultLimit?: number;
     }
-    interface CreateOptions extends MongoEntityService.CreateOptions {
-    }
-    interface CountOptions<T> extends MongoEntityService.CountOptions<T> {
-    }
-    interface DeleteOptions<T> extends MongoEntityService.DeleteOptions<T> {
-    }
-    interface DeleteManyOptions<T> extends MongoEntityService.DeleteManyOptions<T> {
-    }
-    interface DistinctOptions<T> extends MongoEntityService.DistinctOptions<T> {
-    }
-    interface ExistsOptions<T> extends MongoService.ExistsOptions<T> {
-    }
-    interface ExistsOneOptions<T> extends MongoService.ExistsOneOptions<T> {
-    }
-    interface FindOneOptions<T> extends MongoEntityService.FindOneOptions<T> {
-    }
-    interface FindManyOptions<T> extends MongoEntityService.FindManyOptions<T> {
-    }
-    interface UpdateOptions<T> extends MongoEntityService.UpdateOptions<T> {
-    }
-    interface UpdateManyOptions<T> extends MongoEntityService.UpdateManyOptions<T> {
-    }
 }
 /**
  * @class MongoCollectionService
@@ -64,95 +41,95 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
      * Throws a ResourceNotFoundError if the resource does not exist.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the resource to assert.
-     * @param {MongoCollectionService.ExistsOptions<T>} [options] - Optional options for checking the existence.
+     * @param {MongoEntityService.ExistsOptions<T>} [options] - Optional options for checking the existence.
      * @returns {Promise<void>} - A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} - If the resource does not exist.
      */
-    assert(id: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOptions<T>): Promise<void>;
+    assert(id: MongoAdapter.AnyId, options?: MongoEntityService.ExistsOptions<T>): Promise<void>;
     /**
      * Creates a new document in the MongoDB collection.
      * Interceptors will be called before performing db operation
      *
      * @param {PartialDTO<T>} input - The input data for creating the document.
-     * @param {MongoCollectionService.CreateOptions} [options] - The options for creating the document.
+     * @param {MongoEntityService.CreateOptions} [options] - The options for creating the document.
      * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created document.
      * @throws {Error} if an unknown error occurs while creating the document.
      */
-    create(input: PartialDTO<T>, options?: MongoCollectionService.CreateOptions): Promise<PartialDTO<T>>;
+    create(input: PartialDTO<T>, options?: MongoEntityService.CreateOptions): Promise<PartialDTO<T>>;
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
-     * @param {MongoCollectionService.CountOptions<T>} options - The options for the count operation.
+     * @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.
      */
-    count(options?: MongoCollectionService.CountOptions<T>): Promise<number>;
+    count(options?: MongoEntityService.CountOptions<T>): Promise<number>;
     /**
      * Deletes a document from the collection.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
-     * @param {MongoCollectionService.DeleteOptions<T>} [options] - Optional delete options.
+     * @param {MongoEntityService.DeleteOptions<T>} [options] - Optional delete options.
      * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
      */
-    delete(id: MongoAdapter.AnyId, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
+    delete(id: MongoAdapter.AnyId, options?: MongoEntityService.DeleteOptions<T>): Promise<number>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {MongoCollectionService.DeleteManyOptions<T>} options - The options for the delete operation.
+     * @param {MongoEntityService.DeleteManyOptions<T>} options - The options for the delete operation.
      * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
      */
-    deleteMany(options?: MongoCollectionService.DeleteManyOptions<T>): Promise<number>;
+    deleteMany(options?: MongoEntityService.DeleteManyOptions<T>): Promise<number>;
     /**
      * The distinct command returns a list of distinct values for the given key across a collection.
      * @param {string} field
-     * @param {MongoCollectionService.DistinctOptions<T>} [options]
+     * @param {MongoEntityService.DistinctOptions<T>} [options]
      * @protected
      */
-    distinct(field: string, options?: MongoCollectionService.DistinctOptions<T>): Promise<any[]>;
+    distinct(field: string, options?: MongoEntityService.DistinctOptions<T>): Promise<any[]>;
     /**
      * Checks if an object with the given id exists.
      *
      * @param {MongoAdapter.AnyId} id - The id of the object to check.
-     * @param {MongoCollectionService.ExistsOptions<T>} [options] - The options for the query (optional).
+     * @param {MongoEntityService.ExistsOptions<T>} [options] - The options for the query (optional).
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
      */
-    exists(id: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOptions<T>): Promise<boolean>;
+    exists(id: MongoAdapter.AnyId, options?: MongoEntityService.ExistsOptions<T>): Promise<boolean>;
     /**
      * Checks if an object with the given arguments exists.
      *
-     * @param {MongoCollectionService.ExistsOneOptions} [options] - The options for the query (optional).
+     * @param {MongoEntityService.ExistsOneOptions} [options] - The options for the query (optional).
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the object exists or not.
      */
-    existsOne(options?: MongoCollectionService.ExistsOneOptions<T>): Promise<boolean>;
+    existsOne(options?: MongoEntityService.ExistsOptions<T>): Promise<boolean>;
     /**
      * Finds a document by its ID.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document.
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the find query.
+     * @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.
      */
-    findById(id: MongoAdapter.AnyId, options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    findById(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds a document in the collection that matches the specified options.
      *
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - The options for the query.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - The options for the query.
      * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
      */
-    findOne(options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    findOne(options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds multiple documents in the MongoDB collection.
      *
-     * @param {MongoCollectionService.FindManyOptions<T>} options - The options for the find operation.
+     * @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.
      */
-    findMany(options?: MongoCollectionService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
+    findMany(options?: MongoEntityService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
     /**
      * Finds multiple documents in the collection and returns both records (max limit)
      * and total count that matched the given criteria
      *
-     * @param {MongoCollectionService.FindManyOptions<T>} [options] - The options for the find operation.
+     * @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.
      */
-    findManyWithCount(options?: MongoCollectionService.FindManyOptions<T>): Promise<{
+    findManyWithCount(options?: MongoEntityService.FindManyOptions<T>): Promise<{
         count: number;
         items: PartialDTO<T>[];
     }>;
@@ -160,44 +137,37 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
      * @param {MongoAdapter.AnyId} id - The ID of the document to retrieve.
-     * @param {MongoCollectionService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
+     * @param {MongoEntityService.FindOneOptions<T>} [options] - Optional options for the findOne operation.
      * @returns {Promise<PartialDTO<T>>} - A promise that resolves to the retrieved document,
      *    or rejects with a ResourceNotFoundError if the document does not exist.
      * @throws {ResourceNotAvailableError} - If the document with the specified ID does not exist.
      */
-    get(id: MongoAdapter.AnyId, options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T>>;
+    get(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T>>;
     /**
      * Updates a document with the given id in the collection.
      *
      * @param {MongoAdapter.AnyId} id - The id of the document to update.
      * @param {PatchDTO<T>|UpdateFilter<T>} input - The partial input object containing the fields to update.
-     * @param {MongoCollectionService.UpdateOptions<T>} [options] - The options for the update operation.
+     * @param {MongoEntityService.UpdateOneOptions<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.
      */
-    update(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
+    update(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoEntityService.UpdateOneOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * 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 {MongoCollectionService.UpdateOptions<T>} [options] - The options for updating the document.
+     * @param {MongoEntityService.UpdateOneOptions<T>} [options] - The options for updating the document.
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
-    updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<number>;
+    updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoEntityService.UpdateOneOptions<T>): Promise<number>;
     /**
      * 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 {MongoCollectionService.UpdateManyOptions<T>} options - The options for updating the documents.
+     * @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.
      */
-    updateMany(input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
-    /**
-     * Generates an ID.
-     *
-     * @protected
-     * @returns {MongoAdapter.AnyId} The generated ID.
-     */
-    protected _generateId(): MongoAdapter.AnyId;
+    updateMany(input: PatchDTO<T> | UpdateFilter<T>, options?: MongoEntityService.UpdateManyOptions<T>): Promise<number>;
 }