@budibase/backend-core 2.32.11 → 2.32.13

package/dist/index.js

@@ -61260,7 +61260,7 @@ __export(src_exports, {
   sql: () => sql_exports,
   tenancy: () => tenancy,
   timers: () => timers_exports,
-  userUtils: () => utils_exports5,
+  userUtils: () => utils_exports6,
   users: () => users_exports3,
   utils: () => utils_exports4,
   withEnv: () => withEnv
@@ -61911,6 +61911,7 @@ __export(filters_exports, {
   ColumnSplitter: () => ColumnSplitter,
   NoEmptyFilterStrings: () => NoEmptyFilterStrings,
   buildQuery: () => buildQuery,
+  buildQueryLegacy: () => buildQueryLegacy,
   cleanupQuery: () => cleanupQuery,
   fixupFilterArrays: () => fixupFilterArrays,
   getKeyNumbering: () => getKeyNumbering,
@@ -61926,6 +61927,164 @@ __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 (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;
+};
+
 // ../shared-core/src/helpers/index.ts
 var helpers_exports = {};
 __export(helpers_exports, {
@@ -62130,6 +62289,7 @@ var views_exports = {};
 __export(views_exports, {
   basicFields: () => basicFields,
   calculationFields: () => calculationFields,
+  hasCalculationFields: () => hasCalculationFields,
   isBasicViewField: () => isBasicViewField,
   isCalculationField: () => isCalculationField,
   isCalculationView: () => isCalculationView
@@ -62142,6 +62302,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) {
@@ -62221,7 +62384,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 +62404,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 +62494,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 +62642,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 +62688,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];
@@ -62453,7 +62738,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());
   }
@@ -62767,91 +63052,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, {
@@ -66928,8 +67128,12 @@ __export(features_exports, {
   FlagSet: () => FlagSet,
   flags: () => flags,
   init: () => init4,
-  shutdown: () => shutdown2
+  parseEnvFlags: () => parseEnvFlags,
+  shutdown: () => shutdown2,
+  testutils: () => utils_exports5
 });
+
+// src/features/features.ts
 var import_posthog_node = require("posthog-node");
 var import_dd_trace3 = __toESM(require("dd-trace"));
 
@@ -67310,7 +67514,7 @@ var Duration = class _Duration {
   }
 };
 
-// src/features/index.ts
+// src/features/features.ts
 var posthog;
 function init4(opts) {
   if (environment_default.POSTHOG_TOKEN && environment_default.POSTHOG_API_HOST && !environment_default.SELF_HOSTED && environment_default.POSTHOG_FEATURE_FLAGS_ENABLED) {
@@ -67375,6 +67579,21 @@ var NumberFlag = class extends Flag {
     throw new Error(`could not parse value "${value}" as number`);
   }
 };
+function parseEnvFlags(flags2) {
+  const split = flags2.split(",").map((x) => x.split(":"));
+  const result = [];
+  for (const [tenantId, ...features] of split) {
+    for (let feature of features) {
+      let value = true;
+      if (feature.startsWith("!")) {
+        feature = feature.slice(1);
+        value = false;
+      }
+      result.push({ tenantId, key: feature, value });
+    }
+  }
+  return result;
+}
 var FlagSet = class {
   constructor(flagSchema) {
     this.flagSchema = flagSchema;
@@ -67409,28 +67628,24 @@ var FlagSet = class {
       const flagValues = this.defaults();
       const currentTenantId = getTenantId();
       const specificallySetFalse = /* @__PURE__ */ new Set();
-      const split = (environment_default.TENANT_FEATURE_FLAGS || "").split(",").map((x) => x.split(":"));
-      for (const [tenantId, ...features] of split) {
+      for (const { tenantId, key, value } of parseEnvFlags(
+        environment_default.TENANT_FEATURE_FLAGS || ""
+      )) {
         if (!tenantId || tenantId !== "*" && tenantId !== currentTenantId) {
           continue;
         }
         tags[`readFromEnvironmentVars`] = true;
-        for (let feature of features) {
-          let value = true;
-          if (feature.startsWith("!")) {
-            feature = feature.slice(1);
-            value = false;
-            specificallySetFalse.add(feature);
-          }
-          if (!this.isFlagName(feature)) {
-            continue;
-          }
-          if (typeof flagValues[feature] !== "boolean") {
-            throw new Error(`Feature: ${feature} is not a boolean`);
-          }
-          flagValues[feature] = value;
-          tags[`flags.${feature}.source`] = "environment";
+        if (value === false) {
+          specificallySetFalse.add(key);
+        }
+        if (!this.isFlagName(key)) {
+          continue;
         }
+        if (typeof flagValues[key] !== "boolean") {
+          throw new Error(`Feature: ${key} is not a boolean`);
+        }
+        flagValues[key] = value;
+        tags[`flags.${key}.source`] = "environment";
       }
       const license = ctx?.user?.license;
       if (license) {
@@ -67497,6 +67712,60 @@ var flags = new FlagSet({
   ["ENRICHED_RELATIONSHIPS" /* ENRICHED_RELATIONSHIPS */]: Flag.boolean(environment_default.isDev())
 });
 
+// src/features/tests/utils.ts
+var utils_exports5 = {};
+__export(utils_exports5, {
+  setFeatureFlags: () => setFeatureFlags2,
+  withFeatureFlags: () => withFeatureFlags
+});
+function getCurrentFlags() {
+  const result = {};
+  for (const { tenantId, key, value } of parseEnvFlags(
+    process.env.TENANT_FEATURE_FLAGS || ""
+  )) {
+    const tenantFlags = result[tenantId] || {};
+    if (tenantFlags[key] === false) {
+      continue;
+    }
+    tenantFlags[key] = value;
+    result[tenantId] = tenantFlags;
+  }
+  return result;
+}
+function buildFlagString(flags2) {
+  const parts = [];
+  for (const [tenantId, tenantFlags] of Object.entries(flags2)) {
+    for (const [key, value] of Object.entries(tenantFlags)) {
+      if (value === false) {
+        parts.push(`${tenantId}:!${key}`);
+      } else {
+        parts.push(`${tenantId}:${key}`);
+      }
+    }
+  }
+  return parts.join(",");
+}
+function setFeatureFlags2(tenantId, flags2) {
+  const current = getCurrentFlags();
+  for (const [key, value] of Object.entries(flags2)) {
+    const tenantFlags = current[tenantId] || {};
+    tenantFlags[key] = value;
+    current[tenantId] = tenantFlags;
+  }
+  const flagString = buildFlagString(current);
+  return setEnv({ TENANT_FEATURE_FLAGS: flagString });
+}
+function withFeatureFlags(tenantId, flags2, f) {
+  const cleanup3 = setFeatureFlags2(tenantId, flags2);
+  const result = f();
+  if (result instanceof Promise) {
+    return result.finally(cleanup3);
+  } else {
+    cleanup3();
+    return result;
+  }
+}
+
 // src/db/couch/DatabaseImpl.ts
 var DATABASE_NOT_FOUND = "Database does not exist.";
 function buildNano(couchInfo) {
@@ -67760,11 +68029,21 @@ var DatabaseImpl = class _DatabaseImpl {
     return this.performCall(() => {
       return async () => {
         const response = await directCouchUrlCall(args);
-        const json = await response.json();
+        const text = await response.text();
         if (response.status > 300) {
+          let json;
+          try {
+            json = JSON.parse(text);
+          } catch (err) {
+            console.error(`SQS error: ${text}`);
+            throw new CouchDBError(
+              "error while running SQS query, please try again later",
+              { name: "sqs_error", status: response.status }
+            );
+          }
           throw json;
         }
-        return json;
+        return JSON.parse(text);
       };
     });
   }
@@ -68777,8 +69056,8 @@ __export(users_exports3, {
 });
 
 // src/users/utils.ts
-var utils_exports5 = {};
-__export(utils_exports5, {
+var utils_exports6 = {};
+__export(utils_exports6, {
   getAccountHolderFromUserIds: () => getAccountHolderFromUserIds,
   hasAdminPermissions: () => hasAdminPermissions2,
   hasAppBuilderPermissions: () => hasAppBuilderPermissions2,
@@ -72803,6 +73082,12 @@ async function paginatedUsers({
     userList = await bulkGetGlobalUsersById(query?.oneOf?._id, {
       cleanup: true
     });
+  } else if (query) {
+    const response = await db.allDocs(
+      getGlobalUserParams(null, { ...opts, limit: void 0 })
+    );
+    userList = response.rows.map((row) => row.doc);
+    userList = filters_exports.search(userList, { query, limit: opts.limit }).rows;
   } else {
     const response = await db.allDocs(getGlobalUserParams(null, opts));
     userList = response.rows.map((row) => row.doc);
@@ -73620,7 +73905,6 @@ __export(google_exports, {
 });
 
 // src/middleware/passport/sso/sso.ts
-var import_node_fetch5 = __toESM(require("node-fetch"));
 var ssoSaveUserNoOp = (user) => Promise.resolve(user);
 async function authenticate2(details, requireLocalAccount = true, done, saveUserFn) {
   if (!saveUserFn) {
@@ -73675,24 +73959,10 @@ async function authenticate2(details, requireLocalAccount = true, done, saveUser
   }
   return done(null, ssoUser);
 }
-async function getProfilePictureUrl(user, details) {
-  const pictureUrl = details.profile?._json.picture;
-  if (pictureUrl) {
-    const response = await (0, import_node_fetch5.default)(pictureUrl);
-    if (response.status === 200) {
-      const type = response.headers.get("content-type");
-      if (type.startsWith("image/")) {
-        return pictureUrl;
-      }
-    }
-  }
-}
 async function syncUser(user, details) {
   let firstName;
   let lastName;
-  let pictureUrl;
   let oauth2;
-  let thirdPartyProfile;
   if (details.profile) {
     const profile = details.profile;
     if (profile.name) {
@@ -73704,10 +73974,6 @@ async function syncUser(user, details) {
         lastName = name.familyName;
       }
     }
-    pictureUrl = await getProfilePictureUrl(user, details);
-    thirdPartyProfile = {
-      ...profile._json
-    };
   }
   if (details.oauth2) {
     oauth2 = {
@@ -73720,8 +73986,6 @@ async function syncUser(user, details) {
     providerType: details.providerType,
     firstName,
     lastName,
-    thirdPartyProfile,
-    pictureUrl,
     oauth2
   };
 }
@@ -73783,7 +74047,7 @@ __export(oidc_exports, {
   getCallbackUrl: () => getCallbackUrl2,
   strategyFactory: () => strategyFactory2
 });
-var import_node_fetch6 = __toESM(require("node-fetch"));
+var import_node_fetch5 = __toESM(require("node-fetch"));
 var OIDCStrategy = require_lib9().Strategy;
 function buildVerifyFn2(saveUserFn) {
   return async (issuer, sub, profile, jwtClaims, accessToken, refreshToken, idToken, params2, done) => {
@@ -73843,7 +74107,7 @@ async function fetchStrategyConfig(oidcConfig, callbackUrl) {
         "Configuration invalid. Must contain clientID, clientSecret, callbackUrl and configUrl"
       );
     }
-    const response = await (0, import_node_fetch6.default)(configUrl);
+    const response = await (0, import_node_fetch5.default)(configUrl);
     if (!response.ok) {
       throw new Error(
         `Unexpected response when fetching openid-configuration: ${response.statusText}`
@@ -75270,25 +75534,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 +75634,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 +76146,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;