@budibase/backend-core 2.32.11 → 2.32.12

package/dist/index.js

@@ -61911,6 +61911,7 @@ __export(filters_exports, {
   ColumnSplitter: () => ColumnSplitter,
   NoEmptyFilterStrings: () => NoEmptyFilterStrings,
   buildQuery: () => buildQuery,
+  buildQueryLegacy: () => buildQueryLegacy,
   cleanupQuery: () => cleanupQuery,
   fixupFilterArrays: () => fixupFilterArrays,
   getKeyNumbering: () => getKeyNumbering,
@@ -61926,6 +61927,156 @@ __export(filters_exports, {
 });
 var import_dayjs = __toESM(require_dayjs_min());
 
+// ../shared-core/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 index2 = 0;
+  const processItem = async (item) => {
+    try {
+      await task(item);
+    } finally {
+      processNext();
+    }
+  };
+  const processNext = () => {
+    if (index2 >= items.length) {
+      return;
+    }
+    const item = items[index2];
+    index2++;
+    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;
+}
+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;
+};
+
 // ../shared-core/src/helpers/index.ts
 var helpers_exports = {};
 __export(helpers_exports, {
@@ -62221,7 +62372,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)
       );
@@ -62241,9 +62392,6 @@ function recurseSearchFilters(filters, processFn) {
   return filters;
 }
 var cleanupQuery = (query) => {
-  if (!query) {
-    return query;
-  }
   for (let filterField of NoEmptyFilterStrings) {
     if (!query[filterField]) {
       continue;
@@ -62334,7 +62482,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: {},
@@ -62383,10 +62630,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]) {
@@ -62427,6 +62676,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];
@@ -62767,91 +63040,6 @@ var hasFilters = (query) => {
   return check(query);
 };
 
-// ../shared-core/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 index2 = 0;
-  const processItem = async (item) => {
-    try {
-      await task(item);
-    } finally {
-      processNext();
-    }
-  };
-  const processNext = () => {
-    if (index2 >= items.length) {
-      return;
-    }
-    const item = items[index2];
-    index2++;
-    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;
-}
-
 // ../shared-core/src/sdk/index.ts
 var sdk_exports = {};
 __export(sdk_exports, {
@@ -75270,25 +75458,56 @@ var InternalBuilder = class {
     const { column } = this.splitter.run(key);
     return this.table.schema[column];
   }
-  // Takes a string like foo and returns a quoted string like [foo] for SQL Server
-  // and "foo" for Postgres.
-  quote(str) {
+  quoteChars() {
     switch (this.client) {
-      case "sqlite3" /* SQL_LITE */:
       case "oracledb" /* ORACLE */:
       case "pg" /* POSTGRES */:
-        return `"${str}"`;
+        return ['"', '"'];
       case "mssql" /* MS_SQL */:
-        return `[${str}]`;
+        return ["[", "]"];
       case "mariadb" /* MARIADB */:
       case "mysql2" /* MY_SQL */:
-        return `\`${str}\``;
+      case "sqlite3" /* SQL_LITE */:
+        return ["`", "`"];
     }
   }
-  // Takes a string like a.b.c and returns a quoted identifier like [a].[b].[c]
-  // for SQL Server and `a`.`b`.`c` for MySQL.
+  // Takes a string like foo and returns a quoted string like [foo] for SQL Server
+  // and "foo" for Postgres.
+  quote(str) {
+    const [start2, end2] = this.quoteChars();
+    return `${start2}${str}${end2}`;
+  }
+  isQuoted(key) {
+    const [start2, end2] = this.quoteChars();
+    return key.startsWith(start2) && key.endsWith(end2);
+  }
+  // Takes a string like a.b.c or an array like ["a", "b", "c"] and returns a
+  // quoted identifier like [a].[b].[c] for SQL Server and `a`.`b`.`c` for
+  // MySQL.
   quotedIdentifier(key) {
-    return key.split(".").map((part) => this.quote(part)).join(".");
+    if (!Array.isArray(key)) {
+      key = this.splitIdentifier(key);
+    }
+    return key.map((part) => this.quote(part)).join(".");
+  }
+  // Turns an identifier like a.b.c or `a`.`b`.`c` into ["a", "b", "c"]
+  splitIdentifier(key) {
+    const [start2, end2] = this.quoteChars();
+    if (this.isQuoted(key)) {
+      return key.slice(1, -1).split(`${end2}.${start2}`);
+    }
+    return key.split(".");
+  }
+  qualifyIdentifier(key) {
+    const tableName = this.getTableName();
+    const parts = this.splitIdentifier(key);
+    if (parts[0] !== tableName) {
+      parts.unshift(tableName);
+    }
+    if (this.isQuoted(key)) {
+      return this.quotedIdentifier(parts);
+    }
+    return parts.join(".");
   }
   isFullSelectStatementRequired() {
     const { meta } = this.query;
@@ -75339,13 +75558,22 @@ var InternalBuilder = class {
   // OracleDB can't use character-large-objects (CLOBs) in WHERE clauses,
   // so when we use them we need to wrap them in to_char(). This function
   // converts a field name to the appropriate identifier.
-  convertClobs(field) {
-    const parts = field.split(".");
+  convertClobs(field, opts) {
+    if (this.client !== "oracledb" /* ORACLE */) {
+      throw new Error(
+        "you've called convertClobs on a DB that's not Oracle, this is a mistake"
+      );
+    }
+    const parts = this.splitIdentifier(field);
     const col = parts.pop();
     const schema = this.table.schema[col];
     let identifier = this.quotedIdentifier(field);
     if (schema.type === "string" /* STRING */ || schema.type === "longform" /* LONGFORM */ || schema.type === "bb_reference_single" /* BB_REFERENCE_SINGLE */ || schema.type === "bb_reference" /* BB_REFERENCE */ || schema.type === "options" /* OPTIONS */ || schema.type === "barcodeqr" /* BARCODEQR */) {
-      identifier = `to_char(${identifier})`;
+      if (opts?.forSelect) {
+        identifier = `to_char(${identifier}) as ${this.quotedIdentifier(col)}`;
+      } else {
+        identifier = `to_char(${identifier})`;
+      }
     }
     return identifier;
   }
@@ -75842,28 +76070,56 @@ var InternalBuilder = class {
     const fields = this.query.resource?.fields || [];
     const tableName = this.getTableName();
     if (fields.length > 0) {
-      query = query.groupBy(fields.map((field) => `${tableName}.${field}`));
-      query = query.select(fields.map((field) => `${tableName}.${field}`));
+      const qualifiedFields = fields.map((field) => this.qualifyIdentifier(field));
+      if (this.client === "oracledb" /* ORACLE */) {
+        const groupByFields = qualifiedFields.map(
+          (field) => this.convertClobs(field)
+        );
+        const selectFields = qualifiedFields.map(
+          (field) => this.convertClobs(field, { forSelect: true })
+        );
+        query = query.groupByRaw(groupByFields.join(", ")).select(this.knex.raw(selectFields.join(", ")));
+      } else {
+        query = query.groupBy(qualifiedFields).select(qualifiedFields);
+      }
     }
     for (const aggregation of aggregations) {
       const op = aggregation.calculationType;
-      const field = `${tableName}.${aggregation.field} as ${aggregation.name}`;
-      switch (op) {
-        case "count" /* COUNT */:
-          query = query.count(field);
-          break;
-        case "sum" /* SUM */:
-          query = query.sum(field);
-          break;
-        case "avg" /* AVG */:
-          query = query.avg(field);
-          break;
-        case "min" /* MIN */:
-          query = query.min(field);
-          break;
-        case "max" /* MAX */:
-          query = query.max(field);
-          break;
+      if (op === "count" /* COUNT */) {
+        if ("distinct" in aggregation && aggregation.distinct) {
+          if (this.client === "oracledb" /* ORACLE */) {
+            const field = this.convertClobs(`${tableName}.${aggregation.field}`);
+            query = query.select(
+              this.knex.raw(
+                `COUNT(DISTINCT ${field}) as ${this.quotedIdentifier(
+                  aggregation.name
+                )}`
+              )
+            );
+          } else {
+            query = query.countDistinct(
+              `${tableName}.${aggregation.field} as ${aggregation.name}`
+            );
+          }
+        } else {
+          query = query.count(`* as ${aggregation.name}`);
+        }
+      } else {
+        const field = `${tableName}.${aggregation.field} as ${aggregation.name}`;
+        switch (op) {
+          case "sum" /* SUM */:
+            query = query.sum(field);
+            break;
+          case "avg" /* AVG */:
+            query = query.avg(field);
+            break;
+          case "min" /* MIN */:
+            query = query.min(field);
+            break;
+          case "max" /* MAX */:
+            query = query.max(field);
+            break;
+        }
       }
     }
     return query;