@ackplus/nest-crud-request 1.1.2 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ackplus/nest-crud-request",
-  "version": "1.1.2",
+  "version": "1.1.6",
   "type": "commonjs",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/query-builder"), exports);
+tslib_1.__exportStar(require("./lib/where-builder"), exports);
+tslib_1.__exportStar(require("./lib/types"), exports);

package/src/lib/query-builder.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+const relation_builder_1 = require("./relation-builder");
+const utils_1 = require("./utils");
+const where_builder_1 = require("./where-builder");
+class QueryBuilder {
+    options = {};
+    whereBuilder = new where_builder_1.WhereBuilder();
+    relationBuilder = new relation_builder_1.RelationBuilder();
+    constructor(options) {
+        if (options) {
+            this.setOptions(options);
+        }
+    }
+    setOptions(options) {
+        this.options = options;
+        this.whereBuilder = new where_builder_1.WhereBuilder(options.where);
+        this.relationBuilder = new relation_builder_1.RelationBuilder(options.relations);
+        return this;
+    }
+    mergeOptions(options, deep = false) {
+        let updatedOptions = {};
+        if (deep) {
+            updatedOptions = (0, utils_1.deepMerge)(this.options, options);
+        }
+        else {
+            updatedOptions = {
+                ...this.options,
+                ...options,
+            };
+        }
+        this.setOptions(updatedOptions);
+        return this;
+    }
+    addSelect(fields) {
+        // Ensure select is always an array
+        if (!this.options.select || typeof this.options.select === 'string') {
+            this.options.select = [];
+        }
+        if (Array.isArray(fields)) {
+            this.options.select.push(...fields);
+        }
+        else {
+            this.options.select.push(fields);
+        }
+        return this;
+    }
+    removeSelect(fields) {
+        // Ensure select is an array before filtering
+        if (this.options.select && Array.isArray(this.options.select)) {
+            if (Array.isArray(fields)) {
+                this.options.select = this.options.select.filter(field => !fields.includes(field));
+            }
+            else {
+                this.options.select = this.options.select.filter(field => field !== fields);
+            }
+        }
+        return this;
+    }
+    addRelation(relation, select, where) {
+        this.relationBuilder.add(relation, select, where);
+        return this;
+    }
+    removeRelation(relation) {
+        this.relationBuilder.remove(relation);
+        return this;
+    }
+    where(...args) {
+        this.whereBuilder.where(...args);
+        return this;
+    }
+    andWhere(...args) {
+        this.whereBuilder.andWhere(...args);
+        return this;
+    }
+    orWhere(...args) {
+        this.whereBuilder.orWhere(...args);
+        return this;
+    }
+    addOrder(orderBy, order) {
+        if (!this.options.order) {
+            this.options.order = {};
+        }
+        this.options.order[orderBy] = order;
+        return this;
+    }
+    removeOrder(orderBy) {
+        if (this.options.order) {
+            delete this.options.order[orderBy];
+        }
+        return this;
+    }
+    setSkip(skip) {
+        this.options.skip = skip;
+        return this;
+    }
+    setTake(take) {
+        this.options.take = take;
+        return this;
+    }
+    setWithDeleted(withDeleted) {
+        this.options.withDeleted = withDeleted;
+        return this;
+    }
+    setOnlyDeleted(onlyDeleted) {
+        this.options.onlyDeleted = onlyDeleted;
+        return this;
+    }
+    set(key, value) {
+        this.options[key] = value;
+        return this;
+    }
+    toObject(constrainToNestedObject = false) {
+        const options = {
+            ...this.options,
+        };
+        // Convert where conditions to JSON string
+        if (this.whereBuilder.hasConditions()) {
+            if (constrainToNestedObject) {
+                options.where = this.whereBuilder.toObject();
+            }
+            else {
+                options.where = JSON.stringify(this.whereBuilder.toObject());
+            }
+        }
+        else {
+            delete options.where;
+        }
+        // Convert relations to JSON string
+        if (this.relationBuilder.hasRelations()) {
+            if (constrainToNestedObject) {
+                options.relations = this.relationBuilder.toObject();
+            }
+            else {
+                options.relations = JSON.stringify(this.relationBuilder.toObject());
+            }
+        }
+        else {
+            delete options.relations;
+        }
+        // Convert order to JSON string if it exists
+        if (options.order && Object.keys(options.order).length > 0) {
+            if (constrainToNestedObject) {
+                options.order = options.order;
+            }
+            else {
+                options.order = JSON.stringify(options.order);
+            }
+        }
+        else {
+            delete options.order;
+        }
+        // Convert select to JSON string if it exists
+        if (options.select && options.select.length > 0) {
+            if (constrainToNestedObject) {
+                options.select = options.select;
+            }
+            else {
+                options.select = JSON.stringify(options.select);
+            }
+        }
+        else {
+            delete options.select;
+        }
+        return options;
+    }
+    toJson() {
+        const obj = this.toObject(true);
+        return JSON.stringify(obj);
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/src/lib/relation-builder.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationBuilder = void 0;
+class RelationBuilder {
+    relations = {};
+    constructor(relations) {
+        if (relations) {
+            const relationOptions = typeof relations === 'string' ? JSON.parse(relations) : relations;
+            this.setRelations(relationOptions);
+        }
+    }
+    setRelations(relations) {
+        if (relations) {
+            if (Array.isArray(relations)) {
+                relations.forEach(relation => {
+                    this.add(relation);
+                });
+            }
+            else if (typeof relations === 'string') {
+                this.add(relations);
+            }
+            else {
+                this.relations = relations;
+            }
+        }
+        return this;
+    }
+    clear() {
+        this.relations = {};
+        return this;
+    }
+    add(relation, select, where) {
+        if (!select && !where) {
+            this.relations[relation] = true;
+        }
+        else {
+            const obj = {};
+            if (select) {
+                obj.select = select;
+            }
+            if (where) {
+                obj.where = where;
+            }
+            this.relations[relation] = obj;
+        }
+        return this;
+    }
+    remove(relation) {
+        delete this.relations[relation];
+        return this;
+    }
+    hasRelations() {
+        return Object.keys(this.relations).length > 0;
+    }
+    toObject() {
+        return this.relations;
+    }
+    toJson() {
+        return JSON.stringify(this.relations);
+    }
+}
+exports.RelationBuilder = RelationBuilder;

package/src/lib/types.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderDirectionEnum = exports.WhereOperatorEnum = exports.WhereLogicalOperatorEnum = void 0;
+var WhereLogicalOperatorEnum;
+(function (WhereLogicalOperatorEnum) {
+    WhereLogicalOperatorEnum["AND"] = "$and";
+    WhereLogicalOperatorEnum["OR"] = "$or";
+})(WhereLogicalOperatorEnum || (exports.WhereLogicalOperatorEnum = WhereLogicalOperatorEnum = {}));
+var WhereOperatorEnum;
+(function (WhereOperatorEnum) {
+    WhereOperatorEnum["EQ"] = "$eq";
+    WhereOperatorEnum["NOT_EQ"] = "$ne";
+    WhereOperatorEnum["GT"] = "$gt";
+    WhereOperatorEnum["GT_OR_EQ"] = "$gte";
+    WhereOperatorEnum["LT"] = "$lt";
+    WhereOperatorEnum["LT_OR_EQ"] = "$lte";
+    WhereOperatorEnum["IN"] = "$in";
+    WhereOperatorEnum["NOT_IN"] = "$notIn";
+    WhereOperatorEnum["LIKE"] = "$like";
+    WhereOperatorEnum["NOT_LIKE"] = "$notLike";
+    WhereOperatorEnum["ILIKE"] = "$iLike";
+    WhereOperatorEnum["NOT_ILIKE"] = "$notIlike";
+    WhereOperatorEnum["IS_NULL"] = "$isNull";
+    WhereOperatorEnum["IS_NOT_NULL"] = "$isNotNull";
+    WhereOperatorEnum["BETWEEN"] = "$between";
+    WhereOperatorEnum["NOT_BETWEEN"] = "$notBetween";
+    WhereOperatorEnum["IS_TRUE"] = "$isTrue";
+    WhereOperatorEnum["IS_FALSE"] = "$isFalse";
+})(WhereOperatorEnum || (exports.WhereOperatorEnum = WhereOperatorEnum = {}));
+var OrderDirectionEnum;
+(function (OrderDirectionEnum) {
+    OrderDirectionEnum["ASC"] = "ASC";
+    OrderDirectionEnum["DESC"] = "DESC";
+})(OrderDirectionEnum || (exports.OrderDirectionEnum = OrderDirectionEnum = {}));

package/src/lib/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+function deepMerge(target, source) {
+    for (const key in source) {
+        if (source[key] instanceof Object && key in target) {
+            Object.assign(source[key], deepMerge(target[key], source[key]));
+        }
+    }
+    return {
+        ...target,
+        ...source,
+    };
+}

package/src/lib/where-builder.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereBuilder = void 0;
+const types_1 = require("./types");
+class WhereBuilder {
+    whereObject = {};
+    constructor(where) {
+        this.whereObject = typeof where === 'string' ? JSON.parse(where) : where || {};
+    }
+    isOperator(value) {
+        return `${value}`.startsWith('$');
+    }
+    clear() {
+        this.whereObject = {};
+        return this;
+    }
+    where(...args) {
+        this.parseCondition(null, ...args);
+        return this;
+    }
+    andWhere(...args) {
+        this.parseCondition(types_1.WhereLogicalOperatorEnum.AND, ...args);
+        return this;
+    }
+    orWhere(...args) {
+        this.parseCondition(types_1.WhereLogicalOperatorEnum.OR, ...args);
+        return this;
+    }
+    removeWhere(field) {
+        const keys = field.split('.');
+        let current = this.whereObject;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]]) {
+                return this; // If the path doesn't exist, do nothing
+            }
+            current = current[keys[i]];
+        }
+        delete current[keys[keys.length - 1]];
+        return this;
+    }
+    hasConditions() {
+        return Object.keys(this.whereObject).length > 0;
+    }
+    toObject() {
+        return this.whereObject;
+    }
+    toJson() {
+        return JSON.stringify(this.whereObject);
+    }
+    parseCondition(type, ...args) {
+        let field;
+        let operator;
+        let value;
+        if (args.length === 0) {
+            // Do nothing
+        }
+        else if (args.length === 1) {
+            const condition = args[0];
+            if (typeof condition === 'function') {
+                // If the condition is a function, create a new WhereBuilder and call the function with it
+                const builder = new WhereBuilder();
+                condition(builder);
+                this.updateCondition(builder.toObject(), type);
+            }
+            else if (condition instanceof WhereBuilder) {
+                // If the condition is a WhereBuilder
+                this.updateCondition(condition.toObject(), type);
+            }
+            else {
+                // If the condition is a simple object
+                this.updateCondition(condition, type);
+            }
+        }
+        else if (args.length === 2 || args.length === 3) {
+            if (args.length === 2) {
+                // if there are only two arguments, the operator is EQ
+                field = args[0];
+                value = args[1];
+                if (typeof value === 'object') {
+                    const firstKey = Object.keys(value)[0];
+                    // if the first key is a operator, update the value with the operator
+                    if (firstKey.startsWith('$')) {
+                        this.updateCondition({ [field]: value }, type);
+                    }
+                    else {
+                        this.updateCondition({ [field]: { [types_1.WhereOperatorEnum.EQ]: value } }, type);
+                    }
+                }
+                else if (this.isOperator(value)) {
+                    this.updateCondition({ [field]: { [value]: true } }, type);
+                }
+                else {
+                    this.updateCondition({ [field]: { [types_1.WhereOperatorEnum.EQ]: value } }, type);
+                }
+            }
+            else {
+                // if there are three arguments, the operator is the second argument
+                field = args[0];
+                operator = args[1];
+                value = args[2];
+                this.updateCondition({ [field]: { [operator]: value } }, type);
+            }
+        }
+        return this;
+    }
+    // private updateCondition(condition: Record<string, any>, type: '$and' | '$or'): void {
+    //     this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
+    // }
+    updateCondition(condition, type) {
+        if (type === null) {
+            // For direct where conditions, we need to merge intelligently
+            this.mergeConditions(this.whereObject, condition);
+        }
+        else {
+            // For logical operators ($and, $or), add to the array
+            this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
+        }
+    }
+    /**
+     * Intelligently merge two condition objects, handling logical operators properly
+     */
+    mergeConditions(target, source) {
+        for (const key in source) {
+            const sourceValue = source[key];
+            if (key === '$and' || key === '$or') {
+                // Handle logical operators - merge arrays
+                if (target[key]) {
+                    // If target already has this logical operator, merge the arrays
+                    target[key] = [...(target[key] || []), ...(Array.isArray(sourceValue) ? sourceValue : [sourceValue])];
+                }
+                else {
+                    // If target doesn't have this logical operator, set it
+                    target[key] = Array.isArray(sourceValue) ? sourceValue : [sourceValue];
+                }
+            }
+            else {
+                // Handle regular field conditions
+                if (target[key] && typeof target[key] === 'object' && typeof sourceValue === 'object') {
+                    // If both target and source have the same field with object values, merge them
+                    target[key] = { ...target[key], ...sourceValue };
+                }
+                else {
+                    // Otherwise, simply assign the value
+                    target[key] = sourceValue;
+                }
+            }
+        }
+    }
+}
+exports.WhereBuilder = WhereBuilder;