@budibase/shared-core 2.32.0 → 2.32.2

package/dist/index.js

@@ -10082,6 +10082,15 @@ var UserGroupSyncEvents = [
 var AsyncEvents = [...UserGroupSyncEvents];
 
 // ../types/src/sdk/search.ts
+var BasicOperator = /* @__PURE__ */ ((BasicOperator2) => {
+  BasicOperator2["EQUAL"] = "equal";
+  BasicOperator2["NOT_EQUAL"] = "notEqual";
+  BasicOperator2["EMPTY"] = "empty";
+  BasicOperator2["NOT_EMPTY"] = "notEmpty";
+  BasicOperator2["FUZZY"] = "fuzzy";
+  BasicOperator2["STRING"] = "string";
+  return BasicOperator2;
+})(BasicOperator || {});
 var ArrayOperator = /* @__PURE__ */ ((ArrayOperator2) => {
   ArrayOperator2["CONTAINS"] = "contains";
   ArrayOperator2["NOT_CONTAINS"] = "notContains";
@@ -10089,6 +10098,10 @@ var ArrayOperator = /* @__PURE__ */ ((ArrayOperator2) => {
   ArrayOperator2["ONE_OF"] = "oneOf";
   return ArrayOperator2;
 })(ArrayOperator || {});
+var RangeOperator = /* @__PURE__ */ ((RangeOperator2) => {
+  RangeOperator2["RANGE"] = "range";
+  return RangeOperator2;
+})(RangeOperator || {});
 var LogicalOperator = /* @__PURE__ */ ((LogicalOperator2) => {
   LogicalOperator2["AND"] = "$and";
   LogicalOperator2["OR"] = "$or";
@@ -10603,6 +10616,12 @@ function decodeNonAscii(str) {
 // src/filters.ts
 var import_lodash = __toESM(require_lodash());
 var HBS_REGEX = /{{([^{].*?)}}/g;
+var LOGICAL_OPERATORS = Object.values(LogicalOperator);
+var SEARCH_OPERATORS = [
+  ...Object.values(BasicOperator),
+  ...Object.values(ArrayOperator),
+  ...Object.values(RangeOperator)
+];
 var getValidOperatorsForType = (fieldType, field, datasource) => {
   const Op = OperatorOptions;
   const stringOps = [
@@ -10663,7 +10682,7 @@ var NoEmptyFilterStrings = [
   OperatorOptions.In.value
 ];
 function recurseLogicalOperators(filters, fn) {
-  for (const logical of Object.values(LogicalOperator)) {
+  for (const logical of LOGICAL_OPERATORS) {
     if (filters[logical]) {
       filters[logical].conditions = filters[logical].conditions.map(
         (condition) => fn(condition)
@@ -10674,7 +10693,7 @@ function recurseLogicalOperators(filters, fn) {
 }
 function recurseSearchFilters(filters, processFn) {
   filters = processFn(filters);
-  for (const logical of Object.values(LogicalOperator)) {
+  for (const logical of LOGICAL_OPERATORS) {
     if (filters[logical]) {
       filters[logical].conditions = filters[logical].conditions.map(
         (condition) => recurseSearchFilters(condition, processFn)
@@ -11137,7 +11156,9 @@ function runQuery(docs, query) {
     ).map(([key]) => {
       return filterFunctions[key]?.(doc) ?? false;
     });
-    if (query.allOr) {
+    if (!hasFilters(query)) {
+      return true;
+    } else if (query.allOr) {
       return results.some((result) => result === true);
     } else {
       return results.every((result) => result === true);
@@ -11179,16 +11200,33 @@ var hasFilters = (query) => {
   if (!query) {
     return false;
   }
-  const skipped = ["allOr", "onEmptyFilter"];
-  for (let [key, value] of Object.entries(query)) {
-    if (skipped.includes(key) || typeof value !== "object") {
-      continue;
+  const check = (filters) => {
+    for (const logical of LOGICAL_OPERATORS) {
+      if (filters[logical]) {
+        for (const condition of filters[logical]?.conditions || []) {
+          const result = check(condition);
+          if (result) {
+            return result;
+          }
+        }
+      }
     }
-    if (Object.keys(value || {}).length !== 0) {
-      return true;
+    for (const search2 of SEARCH_OPERATORS) {
+      const searchValue = filters[search2];
+      if (!searchValue || typeof searchValue !== "object") {
+        continue;
+      }
+      const filtered = Object.entries(searchValue).filter((entry) => {
+        const valueDefined = entry[1] !== void 0 || entry[1] !== null || entry[1] !== "";
+        return search2 === "notEmpty" /* NOT_EMPTY */ || valueDefined;
+      });
+      if (filtered.length !== 0) {
+        return true;
+      }
     }
-  }
-  return false;
+    return false;
+  };
+  return check(query);
 };
 
 // src/utils.ts