@point-hub/papi 0.6.6 → 0.7.2

package/lib/src/database/mongodb/mongo-test.service.d.ts

@@ -0,0 +1,149 @@
+import { Db, MongoClient } from 'mongodb';
+import type { ISchema } from '../../interfaces/types';
+import { MongoService } from './mongo.service';
+/**
+ * Provides utilities for managing a MongoDB database during tests.
+ *
+ * Handles database connections, collection creation, schema validation,
+ * index creation, and database cleanup.
+ *
+ * @example
+ * ```ts
+ * const database = new MongoTestService(process.env.MONGO_URI!, 'api_test')
+ *
+ * await database.open()
+ *
+ * try {
+ *   await database.createCollections(listSchema)
+ *   // Run tests
+ * } finally {
+ *   await database.close()
+ * }
+ * ```
+ */
+export declare class MongoTestService {
+    private mongoClient;
+    private mongoService;
+    private db;
+    /**
+     * Creates a MongoDB test service.
+     *
+     * Initializes the MongoDB client and database reference.
+     * The connection is not established until {@link open} is called.
+     *
+     * @param uri - MongoDB connection URI.
+     * @param name - Name of the test database.
+     */
+    constructor(uri: string, name: string);
+    /**
+     * Provides access to the MongoDB client.
+     *
+     * Use this to access native MongoDB client functionality,
+     * such as creating sessions and managing transactions.
+     *
+     * @example
+     * ```ts
+     * const session = mongoTestService.client.startSession()
+     * ```
+     */
+    get client(): MongoClient;
+    /**
+     * Provides access to the MongoDB database.
+     *
+     * Use this to perform direct database operations in tests,
+     * such as inserting fixtures and querying documents.
+     *
+     * @example
+     * ```ts
+     * await mongoTestService.database.collection('users').insertOne({
+     *   email: 'john@example.com'
+     * })
+     * ```
+     */
+    get database(): Db;
+    /**
+     * Provides access to the MongoDB service.
+     *
+     * Use this to perform MongoDB operations through the service abstraction
+     * instead of accessing the database directly.
+     *
+     * @example
+     * ```ts
+     * await mongoTestService.service.createUnique('users', { email: 1 })
+     * ```
+     */
+    get service(): MongoService;
+    /**
+     * Establishes a connection to MongoDB.
+     *
+     * @returns A promise that resolves when the connection is established.
+     */
+    open(): Promise<void>;
+    /**
+     * Closes the MongoDB connection.
+     *
+     * @returns A promise that resolves when the connection is closed.
+     */
+    close(): Promise<void>;
+    /**
+     * Creates collections defined in the provided schema configuration.
+     *
+     * For each collection, this method:
+     * - Creates the collection if it does not exist.
+     * - Applies the collection's JSON schema validation.
+     * - Creates unique indexes.
+     * - Creates unique sparse indexes for fields that may be missing or null.
+     *
+     * Existing collections are not dropped or recreated.
+     *
+     * @param listSchema - Grouped collection schema configurations.
+     * @returns A promise that resolves when all collections and indexes are configured.
+     *
+     * @example
+     * ```ts
+     * await database.createCollections(listSchema)
+     * ```
+     */
+    createCollections(listSchema: ISchema[][]): Promise<void>;
+    /**
+     * Drops the entire test database, including all its collections and indexes.
+     *
+     * Use this when a complete database cleanup is required.
+     *
+     * @returns A promise that resolves when the database has been dropped.
+     *
+     * @example
+     * ```ts
+     * await database.dropDatabase()
+     * ```
+     */
+    dropDatabase(): Promise<void>;
+    /**
+     * Drops every collection in the test database.
+     *
+     * Unlike {@link dropDatabase}, this keeps the database itself.
+     *
+     * @returns A promise that resolves when all collections have been dropped.
+     *
+     * @example
+     * ```ts
+     * await database.dropAllCollections()
+     * ```
+     */
+    dropAllCollections(): Promise<void>;
+    /**
+     * Removes all documents from every collection in the test database.
+     *
+     * Collections, indexes, and schema validation rules are preserved.
+     *
+     * @returns A promise that resolves when all collections have been cleared.
+     *
+     * @example
+     * ```ts
+     * // Clear test data before each test.
+     * await database.reset()
+     * ```
+     */
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=mongo-test.service.d.ts.map

package/lib/src/database/mongodb/mongo-test.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo-test.service.d.ts","sourceRoot":"","sources":["../../../../src/database/mongodb/mongo-test.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,WAAW,EAAsB,MAAM,SAAS,CAAC;AAE9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,EAAE,CAAK;IAEf;;;;;;;;OAQG;gBACS,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAWrC;;;;;;;;;;OAUG;IACH,IAAW,MAAM,IAAI,WAAW,CAE/B;IAED;;;;;;;;;;;;OAYG;IACH,IAAW,QAAQ,IAAI,EAAE,CAExB;IAED;;;;;;;;;;OAUG;IACH,IAAW,OAAO,IAAI,YAAY,CAEjC;IAED;;;;OAIG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlC;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC;;;;;;;;;;;;;;;;;;OAkBG;IACU,iBAAiB,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkCtE;;;;;;;;;;;OAWG;IACU,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1C;;;;;;;;;;;OAWG;IACU,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAShD;;;;;;;;;;;;OAYG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAOpC"}

package/lib/src/database/mongodb/mongo-test.service.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mongo-test.service.spec.d.ts.map

package/lib/src/database/mongodb/mongo-test.service.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo-test.service.spec.d.ts","sourceRoot":"","sources":["../../../../src/database/mongodb/mongo-test.service.spec.ts"],"names":[],"mappings":""}

package/lib/src/database/mongodb/mongo.service.d.ts

@@ -0,0 +1,264 @@
+import { type AggregateOptions, type CreateIndexesOptions, type Db, type Document, type IndexSpecification } from 'mongodb';
+import { type IPagination } from '../../index';
+/**
+ * Represents the result of a paginated MongoDB query.
+ *
+ * @typeParam T - The document structure returned by the query.
+ */
+interface IRetrievePaginated<T> {
+    /** The documents retrieved for the current page. */
+    data: T[];
+    /** Pagination metadata, including page count and total documents. */
+    pagination: IPagination;
+}
+/**
+ * Options for retrieving paginated MongoDB documents.
+ */
+export interface IRetrievePaginatedOptions {
+    /** The page number to retrieve. */
+    page?: number;
+    /** The maximum number of documents per page. */
+    pageSize?: number;
+    /**
+     * Sort expression using field names.
+     * Prefix a field with `-` for descending order.
+     *
+     * @example
+     * '-createdAt'
+     * 'name,-createdAt'
+     */
+    sort?: string;
+    /**
+     * Additional aggregation stages appended after pagination.
+     *
+     * Useful for operations such as `$lookup` or `$project`
+     * that should execute after `$skip` and `$limit`.
+     */
+    afterPagination?: Document[];
+    /** Additional MongoDB aggregation options. */
+    aggregateOptions?: AggregateOptions;
+}
+/**
+ * Provides methods for managing MongoDB collections, indexes,
+ * schema validation, and document retrieval.
+ *
+ * Supports standard queries and aggregation-based pagination.
+ *
+ * @see https://www.mongodb.com/docs/drivers/node/current/fundamentals/indexes/
+ * @see https://www.mongodb.com/docs/manual/reference/collation/
+ * @see https://www.mongodb.com/docs/manual/core/index-sparse/
+ * @see https://www.mongodb.com/docs/manual/core/index-partial/
+ */
+export declare class MongoService {
+    private db;
+    /**
+     * Creates a MongoDB service instance.
+     *
+     * @param db - The MongoDB database instance used by this service.
+     */
+    constructor(db: Db);
+    /**
+     * Creates a unique index on the specified collection.
+     *
+     * Uses case-insensitive collation to prevent duplicate values
+     * that differ only in letter casing.
+     *
+     * @param collection - The name of the collection to index.
+     * @param spec - The index specification containing the fields and sort order.
+     *
+     * @example
+     * // Create a unique index on the name field.
+     * await mongoDBService.createUnique('users', {
+     *   name: 1
+     * })
+     *
+     * @example
+     * // Create a compound unique index on firstName and lastName.
+     * await mongoDBService.createUnique('users', {
+     *   firstName: 1,
+     *   lastName: 1
+     * })
+     */
+    createUnique(collection: string, spec: IndexSpecification): Promise<void>;
+    /**
+     * Creates a unique sparse index on the specified collection.
+     *
+     * Documents that do not contain the indexed field are excluded
+     * from the index. Documents containing the indexed field must
+     * have unique values.
+     *
+     * Uses case-insensitive collation.
+     *
+     * @param collection - The name of the collection to index.
+     * @param spec - The index specification containing the fields and sort order.
+     *
+     * @example
+     * // Allow multiple documents without an email field,
+     * // but enforce uniqueness when email is present.
+     * await mongoDBService.createUniqueIfNotNull('users', {
+     *   email: 1
+     * })
+     */
+    createUniqueIfNotNull(collection: string, spec: IndexSpecification): Promise<void>;
+    /**
+     * Creates an index on the specified collection.
+     *
+     * Supports standard MongoDB index options, including unique,
+     * sparse, partialFilterExpression, and expireAfterSeconds.
+     *
+     * @param collection - The name of the collection to index.
+     * @param spec - The index specification containing the fields and sort order.
+     * @param options - Optional MongoDB index creation options.
+     *
+     * @example
+     * // Create a standard index on the createdAt field.
+     * await mongoDBService.createIndex('users', {
+     *   createdAt: -1
+     * })
+     *
+     * @example
+     * // Create a partial index for active users.
+     * await mongoDBService.createIndex(
+     *   'users',
+     *   { email: 1 },
+     *   {
+     *     partialFilterExpression: {
+     *       status: 'active'
+     *     }
+     *   }
+     * )
+     */
+    createIndex(collection: string, spec: IndexSpecification, options?: CreateIndexesOptions): Promise<void>;
+    /**
+     * Checks whether a collection exists in the current database.
+     *
+     * @param name - The name of the collection to check.
+     * @returns True if the collection exists; otherwise, false.
+     *
+     * @example
+     * const exists = await mongoDBService.isExists('users')
+     */
+    isExists(name: string): Promise<boolean>;
+    /**
+     * Updates the JSON Schema validator of an existing MongoDB collection.
+     *
+     * Uses the `collMod` command to modify the collection's validation rules
+     * without dropping or recreating the collection.
+     *
+     * @param name - Name of the collection to update.
+     * @param schema - JSON Schema definition used to validate collection documents.
+     * @throws {Error} If the database connection is not available.
+     */
+    updateSchema(name: string, schema: unknown): Promise<void>;
+    /**
+     * Retrieves paginated documents from a MongoDB collection using an aggregation pipeline.
+     *
+     * Executes the aggregation pipeline twice:
+     * - The count pipeline calculates the total number of documents matching the pipeline.
+     * - The data pipeline retrieves documents for the requested page, applying sorting,
+     *   skipping, and limiting when applicable.
+     *
+     * @typeParam T - The expected document structure of the retrieved data.
+     *
+     * @param collection - The name of the MongoDB collection.
+     * @param pipeline - The aggregation pipeline used to filter or transform documents.
+     * @param options - Pagination, sorting, and aggregation options.
+     *
+     * @returns The retrieved documents and pagination metadata.
+     *
+     * @throws RangeError If the page or page size is invalid.
+     *
+     * @example
+     * // Retrieve the first page of active users, sorted by creation date.
+     * const result = await mongoDBService.retrievePaginated<IUser>(
+     *   'users',
+     *   [
+     *     {
+     *       $match: {
+     *         status: 'active',
+     *       },
+     *     },
+     *   ],
+     *   {
+     *     page: 1,
+     *     pageSize: 10,
+     *     sort: '-createdAt',
+     *   },
+     * );
+     *
+     * @example
+     * // Retrieve users with their associated profiles.
+     * const result = await mongoDBService.retrievePaginated<IUser>(
+     *   'users',
+     *   [
+     *     {
+     *       $lookup: {
+     *         from: 'profiles',
+     *         localField: '_id',
+     *         foreignField: 'user_id',
+     *         as: 'profile',
+     *       },
+     *     },
+     *   ],
+     *   {
+     *     page: 2,
+     *     pageSize: 20,
+     *   },
+     * );
+     */
+    retrievePaginated<T extends Document>(collection: string, pipeline?: Document[], options?: IRetrievePaginatedOptions): Promise<IRetrievePaginated<T>>;
+    /**
+     * Retrieves the first document matching an aggregation pipeline.
+     *
+     * Executes the provided aggregation pipeline and returns the first
+     * matching document. Returns `null` if no document is found.
+     *
+     * @typeParam T - The expected document structure of the retrieved data.
+     *
+     * @param collection - The name of the MongoDB collection.
+     * @param pipeline - The aggregation pipeline used to filter or transform documents.
+     * @param options - MongoDB aggregation options.
+     *
+     * @returns The first matching document, or `null` if no document is found.
+     *
+     * @example
+     * // Retrieve an active user by email.
+     * const user = await mongoDBService.retrieveOne<IUser>(
+     *   'users',
+     *   [
+     *     {
+     *       $match: {
+     *         email: 'john@example.com',
+     *         status: 'active',
+     *       },
+     *     },
+     *   ],
+     *   {},
+     * );
+     *
+     * @example
+     * // Retrieve a user with their associated profile.
+     * const user = await mongoDBService.retrieveOne<IUser>(
+     *   'users',
+     *   [
+     *     {
+     *       $match: {
+     *         _id: userId,
+     *       },
+     *     },
+     *     {
+     *       $lookup: {
+     *         from: 'profiles',
+     *         localField: '_id',
+     *         foreignField: 'user_id',
+     *         as: 'profile',
+     *       },
+     *     },
+     *   ],
+     *   {},
+     * );
+     */
+    retrieveOne<T extends Document>(collection: string, pipeline: Document[] | undefined, options: AggregateOptions): Promise<T | null>;
+}
+export {};
+//# sourceMappingURL=mongo.service.d.ts.map

package/lib/src/database/mongodb/mongo.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo.service.d.ts","sourceRoot":"","sources":["../../../../src/database/mongodb/mongo.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,EAAE,EAAE,KAAK,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE5H,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,aAAa,CAAC;AAElE;;;;GAIG;AACH,UAAU,kBAAkB,CAAC,CAAC;IAC5B,oDAAoD;IACpD,IAAI,EAAE,CAAC,EAAE,CAAC;IAEV,qEAAqE;IACrE,UAAU,EAAE,WAAW,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;IAE7B,8CAA8C;IAC9C,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,EAAE,CAAK;IAEf;;;;OAIG;gBACS,EAAE,EAAE,EAAE;IAIlB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACU,YAAY,CACvB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,IAAI,CAAC;IAUhB;;;;;;;;;;;;;;;;;;OAkBG;IACU,qBAAqB,CAChC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,IAAI,CAAC;IAWhB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACU,WAAW,CACtB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,kBAAkB,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;;;;;OAQG;IACU,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrD;;;;;;;;;OASG;IACU,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAavE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACU,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAC/C,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,QAAQ,EAAO,EACzB,OAAO,GAAE,yBAGR,GACA,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IA+CjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkDG;IACU,WAAW,CAAC,CAAC,SAAS,QAAQ,EACzC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,QAAQ,EAAE,YAAK,EACzB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAQrB"}

package/lib/src/database/mongodb/mongo.service.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mongo.service.spec.d.ts.map

package/lib/src/database/mongodb/mongo.service.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo.service.spec.d.ts","sourceRoot":"","sources":["../../../../src/database/mongodb/mongo.service.spec.ts"],"names":[],"mappings":""}

package/lib/src/index.d.ts

@@ -1,49 +1,23 @@
-import { BaseCommand } from '@point-hub/express-cli';
 import { ApiError, BaseError, errorHandlerMiddleware, find, invalidPathMiddleware, type TypeCodeStatus } from '@point-hub/express-error-handler';
-import { MongoServerError } from 'mongodb';
-import { ConsoleKernel } from './console';
-import { DatabaseConnection } from './database/connection';
-import { MongoDBConnection } from './database/mongodb/connection';
-import { MongoErrorHandler } from './database/mongodb/mongodb-error-handler';
-import { MongoDBHelper } from './database/mongodb/mongodb-helper';
-import mongodbErrorHandlerMiddleware from './middleware/mongodb-error-handler.middleware';
 export declare const stubDir: string;
 export type { IUseCaseError, IUseCaseOutputFailed, IUseCaseOutputSuccess } from './base-usecase';
 export { BaseUseCase } from './base-usecase';
-export { ExpressCli as BaseConsoleCli } from '@point-hub/express-cli';
-export declare const BaseConsoleCommand: typeof BaseCommand;
-export declare const BaseConsoleKernel: typeof ConsoleKernel;
-export { composeUpdate } from './database/mongodb/mongodb-compose';
-export { DatabaseTestUtil } from './test/utils';
-export declare const BaseDatabaseConnection: typeof DatabaseConnection;
-export declare const BaseMongoDBConnection: typeof MongoDBConnection;
-export declare const BaseMongoDBHelper: typeof MongoDBHelper;
-export declare const BaseMongoDBQuerystring: {
-    page: typeof import("./database/mongodb/mongodb-querystring").page;
-    limit: typeof import("./database/mongodb/mongodb-querystring").limit;
-    skip: typeof import("./database/mongodb/mongodb-querystring").skip;
-    sort: typeof import("./database/mongodb/mongodb-querystring").sort;
-    fields: typeof import("./database/mongodb/mongodb-querystring").fields;
-    filter: typeof import("./database/mongodb/mongodb-querystring").filter;
-    filterExludeFields: typeof import("./database/mongodb/mongodb-querystring").filterExludeFields;
-    convertStringToArray: typeof import("./database/mongodb/mongodb-querystring").convertStringToArray;
-    convertFieldObject: typeof import("./database/mongodb/mongodb-querystring").convertFieldObject;
-    convertSortObject: typeof import("./database/mongodb/mongodb-querystring").convertSortObject;
-};
-export { default as BaseMongoDBQueryFilters } from './database/mongodb/mongodb-query-filters';
-export declare const BaseMongoServerError: typeof MongoServerError;
-export declare const BaseMongoErrorHandler: typeof MongoErrorHandler;
+export { ConsoleKernel } from './console';
+export { BaseCommand, ExpressCli } from '@point-hub/express-cli';
+export { MongoService } from './database/mongodb/mongo.service';
+export { MongoErrorHandler } from './database/mongodb/mongo-error-handler';
+export { default as MongoQueryBuilder } from './database/mongodb/mongo-query-builder.utils';
+export { MongoTestService } from './database/mongodb/mongo-test.service';
 export { default as BaseFactory } from '@point-hub/express-factory';
 export declare const BaseErrorHandler: {
     ApiError: typeof ApiError;
     BaseError: typeof BaseError;
     isTrustedError: (err: Error) => boolean;
     getHttpError: typeof find;
-    mongodbErrorHandlerMiddleware: typeof mongodbErrorHandlerMiddleware;
     errorHandlerMiddleware: typeof errorHandlerMiddleware;
     invalidPathMiddleware: typeof invalidPathMiddleware;
 };
 export { Server as BaseServer } from './server';
 export type { TypeCodeStatus };
-export type { IAggregateOutput, IAggregateRepository, IAppInput, IBaseRouterInput, IClientSession, IController, IControllerInput, IControllerOutput, ICreateManyOutput, ICreateManyRepository, ICreateOutput, ICreateRepository, IDatabase, IDeleteManyOutput, IDeleteManyRepository, IDeleteOutput, IDeleteRepository, IDocument, IMakeControllerInput, IMakeMiddlewareInput, IMiddleware, IMiddlewareInput, IMongoDBConfig, IPagination, IPipeline, IQuery, IRetrieveAllOutput, IRetrieveAllRepository, IRetrieveManyOutput, IRetrieveManyRepository, IRetrieveRepository, ISchema, ISchemaValidation, IServerConfig, IUpdateManyOutput, IUpdateManyRepository, IUpdateOutput, IUpdateRepository } from './interfaces/types';
+export type { IAggregateOutput, IAggregateRepository, IAppInput, IBaseRouterInput, IController, IControllerInput, IControllerOutput, ICreateManyOutput, ICreateManyRepository, ICreateOutput, ICreateRepository, IDeleteManyOutput, IDeleteManyRepository, IDeleteOutput, IDeleteRepository, IDocument, IMakeControllerInput, IMakeMiddlewareInput, IMiddleware, IMiddlewareInput, IMongoDBConfig, IPagination, IPipeline, IQuery, IRetrieveManyOutput, IRetrieveManyRepository, IRetrieveRepository, ISchema, ISchemaValidation, IServerConfig, IUpdateManyOutput, IUpdateManyRepository, IUpdateOutput, IUpdateRepository, } from './interfaces/types';
 //# sourceMappingURL=index.d.ts.map

package/lib/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EACL,QAAQ,EACR,SAAS,EACT,sBAAsB,EACtB,IAAI,EACJ,qBAAqB,EAErB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAEjE,OAAO,6BAA6B,MAAM,+CAA+C,CAAA;AAEzF,eAAO,MAAM,OAAO,QAAqF,CAAA;AAGzG,YAAY,EAAE,aAAa,EAAC,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAC/F,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACrE,eAAO,MAAM,kBAAkB,oBAAc,CAAA;AAC7C,eAAO,MAAM,iBAAiB,sBAAgB,CAAA;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,eAAO,MAAM,sBAAsB,2BAAqB,CAAA;AACxD,eAAO,MAAM,qBAAqB,0BAAoB,CAAA;AACtD,eAAO,MAAM,iBAAiB,sBAAgB,CAAA;AAC9C,eAAO,MAAM,sBAAsB;;;;;;;;;;;CAAc,CAAA;AACjD,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AAC7F,eAAO,MAAM,oBAAoB,yBAAmB,CAAA;AACpD,eAAO,MAAM,qBAAqB,0BAAoB,CAAA;AAEtD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAEnE,eAAO,MAAM,gBAAgB;;;;;;;;CAQ5B,CAAA;AAED,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,UAAU,CAAA;AAE/C,YAAY,EAAE,cAAc,EAAE,CAAA;AAC9B,YAAY,EACV,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,SAAS,EACT,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,SAAS,EACT,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,SAAS,EACT,MAAM,EACN,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,OAAO,EACP,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EAClB,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,sBAAsB,EACtB,IAAI,EACJ,qBAAqB,EAErB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAC;AAE1C,eAAO,MAAM,OAAO,QAA2C,CAAC;AAEhE,YAAY,EAAE,aAAa,EAAC,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAEzE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;;;;;;CAO5B,CAAC;AAEF,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,UAAU,CAAC;AAEhD,YAAY,EAAE,cAAc,EAAE,CAAC;AAC/B,YAAY,EACV,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,SAAS,EACT,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,SAAS,EACT,MAAM,EACN,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,OAAO,EACP,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,GAClB,MAAM,oBAAoB,CAAC"}

package/lib/src/interfaces/types.d.ts

@@ -1,12 +1,13 @@
-import type { Request, RequestHandler, Response } from 'express';
-import { ClientSession } from 'mongodb';
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+import { MongoClient, ObjectId } from 'mongodb';
 /**
  * Controller
  */
 export interface IControllerInput {
     req: Request;
     res: Response;
-    dbConnection: IDatabase;
+    next: NextFunction;
+    mongoClient: MongoClient;
 }
 export interface IController {
     (input: IControllerInput): Promise<IControllerOutput | void>;
@@ -22,7 +23,8 @@ export interface IControllerOutput {
 export interface IMiddlewareInput {
     req: Request;
     res: Response;
-    dbConnection: IDatabase;
+    next: NextFunction;
+    mongoClient: MongoClient;
 }
 export type IAppMiddleware = (input: IMiddlewareInput) => Promise<void> | void;
 export type IMiddleware = RequestHandler | IAppMiddleware;
@@ -39,28 +41,22 @@ export interface ICreateRepository {
     handle(document: IDocument, options?: unknown): Promise<ICreateOutput>;
 }
 export interface IDeleteManyRepository {
-    handle(_ids: string[], options?: unknown): Promise<IDeleteManyOutput>;
+    handle(_ids: (string | ObjectId)[], options?: unknown): Promise<IDeleteManyOutput>;
 }
 export interface IDeleteRepository {
-    handle(_id: string, options?: unknown): Promise<IDeleteOutput>;
-}
-/**
- * @deprecated
- */
-export interface IRetrieveAllRepository<TData> {
-    handle(query: IQuery, options?: unknown): Promise<TData>;
+    handle(_id: (string | ObjectId), options?: unknown): Promise<IDeleteOutput>;
 }
 export interface IRetrieveManyRepository<TData> {
     handle(query: IQuery, options?: unknown): Promise<TData>;
 }
 export interface IRetrieveRepository<TOutput extends object> {
-    handle(_id: string, options?: unknown): Promise<TOutput>;
+    handle(_id: (string | ObjectId), options?: unknown): Promise<TOutput>;
 }
 export interface IUpdateManyRepository {
     handle(filter: IDocument, document: IDocument, options?: unknown): Promise<IUpdateManyOutput>;
 }
 export interface IUpdateRepository {
-    handle(_id: string, document: IDocument, options?: unknown): Promise<IUpdateOutput>;
+    handle(_id: (string | ObjectId), document: IDocument, options?: unknown): Promise<IUpdateOutput>;
 }
 /**
  * Database
@@ -105,13 +101,6 @@ export interface IPagination {
     page_size: number;
     total_document: number;
 }
-/**
- * @deprecated
- */
-export interface IRetrieveAllOutput<TData> {
-    data: TData[];
-    pagination: IPagination;
-}
 export interface IRetrieveManyOutput<TData> {
     data: TData[];
     pagination: IPagination;
@@ -134,60 +123,25 @@ export interface IAggregateOutput<TData> {
     data: TData[];
     pagination: IPagination;
 }
-export interface IClientSession extends ClientSession {
-}
-export interface IDatabase {
-    session: unknown;
-    open(): Promise<void>;
-    close(): Promise<void>;
-    database(name: string, options?: unknown): this;
-    collection(name: string, options?: unknown): this;
-    listCollections(): Promise<{
-        name: string;
-    }[]>;
-    startSession(): ClientSession;
-    endSession(): Promise<void>;
-    startTransaction(): void;
-    commitTransaction(): Promise<void>;
-    abortTransaction(): Promise<void>;
-    createIndex(name: string, spec: unknown, options?: unknown): Promise<void>;
-    createCollection(name: string, options?: unknown): Promise<void>;
-    dropCollection(name: string, options?: unknown): Promise<void>;
-    dropDatabase(options?: unknown): Promise<void>;
-    updateSchema(name: string, schema: unknown): Promise<void>;
-    command(document: IDocument, options?: unknown): Promise<IDocument>;
-    create(document: IDocument, options?: unknown): Promise<ICreateOutput>;
-    createMany(documents: IDocument[], options?: unknown): Promise<ICreateManyOutput>;
-    retrieveAll<TData>(query: IQuery, options?: unknown): Promise<IRetrieveAllOutput<TData>>;
-    retrieveMany<TData>(query: IQuery, options?: unknown): Promise<IRetrieveManyOutput<TData>>;
-    retrieve<TOutput extends object>(_id: string, options?: unknown): Promise<TOutput | null>;
-    update(filter: string | IDocument, document: IDocument, options?: unknown): Promise<IUpdateOutput>;
-    updateOne(filter: IDocument, document: IDocument, options?: unknown): Promise<IUpdateOutput>;
-    updateMany(filter: IDocument, document: IDocument, options?: unknown): Promise<IUpdateManyOutput>;
-    delete(_id: string, options?: unknown): Promise<IDeleteOutput>;
-    deleteMany(input: string[] | Record<string, unknown>, options?: unknown): Promise<IDeleteManyOutput>;
-    deleteAll(options?: unknown): Promise<IDeleteManyOutput>;
-    aggregate<TData>(pipeline?: IPipeline[], query?: IQuery, options?: unknown): Promise<IAggregateOutput<TData>>;
-}
 /**
  * Express App
  */
 export interface IAppInput {
-    dbConnection: IDatabase;
+    mongoClient: MongoClient;
 }
 export interface IMakeControllerInput {
     controller: IController;
-    dbConnection: IDatabase;
+    mongoClient: MongoClient;
 }
 export interface IMakeMiddlewareInput {
     middleware: IMiddleware;
-    dbConnection: IDatabase;
+    mongoClient: MongoClient;
 }
 /**
  * Router
  */
 export interface IBaseRouterInput {
-    dbConnection: IDatabase;
+    mongoClient: MongoClient;
 }
 /**
  * Schema Validation