drapcode-utility 2.0.1 → 2.0.2

package/build/query/queryBuilder.js

@@ -0,0 +1,567 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntityCondition = exports.queryBuilder = void 0;
+const drapcode_constant_1 = require("drapcode-constant");
+const query_utils_1 = require("../utils/query-utils");
+const date_util_1 = require("../utils/date-util");
+const prepare_query_1 = require("../utils/prepare-query");
+const util_1 = require("../utils/util");
+const noFieldString = "random_string_since_field_not_present_1318874398806";
+const { boolean, number } = drapcode_constant_1.FieldTypes;
+const isEqualOrIgnore = [drapcode_constant_1.EQUALS, drapcode_constant_1.EQUALS_OR_IGNORE];
+const queryBuilder = async (collectionName, query, constants, externalParams, authDetail, timezone, searchObj = null, refCollectionFieldsInItems = null, searchQueryTypeObj = {}, lookupConfig = [], rowLevelSecurityFilter) => {
+    if (!collectionName || !query)
+        return "";
+    let finalQuery = { $and: [] };
+    // Apply both filters using the helper
+    applyFilterQuery(query, finalQuery, externalParams, constants, timezone, authDetail);
+    console.log("After main query check: ", JSON.stringify(finalQuery));
+    finalQuery = simplifyMongoQuery(finalQuery);
+    console.log("After main simplifyMongoQuery: ", JSON.stringify(finalQuery));
+    applyFilterQuery(rowLevelSecurityFilter, finalQuery, externalParams, constants, timezone, authDetail);
+    console.log("After RLS query check: ", JSON.stringify(finalQuery));
+    finalQuery = simplifyMongoQuery(finalQuery);
+    console.log("After RLS simplifyMongoQuery: ", JSON.stringify(finalQuery));
+    console.log(`==> searchQueryTypeObj :>>`, searchQueryTypeObj);
+    let aggregateQuery = [];
+    let searchQueryObj = null;
+    if (searchObj) {
+        const { searchAggregateQuery, likeQuery } = (0, query_utils_1.getSearchObjQuery)(searchObj, searchQueryTypeObj);
+        aggregateQuery = [...aggregateQuery, ...searchAggregateQuery];
+        if (likeQuery && likeQuery.length > 0) {
+            searchQueryObj = likeQuery;
+        }
+    }
+    console.log("1");
+    if (searchQueryObj) {
+        finalQuery.$and.push(...searchQueryObj);
+    }
+    console.log("2");
+    const { tenant, user } = authDetail;
+    const { addTenantQuery, addSubTenantQuery } = query;
+    const additionalFilters = [];
+    if (addTenantQuery && tenant?.uuid) {
+        additionalFilters.push({ tenantId: tenant.uuid });
+    }
+    console.log("3");
+    if (addSubTenantQuery &&
+        Array.isArray(user.subTenantId) &&
+        user.subTenantId.length > 0) {
+        console.log("4");
+        const subTenantUuids = user.subTenantId
+            .map((item) => item?.uuid)
+            .filter((uuid) => uuid); // Filters out undefined/null
+        console.log("5");
+        if (subTenantUuids && subTenantUuids.length > 0) {
+            additionalFilters.push({ subTenantId: { $in: subTenantUuids } });
+        }
+    }
+    console.log("6");
+    if (additionalFilters.length > 0) {
+        finalQuery.$and.push(...additionalFilters);
+    }
+    console.log("7");
+    //Remove empty and in final query
+    if (!finalQuery?.$and?.length) {
+        delete finalQuery.$and;
+    }
+    console.log("8");
+    if (finalQuery && Object.keys(finalQuery).length) {
+        aggregateQuery.push({ $match: finalQuery });
+    }
+    let projection = (0, query_utils_1.mongoSelectQuery)(query);
+    let { finder, sortBy, orderBy, aggregateFunctionField } = query;
+    if (finder != "COUNT" && refCollectionFieldsInItems) {
+        await Promise.all(refCollectionFieldsInItems.map((field) => (0, prepare_query_1.commonLookupSetting)(field, lookupConfig, aggregateQuery)));
+    }
+    if (!util_1.nonFindQuery.includes(finder) && !(0, util_1.isEmpty)(projection)) {
+        aggregateQuery.push({ $project: projection });
+    }
+    if (finder === "COUNT") {
+        aggregateQuery.push({ $group: { _id: null, count: { $sum: 1 } } });
+    }
+    else if (finder === "SUM") {
+        aggregateQuery.push({
+            $group: { _id: null, total: { $sum: `$${aggregateFunctionField}` } },
+        });
+    }
+    else if (finder === "AVG") {
+        aggregateQuery.push({
+            $group: { _id: null, average: { $avg: `$${aggregateFunctionField}` } },
+        });
+    }
+    else if (finder === "MIN") {
+        aggregateQuery.push({
+            $group: { _id: null, minimum: { $min: `$${aggregateFunctionField}` } },
+        });
+    }
+    else if (finder === "MAX") {
+        aggregateQuery.push({
+            $group: { _id: null, maximum: { $max: `$${aggregateFunctionField}` } },
+        });
+    }
+    let offset = externalParams.offset || 0;
+    let limit = externalParams.limit || 20000;
+    let resetLimit = externalParams.resetLimit || false;
+    if (externalParams.pagination == "false") {
+        limit = 0;
+        sortBy = 0;
+    }
+    // Reset limit value to 1 in case filter is of type FIND or when it's a COUNT finder for FIND filter
+    if (finder === "FIND" || (util_1.nonFindQuery.includes(finder) && resetLimit)) {
+        offset = 0;
+        limit = 1;
+    }
+    if (!util_1.nonFindQuery.includes(finder) && sortBy) {
+        let direction = orderBy && orderBy == "asc" ? 1 : -1;
+        aggregateQuery.push({ $sort: { [sortBy]: direction, _id: 1 } });
+    }
+    if (!util_1.nonFindQuery.includes(finder) && limit) {
+        aggregateQuery.push({ $skip: +offset }, { $limit: +limit });
+    }
+    return aggregateQuery;
+};
+exports.queryBuilder = queryBuilder;
+const simplifyMongoQuery = (query) => {
+    if (typeof query !== "object" || query === null)
+        return query;
+    const keys = Object.keys(query);
+    // Recursively simplify nested queries
+    for (const key of keys) {
+        query[key] = Array.isArray(query[key])
+            ? query[key].map(simplifyMongoQuery)
+            : simplifyMongoQuery(query[key]);
+    }
+    if (keys.length === 1 && (keys[0] === "$and" || keys[0] === "$or")) {
+        const op = keys[0];
+        const conditions = query[op];
+        // Flatten if nested same operator inside
+        const flattened = conditions.flatMap((condition) => {
+            if (condition && condition[op]) {
+                return condition[op];
+            }
+            return [condition];
+        });
+        // If only one condition, replace with that condition
+        if (flattened.length === 1) {
+            return simplifyMongoQuery(flattened[0]);
+        }
+        return { [op]: flattened };
+    }
+    return query;
+};
+const applyFilterQuery = (filter, finalQuery, externalParams, constants, timezone, authDetail) => {
+    const generatedQuery = createFilterQuery(filter, externalParams, constants, timezone, authDetail);
+    console.log("**************************");
+    if (generatedQuery)
+        finalQuery.$and.push(generatedQuery);
+    // const first = generatedQuery;
+    // const hasOr = first?.$or?.length > 0;
+    // const hasAnd = first?.$and?.length > 0;
+    // if (generatedQuery.length && (hasOr || hasAnd)) {
+    //   finalQuery.$and.push(...generatedQuery);
+    // }
+};
+const createFilterQuery = (query, externalParams, constants, timezone, authDetail) => {
+    if (!query || !query.conditions.length)
+        return null;
+    const { conditions } = query;
+    const queryConjunctions = [];
+    const filterQuery = { $or0: [] };
+    const finalConditions = [];
+    conditions.forEach((queryObj, index) => {
+        const { query, requiredExternal, conjunctionType } = queryObj;
+        let mongoQuery = conditionToQuery(query, requiredExternal, externalParams, constants, timezone, authDetail);
+        if (mongoQuery) {
+            finalConditions.push({ conjunctionType, query: mongoQuery });
+            queryConjunctions.push(conjunctionType || "OR");
+            const key = `$${conjunctionType?.toLowerCase() || "or"}${index}`;
+            if (["OR", "AND"].includes(conjunctionType || "")) {
+                const lastKey = Object.keys(filterQuery)[Object.keys(filterQuery).length - 1];
+                if (filterQuery[lastKey] && Array.isArray(filterQuery[lastKey])) {
+                    filterQuery[lastKey].push(mongoQuery);
+                }
+                else {
+                    filterQuery[key] = [mongoQuery];
+                }
+            }
+            else {
+                filterQuery[`$or${index}`] = [mongoQuery];
+            }
+        }
+    });
+    const newQuery = prepareFinalQueryString(finalConditions);
+    console.log("fQuery :>> ", JSON.stringify(newQuery));
+    const hasAndQueryConjunction = queryConjunctions.includes("AND");
+    const oldQuery = (0, query_utils_1.modifyQuery)(filterQuery, hasAndQueryConjunction);
+    console.log("oldQuery :>> ", JSON.stringify(oldQuery));
+    return newQuery;
+};
+const prepareFinalQueryString = (conditions) => {
+    if (!Array.isArray(conditions) || conditions.length === 0) {
+        return {};
+    }
+    let finalQuery = null;
+    for (const condition of conditions) {
+        const { conjunctionType, query } = condition;
+        if (!finalQuery) {
+            finalQuery = query;
+        }
+        else {
+            if (conjunctionType === "AND") {
+                finalQuery = { $and: [finalQuery, query] };
+            }
+            else if (conjunctionType === "OR") {
+                finalQuery = { $or: [finalQuery, query] };
+            }
+            else {
+                throw new Error(`Invalid conjunctionType: ${conjunctionType}`);
+            }
+        }
+    }
+    return finalQuery ?? {};
+};
+const conditionToQuery = (query, requiredExternal, externalParams, constants, timezone, authDetail) => {
+    const { key, field, value, fieldType } = query;
+    if ([drapcode_constant_1.NOT_EQUAL, ...isEqualOrIgnore].includes(key) &&
+        typeof value === "string" &&
+        drapcode_constant_1.DateRangeConstant.some((cnst) => value.includes(cnst))) {
+        let final = (0, date_util_1.getDateRangeValue)(key, field, value);
+        return final;
+    }
+    console.log("No date range constants");
+    let fieldValue = changeExternalParams(query, requiredExternal, externalParams, constants, timezone, authDetail);
+    console.log("After External Params replacements: ", fieldValue);
+    if (["undefined", "null", null, undefined, ""].includes(fieldValue)) {
+        //Assign some random value if fieldValue is missing from old records
+        fieldValue = noFieldString;
+    }
+    console.log("fieldValue queryToMongo 1", fieldValue);
+    let isDate = (0, query_utils_1.isItDate)(fieldValue);
+    console.log("isDate queryToMongo 2", isDate);
+    // Field Type: reference, belongsTo, static option and dynamic option
+    let condition = drapcode_constant_1.AllSelectOptionFields.includes(fieldType);
+    console.log("If field is of type reference, belongs, static or dynamic option:", condition);
+    if (condition) {
+        if (key === drapcode_constant_1.IS_NULL) {
+            return {
+                $or: [
+                    { [field]: { $exists: false } },
+                    { [field]: { $type: "array", $eq: [] } },
+                ],
+            };
+        }
+        if (key === drapcode_constant_1.IS_NOT_NULL) {
+            return { [field]: { $exists: true, $type: "array", $ne: [] } };
+        }
+        if (!isDate) {
+            if (key === drapcode_constant_1.EQUALS_OR_IGNORE &&
+                typeof fieldValue === "string" &&
+                fieldValue.startsWith("CURRENT_")) {
+                //When Current Logged In Tenant/Settings/User have no data in that specific field
+                //Then they return the fieldValue as CURRENT_SETTINGS:field not blank
+                return {};
+            }
+            fieldValue = prepNonArrayValue(fieldValue);
+            console.log("After Non Array check:", fieldValue);
+            if (isEqualOrIgnore.includes(key)) {
+                return { [field]: { $in: fieldValue || [] } };
+            }
+            if (key === drapcode_constant_1.NOT_EQUAL) {
+                return { [field]: { $nin: fieldValue || [] } };
+            }
+        }
+        if (key === drapcode_constant_1.IN_LIST) {
+            if (!Array.isArray(fieldValue)) {
+                fieldValue = [fieldValue];
+            }
+            return { [field]: { $in: fieldValue || [] } };
+        }
+        if (key === drapcode_constant_1.NOT_IN_LIST) {
+            if (!Array.isArray(fieldValue)) {
+                fieldValue = [fieldValue];
+            }
+            return { [field]: { $nin: fieldValue || [] } };
+        }
+    }
+    else {
+        //Since we already checked condition for array/dropdown field type
+        //static_option, dynamic_option, reference, belongsTo
+        //Now check for remaining field type
+        //Let's check for all other keys
+        if (key === drapcode_constant_1.IS_NOT_NULL)
+            return { [field]: { $nin: [null, ""] } };
+        if (key === drapcode_constant_1.IS_NULL)
+            return { [field]: { $in: [null, ""] } };
+        if (key === drapcode_constant_1.LIKE)
+            return { [field]: { $regex: fieldValue, $options: "i" } };
+        if ([drapcode_constant_1.IN_LIST, drapcode_constant_1.NOT_IN_LIST].includes(key)) {
+            console.log("In list or not in list check");
+            fieldValue = prepNonArrayValue(fieldValue);
+            if (key === drapcode_constant_1.IN_LIST) {
+                return { [field]: { $in: fieldValue || [] } };
+            }
+            if (key === drapcode_constant_1.NOT_IN_LIST) {
+                return { [field]: { $nin: fieldValue || [] } };
+            }
+        }
+        if (key === drapcode_constant_1.NOT_EQUAL) {
+            if (fieldType === number.id) {
+                return { [field]: { $ne: +fieldValue } };
+            }
+            if (fieldType === boolean.id) {
+                return {
+                    [field]: { $ne: fieldValue ? JSON.parse(fieldValue) : fieldValue },
+                };
+            }
+            return { [field]: { $ne: fieldValue } };
+        }
+        if (key === drapcode_constant_1.BETWEEN) {
+            const { startValue, endValue, isInteger } = (0, query_utils_1.getMinMaxValue)(fieldValue);
+            return {
+                [field]: {
+                    $gte: isInteger ? +startValue : startValue,
+                    $lte: isInteger ? +endValue : endValue,
+                },
+            };
+        }
+        if (key === drapcode_constant_1.GREATER_THAN_EQUALS_TO)
+            return { [field]: { $gte: isDate ? fieldValue : +fieldValue } };
+        if (key === drapcode_constant_1.LESS_THAN_EQUALS_TO)
+            return { [field]: { $lte: isDate ? fieldValue : +fieldValue } };
+        if (key === drapcode_constant_1.LESS_THAN)
+            return { [field]: { $lt: isDate ? fieldValue : +fieldValue } };
+        if (key === drapcode_constant_1.GREATER_THAN)
+            return { [field]: { $gt: isDate ? fieldValue : +fieldValue } };
+        //Equal & Equal Ignore
+        //Created By
+        if (equalIgnoreCheck(fieldValue, key)) {
+            return {};
+        }
+        if (field === "createdBy" && isEqualOrIgnore.includes(key)) {
+            return {
+                $and: [
+                    { [field]: { $ne: null } },
+                    { [field]: { $ne: "" } },
+                    { [field]: { $eq: fieldValue } },
+                ],
+            };
+        }
+        //Boolean
+        if (fieldType === boolean.id && isEqualOrIgnore.includes(key)) {
+            return prepareBooleanQuery(field, fieldValue);
+        }
+        //Number
+        if (fieldType === number.id && isEqualOrIgnore.includes(key)) {
+            return { [field]: +fieldValue };
+        }
+        //Date
+        if (isDate && isEqualOrIgnore.includes(key)) {
+            return {
+                [field]: {
+                    $gte: fieldValue,
+                    $lt: (0, date_util_1.nextDayDate)(fieldValue),
+                },
+            };
+        }
+        //Since we already check equal & equal ignore for boolean, number, date, createdBy
+        //Now if it still equal & equal ignore, but no field type match then
+        if (isEqualOrIgnore.includes(key)) {
+            return { [field]: fieldValue };
+        }
+    }
+};
+const changeExternalParams = (query, requiredExternal, externalParams, constants, timezone, authDetail) => {
+    const { key, value, fieldType } = query;
+    const { user, tenant, setting, subTenant } = authDetail;
+    //For select
+    if (fieldType &&
+        !requiredExternal &&
+        drapcode_constant_1.AllSelectOptionFields.includes(fieldType)) {
+        const { refCollection, refField } = query;
+        let finalValue = value;
+        if (drapcode_constant_1.OptionTypeFields.includes(fieldType) && !value) {
+            switch (refCollection) {
+                case drapcode_constant_1.CURRENT_USER:
+                    finalValue = user?.[refField];
+                    break;
+                case drapcode_constant_1.CURRENT_TENANT:
+                    finalValue = tenant?.[refField];
+                    break;
+                case drapcode_constant_1.CURRENT_SETTINGS:
+                    finalValue = setting?.[refField];
+                    break;
+                case drapcode_constant_1.CURRENT_SUB_TENANT:
+                    finalValue = subTenant?.[refField];
+                    break;
+            }
+        }
+        if (value === drapcode_constant_1.CURRENT_USER) {
+            finalValue = user?.uuid;
+        }
+        if (!finalValue)
+            finalValue = value;
+        return finalValue;
+    }
+    if (fieldType === boolean.id &&
+        ["true", "false", "", true, false].includes(value)) {
+        return String(value);
+    }
+    const constantDataMap = {
+        [drapcode_constant_1.CURRENT_USER]: user,
+        [drapcode_constant_1.CURRENT_TENANT]: tenant,
+        [drapcode_constant_1.CURRENT_SETTINGS]: setting,
+        [drapcode_constant_1.CURRENT_SUB_TENANT]: subTenant,
+    };
+    if ([drapcode_constant_1.IN_LIST, drapcode_constant_1.NOT_IN_LIST].includes(key)) {
+        let valueList = [];
+        if (Array.isArray(value) && value.length) {
+            valueList.push(...value);
+            value.forEach((val) => {
+                constants.forEach((constant) => {
+                    if (val === constant.name) {
+                        valueList.push(constant.value);
+                    }
+                });
+            });
+        }
+        else if (typeof value === "string") {
+            Object.entries(constantDataMap).forEach(([constantName, data]) => {
+                if (value.includes(constantName)) {
+                    const currentDataValue = getCurrentDataValueFrom(value, constantName, data, true);
+                    if (currentDataValue) {
+                        if (Array.isArray(currentDataValue)) {
+                            valueList.push(...currentDataValue);
+                        }
+                        else {
+                            valueList.push(currentDataValue);
+                        }
+                    }
+                }
+            });
+        }
+        return valueList;
+    }
+    if (key === drapcode_constant_1.BETWEEN) {
+        let { startValue, endValue, isFixedValue } = (0, query_utils_1.getMinMaxValue)(value);
+        if (requiredExternal) {
+            startValue = `${externalParams[startValue]}`;
+            endValue = `${externalParams[endValue]}`;
+        }
+        else {
+            const resolveValue = (val) => {
+                if ([drapcode_constant_1.CURRENT_USER, ...drapcode_constant_1.DateConstant].some((cnst) => val.includes?.(cnst))) {
+                    return (0, query_utils_1.getValueOfProjectConstant)(val, user, timezone);
+                }
+                else if (!isFixedValue) {
+                    const found = constants.find((constant) => constant.name === val);
+                    return found?.value ?? val;
+                }
+                return val;
+            };
+            startValue = resolveValue(startValue);
+            endValue = resolveValue(endValue);
+        }
+        if (Array.isArray(startValue)) {
+            startValue = startValue[0].value;
+        }
+        if (Array.isArray(endValue)) {
+            endValue = endValue[0].value;
+        }
+        const isNumeric = !isNaN(startValue) && !isNaN(endValue);
+        const result = `${startValue}---${endValue}${isNumeric ? "^" : ""}`;
+        return result;
+    }
+    for (const [constant, source] of Object.entries(constantDataMap)) {
+        const valueFromSource = getCurrentDataValueFrom(value, constant, source);
+        console.log(`\n ${constant} Value :>>`, valueFromSource);
+        if (valueFromSource)
+            return valueFromSource;
+    }
+    if (drapcode_constant_1.DateConstant.some((cnst) => value.includes(cnst))) {
+        return (0, query_utils_1.getValueOfProjectConstant)(value, {}, timezone);
+    }
+    if ((0, exports.isEntityCondition)(value)) {
+        const key = value.replace("ENTITY::", "");
+        return externalParams[key] ? externalParams[key] : "";
+    }
+    if ((0, query_utils_1.isFixedValueQuery)(value))
+        return value.replace("FIXED_VALUE::", "");
+    if (requiredExternal) {
+        let externalParamValue = externalParams[`${value}`];
+        if (!isNaN(externalParamValue)) {
+            return +externalParamValue;
+        }
+        return externalParams[`${value}`];
+    }
+    let constantArr = constants.filter((constant) => constant.name == value);
+    return constantArr.length ? "" + constantArr[0].value : "";
+};
+const equalIgnoreCheck = (fieldValue, key) => {
+    return (key === drapcode_constant_1.EQUALS_OR_IGNORE &&
+        Array.isArray(fieldValue) &&
+        fieldValue.includes(noFieldString));
+};
+const getCurrentDataValueFrom = (value, constantName, data, isMultiRef = false) => {
+    if (!value.includes(constantName))
+        return;
+    if (value === constantName)
+        return data[`uuid`];
+    const splitValues = value.split("::");
+    let refCollection = "", refCollectionField = "";
+    if (splitValues.length === 2) {
+        [refCollection, refCollectionField] = splitValues;
+    }
+    else if (splitValues.length >= 3) {
+        [, refCollection, refCollectionField] = splitValues;
+    }
+    else {
+        refCollection = splitValues[0];
+    }
+    if (refCollection && refCollectionField) {
+        console.log("I have refCollection and Field");
+        if (refCollection === constantName) {
+            return data[refCollectionField];
+        }
+        let refCollectionData = data?.[refCollection];
+        if (!refCollectionData)
+            return "";
+        if (Array.isArray(refCollectionData)) {
+            if (!isMultiRef)
+                return "";
+            return refCollectionData
+                .map((ref) => ref?.[refCollectionField])
+                .filter((v) => v !== undefined && v !== null);
+        }
+        refCollectionData = refCollectionData[0];
+        return refCollectionData?.[refCollectionField];
+    }
+    //this means that data has to be match with current user field that is not ref type
+    return data?.[refCollection] ?? data?.uuid;
+};
+const isEntityCondition = (value) => {
+    if (Array.isArray(value)) {
+        return value.some((val) => typeof val === "string" && val.startsWith("ENTITY::"));
+    }
+    return typeof value === "string" && value.startsWith("ENTITY::");
+};
+exports.isEntityCondition = isEntityCondition;
+const prepNonArrayValue = (val) => Array.isArray(val) ? val : [val];
+const parseBooleanSafe = (val) => {
+    try {
+        return JSON.parse(val) === true;
+    }
+    catch {
+        return false;
+    }
+};
+const prepareBooleanQuery = (field, fieldValue) => {
+    const boolVal = parseBooleanSafe(fieldValue);
+    return boolVal
+        ? {
+            [field]: boolVal,
+        }
+        : {
+            $or: [{ [field]: boolVal }, { [field]: { $exists: false } }],
+        };
+};

package/build/utils/check-error.d.ts

@@ -1,9 +1,16 @@
-export declare const checkForError: (result: any, errors: Array<any>, mapping: any, status: number) => Promise<{
-    status: number;
-    responseData: string;
+interface ErrorConfig {
+    message: string;
+    path?: string;
+    value?: string | number;
+}
+interface CheckErrorResult {
+    status?: number;
+    responseData?: string;
     noError: boolean;
-} | {
-    noError: boolean;
-    status?: undefined;
-    responseData?: undefined;
-}>;
+}
+interface ErrorMapping {
+    errorMsgPath: string;
+    errorValue: string | number;
+}
+export declare const checkForError: (result: Record<string, any>, errors: ErrorConfig[], mapping: ErrorMapping, status: number) => Promise<CheckErrorResult>;
+export {};