drapcode-utility 2.0.0 → 2.0.2

package/build/utils/query-utils.d.ts

@@ -1,10 +1,10 @@
-export declare const getSearchObjQuery: (searchObj: any, searchQueryTypeObj: any, timezone: string) => {
+export declare const getSearchObjQuery: (searchObj: any, searchQueryTypeObj: any) => {
     searchAggregateQuery: any;
     likeQuery: any;
 };
 export declare const mongoSelectQuery: (query?: any) => any;
 export declare const modifyQuery: (obj?: {}, hasAndQueryConjunction?: boolean) => any[];
-export declare const checkDate: (queryValue: string) => RegExpMatchArray | null;
+export declare const isItDate: (queryValue: string) => RegExpMatchArray | null;
 export declare const getMinMaxValue: (value: any) => {
     startValue: any;
     endValue: any;

package/build/utils/query-utils.js

@@ -1,196 +1,183 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueOfProjectConstant = exports.isFixedValueQuery = exports.getMinMaxValue = exports.checkDate = exports.modifyQuery = exports.mongoSelectQuery = exports.getSearchObjQuery = void 0;
-var drapcode_constant_1 = require("drapcode-constant");
-var date_util_1 = require("./date-util");
-var util_1 = require("./util");
-var getSearchObjQuery = function (searchObj, searchQueryTypeObj, timezone) {
-    var searchAggregateQuery = [];
-    var likeQuery = [];
-    Object.entries(searchObj).forEach(function (_a) {
-        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
-        var key = _a[0], value = _a[1];
+exports.getValueOfProjectConstant = exports.isFixedValueQuery = exports.getMinMaxValue = exports.isItDate = exports.modifyQuery = exports.mongoSelectQuery = exports.getSearchObjQuery = void 0;
+const drapcode_constant_1 = require("drapcode-constant");
+const date_util_1 = require("./date-util");
+const util_1 = require("./util");
+const getSearchObjQuery = (searchObj, searchQueryTypeObj) => {
+    let searchAggregateQuery = [];
+    let likeQuery = [];
+    Object.entries(searchObj).forEach(([key, value]) => {
         if (value) {
-            var searchQueryTypeKey = searchQueryTypeObj[key];
+            const searchQueryTypeKey = searchQueryTypeObj[key];
             if (searchQueryTypeKey) {
                 if (searchQueryTypeKey === "boolean") {
                     // if input is string and db field type is boolean
                     searchAggregateQuery.push({
-                        $addFields: (_b = {},
-                            _b["_".concat(key)] = "$".concat(key),
-                            _b),
+                        $addFields: {
+                            [`_${key}`]: `$${key}`,
+                        },
+                    });
+                    likeQuery.push({
+                        [`_${key}`]: toBoolean(value),
                     });
-                    likeQuery.push((_c = {},
-                        _c["_".concat(key)] = toBoolean(value),
-                        _c));
                 }
-                else if (__spreadArray(__spreadArray([], drapcode_constant_1.OptionTypeFields, true), drapcode_constant_1.BelongsToReferenceField, true).includes(searchQueryTypeKey)) {
+                else if ([...drapcode_constant_1.OptionTypeFields, ...drapcode_constant_1.BelongsToReferenceField].includes(searchQueryTypeKey) //TODO: Changes
+                ) {
                     // if input is string and db field type is array
                     searchAggregateQuery.push({
-                        $addFields: (_d = {},
-                            _d["_".concat(key)] = "$".concat(key),
-                            _d),
+                        $addFields: {
+                            [`_${key}`]: `$${key}`,
+                        },
+                    });
+                    likeQuery.push({
+                        [`_${key}`]: { $all: [value] },
                     });
-                    likeQuery.push((_e = {},
-                        _e["_".concat(key)] = { $all: [value] },
-                        _e));
                 }
                 else if (searchQueryTypeKey === "tel") {
                     // handling value when db field type is tel
                     searchAggregateQuery.push({
-                        $addFields: (_f = {},
-                            _f["_".concat(key)] = { $toString: "$".concat(key) },
-                            _f),
+                        $addFields: {
+                            [`_${key}`]: { $toString: `$${key}` },
+                        },
                     });
-                    likeQuery.push((_g = {},
-                        _g["_".concat(key)] = {
+                    likeQuery.push({
+                        [`_${key}`]: {
                             $regex: value.startsWith("+") ? value.replace("+", "") : value,
                             $options: "i",
                         },
-                        _g));
+                    });
                 }
                 else if (searchQueryTypeKey === "number") {
                     if (key.startsWith("min_") || key.startsWith("max_")) {
-                        var fieldKey = key.replace("min_", "");
+                        let fieldKey = key.replace("min_", "");
                         fieldKey = fieldKey.replace("max_", "");
-                        var numericValue = Number(value);
+                        const numericValue = Number(value);
                         if (key.startsWith("min_")) {
-                            likeQuery.push((_h = {}, _h["".concat(fieldKey)] = { $gte: numericValue }, _h));
+                            likeQuery.push({ [`${fieldKey}`]: { $gte: numericValue } });
                         }
                         else if (key.startsWith("max_")) {
-                            likeQuery.push((_j = {}, _j["".concat(fieldKey)] = { $lte: numericValue }, _j));
+                            likeQuery.push({ [`${fieldKey}`]: { $lte: numericValue } });
                         }
                     }
                     else {
                         // handling value when db field type is Double/Int
                         searchAggregateQuery.push({
-                            $addFields: (_k = {},
-                                _k["_".concat(key)] = { $toString: { $toLong: "$".concat(key) } },
-                                _k),
+                            $addFields: {
+                                [`_${key}`]: { $toString: { $toLong: `$${key}` } },
+                            },
                         });
-                        likeQuery.push((_l = {},
-                            _l["_".concat(key)] = {
+                        likeQuery.push({
+                            [`_${key}`]: {
                                 $regex: value,
                                 $options: "i",
                             },
-                            _l));
+                        });
                     }
                 }
-                else if (__spreadArray(__spreadArray([
-                    drapcode_constant_1.FieldTypes.date.id
-                ], drapcode_constant_1.systemDateField, true), [
+                else if ([
+                    drapcode_constant_1.FieldTypes.date.id,
+                    ...drapcode_constant_1.systemDateField,
                     drapcode_constant_1.FieldTypes.time_slot.id,
-                ], false).includes(searchQueryTypeKey)) {
+                ].includes(searchQueryTypeKey)) {
                     if (key.startsWith("start_") || key.startsWith("end_")) {
-                        var fieldKey = key.replace("start_", "");
+                        let fieldKey = key.replace("start_", "");
                         fieldKey = fieldKey.replace("end_", "");
                         searchAggregateQuery.push({
-                            $addFields: (_m = {},
-                                _m["_".concat(key)] = { $toString: "$".concat(fieldKey) },
-                                _m),
+                            $addFields: {
+                                [`_${key}`]: { $toString: `$${fieldKey}` },
+                            },
                         });
                         if (key.startsWith("start_")) {
-                            likeQuery.push((_o = {},
-                                _o["_".concat(key)] = {
+                            likeQuery.push({
+                                [`_${key}`]: {
                                     $gte: (0, date_util_1.timezoneDateParse)(value, false, true),
                                 },
-                                _o));
+                            });
                         }
                         else if (key.startsWith("end_")) {
-                            likeQuery.push((_p = {},
-                                _p["_".concat(key)] = {
+                            likeQuery.push({
+                                [`_${key}`]: {
                                     $lt: (0, date_util_1.timezoneDateParse)(value),
                                 },
-                                _p));
+                            });
                         }
                     }
                     else {
                         searchAggregateQuery.push({
-                            $addFields: (_q = {},
-                                _q["_".concat(key)] = { $toString: "$".concat(key) },
-                                _q),
+                            $addFields: {
+                                [`_${key}`]: { $toString: `$${key}` },
+                            },
                         });
-                        likeQuery.push((_r = {},
-                            _r["_".concat(key)] = {
+                        likeQuery.push({
+                            [`_${key}`]: {
                                 $gte: (0, date_util_1.timezoneDateParse)(value, false, true),
                             },
-                            _r));
-                        likeQuery.push((_s = {},
-                            _s["_".concat(key)] = {
+                        });
+                        likeQuery.push({
+                            [`_${key}`]: {
                                 $lt: (0, date_util_1.timezoneDateParse)(value, false),
                             },
-                            _s));
+                        });
                     }
                 }
                 else {
                     // if input is string and db field type is number
                     // converting db field to string first
                     searchAggregateQuery.push({
-                        $addFields: (_t = {},
-                            _t["_".concat(key)] = { $toString: "$".concat(key) },
-                            _t),
+                        $addFields: {
+                            [`_${key}`]: { $toString: `$${key}` },
+                        },
                     });
-                    likeQuery.push((_u = {},
-                        _u["_".concat(key)] = {
+                    likeQuery.push({
+                        [`_${key}`]: {
                             $regex: value,
                             $options: "i",
                         },
-                        _u));
+                    });
                 }
             }
             else {
-                likeQuery.push((_v = {},
-                    _v[key] = {
+                likeQuery.push({
+                    [key]: {
                         $regex: value,
                         $options: "i",
                     },
-                    _v));
+                });
             }
         }
     });
-    console.log("==> searchAggregateQuery", JSON.stringify(searchAggregateQuery));
-    console.log("==> likeQuery", JSON.stringify(likeQuery));
-    return { searchAggregateQuery: searchAggregateQuery, likeQuery: likeQuery };
+    console.log(`==> searchAggregateQuery`, JSON.stringify(searchAggregateQuery));
+    console.log(`==> likeQuery`, JSON.stringify(likeQuery));
+    return { searchAggregateQuery, likeQuery };
 };
 exports.getSearchObjQuery = getSearchObjQuery;
-var mongoSelectQuery = function (query) {
-    if (query === void 0) { query = {}; }
-    var projection = {};
-    var fieldsInclude = query.fieldsInclude, fieldsExclude = query.fieldsExclude, finder = query.finder;
+const mongoSelectQuery = (query = {}) => {
+    const projection = {};
+    let { fieldsInclude, fieldsExclude, finder } = query;
     if (!fieldsExclude)
         fieldsExclude = [];
     if (fieldsInclude[0] === "*") {
-        fieldsExclude.map(function (field) {
+        fieldsExclude.map((field) => {
             if (field)
-                return (projection["".concat(field)] = 0);
+                return (projection[`${field}`] = 0);
         });
     }
     else {
         if (["FIND_ALL", "FIND"].includes(finder))
             fieldsInclude = (0, util_1.processFieldsInclude)(fieldsInclude);
-        fieldsInclude.map(function (field) {
+        fieldsInclude.map((field) => {
             if (field)
-                return (projection["".concat(field)] = 1);
+                return (projection[`${field}`] = 1);
         });
     }
     return projection;
 };
 exports.mongoSelectQuery = mongoSelectQuery;
-var modifyQuery = function (obj, hasAndQueryConjunction) {
-    if (obj === void 0) { obj = {}; }
-    if (hasAndQueryConjunction === void 0) { hasAndQueryConjunction = false; }
-    var arr = [];
-    Object.entries(obj).forEach(function (_a) {
-        var key = _a[0], value = _a[1];
+const modifyQuery = (obj = {}, hasAndQueryConjunction = false) => {
+    let arr = [];
+    Object.entries(obj).forEach(([key, value]) => {
+        console.log("key:>> ", key);
         if (hasAndQueryConjunction) {
             arr.push({ $and: value });
         }
@@ -201,7 +188,7 @@ var modifyQuery = function (obj, hasAndQueryConjunction) {
     return arr;
 };
 exports.modifyQuery = modifyQuery;
-var toBoolean = function (value) {
+const toBoolean = (value) => {
     if (!value) {
         return false;
     }
@@ -215,33 +202,33 @@ var toBoolean = function (value) {
             return false;
     }
 };
-var checkDate = function (queryValue) {
+const isItDate = (queryValue) => {
     return ("" + queryValue).match(date_util_1.DATE_REGEX);
 };
-exports.checkDate = checkDate;
-var getMinMaxValue = function (value) {
-    var isFixedValue = (0, exports.isFixedValueQuery)(value);
+exports.isItDate = isItDate;
+const getMinMaxValue = (value) => {
+    let isFixedValue = (0, exports.isFixedValueQuery)(value);
     if (isFixedValue)
         value = value.replace("FIXED_VALUE::", "");
-    var isValid = value && value.includes("---");
+    let isValid = value && value.includes("---");
     if (isValid) {
-        var isInteger = value.includes("^");
-        var result = value.split("---");
-        var endValue = result[1];
+        let isInteger = value.includes("^");
+        let result = value.split("---");
+        let endValue = result[1];
         if (isInteger && result.length)
             endValue = endValue.slice(0, -1);
-        return { startValue: result[0], endValue: endValue, isInteger: isInteger, isFixedValue: isFixedValue };
+        return { startValue: result[0], endValue, isInteger, isFixedValue };
     }
     else {
-        return { startValue: "", endValue: "", isFixedValue: isFixedValue };
+        return { startValue: "", endValue: "", isFixedValue };
     }
 };
 exports.getMinMaxValue = getMinMaxValue;
 // TODO: can be refactor with entity condition
-var isFixedValueQuery = function (value) {
-    var isFixeValue = false;
+const isFixedValueQuery = (value) => {
+    let isFixeValue = false;
     if (value && Array.isArray(value)) {
-        value.forEach(function (val) {
+        value.forEach((val) => {
             if (typeof val === "string" || val instanceof String)
                 isFixeValue = val.startsWith("FIXED_VALUE::");
         });
@@ -253,18 +240,18 @@ var isFixedValueQuery = function (value) {
     return isFixeValue;
 };
 exports.isFixedValueQuery = isFixedValueQuery;
-var getValueOfProjectConstant = function (value, currentUser, timezone) {
+const getValueOfProjectConstant = (value, currentUser, timezone) => {
     if (!timezone)
         timezone = "(GMT+5:30)";
     timezone = timezone.substring(4, 10);
-    var result;
+    let result;
     if (value === drapcode_constant_1.CURRENT_USER)
-        return currentUser["uuid"];
+        return currentUser[`uuid`];
     if (value === drapcode_constant_1.CURRENT_DATE)
         result = (0, date_util_1.createLoggerDateFormat)(timezone);
     if ([drapcode_constant_1.CURRENT_TIME, drapcode_constant_1.CURRENT_DATE_TIME].includes(value))
         result = (0, date_util_1.createLogsDateFormat)(timezone);
-    if (drapcode_constant_1.DateTimeUnit.some(function (cnst) { return value.includes(cnst); }))
+    if (drapcode_constant_1.DateTimeUnit.some((cnst) => value.includes(cnst)))
         result = (0, date_util_1.getDateValue)(value, timezone);
     return result;
 };