@abejarano/ts-mongodb-criteria 1.2.1 → 1.4.0

package/README.md

@@ -156,6 +156,11 @@ const userRepo = new UserRepository()
 const users = await userRepo.searchByCriteria(criteria)
 ```
 
+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
+
 **Your First Query in 30 Seconds:**
 
 ```typescript
@@ -178,7 +183,7 @@ const activeAdultUsers = new Criteria(
   1 // First page
 )
 
-const results = await repository.searchByCriteria(activeAdultUsers)
+const results = await repository.list(activeAdultUsers)
 ```
 
 ## 📖 Documentation
@@ -219,6 +224,10 @@ const order = Order.desc("createdAt") // or Order.asc("name")
 - `CONTAINS`, `NOT_CONTAINS` - Text search
 - `OR` - Logical OR combinations
 
+## ✅ Runtime Compatibility
+
+This library ships dual builds (CJS + ESM) and works in both Node.js and Bun.
+
 ### 🆕 OR Operator Example
 
 ```typescript

package/dist/{AggregateRoot.js → cjs/AggregateRoot.js}

@@ -2,5 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateRoot = void 0;
 class AggregateRoot {
+    static fromPrimitives(_data) {
+        throw new Error("fromPrimitives must be implemented in subclasses");
+    }
 }
 exports.AggregateRoot = AggregateRoot;

package/dist/{criteria → cjs/criteria}/FilterOperator.js

@@ -14,6 +14,8 @@ var Operator;
     Operator["LTE"] = "<=";
     Operator["BETWEEN"] = "BETWEEN";
     Operator["OR"] = "OR";
+    Operator["IN"] = "IN";
+    Operator["NOT_IN"] = "NOT_IN";
 })(Operator || (exports.Operator = Operator = {}));
 //export class FilterOperator extends EnumValueObject<Operator> {
 class FilterOperator {

package/dist/{criteria → cjs/criteria}/FilterValue.js

@@ -70,5 +70,14 @@ class FilterValue extends valueObject_1.StringValueObject {
         }
         throw new Error("Value is not a BETWEEN structure");
     }
+    get isPrimitiveArray() {
+        return Array.isArray(this._originalValue) && !this.isOrConditions;
+    }
+    get asPrimitiveArray() {
+        if (this.isPrimitiveArray) {
+            return this._originalValue;
+        }
+        throw new Error("Value is not an array of primitive values");
+    }
 }
 exports.FilterValue = FilterValue;

package/dist/{mongo → cjs/mongo}/MongoCriteriaConverter.js

@@ -15,6 +15,8 @@ class MongoCriteriaConverter {
             [criteria_1.Operator.LTE, this.lowerThanOrEqualFilter],
             [criteria_1.Operator.BETWEEN, this.betweenFilter],
             [criteria_1.Operator.OR, this.orFilter],
+            [criteria_1.Operator.IN, this.inFilter],
+            [criteria_1.Operator.NOT_IN, this.notInFilter],
         ]);
     }
     convert(criteria) {
@@ -70,6 +72,18 @@ class MongoCriteriaConverter {
             [filter.field.value]: { $not: { $regex: filter.value.value } },
         };
     }
+    inFilter(filter) {
+        if (!filter.value.isPrimitiveArray) {
+            throw new Error("IN operator requires an array of primitive values");
+        }
+        return { [filter.field.value]: { $in: filter.value.asPrimitiveArray } };
+    }
+    notInFilter(filter) {
+        if (!filter.value.isPrimitiveArray) {
+            throw new Error("NOT_IN operator requires an array of primitive values");
+        }
+        return { [filter.field.value]: { $nin: filter.value.asPrimitiveArray } };
+    }
     orFilter(filter) {
         if (!filter.value.isOrConditions) {
             throw new Error("OR operator requires an array of OrCondition objects");

package/dist/{mongo → cjs/mongo}/MongoRepository.js

@@ -5,45 +5,41 @@ const MongoCriteriaConverter_1 = require("./MongoCriteriaConverter");
 const MongoClientFactory_1 = require("./MongoClientFactory");
 const mongodb_1 = require("mongodb");
 class MongoRepository {
-    constructor() {
+    constructor(aggregateRootClass) {
+        this.aggregateRootClass = aggregateRootClass;
         this.criteriaConverter = new MongoCriteriaConverter_1.MongoCriteriaConverter();
     }
-    // transformationToUpsertInSubDocuments(
-    //   subDocumentField: string,
-    //   primitiveData: any,
-    // ): {} {
-    //   const response = {};
-    //
-    //   for (const key in primitiveData) {
-    //     response[`${subDocumentField}.$.${key}`] = primitiveData[key];
-    //   }
-    //
-    //   return response;
-    // }
-    async paginate(documents) {
+    /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
+    async one(filter) {
         const collection = await this.collection();
-        const count = await collection.countDocuments(this.query.filter);
-        const limit = this.criteria?.limit || 10;
-        const currentPage = this.criteria?.currentPage || 1;
-        const hasNextPage = currentPage * limit < count;
-        if (documents.length === 0) {
-            return {
-                nextPag: null,
-                count: 0,
-                results: [],
-            };
+        const result = await collection.findOne(filter);
+        if (!result) {
+            return null;
         }
-        return {
-            nextPag: hasNextPage ? Number(this.criteria.currentPage) + 1 : null,
-            count: count,
-            results: documents,
-        };
+        const { _id, ...rest } = result;
+        return this.aggregateRootClass.fromPrimitives(rest);
+    }
+    /** Upserts an aggregate by delegating to persist with its id. */
+    async upsert(entity) {
+        return this.persist(entity.getId(), entity);
+    }
+    /** 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 collection() {
         return (await MongoClientFactory_1.MongoClientFactory.createClient())
             .db()
             .collection(this.collectionName());
     }
+    async updateOne(filter, update) {
+        const collection = await this.collection();
+        const result = await collection.updateOne(filter, update, {
+            upsert: true,
+        });
+        return result.upsertedId;
+    }
     async persist(id, aggregateRoot) {
         let primitives;
         if (aggregateRoot.toPrimitives() instanceof Promise) {
@@ -59,13 +55,6 @@ class MongoRepository {
             },
         });
     }
-    async updateOne(filter, update) {
-        const collection = await this.collection();
-        const result = await collection.updateOne(filter, update, {
-            upsert: true,
-        });
-        return result.upsertedId;
-    }
     async searchByCriteria(criteria, fieldsToExclude = []) {
         this.criteria = criteria;
         this.query = this.criteriaConverter.convert(criteria);
@@ -91,5 +80,24 @@ class MongoRepository {
             .toArray();
         return results.map(({ _id, ...rest }) => rest);
     }
+    async paginate(documents) {
+        const collection = await this.collection();
+        const count = await collection.countDocuments(this.query.filter);
+        const limit = this.criteria?.limit || 10;
+        const currentPage = this.criteria?.currentPage || 1;
+        const hasNextPage = currentPage * limit < count;
+        if (documents.length === 0) {
+            return {
+                nextPag: null,
+                count: 0,
+                results: [],
+            };
+        }
+        return {
+            nextPag: hasNextPage ? Number(this.criteria.currentPage) + 1 : null,
+            count: count,
+            results: documents,
+        };
+    }
 }
 exports.MongoRepository = MongoRepository;

package/dist/esm/AggregateRoot.js

@@ -0,0 +1,5 @@
+export class AggregateRoot {
+    static fromPrimitives(_data) {
+        throw new Error("fromPrimitives must be implemented in subclasses");
+    }
+}

package/dist/esm/criteria/Criteria.js

@@ -0,0 +1,15 @@
+export class Criteria {
+    constructor(filters, order, limit, offset) {
+        this.filters = filters;
+        this.order = order;
+        this.limit = limit;
+        this.currentPage = offset;
+        this.offset =
+            offset !== undefined && limit !== undefined
+                ? (offset - 1) * limit
+                : undefined;
+    }
+    hasFilters() {
+        return this.filters.filters.length > 0;
+    }
+}

package/dist/esm/criteria/Filter.js

@@ -0,0 +1,20 @@
+import { FilterField } from "./FilterField";
+import { FilterOperator } from "./FilterOperator";
+import { FilterValue } from "./FilterValue";
+import { InvalidArgumentError } from "../exceptions/InvalidArgumentError.exception";
+export class Filter {
+    constructor(field, operator, value) {
+        this.field = field;
+        this.operator = operator;
+        this.value = value;
+    }
+    static fromValues(values) {
+        const field = values.get("field");
+        const operator = values.get("operator");
+        const value = values.get("value");
+        if (!field || !operator || value === undefined) {
+            throw new InvalidArgumentError(`The filter is invalid`);
+        }
+        return new Filter(new FilterField(field), FilterOperator.fromValue(operator), new FilterValue(value));
+    }
+}

package/dist/esm/criteria/FilterField.js

@@ -0,0 +1,6 @@
+import { StringValueObject } from "../valueObject";
+export class FilterField extends StringValueObject {
+    constructor(value) {
+        super(value);
+    }
+}

package/dist/esm/criteria/FilterOperator.js

@@ -0,0 +1,34 @@
+import { InvalidArgumentError } from "../exceptions/InvalidArgumentError.exception";
+export var Operator;
+(function (Operator) {
+    Operator["EQUAL"] = "=";
+    Operator["NOT_EQUAL"] = "!=";
+    Operator["GT"] = ">";
+    Operator["LT"] = "<";
+    Operator["CONTAINS"] = "CONTAINS";
+    Operator["NOT_CONTAINS"] = "NOT_CONTAINS";
+    Operator["GTE"] = ">=";
+    Operator["LTE"] = "<=";
+    Operator["BETWEEN"] = "BETWEEN";
+    Operator["OR"] = "OR";
+    Operator["IN"] = "IN";
+    Operator["NOT_IN"] = "NOT_IN";
+})(Operator || (Operator = {}));
+//export class FilterOperator extends EnumValueObject<Operator> {
+export class FilterOperator {
+    constructor(value) {
+        this.value = value;
+        //super(value, Object.values(Operator));
+    }
+    static fromValue(value) {
+        for (const operatorValue of Object.values(Operator)) {
+            if (value === operatorValue.toString()) {
+                return new FilterOperator(operatorValue);
+            }
+        }
+        throw new InvalidArgumentError(`The filter operator ${value} is invalid`);
+    }
+    throwErrorForInvalidValue(value) {
+        throw new InvalidArgumentError(`The filter operator ${value} is invalid`);
+    }
+}

package/dist/esm/criteria/FilterValue.js

@@ -0,0 +1,79 @@
+import { StringValueObject } from "../valueObject";
+const isOrConditionArray = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return false;
+    }
+    const candidate = value[0];
+    return (typeof candidate === "object" &&
+        candidate !== null &&
+        "field" in candidate &&
+        "operator" in candidate &&
+        "value" in candidate);
+};
+const isBetweenObject = (value) => {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    const hasStartEnd = "start" in candidate && "end" in candidate;
+    const hasStartDateEndDate = "startDate" in candidate && "endDate" in candidate;
+    const hasFromTo = "from" in candidate && "to" in candidate;
+    return hasStartEnd || hasStartDateEndDate || hasFromTo;
+};
+const normalizeBetweenValue = (value) => {
+    if ("start" in value && "end" in value) {
+        return { start: value.start, end: value.end };
+    }
+    if ("startDate" in value && "endDate" in value) {
+        return { start: value.startDate, end: value.endDate };
+    }
+    return { start: value.from, end: value.to };
+};
+export class FilterValue extends StringValueObject {
+    constructor(value) {
+        if (Array.isArray(value) && isOrConditionArray(value)) {
+            // Handle OrCondition[]
+            super(JSON.stringify(value));
+        }
+        else if (Array.isArray(value)) {
+            // Handle primitive arrays (kept for backward compatibility)
+            super(value.join(","));
+        }
+        else if (isBetweenObject(value)) {
+            // Store serialized version but keep original reference
+            super(JSON.stringify(value));
+        }
+        else {
+            // Handle primitive values (string, number, boolean, Date)
+            super(value);
+        }
+        this._originalValue = value;
+    }
+    get isOrConditions() {
+        return isOrConditionArray(this._originalValue);
+    }
+    get asOrConditions() {
+        if (this.isOrConditions) {
+            return this._originalValue;
+        }
+        throw new Error("Value is not an OrCondition array");
+    }
+    get isBetween() {
+        return isBetweenObject(this._originalValue);
+    }
+    get asBetween() {
+        if (this.isBetween) {
+            return normalizeBetweenValue(this._originalValue);
+        }
+        throw new Error("Value is not a BETWEEN structure");
+    }
+    get isPrimitiveArray() {
+        return Array.isArray(this._originalValue) && !this.isOrConditions;
+    }
+    get asPrimitiveArray() {
+        if (this.isPrimitiveArray) {
+            return this._originalValue;
+        }
+        throw new Error("Value is not an array of primitive values");
+    }
+}

package/dist/esm/criteria/Filters.js

@@ -0,0 +1,12 @@
+import { Filter } from "./Filter";
+export class Filters {
+    constructor(filters) {
+        this.filters = filters;
+    }
+    static fromValues(filters) {
+        return new Filters(filters.map((values) => Filter.fromValues(values)));
+    }
+    static none() {
+        return new Filters([]);
+    }
+}

package/dist/esm/criteria/Order.js

@@ -0,0 +1,26 @@
+import { OrderBy } from "./OrderBy";
+import { OrderType, OrderTypes } from "./OrderType";
+export class Order {
+    constructor(orderBy, orderType) {
+        this.orderBy = orderBy;
+        this.orderType = orderType;
+    }
+    static fromValues(orderBy, orderType) {
+        if (!orderBy) {
+            return Order.none();
+        }
+        return new Order(new OrderBy(orderBy), OrderType.fromValue(orderType || OrderTypes.ASC));
+    }
+    static none() {
+        return new Order(new OrderBy(""), new OrderType(OrderTypes.NONE));
+    }
+    static desc(orderBy) {
+        return new Order(new OrderBy(orderBy), new OrderType(OrderTypes.DESC));
+    }
+    static asc(orderBy) {
+        return new Order(new OrderBy(orderBy), new OrderType(OrderTypes.ASC));
+    }
+    hasOrder() {
+        return !this.orderType.isNone();
+    }
+}

package/dist/esm/criteria/OrderBy.js

@@ -0,0 +1,13 @@
+import { ValueObject } from "../valueObject/ValueObject";
+export class OrderBy extends ValueObject {
+    constructor(value) {
+        super(value);
+        this.value = value;
+    }
+    static create(value) {
+        return new OrderBy(value);
+    }
+    getValue() {
+        return this.value;
+    }
+}

package/dist/esm/criteria/OrderType.js

@@ -0,0 +1,30 @@
+import { EnumValueObject } from "../valueObject";
+import { InvalidArgumentError } from "../exceptions/InvalidArgumentError.exception";
+export var OrderTypes;
+(function (OrderTypes) {
+    OrderTypes["ASC"] = "asc";
+    OrderTypes["DESC"] = "desc";
+    OrderTypes["NONE"] = "none";
+})(OrderTypes || (OrderTypes = {}));
+export class OrderType extends EnumValueObject {
+    constructor(value) {
+        super(value, Object.values(OrderTypes));
+    }
+    static fromValue(value) {
+        for (const orderTypeValue of Object.values(OrderTypes)) {
+            if (value === orderTypeValue.toString()) {
+                return new OrderType(orderTypeValue);
+            }
+        }
+        throw new InvalidArgumentError(`The order type ${value} is invalid`);
+    }
+    isNone() {
+        return this.value === OrderTypes.NONE;
+    }
+    isAsc() {
+        return this.value === OrderTypes.ASC;
+    }
+    throwErrorForInvalidValue(value) {
+        throw new InvalidArgumentError(`The order type ${value} is invalid`);
+    }
+}

package/dist/esm/criteria/Paginate.js

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

package/dist/esm/exceptions/InvalidArgumentError.exception.js

@@ -0,0 +1,2 @@
+export class InvalidArgumentError extends Error {
+}

package/dist/esm/mongo/MongoClientFactory.js

@@ -0,0 +1,45 @@
+import { MongoClient } from "mongodb";
+export class MongoClientFactory {
+    /**
+     * Obtiene o crea una instancia de MongoClient.
+     * Reutiliza la conexión si ya existe.
+     */
+    static async createClient() {
+        if (!MongoClientFactory.client) {
+            MongoClientFactory.client =
+                await MongoClientFactory.createAndConnectClient();
+        }
+        return MongoClientFactory.client;
+    }
+    /**
+     * Cierra la conexión a MongoDB.
+     */
+    static async closeClient() {
+        if (MongoClientFactory.client) {
+            await MongoClientFactory.client.close();
+            MongoClientFactory.client = null; // Limpia la instancia
+        }
+    }
+    /**
+     * Crea y conecta una nueva instancia de MongoClient.
+     */
+    static async createAndConnectClient() {
+        const MONGO_PASS = process.env.MONGO_PASS;
+        const MONGO_USER = process.env.MONGO_USER;
+        const MONGO_DB = process.env.MONGO_DB;
+        const MONGO_SERVER = process.env.MONGO_SERVER;
+        if (!MONGO_PASS || !MONGO_USER || !MONGO_DB || !MONGO_SERVER) {
+            throw new Error("Missing MongoDB environment variables.");
+        }
+        const uri = `mongodb+srv://${MONGO_USER}:${MONGO_PASS}@${MONGO_SERVER}/${MONGO_DB}?retryWrites=true&w=majority`;
+        const client = new MongoClient(uri, { ignoreUndefined: true });
+        try {
+            await client.connect();
+            return client;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+MongoClientFactory.client = null;

package/dist/esm/mongo/MongoCriteriaConverter.js

@@ -0,0 +1,125 @@
+import { Operator } from "../criteria";
+export class MongoCriteriaConverter {
+    constructor() {
+        this.filterTransformers = new Map([
+            [Operator.EQUAL, this.equalFilter],
+            [Operator.NOT_EQUAL, this.notEqualFilter],
+            [Operator.GT, this.greaterThanFilter],
+            [Operator.LT, this.lowerThanFilter],
+            [Operator.CONTAINS, this.containsFilter],
+            [Operator.NOT_CONTAINS, this.notContainsFilter],
+            [Operator.GTE, this.greaterThanOrEqualFilter],
+            [Operator.LTE, this.lowerThanOrEqualFilter],
+            [Operator.BETWEEN, this.betweenFilter],
+            [Operator.OR, this.orFilter],
+            [Operator.IN, this.inFilter],
+            [Operator.NOT_IN, this.notInFilter],
+        ]);
+    }
+    convert(criteria) {
+        return {
+            filter: criteria.hasFilters()
+                ? this.generateFilter(criteria.filters)
+                : {},
+            sort: criteria.order.hasOrder()
+                ? this.generateSort(criteria.order)
+                : { _id: -1 },
+            skip: criteria.offset || 0,
+            limit: criteria.limit || 0,
+        };
+    }
+    generateFilter(filters) {
+        const filter = filters.filters.map((filter) => {
+            const transformer = this.filterTransformers.get(filter.operator.value);
+            if (!transformer) {
+                throw Error(`Unexpected operator value ${filter.operator.value}`);
+            }
+            return transformer(filter);
+        });
+        return Object.assign({}, ...filter);
+    }
+    generateSort(order) {
+        return {
+            [order.orderBy.value === "id" ? "_id" : order.orderBy.value]: order.orderType.isAsc() ? 1 : -1,
+        };
+    }
+    equalFilter(filter) {
+        return { [filter.field.value]: { $eq: filter.value.value } };
+    }
+    notEqualFilter(filter) {
+        return { [filter.field.value]: { $ne: filter.value.value } };
+    }
+    greaterThanFilter(filter) {
+        return { [filter.field.value]: { $gt: filter.value.value } };
+    }
+    greaterThanOrEqualFilter(filter) {
+        return { [filter.field.value]: { $gte: filter.value.value } };
+    }
+    lowerThanOrEqualFilter(filter) {
+        return { [filter.field.value]: { $lte: filter.value.value } };
+    }
+    lowerThanFilter(filter) {
+        return { [filter.field.value]: { $lt: filter.value.value } };
+    }
+    containsFilter(filter) {
+        return { [filter.field.value]: { $regex: filter.value.value } };
+    }
+    notContainsFilter(filter) {
+        return {
+            [filter.field.value]: { $not: { $regex: filter.value.value } },
+        };
+    }
+    inFilter(filter) {
+        if (!filter.value.isPrimitiveArray) {
+            throw new Error("IN operator requires an array of primitive values");
+        }
+        return { [filter.field.value]: { $in: filter.value.asPrimitiveArray } };
+    }
+    notInFilter(filter) {
+        if (!filter.value.isPrimitiveArray) {
+            throw new Error("NOT_IN operator requires an array of primitive values");
+        }
+        return { [filter.field.value]: { $nin: filter.value.asPrimitiveArray } };
+    }
+    orFilter(filter) {
+        if (!filter.value.isOrConditions) {
+            throw new Error("OR operator requires an array of OrCondition objects");
+        }
+        const conditions = filter.value.asOrConditions;
+        const orConditions = conditions.map((condition) => {
+            switch (condition.operator) {
+                case Operator.CONTAINS:
+                    return { [condition.field]: { $regex: condition.value } };
+                case Operator.EQUAL:
+                    return { [condition.field]: { $eq: condition.value } };
+                case Operator.NOT_EQUAL:
+                    return { [condition.field]: { $ne: condition.value } };
+                case Operator.GT:
+                    return { [condition.field]: { $gt: condition.value } };
+                case Operator.LT:
+                    return { [condition.field]: { $lt: condition.value } };
+                case Operator.GTE:
+                    return { [condition.field]: { $gte: condition.value } };
+                case Operator.LTE:
+                    return { [condition.field]: { $lte: condition.value } };
+                case Operator.NOT_CONTAINS:
+                    return { [condition.field]: { $not: { $regex: condition.value } } };
+                default:
+                    throw new Error(`Unsupported operator in OR condition: ${condition.operator}`);
+            }
+        });
+        return { $or: orConditions };
+    }
+    betweenFilter(filter) {
+        if (!filter.value.isBetween) {
+            throw new Error("BETWEEN operator requires an object with start and end values.");
+        }
+        const { start, end } = filter.value.asBetween;
+        return {
+            [filter.field.value]: {
+                $gte: start,
+                $lte: end,
+            },
+        };
+    }
+}

package/dist/esm/mongo/MongoRepository.js

@@ -0,0 +1,99 @@
+import { MongoCriteriaConverter } from "./MongoCriteriaConverter";
+import { MongoClientFactory } from "./MongoClientFactory";
+import { ObjectId } from "mongodb";
+export class MongoRepository {
+    constructor(aggregateRootClass) {
+        this.aggregateRootClass = aggregateRootClass;
+        this.criteriaConverter = new MongoCriteriaConverter();
+    }
+    /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
+    async one(filter) {
+        const collection = await this.collection();
+        const result = await collection.findOne(filter);
+        if (!result) {
+            return null;
+        }
+        const { _id, ...rest } = result;
+        return this.aggregateRootClass.fromPrimitives(rest);
+    }
+    /** Upserts an aggregate by delegating to persist with its id. */
+    async upsert(entity) {
+        return this.persist(entity.getId(), entity);
+    }
+    /** 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 collection() {
+        return (await MongoClientFactory.createClient())
+            .db()
+            .collection(this.collectionName());
+    }
+    async updateOne(filter, update) {
+        const collection = await this.collection();
+        const result = await collection.updateOne(filter, update, {
+            upsert: true,
+        });
+        return result.upsertedId;
+    }
+    async persist(id, aggregateRoot) {
+        let primitives;
+        if (aggregateRoot.toPrimitives() instanceof Promise) {
+            primitives = await aggregateRoot.toPrimitives();
+        }
+        else {
+            primitives = aggregateRoot.toPrimitives();
+        }
+        return await this.updateOne({ _id: new ObjectId(id) }, {
+            $set: {
+                ...primitives,
+                id: id,
+            },
+        });
+    }
+    async searchByCriteria(criteria, fieldsToExclude = []) {
+        this.criteria = criteria;
+        this.query = this.criteriaConverter.convert(criteria);
+        const collection = await this.collection();
+        if (fieldsToExclude.length === 0) {
+            const results = await collection
+                .find(this.query.filter, {})
+                .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, { projection })
+            .sort(this.query.sort)
+            .skip(this.query.skip)
+            .limit(this.query.limit)
+            .toArray();
+        return results.map(({ _id, ...rest }) => rest);
+    }
+    async paginate(documents) {
+        const collection = await this.collection();
+        const count = await collection.countDocuments(this.query.filter);
+        const limit = this.criteria?.limit || 10;
+        const currentPage = this.criteria?.currentPage || 1;
+        const hasNextPage = currentPage * limit < count;
+        if (documents.length === 0) {
+            return {
+                nextPag: null,
+                count: 0,
+                results: [],
+            };
+        }
+        return {
+            nextPag: hasNextPage ? Number(this.criteria.currentPage) + 1 : null,
+            count: count,
+            results: documents,
+        };
+    }
+}

package/dist/esm/valueObject/EnumValueObject.js

@@ -0,0 +1,12 @@
+export class EnumValueObject {
+    constructor(value, validValues) {
+        this.validValues = validValues;
+        this.value = value;
+        this.checkValueIsValid(value);
+    }
+    checkValueIsValid(value) {
+        if (!this.validValues.includes(value)) {
+            this.throwErrorForInvalidValue(value);
+        }
+    }
+}

package/dist/esm/valueObject/StringValueObject.js

@@ -0,0 +1,20 @@
+import { ValueObject } from "./ValueObject";
+import { InvalidArgumentError } from "../exceptions/InvalidArgumentError.exception";
+export class StringValueObject extends ValueObject {
+    constructor(value) {
+        super(value);
+        this.value = value;
+        this.ensureStringIsNotEmpty();
+    }
+    static create(value) {
+        return new StringValueObject(value);
+    }
+    getValue() {
+        return String(this.value);
+    }
+    ensureStringIsNotEmpty() {
+        if (typeof this.value !== "object" && this.value.length < 1) {
+            throw new InvalidArgumentError("String should have a length");
+        }
+    }
+}

package/dist/esm/valueObject/ValueObject.js

@@ -0,0 +1,19 @@
+import { InvalidArgumentError } from "../exceptions/InvalidArgumentError.exception";
+export class ValueObject {
+    constructor(value) {
+        this.value = value;
+        this.ensureValueIsDefined(value);
+    }
+    equals(other) {
+        return (other.constructor.name === this.constructor.name &&
+            other.value === this.value);
+    }
+    toString() {
+        return this.value.toString();
+    }
+    ensureValueIsDefined(value) {
+        if (value === undefined) {
+            throw new InvalidArgumentError("Value must be defined");
+        }
+    }
+}

package/dist/types/AggregateRoot.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class AggregateRoot {
+    abstract getId(): string;
+    abstract toPrimitives(): any;
+    static fromPrimitives(_data: any): AggregateRoot;
+}
+export type AggregateRootClass<T extends AggregateRoot> = {
+    fromPrimitives(data: any): T;
+};

package/dist/{criteria → types/criteria}/FilterOperator.d.ts

@@ -8,7 +8,9 @@ export declare enum Operator {
     GTE = ">=",
     LTE = "<=",
     BETWEEN = "BETWEEN",
-    OR = "OR"
+    OR = "OR",
+    IN = "IN",
+    NOT_IN = "NOT_IN"
 }
 export declare class FilterOperator {
     value: Operator;

package/dist/{criteria → types/criteria}/FilterValue.d.ts

@@ -27,4 +27,6 @@ export declare class FilterValue extends StringValueObject {
         start: FilterPrimitive;
         end: FilterPrimitive;
     };
+    get isPrimitiveArray(): boolean;
+    get asPrimitiveArray(): FilterPrimitive[];
 }

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

@@ -0,0 +1,10 @@
+export * from "./FilterField";
+export * from "./FilterOperator";
+export * from "./FilterValue";
+export * from "./OrderBy";
+export * from "./Filter";
+export * from "./Criteria";
+export * from "./Filters";
+export * from "./Order";
+export * from "./Paginate";
+export * from "./OrderType";

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./criteria";
+export * from "./mongo";
+export * from "./AggregateRoot";

package/dist/{mongo → types/mongo}/MongoCriteriaConverter.d.ts

@@ -1,8 +1,9 @@
 import { Criteria, Filters, Order } from "../criteria";
-type MongoFilterOperator = "$eq" | "$ne" | "$gt" | "$lt" | "$regex" | "$lte" | "$gte" | "$or";
+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;
+    [operator in MongoFilterOperator]?: MongoFilterValue | MongoFilterArrayValue;
 };
 type MongoFilter = {
     [field: string]: MongoFilterOperation;
@@ -37,6 +38,8 @@ export declare class MongoCriteriaConverter {
     private lowerThanFilter;
     private containsFilter;
     private notContainsFilter;
+    private inFilter;
+    private notInFilter;
     private orFilter;
     private betweenFilter;
 }

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

@@ -0,0 +1,22 @@
+import { Criteria, Paginate } from "../criteria";
+import { AggregateRoot, AggregateRootClass } from "../AggregateRoot";
+import { Collection, ObjectId, UpdateFilter } from "mongodb";
+export declare abstract class MongoRepository<T extends AggregateRoot> {
+    private readonly aggregateRootClass;
+    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): Promise<T | null>;
+    /** Upserts an aggregate by delegating to persist with its id. */
+    upsert(entity: T): Promise<ObjectId | null>;
+    /** Lists entities by criteria and returns a paginated response. */
+    list<D>(criteria: Criteria, fieldsToExclude?: string[]): Promise<Paginate<D>>;
+    protected collection<T extends Document>(): Promise<Collection<T>>;
+    protected updateOne(filter: object, update: Document[] | UpdateFilter<any>): Promise<ObjectId | null>;
+    private persist;
+    private searchByCriteria;
+    private paginate;
+}

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

@@ -0,0 +1,3 @@
+export * from "./MongoCriteriaConverter";
+export * from "./MongoRepository";
+export * from "./MongoClientFactory";

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

@@ -0,0 +1,3 @@
+export * from "./EnumValueObject";
+export * from "./StringValueObject";
+export * from "./ValueObject";

package/package.json

@@ -1,15 +1,27 @@
 {
   "name": "@abejarano/ts-mongodb-criteria",
   "author": "angel bejarano / angel.bejarano@jaspesoft.com",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Patrón Criteria para consultas MongoDB en TypeScript",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.types.json",
     "clean": "rimraf dist",
     "prepare": "yarn build",
     "prebuild": "yarn clean",
@@ -22,7 +34,8 @@
     "version:major": "npm version major",
     "test": "jest",
     "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "test:bun": "bun test tests/bun"
   },
   "keywords": [
     "mongodb",

package/dist/AggregateRoot.d.ts

@@ -1,4 +0,0 @@
-export declare abstract class AggregateRoot {
-    abstract getId(): string;
-    abstract toPrimitives(): any;
-}

package/dist/mongo/MongoRepository.d.ts

@@ -1,15 +0,0 @@
-import { Criteria, Paginate } from "../criteria";
-import { AggregateRoot } from "../AggregateRoot";
-import { Collection, ObjectId, UpdateFilter } from "mongodb";
-export declare abstract class MongoRepository<T extends AggregateRoot> {
-    private criteriaConverter;
-    private query;
-    private criteria;
-    protected constructor();
-    abstract collectionName(): string;
-    paginate<T>(documents: T[]): Promise<Paginate<T>>;
-    protected collection<T extends Document>(): Promise<Collection<T>>;
-    protected persist(id: string, aggregateRoot: T): Promise<ObjectId | null>;
-    protected updateOne(filter: object, update: Document[] | UpdateFilter<any>): Promise<ObjectId | null>;
-    protected searchByCriteria<D>(criteria: Criteria, fieldsToExclude?: string[]): Promise<D[]>;
-}