@budibase/shared-core 2.32.11 → 2.32.13

package/dist/filters.d.ts

@@ -1,4 +1,4 @@
-import { Datasource, BBReferenceFieldSubType, FieldType, FormulaType, SearchFilter, SearchFilters, SearchQueryFields, SortType, FieldConstraints, SortOrder, RowSearchParams, SearchResponse, Table } from "@budibase/types";
+import { Datasource, BBReferenceFieldSubType, FieldType, FormulaType, LegacyFilter, SearchFilters, SearchQueryFields, SortType, FieldConstraints, SortOrder, RowSearchParams, SearchResponse, Table, SearchFilterGroup } from "@budibase/types";
 /**
  * Returns the valid operator options for a certain data type
  */
@@ -60,13 +60,21 @@ export declare class ColumnSplitter {
         column: string;
     };
 }
+export declare const buildQueryLegacy: (filter?: LegacyFilter[] | SearchFilters) => SearchFilters | undefined;
 /**
- * Builds a JSON query from the filter structure generated in the builder
- * @param filter the builder filter structure
+ * Converts a **SearchFilterGroup** filter definition into a grouped
+ * search query of type **SearchFilters**
+ *
+ * Legacy support remains for the old **SearchFilter[]** format.
+ * These will be migrated to an appropriate **SearchFilters** object, if encountered
+ *
+ * @param filter
+ *
+ * @returns {SearchFilters}
  */
-export declare const buildQuery: (filter: SearchFilter[]) => SearchFilters;
+export declare const buildQuery: (filter?: SearchFilterGroup | LegacyFilter[]) => SearchFilters | undefined;
 export declare function fixupFilterArrays(filters: SearchFilters): SearchFilters;
-export declare function search<T>(docs: Record<string, T>[], query: RowSearchParams): SearchResponse<Record<string, T>>;
+export declare function search<T extends Record<string, any>>(docs: T[], query: Omit<RowSearchParams, "tableId">): SearchResponse<T>;
 /**
  * Performs a client-side search on an array of data
  * @param docs the data

package/dist/helpers/views.d.ts

@@ -3,6 +3,7 @@ export declare function isCalculationField(field: ViewFieldMetadata): field is V
 export declare function isBasicViewField(field: ViewFieldMetadata): field is BasicViewFieldMetadata;
 type UnsavedViewV2 = Omit<ViewV2, "id" | "version">;
 export declare function isCalculationView(view: UnsavedViewV2): boolean;
+export declare function hasCalculationFields(view: UnsavedViewV2): boolean;
 export declare function calculationFields(view: UnsavedViewV2): import("lodash").Dictionary<ViewCalculationFieldMetadata>;
 export declare function basicFields(view: UnsavedViewV2): import("lodash").Dictionary<ViewFieldMetadata>;
 export {};

package/dist/index.js

@@ -17470,6 +17470,7 @@ __export(filters_exports, {
   ColumnSplitter: () => ColumnSplitter,
   NoEmptyFilterStrings: () => NoEmptyFilterStrings,
   buildQuery: () => buildQuery,
+  buildQueryLegacy: () => buildQueryLegacy,
   cleanupQuery: () => cleanupQuery,
   fixupFilterArrays: () => fixupFilterArrays,
   getKeyNumbering: () => getKeyNumbering,
@@ -17485,6 +17486,164 @@ __export(filters_exports, {
 });
 var import_dayjs = __toESM(require_dayjs_min());
 
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  filterValueToLabel: () => filterValueToLabel,
+  hasSchema: () => hasSchema,
+  isSupportedUserSearch: () => isSupportedUserSearch,
+  parallelForeach: () => parallelForeach,
+  processSearchFilters: () => processSearchFilters,
+  trimOtherProps: () => trimOtherProps,
+  unreachable: () => unreachable
+});
+function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
+  throw new Error(message);
+}
+async function parallelForeach(items, task, maxConcurrency) {
+  const promises = [];
+  let index = 0;
+  const processItem = async (item) => {
+    try {
+      await task(item);
+    } finally {
+      processNext();
+    }
+  };
+  const processNext = () => {
+    if (index >= items.length) {
+      return;
+    }
+    const item = items[index];
+    index++;
+    const promise = processItem(item);
+    promises.push(promise);
+    if (promises.length >= maxConcurrency) {
+      Promise.race(promises).then(processNext);
+    } else {
+      processNext();
+    }
+  };
+  processNext();
+  await Promise.all(promises);
+}
+function filterValueToLabel() {
+  return Object.keys(OperatorOptions).reduce(
+    (acc, key) => {
+      const ops = OperatorOptions;
+      const op = ops[key];
+      acc[op["value"]] = op.label;
+      return acc;
+    },
+    {}
+  );
+}
+function hasSchema(test) {
+  return typeof test === "object" && !Array.isArray(test) && test !== null && !(test instanceof Date) && Object.keys(test).length > 0;
+}
+function trimOtherProps(object, allowedProps) {
+  const result = Object.keys(object).filter((key) => allowedProps.includes(key)).reduce(
+    (acc, key) => ({ ...acc, [key]: object[key] }),
+    {}
+  );
+  return result;
+}
+function isSupportedUserSearch(query) {
+  const allowed = [
+    { op: "string" /* STRING */, key: "email" },
+    { op: "equal" /* EQUAL */, key: "_id" },
+    { op: "oneOf" /* ONE_OF */, key: "_id" }
+  ];
+  for (const [key, operation] of Object.entries(query)) {
+    if (typeof operation !== "object") {
+      return false;
+    }
+    if (isLogicalSearchOperator(key)) {
+      for (const condition of query[key].conditions) {
+        if (!isSupportedUserSearch(condition)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const fields = Object.keys(operation || {});
+    if (fields.length === 0) {
+      continue;
+    }
+    const allowedOperation = allowed.find(
+      (allow) => allow.op === key && fields.length === 1 && fields[0] === allow.key
+    );
+    if (!allowedOperation) {
+      return false;
+    }
+  }
+  return true;
+}
+var processSearchFilters = (filters) => {
+  if (!filters) {
+    return;
+  }
+  const defaultCfg = {
+    logicalOperator: "all" /* ALL */,
+    groups: []
+  };
+  const filterAllowedKeys = [
+    "field",
+    "operator",
+    "value",
+    "type",
+    "externalType",
+    "valueType",
+    "noValue",
+    "formulaType"
+  ];
+  if (Array.isArray(filters)) {
+    let baseGroup = {
+      filters: [],
+      logicalOperator: "all" /* ALL */
+    };
+    return filters.reduce((acc, filter) => {
+      const filterPropertyKeys = Object.keys(filter).sort((a, b) => {
+        return a.localeCompare(b);
+      }).filter((key) => key in filter);
+      if (filterPropertyKeys.length == 1) {
+        const key = filterPropertyKeys[0], value = filter[key];
+        if (key === "onEmptyFilter") {
+          acc.onEmptyFilter = value;
+        } else if (key === "operator" && value === "allOr") {
+          baseGroup.logicalOperator = "any" /* ANY */;
+        }
+        return acc;
+      }
+      const allowedFilterSettings = filterPropertyKeys.reduce(
+        (acc2, key) => {
+          const value = filter[key];
+          if (filterAllowedKeys.includes(key)) {
+            if (key === "field") {
+              acc2.push([key, removeKeyNumbering(value)]);
+            } else {
+              acc2.push([key, value]);
+            }
+          }
+          return acc2;
+        },
+        []
+      );
+      const migratedFilter = Object.fromEntries(
+        allowedFilterSettings
+      );
+      baseGroup.filters.push(migratedFilter);
+      if (!acc.groups || !acc.groups.length) {
+        acc.groups = [baseGroup];
+      }
+      return acc;
+    }, defaultCfg);
+  } else if (!filters?.groups) {
+    return;
+  }
+  return filters;
+};
+
 // src/helpers/index.ts
 var helpers_exports = {};
 __export(helpers_exports, {
@@ -17689,6 +17848,7 @@ var views_exports = {};
 __export(views_exports, {
   basicFields: () => basicFields,
   calculationFields: () => calculationFields,
+  hasCalculationFields: () => hasCalculationFields,
   isBasicViewField: () => isBasicViewField,
   isCalculationField: () => isCalculationField,
   isCalculationView: () => isCalculationView
@@ -17701,6 +17861,9 @@ function isBasicViewField(field) {
   return !isCalculationField(field);
 }
 function isCalculationView(view) {
+  return view.type === "calculation" /* CALCULATION */;
+}
+function hasCalculationFields(view) {
   return Object.values(view.schema || {}).some(isCalculationField);
 }
 function calculationFields(view) {
@@ -17780,7 +17943,7 @@ var NoEmptyFilterStrings = [
 ];
 function recurseLogicalOperators(filters, fn) {
   for (const logical of LOGICAL_OPERATORS) {
-    if (filters?.[logical]) {
+    if (filters[logical]) {
       filters[logical].conditions = filters[logical].conditions.map(
         (condition) => fn(condition)
       );
@@ -17800,9 +17963,6 @@ function recurseSearchFilters(filters, processFn) {
   return filters;
 }
 var cleanupQuery = (query) => {
-  if (!query) {
-    return query;
-  }
   for (let filterField of NoEmptyFilterStrings) {
     if (!query[filterField]) {
       continue;
@@ -17893,7 +18053,106 @@ var ColumnSplitter = class {
     };
   }
 };
-var buildQuery = (filter) => {
+var buildCondition = (expression) => {
+  let query = {
+    string: {},
+    fuzzy: {},
+    range: {},
+    equal: {},
+    notEqual: {},
+    empty: {},
+    notEmpty: {},
+    contains: {},
+    notContains: {},
+    oneOf: {},
+    containsAny: {}
+  };
+  let { operator, field, type, value, externalType, onEmptyFilter } = expression;
+  if (!operator || !field) {
+    return;
+  }
+  const queryOperator = operator;
+  const isHbs = typeof value === "string" && (value.match(HBS_REGEX) || []).length > 0;
+  if (operator === "allOr") {
+    query.allOr = true;
+    return;
+  }
+  if (onEmptyFilter) {
+    query.onEmptyFilter = onEmptyFilter;
+    return;
+  }
+  if (queryOperator === "empty" || queryOperator === "notEmpty") {
+    value = null;
+  }
+  if (type === "datetime" && !isHbs && queryOperator !== "empty" && queryOperator !== "notEmpty") {
+    if (!value) {
+      return;
+    }
+    try {
+      value = new Date(value).toISOString();
+    } catch (error) {
+      return;
+    }
+  }
+  if (type === "number" && typeof value === "string" && !isHbs) {
+    if (queryOperator === "oneOf") {
+      value = value.split(",").map((item) => parseFloat(item));
+    } else {
+      value = parseFloat(value);
+    }
+  }
+  if (type === "boolean") {
+    value = `${value}`?.toLowerCase() === "true";
+  }
+  if (["contains", "notContains", "containsAny"].includes(
+    operator.toLocaleString()
+  ) && type === "array" && typeof value === "string") {
+    value = value.split(",");
+  }
+  if (operator.toLocaleString().startsWith("range") && query.range) {
+    const minint = SqlNumberTypeRangeMap[externalType]?.min || Number.MIN_SAFE_INTEGER;
+    const maxint = SqlNumberTypeRangeMap[externalType]?.max || Number.MAX_SAFE_INTEGER;
+    if (!query.range[field]) {
+      query.range[field] = {
+        low: type === "number" ? minint : "0000-00-00T00:00:00.000Z",
+        high: type === "number" ? maxint : "9999-00-00T00:00:00.000Z"
+      };
+    }
+    if (operator === "rangeLow" && value != null && value !== "") {
+      query.range[field] = {
+        ...query.range[field],
+        low: value
+      };
+    } else if (operator === "rangeHigh" && value != null && value !== "") {
+      query.range[field] = {
+        ...query.range[field],
+        high: value
+      };
+    }
+  } else if (isLogicalSearchOperator(queryOperator)) {
+  } else if (query[queryOperator] && operator !== "onEmptyFilter") {
+    if (type === "boolean") {
+      if (queryOperator === "equal" && value === false) {
+        query.notEqual = query.notEqual || {};
+        query.notEqual[field] = true;
+      } else if (queryOperator === "notEqual" && value === false) {
+        query.equal = query.equal || {};
+        query.equal[field] = true;
+      } else {
+        query[queryOperator] ??= {};
+        query[queryOperator][field] = value;
+      }
+    } else {
+      query[queryOperator] ??= {};
+      query[queryOperator][field] = value;
+    }
+  }
+  return query;
+};
+var buildQueryLegacy = (filter) => {
+  if (!Array.isArray(filter)) {
+    return filter;
+  }
   let query = {
     string: {},
     fuzzy: {},
@@ -17942,10 +18201,12 @@ var buildQuery = (filter) => {
     if (type === "boolean") {
       value = `${value}`?.toLowerCase() === "true";
     }
-    if (["contains", "notContains", "containsAny"].includes(operator) && type === "array" && typeof value === "string") {
+    if (["contains", "notContains", "containsAny"].includes(
+      operator.toLocaleString()
+    ) && type === "array" && typeof value === "string") {
       value = value.split(",");
     }
-    if (operator.startsWith("range") && query.range) {
+    if (operator.toLocaleString().startsWith("range") && query.range) {
       const minint = SqlNumberTypeRangeMap[externalType]?.min || Number.MIN_SAFE_INTEGER;
       const maxint = SqlNumberTypeRangeMap[externalType]?.max || Number.MAX_SAFE_INTEGER;
       if (!query.range[field]) {
@@ -17986,6 +18247,30 @@ var buildQuery = (filter) => {
   });
   return query;
 };
+var buildQuery = (filter) => {
+  const parsedFilter = processSearchFilters(filter);
+  if (!parsedFilter) {
+    return;
+  }
+  const operatorMap = {
+    ["all" /* ALL */]: "$and" /* AND */,
+    ["any" /* ANY */]: "$or" /* OR */
+  };
+  const globalOnEmpty = parsedFilter.onEmptyFilter ? parsedFilter.onEmptyFilter : null;
+  const globalOperator = operatorMap[parsedFilter.logicalOperator];
+  return {
+    ...globalOnEmpty ? { onEmptyFilter: globalOnEmpty } : {},
+    [globalOperator]: {
+      conditions: parsedFilter.groups?.map((group) => {
+        return {
+          [operatorMap[group.logicalOperator]]: {
+            conditions: group.filters?.map((x) => buildCondition(x)).filter((filter2) => filter2)
+          }
+        };
+      })
+    }
+  };
+};
 function fixupFilterArrays(filters) {
   for (const searchField of Object.values(ArrayOperator)) {
     const field = filters[searchField];
@@ -18012,7 +18297,7 @@ function search(docs, query) {
   if (query.sort) {
     result = sort(result, query.sort, query.sortOrder || "ascending" /* ASCENDING */);
   }
-  let totalRows = result.length;
+  const totalRows = result.length;
   if (query.limit) {
     result = limit(result, query.limit.toString());
   }
@@ -18326,91 +18611,6 @@ var hasFilters = (query) => {
   return check(query);
 };
 
-// src/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  filterValueToLabel: () => filterValueToLabel,
-  hasSchema: () => hasSchema,
-  isSupportedUserSearch: () => isSupportedUserSearch,
-  parallelForeach: () => parallelForeach,
-  trimOtherProps: () => trimOtherProps,
-  unreachable: () => unreachable
-});
-function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
-  throw new Error(message);
-}
-async function parallelForeach(items, task, maxConcurrency) {
-  const promises = [];
-  let index = 0;
-  const processItem = async (item) => {
-    try {
-      await task(item);
-    } finally {
-      processNext();
-    }
-  };
-  const processNext = () => {
-    if (index >= items.length) {
-      return;
-    }
-    const item = items[index];
-    index++;
-    const promise = processItem(item);
-    promises.push(promise);
-    if (promises.length >= maxConcurrency) {
-      Promise.race(promises).then(processNext);
-    } else {
-      processNext();
-    }
-  };
-  processNext();
-  await Promise.all(promises);
-}
-function filterValueToLabel() {
-  return Object.keys(OperatorOptions).reduce(
-    (acc, key) => {
-      const ops = OperatorOptions;
-      const op = ops[key];
-      acc[op["value"]] = op.label;
-      return acc;
-    },
-    {}
-  );
-}
-function hasSchema(test) {
-  return typeof test === "object" && !Array.isArray(test) && test !== null && !(test instanceof Date) && Object.keys(test).length > 0;
-}
-function trimOtherProps(object, allowedProps) {
-  const result = Object.keys(object).filter((key) => allowedProps.includes(key)).reduce(
-    (acc, key) => ({ ...acc, [key]: object[key] }),
-    {}
-  );
-  return result;
-}
-function isSupportedUserSearch(query) {
-  const allowed = [
-    { op: "string" /* STRING */, key: "email" },
-    { op: "equal" /* EQUAL */, key: "_id" },
-    { op: "oneOf" /* ONE_OF */, key: "_id" }
-  ];
-  for (let [key, operation] of Object.entries(query)) {
-    if (typeof operation !== "object") {
-      return false;
-    }
-    const fields = Object.keys(operation || {});
-    if (fields.length === 0) {
-      continue;
-    }
-    const allowedOperation = allowed.find(
-      (allow) => allow.op === key && fields.length === 1 && fields[0] === allow.key
-    );
-    if (!allowedOperation) {
-      return false;
-    }
-  }
-  return true;
-}
-
 // src/sdk/index.ts
 var sdk_exports = {};
 __export(sdk_exports, {