@abejarano/ts-mongodb-criteria 1.11.0 → 1.11.2

package/README.md

@@ -6,7 +6,7 @@
 [![MongoDB](https://img.shields.io/badge/MongoDB-6.0+-green.svg)](https://www.mongodb.com/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node.js](https://img.shields.io/badge/Node.js-20+-green.svg)](https://nodejs.org/)
-[![Tests](https://img.shields.io/badge/Tests-30%2F30%20passing-brightgreen.svg)](#testing)
+[![Tests](https://img.shields.io/badge/Tests-46%2F46%20passing-brightgreen.svg)](#testing)
 
 > A robust, type-safe implementation of the **Criteria Pattern** for MongoDB queries in TypeScript. Build complex database queries dynamically with a fluent, composable API designed following Domain-Driven Design (DDD) and Clean Architecture principles.
 
@@ -182,7 +182,7 @@ 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, transaction?)` to fetch multiple entities matching a filter
+- `many(filter, options?)` to fetch multiple entities matching a filter, with optional `{ transaction?, fieldsToExclude?, 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
@@ -199,8 +199,8 @@ export interface IUserRepository extends IRepository<User> {
 }
 ```
 
-The goal of `IRepository` is to prevent signature drift (e.g. `upsert` returning
-`void` in your app while the base repository returns `ObjectId | null`).
+The goal of `IRepository` is to prevent signature drift between your app's
+interfaces and the library's repository return types.
 
 ## Atomic Transactions
 
@@ -218,7 +218,10 @@ await MongoTransaction.run(async (tx) => {
 
   // Reads can observe writes made earlier in this transaction.
   const persistedUser = await userRepository.one({ id: user.getId() }, tx)
-  const activeUsers = await userRepository.many({ status: "active" }, tx)
+  const activeUsers = await userRepository.many(
+    { status: "active" },
+    { transaction: tx, sort: Order.asc("name") }
+  )
 })
 ```
 
@@ -237,8 +240,8 @@ 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`, and `list`.
-Pass `tx` as the third argument to `list` after `fieldsToExclude`, and as the second argument to `many`.
+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`.
 
 **Your First Query in 30 Seconds:**
 
@@ -385,7 +388,7 @@ const criteria = new Criteria(Filters.fromValues(filters), Order.none())
 
 ## 🧪 Testing
 
-The library includes comprehensive test coverage (30/30 tests passing).
+The library includes comprehensive test coverage (46/46 tests passing).
 
 ```bash
 # Run all tests

package/dist/cjs/AggregateRoot.js

@@ -2,8 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateRoot = void 0;
 class AggregateRoot {
-    static fromPrimitives(_data) {
-        throw new Error("fromPrimitives must be implemented in subclasses");
+    constructor(id) {
+        this.aggregateId = id;
+    }
+    getId() {
+        return this.aggregateId;
+    }
+    assignId(mongoId) {
+        if (this.aggregateId !== undefined) {
+            throw new Error("AGGREGATE_ID_ALREADY_ASSIGNED");
+        }
+        this.aggregateId = mongoId;
     }
 }
 exports.AggregateRoot = AggregateRoot;

package/dist/cjs/mongo/MongoRepository.js

@@ -25,11 +25,43 @@ class MongoRepository {
             id: result._id.toString(),
         });
     }
-    async many(filter, transaction) {
+    /**
+     *
+     * @param filter
+     * @param options
+     */
+    async many(filter, options) {
         const collection = await this.collection();
-        const session = MongoTransaction_1.MongoTransaction.sessionFor(transaction);
+        const session = options?.transaction
+            ? MongoTransaction_1.MongoTransaction.sessionFor(options?.transaction)
+            : undefined;
+        const hasFields = options?.fieldsToExclude && options.fieldsToExclude.length > 0;
+        const projection = hasFields
+            ? {}
+            : undefined;
+        if (hasFields) {
+            options.fieldsToExclude.forEach((field) => {
+                projection[field] = 0;
+            });
+        }
+        const findOptions = session
+            ? { ...(projection ? { projection } : {}), session }
+            : projection
+                ? { projection }
+                : undefined;
+        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 documents = await collection
-            .find(filter, session === undefined ? undefined : { session })
+            .find(filter, findOptions)
+            .sort(order)
             .toArray();
         return documents.map((document) => this.aggregateRootClass.fromPrimitives({
             ...document,
@@ -38,7 +70,18 @@ class MongoRepository {
     }
     /** Upserts an aggregate by delegating to persist with its id. */
     async upsert(entity, transaction) {
-        await this.persist(entity.getId(), entity, transaction);
+        const primitiveResult = entity.toPrimitives();
+        const primitives = await Promise.resolve(primitiveResult);
+        const currentId = entity.getId();
+        const mongoId = currentId === undefined ? new mongodb_1.ObjectId() : new mongodb_1.ObjectId(currentId);
+        if (currentId === undefined) {
+            entity.assignId(mongoId.toString());
+        }
+        await this.updateOne({ _id: mongoId }, {
+            $set: {
+                ...primitives,
+            },
+        }, transaction);
     }
     /** Lists entities by criteria and returns a paginated response. */
     async list(criteria, fieldsToExclude = [], transaction) {
@@ -50,6 +93,7 @@ class MongoRepository {
      *
      * @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) {
@@ -79,21 +123,6 @@ class MongoRepository {
             .db()
             .collection(this.collectionName());
     }
-    async persist(id, aggregateRoot, transaction) {
-        let primitives;
-        if (aggregateRoot.toPrimitives() instanceof Promise) {
-            primitives = await aggregateRoot.toPrimitives();
-        }
-        else {
-            primitives = aggregateRoot.toPrimitives();
-        }
-        await this.updateOne({ _id: new mongodb_1.ObjectId(id) }, {
-            $set: {
-                ...primitives,
-                id: id,
-            },
-        }, transaction);
-    }
     async searchByCriteria(criteria, fieldsToExclude = [], transaction) {
         this.criteria = criteria;
         this.query = this.criteriaConverter.convert(criteria);

package/dist/cjs/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/AggregateRoot.js

@@ -1,5 +1,14 @@
 export class AggregateRoot {
-    static fromPrimitives(_data) {
-        throw new Error("fromPrimitives must be implemented in subclasses");
+    constructor(id) {
+        this.aggregateId = id;
+    }
+    getId() {
+        return this.aggregateId;
+    }
+    assignId(mongoId) {
+        if (this.aggregateId !== undefined) {
+            throw new Error("AGGREGATE_ID_ALREADY_ASSIGNED");
+        }
+        this.aggregateId = mongoId;
     }
 }

package/dist/esm/mongo/MongoRepository.js

@@ -22,11 +22,43 @@ export class MongoRepository {
             id: result._id.toString(),
         });
     }
-    async many(filter, transaction) {
+    /**
+     *
+     * @param filter
+     * @param options
+     */
+    async many(filter, options) {
         const collection = await this.collection();
-        const session = MongoTransaction.sessionFor(transaction);
+        const session = options?.transaction
+            ? MongoTransaction.sessionFor(options?.transaction)
+            : undefined;
+        const hasFields = options?.fieldsToExclude && options.fieldsToExclude.length > 0;
+        const projection = hasFields
+            ? {}
+            : undefined;
+        if (hasFields) {
+            options.fieldsToExclude.forEach((field) => {
+                projection[field] = 0;
+            });
+        }
+        const findOptions = session
+            ? { ...(projection ? { projection } : {}), session }
+            : projection
+                ? { projection }
+                : undefined;
+        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 documents = await collection
-            .find(filter, session === undefined ? undefined : { session })
+            .find(filter, findOptions)
+            .sort(order)
             .toArray();
         return documents.map((document) => this.aggregateRootClass.fromPrimitives({
             ...document,
@@ -35,7 +67,18 @@ export class MongoRepository {
     }
     /** Upserts an aggregate by delegating to persist with its id. */
     async upsert(entity, transaction) {
-        await this.persist(entity.getId(), entity, transaction);
+        const primitiveResult = entity.toPrimitives();
+        const primitives = await Promise.resolve(primitiveResult);
+        const currentId = entity.getId();
+        const mongoId = currentId === undefined ? new ObjectId() : new ObjectId(currentId);
+        if (currentId === undefined) {
+            entity.assignId(mongoId.toString());
+        }
+        await this.updateOne({ _id: mongoId }, {
+            $set: {
+                ...primitives,
+            },
+        }, transaction);
     }
     /** Lists entities by criteria and returns a paginated response. */
     async list(criteria, fieldsToExclude = [], transaction) {
@@ -47,6 +90,7 @@ export class MongoRepository {
      *
      * @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) {
@@ -76,21 +120,6 @@ export class MongoRepository {
             .db()
             .collection(this.collectionName());
     }
-    async persist(id, aggregateRoot, transaction) {
-        let primitives;
-        if (aggregateRoot.toPrimitives() instanceof Promise) {
-            primitives = await aggregateRoot.toPrimitives();
-        }
-        else {
-            primitives = aggregateRoot.toPrimitives();
-        }
-        await this.updateOne({ _id: new ObjectId(id) }, {
-            $set: {
-                ...primitives,
-                id: id,
-            },
-        }, transaction);
-    }
     async searchByCriteria(criteria, fieldsToExclude = [], transaction) {
         this.criteria = criteria;
         this.query = this.criteriaConverter.convert(criteria);

package/dist/esm/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/AggregateRoot.d.ts

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

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

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

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

@@ -1,23 +1,5 @@
 import { Criteria, Filters, Order } from "../criteria";
-type MongoFilterOperator = "$eq" | "$ne" | "$gt" | "$lt" | "$regex" | "$lte" | "$gte" | "$or" | "$in" | "$nin";
-type MongoFilterValue = boolean | string | number | Date;
-type MongoFilterArrayValue = MongoFilterValue[];
-type MongoFilterOperation = {
-    [operator in MongoFilterOperator]?: MongoFilterValue | MongoFilterArrayValue;
-};
-type MongoFilter = {
-    [field: string]: MongoFilterOperation;
-} | {
-    [field: string]: {
-        $not: MongoFilterOperation;
-    };
-} | {
-    $or: any[];
-};
-type MongoDirection = 1 | -1;
-type MongoSort = {
-    [field: string]: MongoDirection;
-};
+import { MongoFilter, MongoSort } from "../types";
 export interface MongoQuery {
     filter: MongoFilter;
     sort: MongoSort;
@@ -43,4 +25,3 @@ export declare class MongoCriteriaConverter {
     private orFilter;
     private betweenFilter;
 }
-export {};

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

@@ -1,5 +1,5 @@
 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";
 export declare abstract class MongoRepository<T extends AggregateRoot> {
@@ -12,7 +12,16 @@ export declare abstract class MongoRepository<T extends AggregateRoot> {
     abstract collectionName(): string;
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
     one(filter: object, transaction?: MongoTransaction): Promise<T | null>;
-    many(filter: object, transaction?: MongoTransaction): Promise<T[]>;
+    /**
+     *
+     * @param filter
+     * @param options
+     */
+    many(filter: object, options?: {
+        transaction?: MongoTransaction;
+        fieldsToExclude?: string[];
+        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. */
@@ -22,6 +31,7 @@ export declare abstract class MongoRepository<T extends AggregateRoot> {
      *
      * @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>;
@@ -30,7 +40,6 @@ export declare abstract class MongoRepository<T extends AggregateRoot> {
     protected collection<U extends Document>(): Promise<Collection<U>>;
     protected updateOne(filter: object, update: Document[] | UpdateFilter<any>, transaction?: MongoTransaction): Promise<void>;
     private collectionRaw;
-    private persist;
     private searchByCriteria;
     private paginate;
 }

package/dist/types/types/index.d.ts

@@ -0,0 +1,25 @@
+export type MongoFilterOperator = "$eq" | "$ne" | "$gt" | "$lt" | "$regex" | "$lte" | "$gte" | "$or" | "$in" | "$nin";
+export type MongoFilterBetween = {
+    [p: string]: {
+        $gte: MongoFilterValue;
+        $lte: MongoFilterValue;
+    };
+};
+export type MongoFilterValue = boolean | string | number | Date;
+export type MongoFilterArrayValue = MongoFilterValue[];
+export type MongoFilterOperation = {
+    [operator in MongoFilterOperator]?: MongoFilterValue | MongoFilterArrayValue;
+};
+export type MongoFilter = {
+    [field: string]: MongoFilterOperation;
+} | {
+    [field: string]: {
+        $not: MongoFilterOperation;
+    };
+} | {
+    $or: any[];
+};
+export type MongoDirection = 1 | -1;
+export type MongoSort = {
+    [field: string]: MongoDirection;
+};

package/package.json

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