@abejarano/ts-mongodb-criteria 1.11.1 → 1.11.2

package/README.md

@@ -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, options?)` to fetch multiple entities matching a filter, with optional `{ transaction?, sort }`
+- `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
@@ -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") }
   )
 })
 ```

package/dist/cjs/mongo/MongoRepository.js

@@ -25,16 +25,23 @@ class MongoRepository {
             id: result._id.toString(),
         });
     }
+    /**
+     *
+     * @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;
+        const hasFields = options?.fieldsToExclude && options.fieldsToExclude.length > 0;
+        const projection = hasFields
+            ? {}
+            : undefined;
         if (hasFields) {
-            options.fields.forEach((field) => {
-                projection[field] = 1;
+            options.fieldsToExclude.forEach((field) => {
+                projection[field] = 0;
             });
         }
         const findOptions = session
@@ -42,9 +49,19 @@ class MongoRepository {
             : 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, findOptions)
-            .sort(options?.sort ? options?.sort : { _id: -1 })
+            .sort(order)
             .toArray();
         return documents.map((document) => this.aggregateRootClass.fromPrimitives({
             ...document,
@@ -76,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) {

package/dist/esm/mongo/MongoRepository.js

@@ -22,16 +22,23 @@ export class MongoRepository {
             id: result._id.toString(),
         });
     }
+    /**
+     *
+     * @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;
+        const hasFields = options?.fieldsToExclude && options.fieldsToExclude.length > 0;
+        const projection = hasFields
+            ? {}
+            : undefined;
         if (hasFields) {
-            options.fields.forEach((field) => {
-                projection[field] = 1;
+            options.fieldsToExclude.forEach((field) => {
+                projection[field] = 0;
             });
         }
         const findOptions = session
@@ -39,9 +46,19 @@ export class MongoRepository {
             : 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, findOptions)
-            .sort(options?.sort ? options?.sort : { _id: -1 })
+            .sort(order)
             .toArray();
         return documents.map((document) => this.aggregateRootClass.fromPrimitives({
             ...document,
@@ -73,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) {

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

@@ -2,12 +2,12 @@ import { Criteria, Paginate } from "../criteria";
 import { AggregateRoot } from "../AggregateRoot";
 import { DeleteOptions } from "mongodb";
 import { MongoTransaction } from "./MongoTransaction";
-import { MongoSort } from "../types";
+import { Order } from "../criteria";
 export interface IRepository<T extends AggregateRoot> {
     many(filter: object, options?: {
         transaction?: MongoTransaction;
-        fields?: string[];
-        sort?: MongoSort;
+        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>>;

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

@@ -1,8 +1,7 @@
 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;
@@ -13,10 +12,15 @@ 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>;
+    /**
+     *
+     * @param filter
+     * @param options
+     */
     many(filter: object, options?: {
         transaction?: MongoTransaction;
-        fields?: string[];
-        sort?: MongoSort;
+        fieldsToExclude?: string[];
+        sort?: Order;
     }): Promise<T[]>;
     /** Upserts an aggregate by delegating to persist with its id. */
     upsert(entity: T, transaction?: MongoTransaction): Promise<void>;
@@ -27,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>;

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.2",
   "description": "Patrón Criteria para consultas MongoDB en TypeScript",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",