@budibase/shared-core 2.31.8 → 2.32.1

package/dist/filters.d.ts

@@ -66,16 +66,13 @@ export declare class ColumnSplitter {
  */
 export declare const buildQuery: (filter: SearchFilter[]) => SearchFilters;
 export declare function fixupFilterArrays(filters: SearchFilters): SearchFilters;
-export declare const search: (docs: Record<string, any>[], query: RowSearchParams) => SearchResponse<Record<string, any>>;
+export declare function search<T>(docs: Record<string, T>[], query: RowSearchParams): SearchResponse<Record<string, T>>;
 /**
  * Performs a client-side search on an array of data
  * @param docs the data
  * @param query the JSON query
- * @param findInDoc optional fn when trying to extract a value
- * from custom doc type e.g. Google Sheets
- *
  */
-export declare const runQuery: (docs: Record<string, any>[], query: SearchFilters, findInDoc?: Function) => Record<string, any>[];
+export declare function runQuery<T extends Record<string, any>>(docs: T[], query: SearchFilters): T[];
 /**
  * Performs a client-side sort from the equivalent server-side lucene sort
  * parameters.
@@ -84,12 +81,12 @@ export declare const runQuery: (docs: Record<string, any>[], query: SearchFilter
  * @param sortOrder the sort order ("ascending" or "descending")
  * @param sortType the type of sort ("string" or "number")
  */
-export declare const sort: (docs: any[], sort: string, sortOrder: SortOrder, sortType?: SortType) => any[];
+export declare function sort<T extends Record<string, any>>(docs: T[], sort: keyof T, sortOrder: SortOrder, sortType?: SortType): T[];
 /**
  * Limits the specified docs to the specified number of rows from the equivalent
  * server-side lucene limit parameters.
  * @param docs the data
  * @param limit the number of docs to limit to
  */
-export declare const limit: (docs: any[], limit: string) => any[];
+export declare function limit<T>(docs: T[], limit: string): T[];
 export declare const hasFilters: (query?: SearchFilters) => boolean;

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)
@@ -10891,7 +10910,7 @@ function fixupFilterArrays(filters) {
   recurseLogicalOperators(filters, fixupFilterArrays);
   return filters;
 }
-var search = (docs, query) => {
+function search(docs, query) {
   let result = runQuery(docs, query.query);
   if (query.sort) {
     result = sort(result, query.sort, query.sortOrder || "ascending" /* ASCENDING */);
@@ -10905,8 +10924,8 @@ var search = (docs, query) => {
     response.totalRows = totalRows;
   }
   return response;
-};
-var runQuery = (docs, query, findInDoc = deepGet) => {
+}
+function runQuery(docs, query) {
   if (!docs || !Array.isArray(docs)) {
     return [];
   }
@@ -10920,7 +10939,7 @@ var runQuery = (docs, query, findInDoc = deepGet) => {
   }
   const match = (type, test) => (doc) => {
     for (const [key, testValue] of Object.entries(query[type] || {})) {
-      const valueToCheck = isLogicalSearchOperator(type) ? doc : findInDoc(doc, removeKeyNumbering(key));
+      const valueToCheck = isLogicalSearchOperator(type) ? doc : deepGet(doc, removeKeyNumbering(key));
       const result = test(valueToCheck, testValue);
       if (query.allOr && result) {
         return true;
@@ -11137,15 +11156,17 @@ var runQuery = (docs, query, findInDoc = deepGet) => {
     ).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);
     }
   };
   return docs.filter(docMatch);
-};
-var sort = (docs, sort2, sortOrder, sortType = "string" /* STRING */) => {
+}
+function sort(docs, sort2, sortOrder, sortType = "string" /* STRING */) {
   if (!sort2 || !sortOrder || !sortType) {
     return docs;
   }
@@ -11167,28 +11188,45 @@ var sort = (docs, sort2, sortOrder, sortType = "string" /* STRING */) => {
     }
     return result;
   });
-};
-var limit = (docs, limit2) => {
+}
+function limit(docs, limit2) {
   const numLimit = parseFloat(limit2);
   if (isNaN(numLimit)) {
     return docs;
   }
   return docs.slice(0, numLimit);
-};
+}
 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