@opra/mongodb 1.0.0-alpha.2 → 1.0.0-alpha.21

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>;
 }

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

@@ -1,6 +1,5 @@
 import mongodb from 'mongodb';
-import { PartialDTO, PatchDTO, Type } from 'ts-gems';
-import { MongoAdapter } from './mongo-adapter.js';
+import { PartialDTO, PatchDTO, RequiredSome, StrictOmit, Type } from 'ts-gems';
 import { MongoService } from './mongo-service.js';
 /**
  *
@@ -27,14 +26,57 @@ export declare namespace MongoEntityService {
     }
     interface DistinctOptions<T> extends MongoService.DistinctOptions<T> {
     }
+    interface ExistsOptions<T> extends MongoService.ExistsOptions<T> {
+    }
     interface FindOneOptions<T> extends MongoService.FindOneOptions<T> {
     }
     interface FindManyOptions<T> extends MongoService.FindManyOptions<T> {
     }
-    interface UpdateOptions<T> extends MongoService.UpdateOptions<T> {
+    interface UpdateOneOptions<T> extends MongoService.UpdateOneOptions<T> {
     }
     interface UpdateManyOptions<T> extends MongoService.UpdateManyOptions<T> {
     }
+    interface CreateCommand extends StrictOmit<RequiredSome<CommandInfo, 'input'>, 'documentId' | 'nestedId'> {
+        crud: 'create';
+        options?: CreateOptions;
+    }
+    interface CountCommand<T> extends StrictOmit<CommandInfo, 'documentId' | 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: CountOptions<T>;
+    }
+    interface DeleteCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'delete';
+        options?: DeleteOptions<T>;
+    }
+    interface DistinctCommand<T> extends StrictOmit<CommandInfo, 'documentId' | 'nestedId' | 'input'> {
+        crud: 'read';
+        field: string;
+        options?: DistinctOptions<T>;
+    }
+    interface ExistsCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: ExistsOptions<T>;
+    }
+    interface FindOneCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: FindOneOptions<T>;
+    }
+    interface FindManyCommand<T> extends StrictOmit<CommandInfo, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: FindManyOptions<T>;
+    }
+    interface UpdateOneCommand<T> extends StrictOmit<CommandInfo, 'nestedId'> {
+        crud: 'update';
+        input?: PatchDTO<T>;
+        inputRaw?: mongodb.UpdateFilter<T>;
+        options?: UpdateOneOptions<T>;
+    }
+    interface UpdateManyCommand<T> extends StrictOmit<CommandInfo, 'nestedId'> {
+        crud: 'update';
+        input?: PatchDTO<T>;
+        inputRaw?: mongodb.UpdateFilter<T>;
+        options?: UpdateManyOptions<T>;
+    }
 }
 /**
  * @class MongoEntityService
@@ -52,98 +94,82 @@ export declare class MongoEntityService<T extends mongodb.Document> extends Mong
     /**
      * Creates a new document in the MongoDB collection.
      *
-     * @param {PartialDTO<T>} input
-     * @param {MongoEntityService.CreateOptions} options
+     * @param {MongoEntityService.CreateCommand} command
      * @protected
      */
-    protected _create(input: PartialDTO<T>, options?: MongoEntityService.CreateOptions): Promise<PartialDTO<T>>;
+    protected _create(command: MongoEntityService.CreateCommand): 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.
+     * @param {MongoEntityService.CountCommand<T>} command
+     * @protected
      */
-    protected _count(options?: MongoEntityService.CountOptions<T>): Promise<number>;
+    protected _count(command: MongoEntityService.CountCommand<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.
+     * @param {MongoEntityService.DeleteCommand<T>} command
+     * @protected
      */
-    protected _delete(id: MongoAdapter.AnyId, options?: MongoEntityService.DeleteOptions<T>): Promise<number>;
+    protected _delete(command: MongoEntityService.DeleteCommand<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.
+     * @param {MongoEntityService.DeleteCommand<T>} command
+     * @protected
      */
-    protected _deleteMany(options?: MongoEntityService.DeleteManyOptions<T>): Promise<number>;
+    protected _deleteMany(command: MongoEntityService.DeleteCommand<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
+     *
+     * @param {MongoEntityService.DistinctCommand<T>} command
      * @protected
      */
-    protected _distinct(field: string, options?: MongoEntityService.DistinctOptions<T>): Promise<any[]>;
+    protected _distinct(command: MongoEntityService.DistinctCommand<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.
+     * @param { MongoEntityService.FindOneCommand<T>} command
      */
-    protected _findById(id: MongoAdapter.AnyId, options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _findById(command: MongoEntityService.FindOneCommand<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.
+     * @param {MongoEntityService.FindOneCommand<T>} command
      */
-    protected _findOne(options?: MongoEntityService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _findOne(command: MongoEntityService.FindOneCommand<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.
+     * @param {MongoEntityService.FindManyCommand<T>} command
      */
-    protected _findMany(options?: MongoEntityService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
+    protected _findMany(command: MongoEntityService.FindManyCommand<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.
+     * @param {MongoEntityService.FindManyCommand<T>} command
      */
-    protected _findManyWithCount(options?: MongoEntityService.FindManyOptions<T>): Promise<{
+    protected _findManyWithCount(command: MongoEntityService.FindManyCommand<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.
+     * @param {MongoEntityService.UpdateOneCommand<T>} command
      */
-    protected _update(id: MongoAdapter.AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _update(command: MongoEntityService.UpdateOneCommand<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.
+     * @param {MongoEntityService.UpdateOneCommand<T>} command
      */
-    protected _updateOnly(id: MongoAdapter.AnyId, input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateOptions<T>): Promise<number>;
+    protected _updateOnly(command: MongoEntityService.UpdateOneCommand<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.
+     * @param {MongoEntityService.UpdateManyCommand<T>} command
      */
-    protected _updateMany(input: PatchDTO<T> | mongodb.UpdateFilter<T>, options?: MongoEntityService.UpdateManyOptions<T>): Promise<number>;
+    protected _updateMany(command: MongoEntityService.UpdateManyCommand<T>): Promise<number>;
 }

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

@@ -1,8 +1,7 @@
-import mongodb from 'mongodb';
-import { PartialDTO, PatchDTO, Type } from 'ts-gems';
 import { ComplexType } from '@opra/common';
+import mongodb from 'mongodb';
+import { PartialDTO, PatchDTO, RequiredSome, StrictOmit, Type } from 'ts-gems';
 import { MongoAdapter } from './mongo-adapter.js';
-import { MongoCollectionService } from './mongo-collection-service.js';
 import { MongoService } from './mongo-service.js';
 import FilterInput = MongoAdapter.FilterInput;
 /**
@@ -16,7 +15,9 @@ export declare namespace MongoNestedService {
     interface Options extends MongoService.Options {
         defaultLimit?: number;
         nestedKey?: string;
-        $nestedFilter?: FilterInput | ((args: MongoService.CommandInfo, _this: this) => FilterInput | Promise<FilterInput> | undefined);
+        nestedFilter?: FilterInput | ((args: MongoService.CommandInfo, _this: this) => FilterInput | Promise<FilterInput> | undefined);
+    }
+    interface CommandInfo extends MongoService.CommandInfo {
     }
     interface CreateOptions extends MongoService.CreateOptions {
     }
@@ -40,13 +41,47 @@ export declare namespace MongoNestedService {
         documentFilter?: FilterInput;
         nestedFilter?: FilterInput;
     }
-    interface UpdateOptions<T> extends MongoService.UpdateOptions<T> {
+    interface UpdateOneOptions<T> extends MongoService.UpdateOneOptions<T> {
         documentFilter?: FilterInput;
     }
     interface UpdateManyOptions<T> extends MongoService.UpdateManyOptions<T> {
         documentFilter?: FilterInput;
         count?: boolean;
     }
+    interface CreateCommand extends RequiredSome<CommandInfo, 'documentId' | 'input'> {
+        crud: 'create';
+        options?: CreateOptions;
+    }
+    interface CountCommand<T> extends StrictOmit<RequiredSome<CommandInfo, 'documentId'>, 'nestedId' | 'input'> {
+        crud: 'read';
+        options?: CountOptions<T>;
+    }
+    interface DeleteCommand<T> extends StrictOmit<RequiredSome<CommandInfo, 'documentId'>, 'input'> {
+        crud: 'delete';
+        options?: DeleteOptions<T>;
+    }
+    interface ExistsCommand<T> extends StrictOmit<RequiredSome<CommandInfo, 'documentId'>, 'input'> {
+        crud: 'read';
+        options?: ExistsOptions<T>;
+    }
+    interface FindOneCommand<T> extends StrictOmit<RequiredSome<CommandInfo, 'documentId'>, 'input'> {
+        crud: 'read';
+        options?: FindOneOptions<T>;
+    }
+    interface FindManyCommand<T> extends StrictOmit<RequiredSome<CommandInfo, 'documentId'>, 'input'> {
+        crud: 'read';
+        options?: FindManyOptions<T>;
+    }
+    interface UpdateOneCommand<T> extends RequiredSome<CommandInfo, 'documentId'> {
+        crud: 'update';
+        input: PatchDTO<T> | mongodb.UpdateFilter<T>;
+        options?: MongoNestedService.UpdateOneOptions<T>;
+    }
+    interface UpdateManyCommand<T> extends RequiredSome<CommandInfo, 'documentId'> {
+        crud: 'update';
+        input: PatchDTO<T> | mongodb.UpdateFilter<T>;
+        options?: MongoNestedService.UpdateManyOptions<T>;
+    }
 }
 /**
  * A class that provides methods to perform operations on an array field in a MongoDB collection.
@@ -77,7 +112,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      *
      * @type {FilterInput | Function}
      */
-    $nestedFilter?: FilterInput | ((args: MongoService.CommandInfo, _this: this) => FilterInput | Promise<FilterInput> | undefined);
+    nestedFilter?: FilterInput | ((args: MongoService.CommandInfo, _this: this) => FilterInput | Promise<FilterInput> | undefined);
     /**
      * Constructs a new instance
      *
@@ -87,6 +122,13 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @constructor
      */
     constructor(dataType: Type | string, fieldName: string, options?: MongoNestedService.Options);
+    /**
+     * Retrieves the data type of the array field
+     *
+     * @returns {ComplexType} The complex data type of the field.
+     * @throws {NotAcceptableError} If the data type is not a ComplexType.
+     */
+    get dataType(): ComplexType;
     /**
      * Asserts whether a resource with the specified parentId and id exists.
      * Throws a ResourceNotFoundError if the resource does not exist.
@@ -108,7 +150,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @throws {ResourceNotAvailableError} - If the parent document is not found.
      */
     create(documentId: MongoAdapter.AnyId, input: PartialDTO<T>, options?: MongoNestedService.CreateOptions): Promise<PartialDTO<T>>;
-    protected _create(documentId: MongoAdapter.AnyId, input: PartialDTO<T>, options?: MongoNestedService.CreateOptions): Promise<PartialDTO<T>>;
+    protected _create(command: MongoNestedService.CreateCommand): Promise<PartialDTO<T>>;
     /**
      * Counts the number of documents in the collection that match the specified parentId and options.
      *
@@ -117,7 +159,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @returns {Promise<number>} - A promise that resolves to the count of documents.
      */
     count(documentId: MongoAdapter.AnyId, options?: MongoNestedService.CountOptions<T>): Promise<number>;
-    protected _count(documentId: MongoAdapter.AnyId, options?: MongoNestedService.CountOptions<T>): Promise<number>;
+    protected _count(command: MongoNestedService.CountCommand<T>): Promise<number>;
     /**
      * Deletes an element from an array within a document in the MongoDB collection.
      *
@@ -127,7 +169,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @return {Promise<number>} - A Promise that resolves to the number of elements deleted (1 if successful, 0 if not).
      */
     delete(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, options?: MongoNestedService.DeleteOptions<T>): Promise<number>;
-    protected _delete(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, options?: MongoNestedService.DeleteOptions<T>): Promise<number>;
+    protected _delete(command: MongoNestedService.DeleteCommand<T>): Promise<number>;
     /**
      * Deletes multiple items from a collection based on the parent ID and optional filter.
      *
@@ -136,7 +178,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @returns {Promise<number>} - A Promise that resolves to the number of items deleted.
      */
     deleteMany(documentId: MongoAdapter.AnyId, options?: MongoNestedService.DeleteManyOptions<T>): Promise<number>;
-    protected _deleteMany(documentId: MongoAdapter.AnyId, options?: MongoNestedService.DeleteManyOptions<T>): Promise<number>;
+    protected _deleteMany(command: MongoNestedService.DeleteCommand<T>): Promise<number>;
     /**
      * Checks if an array element with the given parentId and id exists.
      *
@@ -153,7 +195,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @param {MongoNestedService.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(documentId: MongoAdapter.AnyId, options?: MongoCollectionService.ExistsOneOptions<T>): Promise<boolean>;
+    existsOne(documentId: MongoAdapter.AnyId, options?: MongoNestedService.ExistsOneOptions<T>): Promise<boolean>;
     /**
      * Finds an element in array field by its parent ID and ID.
      *
@@ -163,7 +205,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
      */
     findById(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, options?: MongoNestedService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
-    protected _findById(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, options?: MongoNestedService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _findById(command: MongoNestedService.FindOneCommand<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds the first array element that matches the given parentId.
      *
@@ -172,7 +214,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the first matching document, or `undefined` if no match is found.
      */
     findOne(documentId: MongoAdapter.AnyId, options?: MongoNestedService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
-    protected _findOne(documentId: MongoAdapter.AnyId, options?: MongoNestedService.FindOneOptions<T>): Promise<PartialDTO<T> | undefined>;
+    protected _findOne(command: MongoNestedService.FindOneCommand<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Finds multiple elements in an array field.
      *
@@ -181,7 +223,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @returns {Promise<PartialDTO<T>[]>} - The found documents.
      */
     findMany(documentId: MongoAdapter.AnyId, options?: MongoNestedService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
-    protected _findMany(documentId: MongoAdapter.AnyId, options: MongoNestedService.FindManyOptions<T>): Promise<PartialDTO<T>[]>;
+    protected _findMany(command: MongoNestedService.FindManyCommand<T>): Promise<PartialDTO<T>[]>;
     /**
      * Finds multiple elements in an array field.
      *
@@ -193,7 +235,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
         count: number;
         items: PartialDTO<T>[];
     }>;
-    protected _findManyWithCount(documentId: MongoAdapter.AnyId, options: MongoNestedService.FindManyOptions<T>): Promise<{
+    protected _findManyWithCount(command: MongoNestedService.FindManyCommand<T>): Promise<{
         count: number;
         items: PartialDTO<T>[];
     }>;
@@ -213,22 +255,22 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @param {AnyId} documentId - The ID of the document to update.
      * @param {AnyId} nestedId - The ID of the item to update within the document.
      * @param {PatchDTO<T>} input - The new data to update the item with.
-     * @param {MongoNestedService.UpdateOptions<T>} [options] - Additional update options.
+     * @param {MongoNestedService.UpdateOneOptions<T>} [options] - Additional update options.
      * @returns {Promise<PartialDTO<T> | undefined>} The updated item or undefined if it does not exist.
      * @throws {Error} If an error occurs while updating the item.
      */
-    update(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateOptions<T>): Promise<PartialDTO<T> | undefined>;
+    update(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateOneOptions<T>): Promise<PartialDTO<T> | undefined>;
     /**
      * Update an array element with new data. Returns 1 if document updated 0 otherwise.
      *
      * @param {MongoAdapter.AnyId} documentId - The ID of the parent document.
      * @param {MongoAdapter.AnyId} nestedId - The ID of the document to update.
      * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
-     * @param {MongoNestedService.UpdateOptions<T>} [options] - Optional update options.
+     * @param {MongoNestedService.UpdateOneOptions<T>} [options] - Optional update options.
      * @returns {Promise<number>} - A promise that resolves to the number of elements updated.
      */
-    updateOnly(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateOptions<T>): Promise<number>;
-    protected _updateOnly(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateOptions<T>): Promise<number>;
+    updateOnly(documentId: MongoAdapter.AnyId, nestedId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateOneOptions<T>): Promise<number>;
+    protected _updateOnly(command: MongoNestedService.UpdateOneCommand<T>): Promise<number>;
     /**
      * Updates multiple array elements in document
      *
@@ -238,14 +280,7 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
      * @returns {Promise<number>} - A promise that resolves to the number of documents updated.
      */
     updateMany(documentId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateManyOptions<T>): Promise<number>;
-    protected _updateMany(documentId: MongoAdapter.AnyId, input: PatchDTO<T>, options?: MongoNestedService.UpdateManyOptions<T>): Promise<number>;
-    /**
-     * Retrieves the data type of the array field
-     *
-     * @returns {ComplexType} The complex data type of the field.
-     * @throws {NotAcceptableError} If the data type is not a ComplexType.
-     */
-    getDataType(): ComplexType;
+    protected _updateMany(command: MongoNestedService.UpdateManyCommand<T>): Promise<number>;
     /**
      * Retrieves the common filter used for querying array elements.
      * This method is mostly used for security issues like securing multi-tenant applications.