@abejarano/ts-mongodb-criteria 1.9.0 → 1.11.0

package/README.md

@@ -182,8 +182,9 @@ 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
-- `one(filter)` to fetch a single entity
-- `upsert(entity)` to persist an aggregate
+- `many(filter, transaction?)` to fetch multiple entities matching a filter
+- `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
   directly.
 
@@ -214,6 +215,10 @@ await MongoTransaction.run(async (tx) => {
   await userRepository.upsert(user, tx)
   await auditRepository.upsert(auditEntry, tx)
   await sessionRepository.delete({ userId: user.getId() }, undefined, 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)
 })
 ```
 
@@ -232,8 +237,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 only to `upsert`, `delete`, and protected `updateOne`; `one` and `list`
-remain regular reads.
+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`.
 
 **Your First Query in 30 Seconds:**
 

package/dist/cjs/mongo/MongoRepository.js

@@ -11,9 +11,12 @@ class MongoRepository {
         this.criteriaConverter = new MongoCriteriaConverter_1.MongoCriteriaConverter();
     }
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
-    async one(filter) {
+    async one(filter, transaction) {
         const collection = await this.collection();
-        const result = await collection.findOne(filter);
+        const session = MongoTransaction_1.MongoTransaction.sessionFor(transaction);
+        const result = session
+            ? await collection.findOne(filter, { session })
+            : await collection.findOne(filter);
         if (!result) {
             return null;
         }
@@ -22,14 +25,25 @@ class MongoRepository {
             id: result._id.toString(),
         });
     }
+    async many(filter, transaction) {
+        const collection = await this.collection();
+        const session = MongoTransaction_1.MongoTransaction.sessionFor(transaction);
+        const documents = await collection
+            .find(filter, session === undefined ? undefined : { session })
+            .toArray();
+        return documents.map((document) => this.aggregateRootClass.fromPrimitives({
+            ...document,
+            id: document._id.toString(),
+        }));
+    }
     /** Upserts an aggregate by delegating to persist with its id. */
     async upsert(entity, transaction) {
         await this.persist(entity.getId(), entity, transaction);
     }
     /** Lists entities by criteria and returns a paginated response. */
-    async list(criteria, fieldsToExclude = []) {
-        const documents = await this.searchByCriteria(criteria, fieldsToExclude);
-        return this.paginate(documents);
+    async list(criteria, fieldsToExclude = [], transaction) {
+        const documents = await this.searchByCriteria(criteria, fieldsToExclude, transaction);
+        return this.paginate(documents, transaction);
     }
     /**
      * Deletes documents from the database based on a filter and optional options.
@@ -80,13 +94,14 @@ class MongoRepository {
             },
         }, transaction);
     }
-    async searchByCriteria(criteria, fieldsToExclude = []) {
+    async searchByCriteria(criteria, fieldsToExclude = [], transaction) {
         this.criteria = criteria;
         this.query = this.criteriaConverter.convert(criteria);
         const collection = await this.collection();
+        const session = MongoTransaction_1.MongoTransaction.sessionFor(transaction);
         if (fieldsToExclude.length === 0) {
             const results = await collection
-                .find(this.query.filter, {})
+                .find(this.query.filter, session ? { session } : {})
                 .sort(this.query.sort)
                 .skip(this.query.skip)
                 .limit(this.query.limit)
@@ -98,16 +113,19 @@ class MongoRepository {
             projection[field] = 0;
         });
         const results = await collection
-            .find(this.query.filter, { projection })
+            .find(this.query.filter, session ? { projection, session } : { projection })
             .sort(this.query.sort)
             .skip(this.query.skip)
             .limit(this.query.limit)
             .toArray();
         return results.map(({ _id, ...rest }) => rest);
     }
-    async paginate(documents) {
+    async paginate(documents, transaction) {
         const collection = await this.collection();
-        const count = await collection.countDocuments(this.query.filter);
+        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;

package/dist/esm/mongo/MongoRepository.js

@@ -8,9 +8,12 @@ export class MongoRepository {
         this.criteriaConverter = new MongoCriteriaConverter();
     }
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
-    async one(filter) {
+    async one(filter, transaction) {
         const collection = await this.collection();
-        const result = await collection.findOne(filter);
+        const session = MongoTransaction.sessionFor(transaction);
+        const result = session
+            ? await collection.findOne(filter, { session })
+            : await collection.findOne(filter);
         if (!result) {
             return null;
         }
@@ -19,14 +22,25 @@ export class MongoRepository {
             id: result._id.toString(),
         });
     }
+    async many(filter, transaction) {
+        const collection = await this.collection();
+        const session = MongoTransaction.sessionFor(transaction);
+        const documents = await collection
+            .find(filter, session === undefined ? undefined : { session })
+            .toArray();
+        return documents.map((document) => this.aggregateRootClass.fromPrimitives({
+            ...document,
+            id: document._id.toString(),
+        }));
+    }
     /** Upserts an aggregate by delegating to persist with its id. */
     async upsert(entity, transaction) {
         await this.persist(entity.getId(), entity, transaction);
     }
     /** Lists entities by criteria and returns a paginated response. */
-    async list(criteria, fieldsToExclude = []) {
-        const documents = await this.searchByCriteria(criteria, fieldsToExclude);
-        return this.paginate(documents);
+    async list(criteria, fieldsToExclude = [], transaction) {
+        const documents = await this.searchByCriteria(criteria, fieldsToExclude, transaction);
+        return this.paginate(documents, transaction);
     }
     /**
      * Deletes documents from the database based on a filter and optional options.
@@ -77,13 +91,14 @@ export class MongoRepository {
             },
         }, transaction);
     }
-    async searchByCriteria(criteria, fieldsToExclude = []) {
+    async searchByCriteria(criteria, fieldsToExclude = [], transaction) {
         this.criteria = criteria;
         this.query = this.criteriaConverter.convert(criteria);
         const collection = await this.collection();
+        const session = MongoTransaction.sessionFor(transaction);
         if (fieldsToExclude.length === 0) {
             const results = await collection
-                .find(this.query.filter, {})
+                .find(this.query.filter, session ? { session } : {})
                 .sort(this.query.sort)
                 .skip(this.query.skip)
                 .limit(this.query.limit)
@@ -95,16 +110,19 @@ export class MongoRepository {
             projection[field] = 0;
         });
         const results = await collection
-            .find(this.query.filter, { projection })
+            .find(this.query.filter, session ? { projection, session } : { projection })
             .sort(this.query.sort)
             .skip(this.query.skip)
             .limit(this.query.limit)
             .toArray();
         return results.map(({ _id, ...rest }) => rest);
     }
-    async paginate(documents) {
+    async paginate(documents, transaction) {
         const collection = await this.collection();
-        const count = await collection.countDocuments(this.query.filter);
+        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;

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

@@ -3,8 +3,9 @@ import { AggregateRoot } from "../AggregateRoot";
 import { DeleteOptions } from "mongodb";
 import { MongoTransaction } from "./MongoTransaction";
 export interface IRepository<T extends AggregateRoot> {
-    one(filter: object): Promise<T | null>;
-    list<D>(criteria: Criteria, fieldsToExclude?: string[]): Promise<Paginate<D>>;
+    many(filter: object, transaction?: MongoTransaction): 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>;
     delete(filter: object, options?: DeleteOptions, transaction?: MongoTransaction): Promise<void>;
 }

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

@@ -11,11 +11,12 @@ export declare abstract class MongoRepository<T extends AggregateRoot> {
     protected constructor(aggregateRootClass: AggregateRootClass<T>);
     abstract collectionName(): string;
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
-    one(filter: object): Promise<T | null>;
+    one(filter: object, transaction?: MongoTransaction): Promise<T | null>;
+    many(filter: object, transaction?: MongoTransaction): 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[]): Promise<Paginate<D>>;
+    list<D>(criteria: Criteria, fieldsToExclude?: string[], transaction?: MongoTransaction): Promise<Paginate<D>>;
     /**
      * Deletes documents from the database based on a filter and optional options.
      *

package/package.json

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