@abejarano/ts-mongodb-criteria 1.11.1 → 1.11.3

package/README.md

@@ -181,8 +181,8 @@ Use the `collection` argument inside `ensureIndexes` to avoid recursion.
 
 MongoRepository provides ready-to-use public methods for repositories that extend it:
 
-- `list(criteria, fieldsToExclude?)` for paginated queries
-- `many(filter, options?)` to fetch multiple entities matching a filter, with optional `{ transaction?, sort }`
+- `list(criteria, transaction?)` for paginated queries
+- `many(filter, options?)` to fetch multiple entities matching a filter, with optional `{ transaction?, sort? }`
 - `one(filter, transaction?)` to fetch a single entity
 - `upsert(entity, transaction?)` to persist an aggregate
   Internal helpers are private, so repositories should call these public methods
@@ -220,7 +220,7 @@ await MongoTransaction.run(async (tx) => {
   const persistedUser = await userRepository.one({ id: user.getId() }, tx)
   const activeUsers = await userRepository.many(
     { status: "active" },
-    { transaction: tx, sort: { name: 1 } }
+    { transaction: tx, sort: Order.asc("name") }
   )
 })
 ```
@@ -241,7 +241,7 @@ async deactivateUser(id: string, tx: MongoTransaction): Promise<void> {
 MongoDB transactions require a replica set or a sharded cluster; standalone
 MongoDB instances do not support them. This initial API applies the transaction
 context to `upsert`, `delete`, protected `updateOne`, `one`, `list`, and `many`.
-Pass `tx` as the third argument to `list` after `fieldsToExclude`, and inside the options object (`{ transaction: tx }`) to `many`.
+Pass `tx` as the second argument to `list`, and inside the options object (`{ transaction: tx }`) to `many`.
 
 **Your First Query in 30 Seconds:**
 
@@ -388,7 +388,7 @@ const criteria = new Criteria(Filters.fromValues(filters), Order.none())
 
 ## 🧪 Testing
 
-The library includes comprehensive test coverage (46/46 tests passing).
+The library includes comprehensive test coverage (45/45 tests passing).
 
 ```bash
 # Run all tests

package/dist/cjs/AggregateRoot.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateRoot = void 0;
 class AggregateRoot {
-    constructor(id) {
-        this.aggregateId = id;
-    }
     getId() {
         return this.aggregateId;
     }

package/dist/cjs/criteria/Criteria.js

@@ -2,16 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Criteria = void 0;
 class Criteria {
-    constructor(filters, order, limit, offset) {
+    constructor(filters, order, limit = 10, currentPage = 1) {
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new Error("CRITERIA_LIMIT_MUST_BE_A_POSITIVE_INTEGER");
+        }
+        if (!Number.isInteger(currentPage) || currentPage <= 0) {
+            throw new Error("CRITERIA_PAGE_MUST_BE_A_POSITIVE_INTEGER");
+        }
         this.filters = filters;
         this.order = order;
         this.limit = limit;
-        this.currentPage = offset;
-        if (offset && limit) {
-            this.offset = offset > 0 ? (offset - 1) * limit : 0;
-        }
-        else
-            this.offset = undefined;
+        this.currentPage = currentPage;
+        this.offset = (currentPage - 1) * limit;
     }
     hasFilters() {
         return this.filters.filters.length > 0;

package/dist/cjs/mongo/MongoCriteriaConverter.js

@@ -27,8 +27,8 @@ class MongoCriteriaConverter {
             sort: criteria.order.hasOrder()
                 ? this.generateSort(criteria.order)
                 : { _id: -1 },
-            skip: criteria.offset || 0,
-            limit: criteria.limit || 0,
+            skip: criteria.offset,
+            limit: criteria.limit,
         };
     }
     generateFilter(filters) {

package/dist/cjs/mongo/MongoRepository.js

@@ -20,36 +20,39 @@ class MongoRepository {
         if (!result) {
             return null;
         }
-        return this.aggregateRootClass.fromPrimitives({
-            ...result,
-            id: result._id.toString(),
-        });
+        const { _id, ...primitives } = result;
+        const entity = this.aggregateRootClass.fromPrimitives(primitives);
+        entity.assignId(_id.toString());
+        return entity;
     }
+    /**
+     *
+     * @param filter
+     * @param options
+     */
     async many(filter, options) {
         const collection = await this.collection();
-        const session = options?.transaction
-            ? MongoTransaction_1.MongoTransaction.sessionFor(options?.transaction)
-            : undefined;
-        const hasFields = options?.fields && options.fields.length > 0;
-        const projection = hasFields ? {} : undefined;
-        if (hasFields) {
-            options.fields.forEach((field) => {
-                projection[field] = 1;
-            });
+        let order = { _id: -1 };
+        if (options?.sort?.hasOrder()) {
+            order = {
+                [options?.sort.orderBy.value === "id"
+                    ? "_id"
+                    : options?.sort.orderBy.value]: options.sort.orderType.isAsc()
+                    ? 1
+                    : -1,
+            };
         }
-        const findOptions = session
-            ? { ...(projection ? { projection } : {}), session }
-            : projection
-                ? { projection }
-                : undefined;
+        const session = MongoTransaction_1.MongoTransaction.sessionFor(options?.transaction);
         const documents = await collection
-            .find(filter, findOptions)
-            .sort(options?.sort ? options?.sort : { _id: -1 })
+            .find(filter, session ? { session } : undefined)
+            .sort(order)
             .toArray();
-        return documents.map((document) => this.aggregateRootClass.fromPrimitives({
-            ...document,
-            id: document._id.toString(),
-        }));
+        return documents.map((document) => {
+            const { _id, ...primitives } = document;
+            const entity = this.aggregateRootClass.fromPrimitives(primitives);
+            entity.assignId(_id.toString());
+            return entity;
+        });
     }
     /** Upserts an aggregate by delegating to persist with its id. */
     async upsert(entity, transaction) {
@@ -67,15 +70,17 @@ class MongoRepository {
         }, transaction);
     }
     /** Lists entities by criteria and returns a paginated response. */
-    async list(criteria, fieldsToExclude = [], transaction) {
-        const documents = await this.searchByCriteria(criteria, fieldsToExclude, transaction);
-        return this.paginate(documents, transaction);
+    async list(criteria, transaction) {
+        const query = this.criteriaConverter.convert(criteria);
+        const documents = await this.searchByCriteria(query, transaction);
+        return this.paginate(documents, query, criteria, transaction);
     }
     /**
      * Deletes documents from the database based on a filter and optional options.
      *
      * @param {object} filter - The query to match documents that should be deleted.
      * @param {DeleteOptions} [options] - Optional parameters that modify the behavior of the delete operation.
+     * @param transaction
      * @return {Promise<void>} A promise that resolves when the deletion is complete, or rejects if an error occurs.
      */
     async delete(filter, options, transaction) {
@@ -105,50 +110,37 @@ class MongoRepository {
             .db()
             .collection(this.collectionName());
     }
-    async searchByCriteria(criteria, fieldsToExclude = [], transaction) {
-        this.criteria = criteria;
-        this.query = this.criteriaConverter.convert(criteria);
+    async searchByCriteria(query, transaction) {
         const collection = await this.collection();
         const session = MongoTransaction_1.MongoTransaction.sessionFor(transaction);
-        if (fieldsToExclude.length === 0) {
-            const results = await collection
-                .find(this.query.filter, session ? { session } : {})
-                .sort(this.query.sort)
-                .skip(this.query.skip)
-                .limit(this.query.limit)
-                .toArray();
-            return results.map(({ _id, ...rest }) => rest);
-        }
-        const projection = {};
-        fieldsToExclude.forEach((field) => {
-            projection[field] = 0;
-        });
         const results = await collection
-            .find(this.query.filter, session ? { projection, session } : { projection })
-            .sort(this.query.sort)
-            .skip(this.query.skip)
-            .limit(this.query.limit)
+            .find(query.filter, session ? { session } : undefined)
+            .sort(query.sort)
+            .skip(query.skip)
+            .limit(query.limit)
             .toArray();
-        return results.map(({ _id, ...rest }) => rest);
+        return results.map(({ _id, ...rest }) => {
+            const entity = this.aggregateRootClass.fromPrimitives(rest);
+            entity.assignId(_id.toString());
+            return entity;
+        });
     }
-    async paginate(documents, transaction) {
+    async paginate(documents, query, criteria, transaction) {
         const collection = await this.collection();
         const session = MongoTransaction_1.MongoTransaction.sessionFor(transaction);
-        const count = session
-            ? await collection.countDocuments(this.query.filter, { session })
-            : await collection.countDocuments(this.query.filter);
-        const limit = this.criteria?.limit || 10;
-        const currentPage = this.criteria?.currentPage || 1;
-        const hasNextPage = currentPage * limit < count;
+        const count = await collection.countDocuments(query.filter, session ? { session } : undefined);
+        const limit = criteria.limit;
+        const currentPage = criteria.currentPage;
+        const hasNextPage = limit > 0 && currentPage * limit < count;
         if (documents.length === 0) {
             return {
                 nextPag: null,
-                count: 0,
+                count,
                 results: [],
             };
         }
         return {
-            nextPag: hasNextPage ? Number(this.criteria.currentPage) + 1 : null,
+            nextPag: hasNextPage ? Number(criteria.currentPage) + 1 : null,
             count: count,
             results: documents,
         };

package/dist/esm/AggregateRoot.js

@@ -1,7 +1,4 @@
 export class AggregateRoot {
-    constructor(id) {
-        this.aggregateId = id;
-    }
     getId() {
         return this.aggregateId;
     }

package/dist/esm/criteria/Criteria.js

@@ -1,14 +1,16 @@
 export class Criteria {
-    constructor(filters, order, limit, offset) {
+    constructor(filters, order, limit = 10, currentPage = 1) {
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new Error("CRITERIA_LIMIT_MUST_BE_A_POSITIVE_INTEGER");
+        }
+        if (!Number.isInteger(currentPage) || currentPage <= 0) {
+            throw new Error("CRITERIA_PAGE_MUST_BE_A_POSITIVE_INTEGER");
+        }
         this.filters = filters;
         this.order = order;
         this.limit = limit;
-        this.currentPage = offset;
-        if (offset && limit) {
-            this.offset = offset > 0 ? (offset - 1) * limit : 0;
-        }
-        else
-            this.offset = undefined;
+        this.currentPage = currentPage;
+        this.offset = (currentPage - 1) * limit;
     }
     hasFilters() {
         return this.filters.filters.length > 0;

package/dist/esm/mongo/MongoCriteriaConverter.js

@@ -24,8 +24,8 @@ export class MongoCriteriaConverter {
             sort: criteria.order.hasOrder()
                 ? this.generateSort(criteria.order)
                 : { _id: -1 },
-            skip: criteria.offset || 0,
-            limit: criteria.limit || 0,
+            skip: criteria.offset,
+            limit: criteria.limit,
         };
     }
     generateFilter(filters) {

package/dist/esm/mongo/MongoRepository.js

@@ -17,36 +17,39 @@ export class MongoRepository {
         if (!result) {
             return null;
         }
-        return this.aggregateRootClass.fromPrimitives({
-            ...result,
-            id: result._id.toString(),
-        });
+        const { _id, ...primitives } = result;
+        const entity = this.aggregateRootClass.fromPrimitives(primitives);
+        entity.assignId(_id.toString());
+        return entity;
     }
+    /**
+     *
+     * @param filter
+     * @param options
+     */
     async many(filter, options) {
         const collection = await this.collection();
-        const session = options?.transaction
-            ? MongoTransaction.sessionFor(options?.transaction)
-            : undefined;
-        const hasFields = options?.fields && options.fields.length > 0;
-        const projection = hasFields ? {} : undefined;
-        if (hasFields) {
-            options.fields.forEach((field) => {
-                projection[field] = 1;
-            });
+        let order = { _id: -1 };
+        if (options?.sort?.hasOrder()) {
+            order = {
+                [options?.sort.orderBy.value === "id"
+                    ? "_id"
+                    : options?.sort.orderBy.value]: options.sort.orderType.isAsc()
+                    ? 1
+                    : -1,
+            };
         }
-        const findOptions = session
-            ? { ...(projection ? { projection } : {}), session }
-            : projection
-                ? { projection }
-                : undefined;
+        const session = MongoTransaction.sessionFor(options?.transaction);
         const documents = await collection
-            .find(filter, findOptions)
-            .sort(options?.sort ? options?.sort : { _id: -1 })
+            .find(filter, session ? { session } : undefined)
+            .sort(order)
             .toArray();
-        return documents.map((document) => this.aggregateRootClass.fromPrimitives({
-            ...document,
-            id: document._id.toString(),
-        }));
+        return documents.map((document) => {
+            const { _id, ...primitives } = document;
+            const entity = this.aggregateRootClass.fromPrimitives(primitives);
+            entity.assignId(_id.toString());
+            return entity;
+        });
     }
     /** Upserts an aggregate by delegating to persist with its id. */
     async upsert(entity, transaction) {
@@ -64,15 +67,17 @@ export class MongoRepository {
         }, transaction);
     }
     /** Lists entities by criteria and returns a paginated response. */
-    async list(criteria, fieldsToExclude = [], transaction) {
-        const documents = await this.searchByCriteria(criteria, fieldsToExclude, transaction);
-        return this.paginate(documents, transaction);
+    async list(criteria, transaction) {
+        const query = this.criteriaConverter.convert(criteria);
+        const documents = await this.searchByCriteria(query, transaction);
+        return this.paginate(documents, query, criteria, transaction);
     }
     /**
      * Deletes documents from the database based on a filter and optional options.
      *
      * @param {object} filter - The query to match documents that should be deleted.
      * @param {DeleteOptions} [options] - Optional parameters that modify the behavior of the delete operation.
+     * @param transaction
      * @return {Promise<void>} A promise that resolves when the deletion is complete, or rejects if an error occurs.
      */
     async delete(filter, options, transaction) {
@@ -102,50 +107,37 @@ export class MongoRepository {
             .db()
             .collection(this.collectionName());
     }
-    async searchByCriteria(criteria, fieldsToExclude = [], transaction) {
-        this.criteria = criteria;
-        this.query = this.criteriaConverter.convert(criteria);
+    async searchByCriteria(query, transaction) {
         const collection = await this.collection();
         const session = MongoTransaction.sessionFor(transaction);
-        if (fieldsToExclude.length === 0) {
-            const results = await collection
-                .find(this.query.filter, session ? { session } : {})
-                .sort(this.query.sort)
-                .skip(this.query.skip)
-                .limit(this.query.limit)
-                .toArray();
-            return results.map(({ _id, ...rest }) => rest);
-        }
-        const projection = {};
-        fieldsToExclude.forEach((field) => {
-            projection[field] = 0;
-        });
         const results = await collection
-            .find(this.query.filter, session ? { projection, session } : { projection })
-            .sort(this.query.sort)
-            .skip(this.query.skip)
-            .limit(this.query.limit)
+            .find(query.filter, session ? { session } : undefined)
+            .sort(query.sort)
+            .skip(query.skip)
+            .limit(query.limit)
             .toArray();
-        return results.map(({ _id, ...rest }) => rest);
+        return results.map(({ _id, ...rest }) => {
+            const entity = this.aggregateRootClass.fromPrimitives(rest);
+            entity.assignId(_id.toString());
+            return entity;
+        });
     }
-    async paginate(documents, transaction) {
+    async paginate(documents, query, criteria, transaction) {
         const collection = await this.collection();
         const session = MongoTransaction.sessionFor(transaction);
-        const count = session
-            ? await collection.countDocuments(this.query.filter, { session })
-            : await collection.countDocuments(this.query.filter);
-        const limit = this.criteria?.limit || 10;
-        const currentPage = this.criteria?.currentPage || 1;
-        const hasNextPage = currentPage * limit < count;
+        const count = await collection.countDocuments(query.filter, session ? { session } : undefined);
+        const limit = criteria.limit;
+        const currentPage = criteria.currentPage;
+        const hasNextPage = limit > 0 && currentPage * limit < count;
         if (documents.length === 0) {
             return {
                 nextPag: null,
-                count: 0,
+                count,
                 results: [],
             };
         }
         return {
-            nextPag: hasNextPage ? Number(this.criteria.currentPage) + 1 : null,
+            nextPag: hasNextPage ? Number(criteria.currentPage) + 1 : null,
             count: count,
             results: documents,
         };

package/dist/types/AggregateRoot.d.ts

@@ -1,12 +1,9 @@
 export declare abstract class AggregateRoot {
     private aggregateId?;
-    protected constructor(id?: string);
     getId(): string | undefined;
     assignId(mongoId: string): void;
     abstract toPrimitives(): any;
 }
 export type AggregateRootClass<T extends AggregateRoot> = {
-    fromPrimitives(data: Record<string, unknown> & {
-        readonly id: string;
-    }): T;
+    fromPrimitives(data: Record<string, unknown>): T;
 };

package/dist/types/criteria/Criteria.d.ts

@@ -3,9 +3,9 @@ import { Order } from "./Order";
 export declare class Criteria {
     readonly filters: Filters;
     readonly order: Order;
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly currentPage?: number;
-    constructor(filters: Filters, order: Order, limit?: number, offset?: number);
+    readonly limit: number;
+    readonly offset: number;
+    readonly currentPage: number;
+    constructor(filters: Filters, order: Order, limit?: number, currentPage?: number);
     hasFilters(): boolean;
 }

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./criteria";
 export * from "./mongo";
 export * from "./AggregateRoot";
-export type { MongoSort, MongoDirection } from "./types";

package/dist/types/mongo/IRepository.d.ts

@@ -1,16 +1,14 @@
-import { Criteria, Paginate } from "../criteria";
+import { Criteria, Order, Paginate } from "../criteria";
 import { AggregateRoot } from "../AggregateRoot";
 import { DeleteOptions } from "mongodb";
 import { MongoTransaction } from "./MongoTransaction";
-import { MongoSort } from "../types";
 export interface IRepository<T extends AggregateRoot> {
     many(filter: object, options?: {
         transaction?: MongoTransaction;
-        fields?: string[];
-        sort?: MongoSort;
+        sort?: Order;
     }): Promise<T[]>;
     one(filter: object, transaction?: MongoTransaction): Promise<T | null>;
-    list<D>(criteria: Criteria, fieldsToExclude?: string[], transaction?: MongoTransaction): Promise<Paginate<D>>;
+    list(criteria: Criteria, transaction?: MongoTransaction): Promise<Paginate<T>>;
     upsert(entity: T, transaction?: MongoTransaction): Promise<void>;
     delete(filter: object, options?: DeleteOptions, transaction?: MongoTransaction): Promise<void>;
 }

package/dist/types/mongo/MongoRepository.d.ts

@@ -1,32 +1,34 @@
 import { MongoTransaction } from "./MongoTransaction";
-import { Criteria, Paginate } from "../criteria";
+import { Criteria, Order, Paginate } from "../criteria";
 import { AggregateRoot, AggregateRootClass } from "../AggregateRoot";
 import { Collection, DeleteOptions, Document, UpdateFilter } from "mongodb";
-import { MongoSort } from "../types";
 export declare abstract class MongoRepository<T extends AggregateRoot> {
     private readonly aggregateRootClass;
     private static indexRegistry;
     private criteriaConverter;
-    private query;
-    private criteria;
     protected constructor(aggregateRootClass: AggregateRootClass<T>);
     abstract collectionName(): string;
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
     one(filter: object, transaction?: MongoTransaction): Promise<T | null>;
+    /**
+     *
+     * @param filter
+     * @param options
+     */
     many(filter: object, options?: {
         transaction?: MongoTransaction;
-        fields?: string[];
-        sort?: MongoSort;
+        sort?: Order;
     }): Promise<T[]>;
     /** Upserts an aggregate by delegating to persist with its id. */
     upsert(entity: T, transaction?: MongoTransaction): Promise<void>;
     /** Lists entities by criteria and returns a paginated response. */
-    list<D>(criteria: Criteria, fieldsToExclude?: string[], transaction?: MongoTransaction): Promise<Paginate<D>>;
+    list(criteria: Criteria, transaction?: MongoTransaction): Promise<Paginate<T>>;
     /**
      * Deletes documents from the database based on a filter and optional options.
      *
      * @param {object} filter - The query to match documents that should be deleted.
      * @param {DeleteOptions} [options] - Optional parameters that modify the behavior of the delete operation.
+     * @param transaction
      * @return {Promise<void>} A promise that resolves when the deletion is complete, or rejects if an error occurs.
      */
     delete(filter: object, options?: DeleteOptions, transaction?: MongoTransaction): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abejarano/ts-mongodb-criteria",
   "author": "angel bejarano / angel.bejarano@jaspesoft.com",
-  "version": "1.11.1",
+  "version": "1.11.3",
   "description": "Patrón Criteria para consultas MongoDB en TypeScript",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",