@cocreate/utils 1.31.0 → 1.32.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+# [1.32.0](https://github.com/CoCreate-app/CoCreate-utils/compare/v1.31.0...v1.32.0) (2024-01-17)
+
+
+### Bug Fixes
+
+* getValueFromObject conditions and param names ([2fd7387](https://github.com/CoCreate-app/CoCreate-utils/commit/2fd73873cc42d0a22e43e04fee35f31227790f7b))
+* getValueFromObject param trowError boolean will trow erro if property does not exist vs returning undefined ([39a9cab](https://github.com/CoCreate-app/CoCreate-utils/commit/39a9cabb9e109d1aae6a695ba47d76c95c8581f6))
+* renamed isMatch to queryMatch ([b3c9429](https://github.com/CoCreate-app/CoCreate-utils/commit/b3c942950661b1d906c9f8a77a3bbd2f5693fd47))
+* update to support new query system ([a267b52](https://github.com/CoCreate-app/CoCreate-utils/commit/a267b5260955a631330a2b22bd9fb316a00004c6))
+
+
+### Features
+
+* query() function to handle queries similar to mongodb ([164bf45](https://github.com/CoCreate-app/CoCreate-utils/commit/164bf45d44f620fe8e6a4cf75fe744be68277d6c))
+* sort by multiple keys ([7872a53](https://github.com/CoCreate-app/CoCreate-utils/commit/7872a5308bcf510e40385c57b45c0d899a40295a))
+
 # [1.31.0](https://github.com/CoCreate-app/CoCreate-utils/compare/v1.30.0...v1.31.0) (2024-01-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/utils",
-  "version": "1.31.0",
+  "version": "1.32.0",
   "description": "A simple utils component in vanilla javascript. Easily configured using HTML5 attributes and/or JavaScript API.",
   "keywords": [
     "utils",

package/src/index.js

@@ -142,32 +142,36 @@
         }
     }
 
-    function getValueFromObject(json, path) {
+    function getValueFromObject(object = {}, path = '', throwError = false) {
         try {
-            if (typeof json == 'undefined' || !path)
-                return;
+            if (!Object.keys(object).length || !path) {
+                if (throwError)
+                    throw new Error("Invalid input to getValueFromObject");
+                return
+
+            }
 
             path = path.replace(/\[(\d+)\]/g, '.$1');
 
-            let jsonData = json, subpath = path.split('.');
+            let data = object, subpath = path.split('.');
 
             for (let i = 0; i < subpath.length; i++) {
-                jsonData = jsonData[subpath[i]];
-                if (!jsonData)
-                    return jsonData;
+                if (throwError && !(subpath[i] in data))
+                    throw new Error("Key not found in object: " + subpath[i]);
+
+                data = data[subpath[i]];
+                if (!data)
+                    return;
             }
-            return jsonData;
+
+            return data;
         } catch (error) {
-            console.log("Error in getValueFromObject", error);
-            return;
+            // console.error("Error in getValueFromObject:", error);
+            if (throwError)
+                throw error;
         }
     }
 
-    function isObjectEmpty(obj) {
-        for (var x in obj) { return false }
-        return true;
-    }
-
     function domParser(str) {
         try {
             var mainTag = str.match(/\<(?<tag>[a-z0-9]+)(.*?)?\>/).groups.tag;
@@ -298,6 +302,7 @@
             }
 
             if (Selector) {
+                // let selectors = Selector.split(/,(?![^()]*\))/g);
 
                 let selectors = Selector.split(',');
                 for (let j = 0; j < selectors.length; j++) {
@@ -418,146 +423,153 @@
         return selector
     }
 
-
     function queryData(data, query) {
-        if (!data)
-            return false;
-
-        if (!Array.isArray(data))
-            data = [data]
+        if (query.$and) {
+            for (let i = 0; i < query.$and.length; i++) {
+                if (!queryData(data, query.$and[i]))
+                    return false
+            }
+        }
 
-        if (!query)
-            return true
+        if (query.$nor) {
+            for (let i = 0; i < query.$nor.length; i++) {
+                if (queryData(data, query.$nor[i]))
+                    return false;
+            }
+        }
 
-        if (!Array.isArray(query))
-            query = [query]
-        if (!query.length)
-            return true
+        for (let key of Object.keys(query)) {
+            if (key === '$and' || key === '$or')
+                continue
+            if (!queryMatch(data, { [key]: query[key] }))
+                return false
+        }
 
-        let queryResult = false
-        for (let n = 0; n < data.length; n++) {
-            for (let i = 0; i < query.length; i++) {
-                let dataValue
-                if (query[i].key.includes('.') || /\[([0-9]*)\]/g.test(query[i].key))
-                    dataValue = getValueFromObject(data[n], query[i].key)
-                else
-                    dataValue = data[n][query[i].key]
-                if (dataValue == undefined)
-                    dataValue = ''
-                let logicalOperator = query[i].logicalOperator || 'and'
-                let queryValues = query[i].value
-
-                let queryIsArray = false
-                if (!Array.isArray(queryValues))
-                    queryValues = [queryValues]
-                else
-                    queryIsArray = true
+        if (query.$or) {
+            for (let i = 0; i < query.$or.length; i++) {
+                if (queryData(data, query.$or[i]))
+                    return true
+            }
+        }
 
+        return true;
+    }
 
-                let queryStatus = false
-                for (let queryValue of queryValues) {
-                    if (query[i].caseSensitive != 'true' || query[i].caseSensitive != true) {
-                        if (typeof dataValue == 'string')
-                            dataValue = dataValue.toLowerCase()
-                        if (typeof queryValue == 'string')
-                            queryValue = queryValue.toLowerCase()
-                    }
+    function queryMatch(data, query) {
+        for (let key of Object.keys(query)) {
+            // if (!data.hasOwnProperty(key))
+            //     return false
 
-                    if (isValidDate(dataValue) && isValidDate(queryValue)) {
-                        dataValue = new Date(dataValue)
-                        queryValue = new Date(queryValue)
-                    }
-                    switch (query[i].operator) {
-                        case '$includes':
-                        case 'includes':
-                            if (dataValue.includes(queryValue))
-                                queryStatus = true
-                            // if (queryValue === "" && logicalOperator === 'and') {
-                            //     if (dataValue !== "")
-                            //         queryStatus = false
-                            // }
-                            break;
-                        case '$eq':
-                            if (dataValue == queryValue)
-                                queryStatus = true
-                            break;
-                        case '$ne':
-                            if (Array.isArray(dataValue)) {
-                                // Check if the entire array is different from queryValue
-                                queryStatus = !isEqualArray(dataValue, queryValue);
-                            } else if (Array.isArray(queryValue)) {
-                                // If queryValue is an array, check if dataValue is different from this array
-                                queryStatus = !isEqualArray(queryValue, dataValue);
-                            } else {
-                                // If neither is an array, simple comparison
-                                queryStatus = (dataValue != queryValue);
-                            }
-                            break;
-                        case '$lt':
-                            if (dataValue < queryValue)
-                                queryStatus = true
-                            break;
-                        case '$lte':
-                            if (dataValue <= queryValue)
-                                queryStatus = true
-                            break;
-                        case '$gt':
-                            if (dataValue > queryValue)
-                                queryStatus = true
-                            break;
-                        case '$gte':
-                            if (dataValue >= queryValue)
-                                queryStatus = true
-                            break;
-                        case '$in':
-                            if (Array.isArray(dataValue)) {
-                                queryStatus = dataValue.some(element => queryValue.includes(element));
-                            } else {
-                                queryStatus = queryValue.includes(dataValue);
-                            }
-                            break;
-                        case '$nin':
-                            if (Array.isArray(dataValue)) {
-                                queryStatus = !dataValue.some(element => queryValue.includes(element));
-                            } else {
-                                queryStatus = !queryValue.includes(dataValue);
-                            }
-                            break;
-                        case '$range':
-                            if (queryValue[0] !== null && queryValue[1] !== null) {
-                                if (dataValue >= queryValue[0] && dataValue <= queryValue[1])
-                                    queryStatus = true
-                            } else if (queryValue[0] == null && dataValue <= queryValue[1]) {
-                                queryStatus = true
-                            } else if (queryValue[1] == null && dataValue >= queryValue[0]) {
-                                queryStatus = true
-                            }
-                            break;
+            let dataValue
+            try {
+                dataValue = getValueFromObject(data, key, true)
+            } catch (error) {
+                return false
+            }
 
-                        default:
-                            if (dataValue.includes(queryValue))
-                                queryStatus = true
-                            break;
-                    }
-                    if (!queryIsArray || query[i].operator === "$nin") {
-                        switch (logicalOperator) {
-                            case 'and':
-                                if (queryStatus == false)
-                                    return false
+            if (typeof query[key] === 'string' || typeof query[key] === 'number' || typeof query[key] === 'boolean') {
+                if (Array.isArray(dataValue))
+                    return dataValue.includes(query[key])
+                else
+                    return dataValue === query[key]
+            } else if (Array.isArray(query[key])) {
+                if (Array.isArray(dataValue)) {
+                    return isEqualArray(dataValue, query[key]);
+                } else {
+                    return false;
+                }
+            } else {
+                for (let property of Object.keys(query[key])) {
+                    if (!property.startsWith('$')) {
+                        if (typeof dataValue !== 'object') {
+                            return false;
+                        } else
+                            return queryMatch({ [property]: getValueFromObject(dataValue, property) }, { [property]: query[key][property] })
+                    } else {
+                        let queryValue = query[key][property]
+                        let queryStatus = false
+                        switch (property) {
+                            case '$eq':
+                                if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                                    queryStatus = isEqualArray(dataValue, queryValue);
+                                } else {
+                                    queryStatus = (dataValue === queryValue);
+                                }
+                                break;
+                            case '$ne':
+                                if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                                    queryStatus = !isEqualArray(dataValue, queryValue);
+                                } else {
+                                    queryStatus = (dataValue !== queryValue);
+                                }
+                                break;
+                            case '$not':
+                                queryStatus = !queryMatch(data, { [key]: query[key]['$not'] });
+                                break;
+                            case '$lt':
+                                queryStatus = (dataValue < queryValue)
+                                break;
+                            case '$lte':
+                                queryStatus = (dataValue <= queryValue)
+                                break;
+                            case '$gt':
+                                queryStatus = (dataValue > queryValue)
+                                break;
+                            case '$gte':
+                                queryStatus = (dataValue >= queryValue)
+                                break;
+                            case '$in':
+                                if (Array.isArray(dataValue)) {
+                                    queryStatus = dataValue.some(element => queryValue.includes(element));
+                                } else {
+                                    queryStatus = queryValue.includes(dataValue);
+                                }
+                                break;
+                            case '$nin':
+                                if (Array.isArray(dataValue)) {
+                                    queryStatus = !dataValue.some(element => queryValue.includes(element));
+                                } else {
+                                    queryStatus = !queryValue.includes(dataValue);
+                                }
+                                break;
+                            case '$all':
+                                if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                                    queryStatus = queryValue.every(element => dataValue.includes(element));
+                                }
+                                break;
+                            case '$elemMatch':
+                                if (Array.isArray(data[key])) {
+                                    queryStatus = data[key].some(element => queryMatch(element, query[key][property]));
+                                }
+                                break;
+                            case '$size':
+                                if (Array.isArray(dataValue)) {
+                                    queryStatus = (dataValue.length === queryValue);
+                                }
+                                break;
+                            case '$exists':
+                                queryStatus = (queryValue ? data.hasOwnProperty(key) : !data.hasOwnProperty(key));
                                 break;
-                            // case 'or':
-                            //     if (queryStatus == true)
-                            //         queryResult = queryStatus
-                            //     break;
+                            case '$regex':
+                                if (typeof dataValue === 'string') {
+                                    let regex = new RegExp(queryValue);
+                                    queryStatus = regex.test(dataValue);
+                                }
+                                break;
+                            default:
+                                console.log('unknown operator')
+                                break;
+
                         }
-                    } else if (queryStatus && query[i].operator === "$in")
-                        return true
-                    queryResult = queryStatus
+                        if (!queryStatus)
+                            return false
+
+                    }
                 }
+                return true
             }
-        }
 
-        return queryResult;
+        }
     }
 
     function isEqualArray(arr1, arr2) {
@@ -643,7 +655,38 @@
         return true
     }
 
+
     function sortData(data, sort) {
+        return data.sort((a, b) => {
+            for (let i = 0; i < sort.length; i++) {
+                let key = sort[i].key;
+                if (a[key] == null && b[key] == null) continue;
+                if (a[key] == null)
+                    return sort[i].direction === 'desc' ? -1 : 1;
+                if (b[key] == null)
+                    return sort[i].direction === 'desc' ? 1 : -1;
+
+                if (typeof a[key] !== typeof b[key]) {
+                    return typeof a[key] < typeof b[key] ? -1 : 1;
+                }
+
+                if (a[key] !== b[key]) {
+                    if (typeof a[key] === 'string') {
+                        return sort[i].direction === 'desc' ?
+                            b[key].localeCompare(a[key]) :
+                            a[key].localeCompare(b[key]);
+                    } else { // Assuming numeric or other comparable types
+                        return sort[i].direction === 'desc' ?
+                            (b[key] - a[key]) :
+                            (a[key] - b[key]);
+                    }
+                }
+            }
+            return 0;
+        });
+    }
+
+    function sortDataOld(data, sort) {
         if (!Array.isArray(sort))
             sort = [sort]
         for (let i = 0; i < sort.length; i++) {
@@ -748,7 +791,6 @@
         isValidDate,
         dotNotationToObject,
         getValueFromObject,
-        isObjectEmpty,
         domParser,
         parseTextToHtml,
         escapeHtml,