@abejarano/ts-mongodb-criteria 1.2.1

package/dist/criteria/OrderType.d.ts

@@ -0,0 +1,13 @@
+import { EnumValueObject } from "../valueObject";
+export declare enum OrderTypes {
+    ASC = "asc",
+    DESC = "desc",
+    NONE = "none"
+}
+export declare class OrderType extends EnumValueObject<OrderTypes> {
+    constructor(value: OrderTypes);
+    static fromValue(value: string): OrderType;
+    isNone(): boolean;
+    isAsc(): boolean;
+    protected throwErrorForInvalidValue(value: OrderTypes): void;
+}

package/dist/criteria/OrderType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderType = exports.OrderTypes = void 0;
+const valueObject_1 = require("../valueObject");
+const InvalidArgumentError_exception_1 = require("../exceptions/InvalidArgumentError.exception");
+var OrderTypes;
+(function (OrderTypes) {
+    OrderTypes["ASC"] = "asc";
+    OrderTypes["DESC"] = "desc";
+    OrderTypes["NONE"] = "none";
+})(OrderTypes || (exports.OrderTypes = OrderTypes = {}));
+class OrderType extends valueObject_1.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_exception_1.InvalidArgumentError(`The order type ${value} is invalid`);
+    }
+    isNone() {
+        return this.value === OrderTypes.NONE;
+    }
+    isAsc() {
+        return this.value === OrderTypes.ASC;
+    }
+    throwErrorForInvalidValue(value) {
+        throw new InvalidArgumentError_exception_1.InvalidArgumentError(`The order type ${value} is invalid`);
+    }
+}
+exports.OrderType = OrderType;

package/dist/criteria/Paginate.d.ts

@@ -0,0 +1,5 @@
+export type Paginate<T> = {
+    nextPag: string | number | null;
+    count: number;
+    results: Array<T>;
+};

package/dist/criteria/Paginate.js

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

package/dist/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/criteria/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FilterField"), exports);
+__exportStar(require("./FilterOperator"), exports);
+__exportStar(require("./FilterValue"), exports);
+__exportStar(require("./OrderBy"), exports);
+__exportStar(require("./Filter"), exports);
+__exportStar(require("./Criteria"), exports);
+__exportStar(require("./Filters"), exports);
+__exportStar(require("./Order"), exports);
+__exportStar(require("./Paginate"), exports);
+__exportStar(require("./OrderType"), exports);

package/dist/exceptions/InvalidArgumentError.exception.d.ts

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

package/dist/exceptions/InvalidArgumentError.exception.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidArgumentError = void 0;
+class InvalidArgumentError extends Error {
+}
+exports.InvalidArgumentError = InvalidArgumentError;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./criteria"), exports);
+__exportStar(require("./mongo"), exports);
+__exportStar(require("./AggregateRoot"), exports);

package/dist/mongo/MongoClientFactory.d.ts

@@ -0,0 +1,17 @@
+import { MongoClient } from "mongodb";
+export declare class MongoClientFactory {
+    private static client;
+    /**
+     * Obtiene o crea una instancia de MongoClient.
+     * Reutiliza la conexión si ya existe.
+     */
+    static createClient(): Promise<MongoClient>;
+    /**
+     * Cierra la conexión a MongoDB.
+     */
+    static closeClient(): Promise<void>;
+    /**
+     * Crea y conecta una nueva instancia de MongoClient.
+     */
+    private static createAndConnectClient;
+}

package/dist/mongo/MongoClientFactory.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoClientFactory = void 0;
+const mongodb_1 = require("mongodb");
+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 mongodb_1.MongoClient(uri, { ignoreUndefined: true });
+        try {
+            await client.connect();
+            return client;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+exports.MongoClientFactory = MongoClientFactory;
+MongoClientFactory.client = null;

package/dist/mongo/MongoCriteriaConverter.d.ts

@@ -0,0 +1,43 @@
+import { Criteria, Filters, Order } from "../criteria";
+type MongoFilterOperator = "$eq" | "$ne" | "$gt" | "$lt" | "$regex" | "$lte" | "$gte" | "$or";
+type MongoFilterValue = boolean | string | number | Date;
+type MongoFilterOperation = {
+    [operator in MongoFilterOperator]?: MongoFilterValue;
+};
+type MongoFilter = {
+    [field: string]: MongoFilterOperation;
+} | {
+    [field: string]: {
+        $not: MongoFilterOperation;
+    };
+} | {
+    $or: any[];
+};
+type MongoDirection = 1 | -1;
+type MongoSort = {
+    [field: string]: MongoDirection;
+};
+export interface MongoQuery {
+    filter: MongoFilter;
+    sort: MongoSort;
+    skip: number;
+    limit: number;
+}
+export declare class MongoCriteriaConverter {
+    private filterTransformers;
+    constructor();
+    convert(criteria: Criteria): MongoQuery;
+    protected generateFilter(filters: Filters): MongoFilter;
+    protected generateSort(order: Order): MongoSort;
+    private equalFilter;
+    private notEqualFilter;
+    private greaterThanFilter;
+    private greaterThanOrEqualFilter;
+    private lowerThanOrEqualFilter;
+    private lowerThanFilter;
+    private containsFilter;
+    private notContainsFilter;
+    private orFilter;
+    private betweenFilter;
+}
+export {};

package/dist/mongo/MongoCriteriaConverter.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCriteriaConverter = void 0;
+const criteria_1 = require("../criteria");
+class MongoCriteriaConverter {
+    constructor() {
+        this.filterTransformers = new Map([
+            [criteria_1.Operator.EQUAL, this.equalFilter],
+            [criteria_1.Operator.NOT_EQUAL, this.notEqualFilter],
+            [criteria_1.Operator.GT, this.greaterThanFilter],
+            [criteria_1.Operator.LT, this.lowerThanFilter],
+            [criteria_1.Operator.CONTAINS, this.containsFilter],
+            [criteria_1.Operator.NOT_CONTAINS, this.notContainsFilter],
+            [criteria_1.Operator.GTE, this.greaterThanOrEqualFilter],
+            [criteria_1.Operator.LTE, this.lowerThanOrEqualFilter],
+            [criteria_1.Operator.BETWEEN, this.betweenFilter],
+            [criteria_1.Operator.OR, this.orFilter],
+        ]);
+    }
+    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 } },
+        };
+    }
+    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 criteria_1.Operator.CONTAINS:
+                    return { [condition.field]: { $regex: condition.value } };
+                case criteria_1.Operator.EQUAL:
+                    return { [condition.field]: { $eq: condition.value } };
+                case criteria_1.Operator.NOT_EQUAL:
+                    return { [condition.field]: { $ne: condition.value } };
+                case criteria_1.Operator.GT:
+                    return { [condition.field]: { $gt: condition.value } };
+                case criteria_1.Operator.LT:
+                    return { [condition.field]: { $lt: condition.value } };
+                case criteria_1.Operator.GTE:
+                    return { [condition.field]: { $gte: condition.value } };
+                case criteria_1.Operator.LTE:
+                    return { [condition.field]: { $lte: condition.value } };
+                case criteria_1.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,
+            },
+        };
+    }
+}
+exports.MongoCriteriaConverter = MongoCriteriaConverter;

package/dist/mongo/MongoRepository.d.ts

@@ -0,0 +1,15 @@
+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[]>;
+}

package/dist/mongo/MongoRepository.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoRepository = void 0;
+const MongoCriteriaConverter_1 = require("./MongoCriteriaConverter");
+const MongoClientFactory_1 = require("./MongoClientFactory");
+const mongodb_1 = require("mongodb");
+class MongoRepository {
+    constructor() {
+        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) {
+        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,
+        };
+    }
+    async collection() {
+        return (await MongoClientFactory_1.MongoClientFactory.createClient())
+            .db()
+            .collection(this.collectionName());
+    }
+    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 mongodb_1.ObjectId(id) }, {
+            $set: {
+                ...primitives,
+                id: id,
+            },
+        });
+    }
+    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);
+        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);
+    }
+}
+exports.MongoRepository = MongoRepository;

package/dist/mongo/index.d.ts

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

package/dist/mongo/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MongoCriteriaConverter"), exports);
+__exportStar(require("./MongoRepository"), exports);
+__exportStar(require("./MongoClientFactory"), exports);

package/dist/valueObject/EnumValueObject.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class EnumValueObject<T> {
+    readonly validValues: T[];
+    readonly value: T;
+    constructor(value: T, validValues: T[]);
+    checkValueIsValid(value: T): void;
+    protected abstract throwErrorForInvalidValue(value: T): void;
+}

package/dist/valueObject/EnumValueObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumValueObject = void 0;
+class EnumValueObject {
+    constructor(value, validValues) {
+        this.validValues = validValues;
+        this.value = value;
+        this.checkValueIsValid(value);
+    }
+    checkValueIsValid(value) {
+        if (!this.validValues.includes(value)) {
+            this.throwErrorForInvalidValue(value);
+        }
+    }
+}
+exports.EnumValueObject = EnumValueObject;

package/dist/valueObject/StringValueObject.d.ts

@@ -0,0 +1,8 @@
+import { ValueObject } from "./ValueObject";
+export declare class StringValueObject extends ValueObject<string> {
+    readonly value: any;
+    constructor(value: any);
+    static create(value: string): StringValueObject;
+    getValue(): string;
+    private ensureStringIsNotEmpty;
+}

package/dist/valueObject/StringValueObject.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringValueObject = void 0;
+const ValueObject_1 = require("./ValueObject");
+const InvalidArgumentError_exception_1 = require("../exceptions/InvalidArgumentError.exception");
+class StringValueObject extends ValueObject_1.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_exception_1.InvalidArgumentError("String should have a length");
+        }
+    }
+}
+exports.StringValueObject = StringValueObject;

package/dist/valueObject/ValueObject.d.ts

@@ -0,0 +1,8 @@
+export type Primitives = String | string | number | Boolean | boolean | Date;
+export declare abstract class ValueObject<T extends Primitives> {
+    readonly value: T;
+    constructor(value: T);
+    equals(other: ValueObject<T>): boolean;
+    toString(): string;
+    private ensureValueIsDefined;
+}

package/dist/valueObject/ValueObject.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObject = void 0;
+const InvalidArgumentError_exception_1 = require("../exceptions/InvalidArgumentError.exception");
+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_exception_1.InvalidArgumentError("Value must be defined");
+        }
+    }
+}
+exports.ValueObject = ValueObject;

package/dist/valueObject/index.d.ts

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

package/dist/valueObject/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EnumValueObject"), exports);
+__exportStar(require("./StringValueObject"), exports);
+__exportStar(require("./ValueObject"), exports);