@opra/mongodb 0.33.13 → 1.0.0-alpha.2

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

@@ -1,62 +1,56 @@
-import mongodb from 'mongodb';
-import { StrictOmit, Type } from 'ts-gems';
-import { PartialDTO, PatchDTO } from '@opra/common';
-import * as OpraCommon from '@opra/common';
-import { FilterInput } from './adapter-utils/prepare-filter.js';
+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';
-import { AnyId } from './types.js';
 /**
- * @class MongoCollectionService
- * @template T - The type of the documents in the collection.
+ *
+ * @namespace MongoCollectionService
  */
-export declare class MongoCollectionService<T extends mongodb.Document> extends MongoService<T> {
+export declare namespace MongoCollectionService {
     /**
-     * Represents the key for a collection.
+     * The constructor options of MongoCollectionService.
      *
-     * @type {string}
+     * @interface Options
+     * @extends MongoService.Options
      */
-    collectionKey: string;
+    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
+ * @template T - The type of the documents in the collection.
+ */
+export declare class MongoCollectionService<T extends mongodb.Document> extends MongoEntityService<T> {
     /**
      * Represents the default limit value for a certain operation.
      *
      * @type {number}
      */
     defaultLimit: number;
-    /**
-     * Represents a common filter function for a MongoCollectionService.
-     *
-     * @type {FilterInput | Function}
-     */
-    $documentFilter?: FilterInput | ((args: {
-        crud: MongoService.CrudOp;
-        method: string;
-        byId: boolean;
-        documentId?: AnyId;
-        input?: Record<string, any>;
-        options?: Record<string, any>;
-    }, _this: this) => FilterInput | Promise<FilterInput> | undefined);
-    /**
-     * Interceptor function for handling callback execution with provided arguments.
-     *
-     * @param callback - The callback function to be intercepted.
-     * @param args - The arguments object containing the following properties:
-     *   @param crud - The CRUD operation type.
-     *   @param method - The method name.
-     *   @param byId - True if current operation affects byId records (updateMany, deleteMany etc)
-     *   @param documentId - The document ID (optional).
-     *   @param input - The input object (optional).
-     *   @param options - Additional options (optional).
-     * @param _this - The reference to the current object.
-     * @returns - The promise that resolves to the result of the callback execution.
-     */
-    $interceptor?: (callback: () => any, args: {
-        crud: MongoService.CrudOp;
-        method: string;
-        byId: boolean;
-        documentId?: AnyId;
-        input?: Record<string, any>;
-        options?: Record<string, any>;
-    }, _this: any) => Promise<any>;
     /**
      * Constructs a new instance
      *
@@ -69,22 +63,22 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
      * Asserts the existence of a resource with the given ID.
      * Throws a ResourceNotFoundError if the resource does not exist.
      *
-     * @param {AnyId} id - The ID of the resource to assert.
-     * @param {MongoCollectionService.ExistsOptions} [options] - Optional options for checking the existence.
+     * @param {MongoAdapter.AnyId} id - The ID of the resource to assert.
+     * @param {MongoCollectionService.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: AnyId, options?: MongoCollectionService.ExistsOptions): Promise<void>;
+    assert(id: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOptions<T>): Promise<void>;
     /**
      * Creates a new document in the MongoDB collection.
+     * Interceptors will be called before performing db operation
      *
-     * @param {DTO<T>} input - The input data for creating the document.
+     * @param {PartialDTO<T>} input - The input data for creating the document.
      * @param {MongoCollectionService.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>>;
-    protected _create(input: PartialDTO<T>, options?: MongoCollectionService.CreateOptions): Promise<PartialDTO<T>>;
     /**
      * Returns the count of documents in the collection based on the provided options.
      *
@@ -92,16 +86,14 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
      * @return {Promise<number>} - A promise that resolves to the count of documents in the collection.
      */
     count(options?: MongoCollectionService.CountOptions<T>): Promise<number>;
-    protected _count(options?: MongoCollectionService.CountOptions<T>): Promise<number>;
     /**
      * Deletes a document from the collection.
      *
-     * @param {AnyId} id - The ID of the document to delete.
+     * @param {MongoAdapter.AnyId} id - The ID of the document to delete.
      * @param {MongoCollectionService.DeleteOptions<T>} [options] - Optional delete options.
      * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
      */
-    delete(id: AnyId, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
-    protected _delete(id: AnyId, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
+    delete(id: MongoAdapter.AnyId, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
@@ -109,17 +101,21 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
      * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
      */
     deleteMany(options?: MongoCollectionService.DeleteManyOptions<T>): Promise<number>;
-    protected _deleteMany(options?: MongoCollectionService.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]
+     * @protected
+     */
     distinct(field: string, options?: MongoCollectionService.DistinctOptions<T>): Promise<any[]>;
-    protected _distinct(field: string, options?: MongoCollectionService.DistinctOptions<T>): Promise<any[]>;
     /**
      * Checks if an object with the given id exists.
      *
-     * @param {AnyId} id - The id of the object to check.
-     * @param {MongoCollectionService.ExistsOptions} [options] - The options for the query (optional).
+     * @param {MongoAdapter.AnyId} id - The id of the object to check.
+     * @param {MongoCollectionService.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: AnyId, options?: MongoCollectionService.ExistsOptions): Promise<boolean>;
+    exists(id: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOptions<T>): Promise<boolean>;
     /**
      * Checks if an object with the given arguments exists.
      *
@@ -130,237 +126,78 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
     /**
      * Finds a document by its ID.
      *
-     * @param {AnyId} id - The ID of the document.
-     * @param {MongoCollectionService.FindOneOptions} [options] - The options for the find query.
+     * @param {MongoAdapter.AnyId} id - The ID of the document.
+     * @param {MongoCollectionService.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: AnyId, options?: MongoCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
-    protected _findById(id: AnyId, options?: MongoCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    findById(id: MongoAdapter.AnyId, options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds a document in the collection that matches the specified options.
      *
-     * @param {MongoCollectionService.FindOneOptions} options - The options for the query.
+     * @param {MongoCollectionService.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): Promise<PartialDTO<T> | undefined>;
-    protected _findOne(options?: MongoCollectionService.FindOneOptions): Promise<PartialDTO<T> | undefined>;
+    findOne(options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds multiple documents in the MongoDB collection.
      *
-     * @param options - The options for the find operation.
-     *  - pick: string[] - An array of fields to include in the returned documents.
-     *  - include: string[] - An array of fields to include in the returned documents.
-     *  - omit: string[] - An array of fields to exclude from the returned documents.
-     *  - sort: Record<string, number> - The sorting criteria.
-     *  - skip: number - The number of documents to skip.
-     *  - limit: number - The maximum number of documents to return.
-     *  - filter: FilterQuery<T> - The filter conditions to apply to the find operation.
-     *  - count: boolean - If set to true, returns the total count of matching documents.
-     *
+     * @param {MongoCollectionService.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>[]>;
-    protected _findMany(options?: MongoCollectionService.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.
+     * @return A Promise that resolves to an array of partial outputs of type T.
+     */
+    findManyWithCount(options?: MongoCollectionService.FindManyOptions<T>): Promise<{
+        count: number;
+        items: PartialDTO<T>[];
+    }>;
     /**
      * Retrieves a document from the collection by its ID. Throws error if not found.
      *
-     * @param {*} id - The ID of the document to retrieve.
-     * @param {MongoCollectionService.FindOneOptions} [options] - Optional options for the findOne operation.
+     * @param {MongoAdapter.AnyId} id - The ID of the document to retrieve.
+     * @param {MongoCollectionService.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: AnyId, options?: MongoCollectionService.FindOneOptions): Promise<PartialDTO<T>>;
+    get(id: MongoAdapter.AnyId, options?: MongoCollectionService.FindOneOptions<T>): Promise<PartialDTO<T>>;
     /**
      * Updates a document with the given id in the collection.
      *
-     * @param {any} id - The id of the document to update.
-     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
+     * @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.
      * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
      * undefined if the document was not found.
      */
-    update(id: AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
-    protected _update(id: AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
+    update(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Updates a document in the collection with the specified ID.
      *
-     * @param {any} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {MongoCollectionService.UpdateOptions<T>} options - The options for updating the document.
+     * @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.
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
-    updateOnly(id: AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<number>;
-    protected _updateOnly(id: AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<number>;
+    updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<number>;
     /**
      * Updates multiple documents in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
+     * @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.
      * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
      */
-    updateMany(input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
-    protected _updateMany(input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
+    updateMany(input: PatchDTO<T> | UpdateFilter<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
     /**
      * Generates an ID.
      *
      * @protected
-     * @returns {AnyId} The generated ID.
+     * @returns {MongoAdapter.AnyId} The generated ID.
      */
-    protected _generateId(): AnyId;
-    /**
-     * Retrieves the common filter used for querying documents.
-     * This method is mostly used for security issues like securing multi-tenant applications.
-     *
-     * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
-     */
-    protected _getDocumentFilter(args: {
-        crud: MongoService.CrudOp;
-        method: string;
-        byId: boolean;
-        documentId?: AnyId;
-        input?: Object;
-        options?: Record<string, any>;
-    }): FilterInput | Promise<FilterInput> | undefined;
-    protected _intercept(callback: (...args: any[]) => any, args: {
-        crud: MongoService.CrudOp;
-        method: string;
-        byId: boolean;
-        documentId?: AnyId;
-        input?: Object;
-        options?: Record<string, any>;
-    }): Promise<any>;
-}
-/**
- *
- * @namespace MongoCollectionService
- */
-export declare namespace MongoCollectionService {
-    /**
-     * The constructor options of MongoCollectionService.
-     *
-     * @interface Options
-     * @extends MongoService.Options
-     */
-    interface Options extends MongoService.Options {
-        collectionKey?: MongoCollectionService<any>['collectionKey'];
-        defaultLimit?: MongoCollectionService<any>['defaultLimit'];
-        documentFilter?: MongoCollectionService<any>['$documentFilter'];
-        interceptor?: MongoCollectionService<any>['$interceptor'];
-    }
-    /**
-     * Represents options for "create" operation
-     *
-     * @interface
-     */
-    interface CreateOptions extends mongodb.InsertOneOptions {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    }
-    /**
-     * Represents options for "count" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface CountOptions<T> extends mongodb.CountOptions {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    /**
-     * Represents options for "delete" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface DeleteOptions<T> extends mongodb.DeleteOptions {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    /**
-     * Represents options for "deleteMany" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface DeleteManyOptions<T> extends mongodb.DeleteOptions {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    /**
-     * Represents options for "distinct" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface DistinctOptions<T> extends mongodb.DistinctOptions {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    /**
-     * Represents options for "findOne" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface FindOneOptions<T = any> extends StrictOmit<FindManyOptions<T>, 'count' | 'limit'> {
-    }
-    /**
-     * Represents options for "findMany" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface FindManyOptions<T> extends mongodb.AggregateOptions {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        sort?: string[];
-        limit?: number;
-        skip?: number;
-        count?: boolean;
-    }
-    /**
-     * Represents options for "update" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface UpdateOptions<T> extends StrictOmit<mongodb.FindOneAndUpdateOptions, 'projection' | 'returnDocument' | 'includeResultMetadata'> {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    /**
-     * Represents options for "updateMany" operation
-     *
-     * @interface
-     * @template T - The type of the document.
-     */
-    interface UpdateManyOptions<T> extends StrictOmit<mongodb.UpdateOptions, 'upsert'> {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    /**
-     * Represents options for "exists" operation
-     *
-     * @interface
-     */
-    interface ExistsOptions extends Omit<mongodb.CommandOperationOptions, 'writeConcern'> {
-    }
-    /**
-     * Represents options for checking the document exists
-     *
-     * @interface
-     */
-    interface ExistsOneOptions<T> extends Omit<mongodb.CommandOperationOptions, 'writeConcern'> {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-    }
-    interface OperationInfo {
-        crud: MongoService.CrudOp;
-        method: string;
-        documentId?: AnyId;
-        input?: Record<string, any>;
-        options?: Record<string, any>;
-    }
+    protected _generateId(): MongoAdapter.AnyId;
 }

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

@@ -0,0 +1,149 @@
+import mongodb from 'mongodb';
+import { PartialDTO, PatchDTO, Type } from 'ts-gems';
+import { MongoAdapter } from './mongo-adapter.js';
+import { MongoService } from './mongo-service.js';
+/**
+ *
+ * @namespace MongoEntityService
+ */
+export declare namespace MongoEntityService {
+    /**
+     * The constructor options of MongoEntityService.
+     *
+     * @interface Options
+     * @extends MongoService.Options
+     */
+    interface Options extends MongoService.Options {
+    }
+    interface CommandInfo extends MongoService.CommandInfo {
+    }
+    interface CreateOptions extends MongoService.CreateOptions {
+    }
+    interface CountOptions<T> extends MongoService.CountOptions<T> {
+    }
+    interface DeleteOptions<T> extends MongoService.DeleteOptions<T> {
+    }
+    interface DeleteManyOptions<T> extends MongoService.DeleteManyOptions<T> {
+    }
+    interface DistinctOptions<T> extends MongoService.DistinctOptions<T> {
+    }
+    interface FindOneOptions<T> extends MongoService.FindOneOptions<T> {
+    }
+    interface FindManyOptions<T> extends MongoService.FindManyOptions<T> {
+    }
+    interface UpdateOptions<T> extends MongoService.UpdateOptions<T> {
+    }
+    interface UpdateManyOptions<T> extends MongoService.UpdateManyOptions<T> {
+    }
+}
+/**
+ * @class MongoEntityService
+ * @template T - The type of the documents in the collection.
+ */
+export declare class MongoEntityService<T extends mongodb.Document> extends MongoService<T> {
+    /**
+     * Constructs a new instance
+     *
+     * @param {Type | string} dataType - The data type of the array elements.
+     * @param {MongoEntityService.Options} [options] - The options for the array service.
+     * @constructor
+     */
+    constructor(dataType: Type | string, options?: MongoEntityService.Options);
+    /**
+     * Creates a new document in the MongoDB collection.
+     *
+     * @param {PartialDTO<T>} input
+     * @param {MongoEntityService.CreateOptions} options
+     * @protected
+     */
+    protected _create(input: PartialDTO<T>, options?: MongoEntityService.CreateOptions): Promise<PartialDTO<T>>;
+    /**
+     * 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.
+     */
+    protected _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 {MongoEntityService.DeleteOptions<T>} [options] - Optional delete options.
+     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     */
+    protected _delete(id: MongoAdapter.AnyId, options?: MongoEntityService.DeleteOptions<T>): Promise<number>;
+    /**
+     * 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.
+     */
+    protected _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 {MongoEntityService.DistinctOptions<T>} options
+     * @protected
+     */
+    protected _distinct(field: string, options?: MongoEntityService.DistinctOptions<T>): Promise<any[]>;
+    /**
+     * 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.
+     */
+    protected _findById(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    /**
+     * 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.
+     */
+    protected _findOne(options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    /**
+     * 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.
+     */
+    protected _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 {MongoEntityService.FindManyOptions<T>} [options] - The options for the find operation.
+     * @return A Promise that resolves to an array of partial outputs of type T.
+     */
+    protected _findManyWithCount(options?: MongoEntityService.FindManyOptions<T>): Promise<{
+        count: number;
+        items: PartialDTO<T>[];
+    }>;
+    /**
+     * 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.
+     */
+    protected _update(id: MongoAdapter.AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateOptions<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 {MongoEntityService.UpdateOptions<T>} [options] - The options for updating the document.
+     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     */
+    protected _updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateOptions<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 {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.
+     */
+    protected _updateMany(input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateManyOptions<T>): Promise<number>;
+}