@budibase/backend-core 2.33.14 → 3.0.1

package/dist/index.js

@@ -61,7 +61,7 @@ var require_dayjs_min = __commonJS({
       } }, g = "en", D = {};
       D[g] = M;
       var p = "$isDayjsObject", S = function(t2) {
-        return t2 instanceof _2 || !(!t2 || !t2[p]);
+        return t2 instanceof _3 || !(!t2 || !t2[p]);
       }, w = function t2(e2, n2, r2) {
         var i2;
         if (!e2)
@@ -81,12 +81,12 @@ var require_dayjs_min = __commonJS({
         if (S(t2))
           return t2.clone();
         var n2 = "object" == typeof e2 ? e2 : {};
-        return n2.date = t2, n2.args = arguments, new _2(n2);
+        return n2.date = t2, n2.args = arguments, new _3(n2);
       }, b = v;
       b.l = w, b.i = S, b.w = function(t2, e2) {
         return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
       };
-      var _2 = function() {
+      var _3 = function() {
         function M2(t2) {
           this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true;
         }
@@ -311,13 +311,13 @@ var require_dayjs_min = __commonJS({
         }, m2.toString = function() {
           return this.$d.toUTCString();
         }, M2;
-      }(), k = _2.prototype;
+      }(), k = _3.prototype;
       return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) {
         k[t2[1]] = function(e2) {
           return this.$g(e2, t2[0], t2[1]);
         };
       }), O.extend = function(t2, e2) {
-        return t2.$i || (t2(e2, _2, O), t2.$i = true), O;
+        return t2.$i || (t2(e2, _3, O), t2.$i = true), O;
       }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
         return O(1e3 * t2);
       }, O.en = D[g], O.Ls = D, O.p = {}, O;
@@ -797,12 +797,12 @@ var require_nanoclone = __commonJS({
     var map;
     try {
       map = Map;
-    } catch (_2) {
+    } catch (_3) {
     }
     var set2;
     try {
       set2 = Set;
-    } catch (_2) {
+    } catch (_3) {
     }
     function baseClone(src, circulars, clones) {
       if (!src || typeof src !== "object" || typeof src === "function") {
@@ -1110,7 +1110,7 @@ var require_ValidationError = __commonJS({
             path: path3
           });
         if (typeof message === "string")
-          return message.replace(strReg, (_2, key) => (0, _printValue.default)(params2[key]));
+          return message.replace(strReg, (_3, key) => (0, _printValue.default)(params2[key]));
         if (typeof message === "function")
           return message(params2);
         return message;
@@ -2989,7 +2989,7 @@ var require_object = __commonJS({
             return;
           }
           originalValue = originalValue || value;
-          let tests = this._nodes.map((key) => (_2, cb) => {
+          let tests = this._nodes.map((key) => (_3, cb) => {
             let path3 = key.indexOf(".") === -1 ? (opts.path ? `${opts.path}.` : "") + key : `${opts.path || ""}["${key}"]`;
             let field = this.fields[key];
             if (field && "validate" in field) {
@@ -3133,7 +3133,7 @@ var require_object = __commonJS({
         return this.noUnknown(!allow, message);
       }
       transformKeys(fn) {
-        return this.transform((obj) => obj && (0, _mapKeys.default)(obj, (_2, key) => fn(key)));
+        return this.transform((obj) => obj && (0, _mapKeys.default)(obj, (_3, key) => fn(key)));
       }
       camelCase() {
         return this.transformKeys(_camelCase.default);
@@ -3266,7 +3266,7 @@ var require_array = __commonJS({
               index: idx,
               originalValue: originalValue[idx]
             });
-            tests[idx] = (_2, cb) => innerType.validate(item, innerOptions, cb);
+            tests[idx] = (_3, cb) => innerType.validate(item, innerOptions, cb);
           }
           (0, _runTests.default)({
             sync,
@@ -10474,7 +10474,7 @@ var require_field_stringify = __commonJS({
         var multiplier = range.start == 0 ? range.count - 1 : range.count;
         if (range.step * multiplier > range.end) {
           result = result.concat(
-            Array.from({ length: range.end - range.start + 1 }).map(function(_2, index2) {
+            Array.from({ length: range.end - range.start + 1 }).map(function(_3, index2) {
               var value = range.start + index2;
               if ((value - range.start) % range.step === 0) {
                 return value;
@@ -48989,7 +48989,7 @@ var require_uri_all = __commonJS({
           uriTokens.push("@");
         }
         if (components.host !== void 0) {
-          uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function(_2, $1, $2) {
+          uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function(_3, $1, $2) {
             return "[" + $1 + ($2 ? "%25" + $2 : "") + "]";
           }));
         }
@@ -61537,7 +61537,16 @@ var LogicalOperator = /* @__PURE__ */ ((LogicalOperator2) => {
   return LogicalOperator2;
 })(LogicalOperator || {});
 function isLogicalSearchOperator(value) {
-  return value === "$and" /* AND */ || value === "$or" /* OR */;
+  return Object.values(LogicalOperator).includes(value);
+}
+function isBasicSearchOperator(value) {
+  return Object.values(BasicOperator).includes(value);
+}
+function isArraySearchOperator(value) {
+  return Object.values(ArrayOperator).includes(value);
+}
+function isRangeSearchOperator(value) {
+  return Object.values(RangeOperator).includes(value);
 }
 
 // ../types/src/sdk/db.ts
@@ -61795,6 +61804,33 @@ __export(constants_exports2, {
   ViewName: () => ViewName
 });
 
+// ../shared-core/src/constants/ai.ts
+var OperationFields = {
+  ["SUMMARISE_TEXT" /* SUMMARISE_TEXT */]: {
+    columns: "columns" /* MULTI_COLUMN */
+  },
+  ["CLEAN_DATA" /* CLEAN_DATA */]: {
+    column: "column" /* COLUMN */
+  },
+  ["TRANSLATE" /* TRANSLATE */]: {
+    column: "column" /* COLUMN */,
+    language: "prompt" /* BINDABLE_TEXT */
+  },
+  ["CATEGORISE_TEXT" /* CATEGORISE_TEXT */]: {
+    columns: "columns" /* MULTI_COLUMN */,
+    categories: "prompt" /* BINDABLE_TEXT */
+  },
+  ["SENTIMENT_ANALYSIS" /* SENTIMENT_ANALYSIS */]: {
+    column: "column" /* COLUMN */
+  },
+  ["PROMPT" /* PROMPT */]: {
+    prompt: "prompt" /* BINDABLE_TEXT */
+  },
+  ["SEARCH_WEB" /* SEARCH_WEB */]: {
+    columns: "columns" /* MULTI_COLUMN */
+  }
+};
+
 // ../shared-core/src/constants/api.ts
 var Header = /* @__PURE__ */ ((Header2) => {
   Header2["API_KEY"] = "x-budibase-api-key";
@@ -61847,6 +61883,31 @@ var SWITCHABLE_TYPES = {
   ["number" /* NUMBER */]: ["number" /* NUMBER */, "boolean" /* BOOLEAN */]
 };
 
+// ../shared-core/src/constants/themes.ts
+var DefaultBuilderTheme = "darkest" /* DARKEST */;
+var DefaultAppTheme = "light" /* LIGHT */;
+var ThemeOptions = [
+  {
+    id: "light" /* LIGHT */,
+    name: "Light"
+  },
+  {
+    // We call this dark for simplicity, but we want to use the spectrum darkest style
+    id: "darkest" /* DARKEST */,
+    name: "Dark"
+  },
+  {
+    id: "nord" /* NORD */,
+    name: "Nord",
+    base: "darkest" /* DARKEST */
+  },
+  {
+    id: "midnight" /* MIDNIGHT */,
+    name: "Midnight",
+    base: "darkest" /* DARKEST */
+  }
+];
+
 // ../shared-core/src/constants/index.ts
 var OperatorOptions = {
   Equals: {
@@ -61924,7 +61985,6 @@ __export(filters_exports, {
   ColumnSplitter: () => ColumnSplitter,
   NoEmptyFilterStrings: () => NoEmptyFilterStrings,
   buildQuery: () => buildQuery,
-  buildQueryLegacy: () => buildQueryLegacy,
   cleanupQuery: () => cleanupQuery,
   fixupFilterArrays: () => fixupFilterArrays,
   getKeyNumbering: () => getKeyNumbering,
@@ -61936,7 +61996,8 @@ __export(filters_exports, {
   removeKeyNumbering: () => removeKeyNumbering,
   runQuery: () => runQuery,
   search: () => search,
-  sort: () => sort
+  sort: () => sort,
+  splitFiltersArray: () => splitFiltersArray
 });
 var import_dayjs = __toESM(require_dayjs_min());
 
@@ -61951,6 +62012,17 @@ __export(utils_exports, {
   trimOtherProps: () => trimOtherProps,
   unreachable: () => unreachable
 });
+var import_lodash = __toESM(require("lodash"));
+var FILTER_ALLOWED_KEYS = [
+  "field",
+  "operator",
+  "value",
+  "type",
+  "externalType",
+  "valueType",
+  "noValue",
+  "formulaType"
+];
 function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
   throw new Error(message);
 }
@@ -62033,70 +62105,29 @@ function isSupportedUserSearch(query) {
   }
   return true;
 }
-var processSearchFilters = (filters) => {
-  if (!filters) {
-    return;
+function processSearchFilters(filterArray) {
+  if (!filterArray || filterArray.length === 0) {
+    return void 0;
   }
-  const defaultCfg = {
+  const { allOr, onEmptyFilter, filters } = splitFiltersArray(filterArray);
+  return {
     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) => filter[key]);
-      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];
+    onEmptyFilter: onEmptyFilter || "all" /* RETURN_ALL */,
+    groups: [
+      {
+        logicalOperator: allOr ? "any" /* ANY */ : "all" /* ALL */,
+        filters: filters.map((filter) => {
+          const trimmedFilter = import_lodash.default.pick(
+            filter,
+            FILTER_ALLOWED_KEYS
+          );
+          trimmedFilter.field = removeKeyNumbering(trimmedFilter.field);
+          return trimmedFilter;
+        })
       }
-      return acc;
-    }, defaultCfg);
-  } else if (!filters?.groups) {
-    return;
-  }
-  return filters;
-};
+    ]
+  };
+}
 
 // ../shared-core/src/helpers/index.ts
 var helpers_exports = {};
@@ -62309,7 +62340,7 @@ __export(views_exports, {
   isCalculationView: () => isCalculationView,
   isVisible: () => isVisible
 });
-var import_lodash = require("lodash");
+var import_lodash2 = require("lodash");
 function isCalculationField(field) {
   return "calculationType" in field;
 }
@@ -62323,14 +62354,14 @@ function hasCalculationFields(view) {
   return Object.values(view.schema || {}).some(isCalculationField);
 }
 function calculationFields(view) {
-  return (0, import_lodash.pickBy)(view.schema || {}, isCalculationField);
+  return (0, import_lodash2.pickBy)(view.schema || {}, isCalculationField);
 }
 function isVisible(field) {
   return field.visible !== false;
 }
 function basicFields(view, opts) {
   const { visible = true } = opts || {};
-  return (0, import_lodash.pickBy)(view.schema || {}, (field) => {
+  return (0, import_lodash2.pickBy)(view.schema || {}, (field) => {
     return !isCalculationField(field) && (!visible || isVisible(field));
   });
 }
@@ -62378,7 +62409,7 @@ function checkForRoleInheritanceLoops(roles) {
 }
 
 // ../shared-core/src/filters.ts
-var import_lodash2 = require("lodash");
+var import_lodash3 = require("lodash");
 var HBS_REGEX = /{{([^{].*?)}}/g;
 var LOGICAL_OPERATORS = Object.values(LogicalOperator);
 var SEARCH_OPERATORS = [
@@ -62424,6 +62455,8 @@ var getValidOperatorsForType = (fieldType, field, datasource2) => {
     ops = numOps;
   } else if (type === "formula" /* FORMULA */ && formulaType === "static" /* STATIC */) {
     ops = stringOps.concat([Op.MoreThan, Op.LessThan]);
+  } else if (type === "ai" /* AI */) {
+    ops = stringOps.concat([Op.MoreThan, Op.LessThan]);
   } else if (type === "bb_reference_single" /* BB_REFERENCE_SINGLE */ || schema_exports.isDeprecatedSingleUserColumn(fieldType)) {
     ops = [Op.Equals, Op.NotEquals, Op.Empty, Op.NotEmpty, Op.In];
   } else if (type === "bb_reference" /* BB_REFERENCE */) {
@@ -62557,228 +62590,153 @@ var ColumnSplitter = class {
     };
   }
 };
-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) {
+function buildCondition(filter) {
+  if (!filter) {
     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") {
+  const query = {};
+  const { operator, field, type, externalType } = filter;
+  let { value } = filter;
+  if (operator === "empty" || operator === "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(",");
+  const isHbs = typeof value === "string" && (value.match(HBS_REGEX) || []).length > 0;
+  switch (type) {
+    case "datetime" /* DATETIME */:
+      if (!isHbs && operator !== "empty" && operator !== "notEmpty") {
+        if (!value) {
+          return;
+        }
+        value = new Date(value).toISOString();
+      }
+      break;
+    case "number" /* NUMBER */:
+      if (typeof value === "string" && !isHbs) {
+        if (operator === "oneOf") {
+          value = value.split(",").map(parseFloat);
+        } else {
+          value = parseFloat(value);
+        }
+      }
+      break;
+    case "boolean" /* BOOLEAN */:
+      value = `${value}`.toLowerCase() === "true";
+      break;
+    case "array" /* ARRAY */:
+      if (["contains", "notContains", "containsAny"].includes(
+        operator.toLocaleString()
+      ) && typeof value === "string") {
+        value = value.split(",");
+      }
+      break;
   }
-  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 (isRangeSearchOperator(operator)) {
+    const key = externalType;
+    const limits = SqlNumberTypeRangeMap[key] || {
+      min: Number.MIN_SAFE_INTEGER,
+      max: Number.MAX_SAFE_INTEGER
+    };
+    query[operator] ??= {};
+    query[operator][field] = {
+      low: type === "number" ? limits.min : "0000-00-00T00:00:00.000Z",
+      high: type === "number" ? limits.max : "9999-00-00T00:00:00.000Z"
+    };
+  } else if (operator === "rangeHigh" && value != null && value !== "") {
+    query.range ??= {};
+    query.range[field] = {
+      ...query.range[field],
+      high: value
+    };
+  } else if (operator === "rangeLow" && value != null && value !== "") {
+    query.range ??= {};
+    query.range[field] = {
+      ...query.range[field],
+      low: value
+    };
+  } else if (isBasicSearchOperator(operator) || isArraySearchOperator(operator) || isRangeSearchOperator(operator)) {
     if (type === "boolean") {
-      if (queryOperator === "equal" && value === false) {
+      if (operator === "equal" && value === false) {
         query.notEqual = query.notEqual || {};
         query.notEqual[field] = true;
-      } else if (queryOperator === "notEqual" && value === false) {
+      } else if (operator === "notEqual" && value === false) {
         query.equal = query.equal || {};
         query.equal[field] = true;
       } else {
-        query[queryOperator] ??= {};
-        query[queryOperator][field] = value;
+        query[operator] ??= {};
+        query[operator][field] = value;
       }
     } else {
-      query[queryOperator] ??= {};
-      query[queryOperator][field] = value;
+      query[operator] ??= {};
+      query[operator][field] = value;
     }
+  } else {
+    throw new Error(`Unsupported operator: ${operator}`);
   }
   return query;
-};
-var buildQueryLegacy = (filter) => {
-  if (!Array.isArray(filter)) {
-    return filter;
-  }
-  let query = {
-    string: {},
-    fuzzy: {},
-    range: {},
-    equal: {},
-    notEqual: {},
-    empty: {},
-    notEmpty: {},
-    contains: {},
-    notContains: {},
-    oneOf: {},
-    containsAny: {}
+}
+function splitFiltersArray(filters) {
+  const split = {
+    filters: []
   };
-  if (!Array.isArray(filter)) {
-    return query;
-  }
-  filter.forEach((expression) => {
-    let { operator, field, type, value, externalType, onEmptyFilter } = expression;
-    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 (type === "datetime" && !isHbs && queryOperator !== "empty" && queryOperator !== "notEmpty") {
-      if (!value) {
-        return;
-      }
-      try {
-        value = new Date(value).toISOString();
-      } catch (error) {
-        return;
-      }
+  for (const filter of filters) {
+    if ("operator" in filter && filter.operator === "allOr") {
+      split.allOr = true;
+    } else if ("onEmptyFilter" in filter) {
+      split.onEmptyFilter = filter.onEmptyFilter;
+    } else {
+      split.filters.push(filter);
     }
-    if (type === "number" && typeof value === "string" && !isHbs) {
-      if (queryOperator === "oneOf") {
-        value = value.split(",").map((item) => parseFloat(item));
-      } else {
-        value = parseFloat(value);
-      }
+  }
+  return split;
+}
+function buildQuery(filter) {
+  if (!filter) {
+    return {};
+  }
+  if (Array.isArray(filter)) {
+    filter = processSearchFilters(filter);
+    if (!filter) {
+      return {};
     }
-    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
-        };
+  }
+  const operator = logicalOperatorFromUI(
+    filter.logicalOperator || "all" /* ALL */
+  );
+  const query = {};
+  if (filter.onEmptyFilter) {
+    query.onEmptyFilter = filter.onEmptyFilter;
+  } else {
+    query.onEmptyFilter = "all" /* RETURN_ALL */;
+  }
+  query[operator] = {
+    conditions: (filter.groups || []).map((group) => {
+      const { allOr, onEmptyFilter, filters } = splitFiltersArray(
+        group.filters || []
+      );
+      if (onEmptyFilter) {
+        query.onEmptyFilter = onEmptyFilter;
       }
-    } 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;
+      let operator2 = allOr ? "$or" /* OR */ : "$and" /* AND */;
+      if (group.logicalOperator) {
+        operator2 = logicalOperatorFromUI(group.logicalOperator);
       }
-    }
-  });
-  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)
-          }
-        };
-      })
-    }
+      return {
+        [operator2]: { conditions: filters.map(buildCondition).filter((f) => f) }
+      };
+    })
   };
-};
+  return query;
+}
+function logicalOperatorFromUI(operator) {
+  return operator === "all" /* ALL */ ? "$and" /* AND */ : "$or" /* OR */;
+}
 function fixupFilterArrays(filters) {
+  if (!filters) {
+    return filters;
+  }
   for (const searchField of Object.values(ArrayOperator)) {
     const field = filters[searchField];
-    if (field == null || !(0, import_lodash2.isPlainObject)(field)) {
+    if (field == null || !(0, import_lodash3.isPlainObject)(field)) {
       continue;
     }
     for (const key of Object.keys(field)) {
@@ -62865,10 +62823,10 @@ function runQuery(docs, query) {
       if (docValue == null || docValue === "") {
         return false;
       }
-      if ((0, import_lodash2.isPlainObject)(testValue.low) && (0, import_lodash2.isEmpty)(testValue.low)) {
+      if ((0, import_lodash3.isPlainObject)(testValue.low) && (0, import_lodash3.isEmpty)(testValue.low)) {
         testValue.low = void 0;
       }
-      if ((0, import_lodash2.isPlainObject)(testValue.high) && (0, import_lodash2.isEmpty)(testValue.high)) {
+      if ((0, import_lodash3.isPlainObject)(testValue.high) && (0, import_lodash3.isEmpty)(testValue.high)) {
         testValue.high = void 0;
       }
       if (testValue.low == null && testValue.high == null) {
@@ -63189,7 +63147,7 @@ __export(users_exports, {
   isCreator: () => isCreator,
   isGlobalBuilder: () => isGlobalBuilder
 });
-var _ = __toESM(require("lodash/fp"));
+var _2 = __toESM(require("lodash/fp"));
 function isBuilder(user, appId) {
   if (!user) {
     return false;
@@ -63231,10 +63189,10 @@ function hasAppCreatorPermissions(user) {
   if (!user) {
     return false;
   }
-  return _.flow(
-    _.get("roles"),
-    _.values,
-    _.find((x) => ["CREATOR", "ADMIN"].includes(x)),
+  return _2.flow(
+    _2.get("roles"),
+    _2.values,
+    _2.find((x) => ["CREATOR", "ADMIN"].includes(x)),
     (x) => !!x
   )(user);
 }
@@ -63332,11 +63290,11 @@ var allowDefaultColumnByType = {
   ["string" /* STRING */]: true,
   ["options" /* OPTIONS */]: true,
   ["array" /* ARRAY */]: true,
+  ["bigint" /* BIGINT */]: true,
+  ["boolean" /* BOOLEAN */]: true,
   ["auto" /* AUTO */]: false,
   ["internal" /* INTERNAL */]: false,
   ["barcodeqr" /* BARCODEQR */]: false,
-  ["bigint" /* BIGINT */]: false,
-  ["boolean" /* BOOLEAN */]: false,
   ["formula" /* FORMULA */]: false,
   ["ai" /* AI */]: false,
   ["attachment" /* ATTACHMENTS */]: false,
@@ -63438,6 +63396,7 @@ var Config = /* @__PURE__ */ ((Config3) => {
   Config3["OIDC"] = "oidc";
   Config3["OIDC_LOGOS"] = "logos_oidc";
   Config3["SCIM"] = "scim";
+  Config3["AI"] = "AI";
   return Config3;
 })(Config || {});
 var MIN_VALID_DATE = /* @__PURE__ */ new Date(-2147483647e3);
@@ -63572,7 +63531,7 @@ function getAccountUserId(account) {
 
 // src/environment.ts
 var import_fs = require("fs");
-var import_lodash3 = require("lodash");
+var import_lodash4 = require("lodash");
 function isTest() {
   return isJest();
 }
@@ -63749,10 +63708,11 @@ var environment = {
   DISABLE_SCIM_CALLS: process.env.DISABLE_SCIM_CALLS,
   BB_ADMIN_USER_EMAIL: process.env.BB_ADMIN_USER_EMAIL,
   BB_ADMIN_USER_PASSWORD: process.env.BB_ADMIN_USER_PASSWORD,
-  OPENAI_API_KEY: process.env.OPENAI_API_KEY
+  OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+  MIN_VERSION_WITHOUT_POWER_ROLE: process.env.MIN_VERSION_WITHOUT_POWER_ROLE || "3.0.0"
 };
 function setEnv(newEnvVars) {
-  const oldEnv = (0, import_lodash3.cloneDeep)(environment);
+  const oldEnv = (0, import_lodash4.cloneDeep)(environment);
   let key;
   for (key in newEnvVars) {
     environment._set(key, newEnvVars[key]);
@@ -69371,7 +69331,6 @@ __export(roles_exports2, {
   RoleIDVersion: () => RoleIDVersion,
   builtinRoleToNumber: () => builtinRoleToNumber,
   checkForRoleResourceArray: () => checkForRoleResourceArray,
-  compareRoleIds: () => compareRoleIds,
   externalRole: () => externalRole,
   findRole: () => findRole,
   getAllRoleIds: () => getAllRoleIds,
@@ -69387,162 +69346,14 @@ __export(roles_exports2, {
   isBuiltin: () => isBuiltin,
   lowerBuiltinRoleID: () => lowerBuiltinRoleID,
   prefixRoleIDNoBuiltin: () => prefixRoleIDNoBuiltin,
+  roleIDsAreEqual: () => roleIDsAreEqual,
   roleToNumber: () => roleToNumber,
-  saveRoles: () => saveRoles
+  saveRoles: () => saveRoles,
+  validInherits: () => validInherits
 });
 var import_semver = __toESM(require("semver"));
-
-// src/security/permissions.ts
-var permissions_exports = {};
-__export(permissions_exports, {
-  BUILDER: () => BUILDER,
-  BUILTIN_PERMISSIONS: () => BUILTIN_PERMISSIONS,
-  BuiltinPermissionID: () => BuiltinPermissionID,
-  CREATOR: () => CREATOR,
-  GLOBAL_BUILDER: () => GLOBAL_BUILDER,
-  Permission: () => Permission,
-  PermissionLevel: () => PermissionLevel,
-  PermissionType: () => PermissionType,
-  doesHaveBasePermission: () => doesHaveBasePermission,
-  getAllowedLevels: () => getAllowedLevels,
-  getBuiltinPermissionByID: () => getBuiltinPermissionByID,
-  getBuiltinPermissions: () => getBuiltinPermissions,
-  isPermissionLevelHigherThanRead: () => isPermissionLevelHigherThanRead,
-  levelToNumber: () => levelToNumber
-});
-var import_flatten = __toESM(require("lodash/flatten"));
 var import_cloneDeep = __toESM(require("lodash/fp/cloneDeep"));
-var Permission = class {
-  constructor(type, level) {
-    this.type = type;
-    this.level = level;
-  }
-};
-function levelToNumber(perm) {
-  switch (perm) {
-    case "execute" /* EXECUTE */:
-      return 0;
-    case "read" /* READ */:
-      return 1;
-    case "write" /* WRITE */:
-      return 2;
-    case "admin" /* ADMIN */:
-      return 3;
-    default:
-      return -1;
-  }
-}
-function getAllowedLevels(userPermLevel) {
-  switch (userPermLevel) {
-    case "execute" /* EXECUTE */:
-      return ["execute" /* EXECUTE */];
-    case "read" /* READ */:
-      return ["execute" /* EXECUTE */, "read" /* READ */];
-    case "write" /* WRITE */:
-    case "admin" /* ADMIN */:
-      return [
-        "execute" /* EXECUTE */,
-        "read" /* READ */,
-        "write" /* WRITE */
-      ];
-    default:
-      return [];
-  }
-}
-var BuiltinPermissionID = /* @__PURE__ */ ((BuiltinPermissionID2) => {
-  BuiltinPermissionID2["PUBLIC"] = "public";
-  BuiltinPermissionID2["READ_ONLY"] = "read_only";
-  BuiltinPermissionID2["WRITE"] = "write";
-  BuiltinPermissionID2["ADMIN"] = "admin";
-  BuiltinPermissionID2["POWER"] = "power";
-  return BuiltinPermissionID2;
-})(BuiltinPermissionID || {});
-var BUILTIN_PERMISSIONS = {
-  PUBLIC: {
-    _id: "public" /* PUBLIC */,
-    name: "Public",
-    permissions: [
-      new Permission("webhook" /* WEBHOOK */, "execute" /* EXECUTE */)
-    ]
-  },
-  READ_ONLY: {
-    _id: "read_only" /* READ_ONLY */,
-    name: "Read only",
-    permissions: [
-      new Permission("query" /* QUERY */, "read" /* READ */),
-      new Permission("table" /* TABLE */, "read" /* READ */),
-      new Permission("app" /* APP */, "read" /* READ */)
-    ]
-  },
-  WRITE: {
-    _id: "write" /* WRITE */,
-    name: "Read/Write",
-    permissions: [
-      new Permission("query" /* QUERY */, "write" /* WRITE */),
-      new Permission("table" /* TABLE */, "write" /* WRITE */),
-      new Permission("automation" /* AUTOMATION */, "execute" /* EXECUTE */),
-      new Permission("legacy_view" /* LEGACY_VIEW */, "read" /* READ */),
-      new Permission("app" /* APP */, "read" /* READ */)
-    ]
-  },
-  POWER: {
-    _id: "power" /* POWER */,
-    name: "Power",
-    permissions: [
-      new Permission("table" /* TABLE */, "write" /* WRITE */),
-      new Permission("user" /* USER */, "read" /* READ */),
-      new Permission("automation" /* AUTOMATION */, "execute" /* EXECUTE */),
-      new Permission("webhook" /* WEBHOOK */, "read" /* READ */),
-      new Permission("legacy_view" /* LEGACY_VIEW */, "read" /* READ */),
-      new Permission("app" /* APP */, "read" /* READ */)
-    ]
-  },
-  ADMIN: {
-    _id: "admin" /* ADMIN */,
-    name: "Admin",
-    permissions: [
-      new Permission("table" /* TABLE */, "admin" /* ADMIN */),
-      new Permission("user" /* USER */, "admin" /* ADMIN */),
-      new Permission("automation" /* AUTOMATION */, "admin" /* ADMIN */),
-      new Permission("webhook" /* WEBHOOK */, "read" /* READ */),
-      new Permission("query" /* QUERY */, "admin" /* ADMIN */),
-      new Permission("legacy_view" /* LEGACY_VIEW */, "read" /* READ */),
-      new Permission("app" /* APP */, "read" /* READ */)
-    ]
-  }
-};
-function getBuiltinPermissions() {
-  return (0, import_cloneDeep.default)(BUILTIN_PERMISSIONS);
-}
-function getBuiltinPermissionByID(id) {
-  const perms = Object.values(BUILTIN_PERMISSIONS);
-  return perms.find((perm) => perm._id === id);
-}
-function doesHaveBasePermission(permType, permLevel, rolesHierarchy) {
-  const basePermissions = [
-    ...new Set(rolesHierarchy.map((role) => role.permissionId))
-  ];
-  const builtins = Object.values(BUILTIN_PERMISSIONS);
-  let permissions = (0, import_flatten.default)(
-    builtins.filter((builtin) => basePermissions.indexOf(builtin._id) !== -1).map((builtin) => builtin.permissions)
-  );
-  for (let permission of permissions) {
-    if (permission.type === permType && getAllowedLevels(permission.level).indexOf(permLevel) !== -1) {
-      return true;
-    }
-  }
-  return false;
-}
-function isPermissionLevelHigherThanRead(level) {
-  return levelToNumber(level) > 1;
-}
-var BUILDER = "builder" /* BUILDER */;
-var CREATOR = "creator" /* CREATOR */;
-var GLOBAL_BUILDER = "globalBuilder" /* GLOBAL_BUILDER */;
-
-// src/security/roles.ts
-var import_cloneDeep2 = __toESM(require("lodash/fp/cloneDeep"));
-var import_lodash4 = require("lodash");
+var import_lodash5 = require("lodash");
 var BUILTIN_ROLE_IDS = {
   ADMIN: "ADMIN",
   POWER: "POWER",
@@ -69622,7 +69433,7 @@ var RoleHierarchyTraversal = class {
         }
       }
     }
-    return (0, import_lodash4.uniqBy)(roleList, (role2) => role2._id);
+    return (0, import_lodash5.uniqBy)(roleList, (role2) => role2._id);
   }
 };
 var BUILTIN_ROLES = {
@@ -69678,7 +69489,7 @@ var BUILTIN_ROLES = {
   )
 };
 function getBuiltinRoles() {
-  return (0, import_cloneDeep2.default)(BUILTIN_ROLES);
+  return (0, import_cloneDeep.default)(BUILTIN_ROLES);
 }
 function isBuiltin(role) {
   return Object.values(BUILTIN_ROLE_IDS).includes(role);
@@ -69697,12 +69508,24 @@ function getBuiltinRole(roleId) {
   if (!role) {
     return void 0;
   }
-  return (0, import_cloneDeep2.default)(role);
+  return (0, import_cloneDeep.default)(role);
+}
+function validInherits(allRoles, inherits) {
+  if (!inherits) {
+    return false;
+  }
+  const find2 = (id) => allRoles.find((r) => roleIDsAreEqual(r._id, id));
+  if (Array.isArray(inherits)) {
+    const filtered2 = inherits.filter((roleId) => find2(roleId));
+    return inherits.length !== 0 && filtered2.length === inherits.length;
+  } else {
+    return !!find2(inherits);
+  }
 }
 function builtinRoleToNumber(id) {
   const builtins = getBuiltinRoles();
   const MAX = Object.values(builtins).length + 1;
-  if (compareRoleIds(id, BUILTIN_IDS.ADMIN) || compareRoleIds(id, BUILTIN_IDS.BUILDER)) {
+  if (roleIDsAreEqual(id, BUILTIN_IDS.ADMIN) || roleIDsAreEqual(id, BUILTIN_IDS.BUILDER)) {
     return MAX;
   }
   let role = builtins[id], count = 0;
@@ -69733,7 +69556,7 @@ async function roleToNumber(id) {
     if (Array.isArray(role.inherits)) {
       const highestBuiltin = role.inherits.map((roleId) => {
         const foundRole = hierarchy.find(
-          (role2) => compareRoleIds(role2._id, roleId)
+          (role2) => roleIDsAreEqual(role2._id, roleId)
         );
         if (foundRole) {
           return findNumber(foundRole) + 1;
@@ -69758,7 +69581,7 @@ function lowerBuiltinRoleID(roleId1, roleId2) {
   }
   return builtinRoleToNumber(roleId1) > builtinRoleToNumber(roleId2) ? roleId2 : roleId1;
 }
-function compareRoleIds(roleId1, roleId2) {
+function roleIDsAreEqual(roleId1, roleId2) {
   return prefixRoleID(roleId1) === prefixRoleID(roleId2);
 }
 function externalRole(role) {
@@ -69778,10 +69601,10 @@ function findRole(roleId, roles, opts) {
     roleId = prefixRoleID(roleId);
   }
   const dbRole = roles.find(
-    (role2) => role2._id && compareRoleIds(role2._id, roleId)
+    (role2) => role2._id && roleIDsAreEqual(role2._id, roleId)
   );
   if (!dbRole && !isBuiltin(roleId) && opts?.defaultPublic) {
-    return (0, import_cloneDeep2.default)(BUILTIN_ROLES.PUBLIC);
+    return (0, import_cloneDeep.default)(BUILTIN_ROLES.PUBLIC);
   }
   role = Object.assign(role || {}, dbRole);
   if (role?._id) {
@@ -69811,7 +69634,7 @@ async function saveRoles(roles) {
 }
 async function getAllUserRoles(userRoleId, opts) {
   const allRoles = await getAllRoles();
-  if (compareRoleIds(userRoleId, BUILTIN_IDS.ADMIN)) {
+  if (roleIDsAreEqual(userRoleId, BUILTIN_IDS.ADMIN)) {
     return allRoles;
   }
   const foundRole = findRole(userRoleId, allRoles, opts);
@@ -69886,7 +69709,7 @@ async function getAllRoles(appId) {
     for (let builtinRoleId of externalBuiltinRoles) {
       const builtinRole = builtinRoles[builtinRoleId];
       const dbBuiltin = roles.filter(
-        (dbRole) => compareRoleIds(dbRole._id, builtinRoleId)
+        (dbRole) => roleIDsAreEqual(dbRole._id, builtinRoleId)
       )[0];
       if (dbBuiltin == null) {
         roles.push(builtinRole || builtinRoles.BASIC);
@@ -69921,7 +69744,10 @@ async function shouldIncludePowerRole(db) {
   if (!creationVersion || !import_semver.default.valid(creationVersion)) {
     return true;
   }
-  const isGreaterThan3x = import_semver.default.gte(creationVersion, "3.0.0");
+  const isGreaterThan3x = import_semver.default.gte(
+    creationVersion,
+    environment_default.MIN_VERSION_WITHOUT_POWER_ROLE
+  );
   return !isGreaterThan3x;
 }
 var AccessController = class {
@@ -69929,7 +69755,7 @@ var AccessController = class {
     this.userHierarchies = {};
   }
   async hasAccess(tryingRoleId, userRoleId) {
-    if (tryingRoleId == null || tryingRoleId === "" || compareRoleIds(tryingRoleId, BUILTIN_IDS.BUILDER) || compareRoleIds(userRoleId, tryingRoleId) || compareRoleIds(userRoleId, BUILTIN_IDS.BUILDER)) {
+    if (tryingRoleId == null || tryingRoleId === "" || roleIDsAreEqual(tryingRoleId, BUILTIN_IDS.BUILDER) || roleIDsAreEqual(userRoleId, tryingRoleId) || roleIDsAreEqual(userRoleId, BUILTIN_IDS.BUILDER)) {
       return true;
     }
     let roleIds = userRoleId ? this.userHierarchies[userRoleId] : null;
@@ -69937,7 +69763,7 @@ var AccessController = class {
       roleIds = await getUserRoleIdHierarchy(userRoleId);
       this.userHierarchies[userRoleId] = roleIds;
     }
-    return roleIds?.find((roleId) => compareRoleIds(roleId, tryingRoleId)) !== void 0;
+    return roleIds?.find((roleId) => roleIDsAreEqual(roleId, tryingRoleId)) !== void 0;
   }
   async checkScreensAccess(screens, userRoleId) {
     let accessibleScreens = [];
@@ -74030,6 +73856,145 @@ var DEFINITIONS = [
   }
 ];
 
+// src/security/permissions.ts
+var permissions_exports = {};
+__export(permissions_exports, {
+  BUILDER: () => BUILDER,
+  BUILTIN_PERMISSIONS: () => BUILTIN_PERMISSIONS,
+  CREATOR: () => CREATOR,
+  GLOBAL_BUILDER: () => GLOBAL_BUILDER,
+  Permission: () => Permission,
+  PermissionLevel: () => PermissionLevel,
+  PermissionType: () => PermissionType,
+  doesHaveBasePermission: () => doesHaveBasePermission,
+  getAllowedLevels: () => getAllowedLevels,
+  getBuiltinPermissionByID: () => getBuiltinPermissionByID,
+  getBuiltinPermissions: () => getBuiltinPermissions,
+  isPermissionLevelHigherThanRead: () => isPermissionLevelHigherThanRead,
+  levelToNumber: () => levelToNumber
+});
+var import_flatten = __toESM(require("lodash/flatten"));
+var import_cloneDeep2 = __toESM(require("lodash/fp/cloneDeep"));
+var Permission = class {
+  constructor(type, level) {
+    this.type = type;
+    this.level = level;
+  }
+};
+function levelToNumber(perm) {
+  switch (perm) {
+    case "execute" /* EXECUTE */:
+      return 0;
+    case "read" /* READ */:
+      return 1;
+    case "write" /* WRITE */:
+      return 2;
+    case "admin" /* ADMIN */:
+      return 3;
+    default:
+      return -1;
+  }
+}
+function getAllowedLevels(userPermLevel) {
+  switch (userPermLevel) {
+    case "execute" /* EXECUTE */:
+      return ["execute" /* EXECUTE */];
+    case "read" /* READ */:
+      return ["execute" /* EXECUTE */, "read" /* READ */];
+    case "write" /* WRITE */:
+    case "admin" /* ADMIN */:
+      return [
+        "execute" /* EXECUTE */,
+        "read" /* READ */,
+        "write" /* WRITE */
+      ];
+    default:
+      return [];
+  }
+}
+var BUILTIN_PERMISSIONS = {
+  PUBLIC: {
+    _id: "public" /* PUBLIC */,
+    name: "Public",
+    permissions: [
+      new Permission("webhook" /* WEBHOOK */, "execute" /* EXECUTE */)
+    ]
+  },
+  READ_ONLY: {
+    _id: "read_only" /* READ_ONLY */,
+    name: "Read only",
+    permissions: [
+      new Permission("query" /* QUERY */, "read" /* READ */),
+      new Permission("table" /* TABLE */, "read" /* READ */),
+      new Permission("app" /* APP */, "read" /* READ */)
+    ]
+  },
+  WRITE: {
+    _id: "write" /* WRITE */,
+    name: "Read/Write",
+    permissions: [
+      new Permission("query" /* QUERY */, "write" /* WRITE */),
+      new Permission("table" /* TABLE */, "write" /* WRITE */),
+      new Permission("automation" /* AUTOMATION */, "execute" /* EXECUTE */),
+      new Permission("legacy_view" /* LEGACY_VIEW */, "read" /* READ */),
+      new Permission("app" /* APP */, "read" /* READ */)
+    ]
+  },
+  POWER: {
+    _id: "power" /* POWER */,
+    name: "Power",
+    permissions: [
+      new Permission("table" /* TABLE */, "write" /* WRITE */),
+      new Permission("user" /* USER */, "read" /* READ */),
+      new Permission("automation" /* AUTOMATION */, "execute" /* EXECUTE */),
+      new Permission("webhook" /* WEBHOOK */, "read" /* READ */),
+      new Permission("legacy_view" /* LEGACY_VIEW */, "read" /* READ */),
+      new Permission("app" /* APP */, "read" /* READ */)
+    ]
+  },
+  ADMIN: {
+    _id: "admin" /* ADMIN */,
+    name: "Admin",
+    permissions: [
+      new Permission("table" /* TABLE */, "admin" /* ADMIN */),
+      new Permission("user" /* USER */, "admin" /* ADMIN */),
+      new Permission("automation" /* AUTOMATION */, "admin" /* ADMIN */),
+      new Permission("webhook" /* WEBHOOK */, "read" /* READ */),
+      new Permission("query" /* QUERY */, "admin" /* ADMIN */),
+      new Permission("legacy_view" /* LEGACY_VIEW */, "read" /* READ */),
+      new Permission("app" /* APP */, "read" /* READ */)
+    ]
+  }
+};
+function getBuiltinPermissions() {
+  return (0, import_cloneDeep2.default)(BUILTIN_PERMISSIONS);
+}
+function getBuiltinPermissionByID(id) {
+  const perms = Object.values(BUILTIN_PERMISSIONS);
+  return perms.find((perm) => perm._id === id);
+}
+function doesHaveBasePermission(permType, permLevel, rolesHierarchy) {
+  const basePermissions = [
+    ...new Set(rolesHierarchy.map((role) => role.permissionId))
+  ];
+  const builtins = Object.values(BUILTIN_PERMISSIONS);
+  let permissions = (0, import_flatten.default)(
+    builtins.filter((builtin) => basePermissions.indexOf(builtin._id) !== -1).map((builtin) => builtin.permissions)
+  );
+  for (let permission of permissions) {
+    if (permission.type === permType && getAllowedLevels(permission.level).indexOf(permLevel) !== -1) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPermissionLevelHigherThanRead(level) {
+  return levelToNumber(level) > 1;
+}
+var BUILDER = "builder" /* BUILDER */;
+var CREATOR = "creator" /* CREATOR */;
+var GLOBAL_BUILDER = "globalBuilder" /* GLOBAL_BUILDER */;
+
 // src/auth/index.ts
 var auth_exports = {};
 __export(auth_exports, {
@@ -75729,7 +75694,7 @@ var SqlTableQueryBuilder = class {
 var sqlTable_default = SqlTableQueryBuilder;
 
 // src/sql/sql.ts
-var import_lodash5 = require("lodash");
+var import_lodash6 = require("lodash");
 var COUNT_FIELD_NAME = "__bb_total";
 function getBaseLimit() {
   const envLimit = environment_default.SQL_MAX_ROWS ? parseInt(environment_default.SQL_MAX_ROWS) : null;
@@ -75828,9 +75793,6 @@ var InternalBuilder = class {
     const { column } = this.splitter.run(key);
     return this.table.schema[column];
   }
-  supportsILike() {
-    return !(this.client === "oracledb" /* ORACLE */ || this.client === "sqlite3" /* SQL_LITE */);
-  }
   quoteChars() {
     const wrapped = this.knexClient.wrapIdentifier("foo", {});
     return [wrapped[0], wrapped[wrapped.length - 1]];
@@ -75857,8 +75819,25 @@ var InternalBuilder = class {
     const formatter = this.knexClient.formatter(this.knexClient.queryBuilder());
     return formatter.wrap(value, false);
   }
-  rawQuotedValue(value) {
-    return this.knex.raw(this.quotedValue(value));
+  castIntToString(identifier) {
+    switch (this.client) {
+      case "oracledb" /* ORACLE */: {
+        return this.knex.raw("to_char(??)", [identifier]);
+      }
+      case "pg" /* POSTGRES */: {
+        return this.knex.raw("??::TEXT", [identifier]);
+      }
+      case "mysql2" /* MY_SQL */:
+      case "mariadb" /* MARIADB */: {
+        return this.knex.raw("CAST(?? AS CHAR)", [identifier]);
+      }
+      case "sqlite3" /* SQL_LITE */: {
+        return this.knex.raw("printf('%d', ??)", [identifier]);
+      }
+      case "mssql" /* MS_SQL */: {
+        return this.knex.raw("CONVERT(NVARCHAR, ??)", [identifier]);
+      }
+    }
   }
   // Unfortuantely we cannot rely on knex's identifier escaping because it trims
   // the identifier string before escaping it, which breaks cases for us where
@@ -76009,7 +75988,7 @@ var InternalBuilder = class {
     return body2;
   }
   parseFilters(filters) {
-    filters = (0, import_lodash5.cloneDeep)(filters);
+    filters = (0, import_lodash6.cloneDeep)(filters);
     for (const op of Object.values(BasicOperator)) {
       const filter = filters[op];
       if (!filter) {
@@ -76089,7 +76068,7 @@ var InternalBuilder = class {
         if (!matchesTableName) {
           updatedKey = filterKey.replace(
             new RegExp(`^${relationship.column}.`),
-            `${aliases[relationship.tableName]}.`
+            `${aliases?.[relationship.tableName] || relationship.tableName}.`
           );
         } else {
           updatedKey = filterKey;
@@ -76547,24 +76526,32 @@ var InternalBuilder = class {
             );
           }
         } else {
-          query = query.count(`* as ${aggregation.name}`);
+          if (this.client === "oracledb" /* ORACLE */) {
+            const field = this.convertClobs(`${tableName}.${aggregation.field}`);
+            query = query.select(
+              this.knex.raw(`COUNT(??) as ??`, [field, aggregation.name])
+            );
+          } else {
+            query = query.count(`${aggregation.field} 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;
+        const fieldSchema = this.getFieldSchema(aggregation.field);
+        if (!fieldSchema) {
+          throw new Error(
+            `field schema missing for aggregation target: ${aggregation.field}`
+          );
+        }
+        let aggregate = this.knex.raw("??(??)", [
+          this.knex.raw(op),
+          this.rawQuotedIdentifier(`${tableName}.${aggregation.field}`)
+        ]);
+        if (fieldSchema.type === "bigint" /* BIGINT */) {
+          aggregate = this.castIntToString(aggregate);
         }
+        query = query.select(
+          this.knex.raw("?? as ??", [aggregate, aggregation.name])
+        );
       }
     }
     return query;
@@ -76812,7 +76799,7 @@ var InternalBuilder = class {
       for (const [column, schema] of Object.entries(
         this.query.meta.table.schema
       )) {
-        if (schema.constraints?.presence === true || schema.type === "formula" /* FORMULA */ || schema.type === "auto" /* AUTO */ || schema.type === "link" /* LINK */) {
+        if (schema.constraints?.presence === true || schema.type === "formula" /* FORMULA */ || schema.type === "auto" /* AUTO */ || schema.type === "link" /* LINK */ || schema.type === "ai" /* AI */) {
           continue;
         }
         const value = parsedBody[column];
@@ -76899,7 +76886,7 @@ var InternalBuilder = class {
       query = this.addSorting(query);
     }
     query = this.addFilters(query, filters, { relationship: true });
-    if (relationships?.length) {
+    if (relationships?.length && aggregations.length === 0) {
       const mainTable = this.query.tableAliases?.[this.query.endpoint.entityId] || this.query.endpoint.entityId;
       const cte = this.addSorting(
         this.knex.with("paginated", query).select(this.generateSelectStatement()).from({
@@ -76907,9 +76894,8 @@ var InternalBuilder = class {
         })
       );
       return this.addJsonRelationships(cte, tableName, relationships);
-    } else {
-      return query;
     }
+    return query;
   }
   update(opts) {
     const { body: body2, filters } = this.query;