@budibase/backend-core 2.29.29 → 2.30.0

package/dist/index.js

@@ -54195,8 +54195,7 @@ __export(src_exports, {
   env: () => environment_default,
   errors: () => errors_exports,
   events: () => events_exports,
-  featureFlags: () => features_exports,
-  features: () => installation_exports2,
+  features: () => features_exports,
   getPublicError: () => getPublicError,
   init: () => init9,
   installation: () => installation_exports,
@@ -54482,6 +54481,9 @@ var RangeOperator = /* @__PURE__ */ ((RangeOperator2) => {
   RangeOperator2["RANGE"] = "range";
   return RangeOperator2;
 })(RangeOperator || {});
+function isLogicalSearchOperator(value) {
+  return value === "$and" /* AND */ || value === "$or" /* OR */;
+}
 
 // ../types/src/sdk/db.ts
 var isDocument = (doc) => {
@@ -55253,6 +55255,7 @@ var buildQuery = (filter) => {
           high: value
         };
       }
+    } else if (isLogicalSearchOperator(queryOperator)) {
     } else if (query[queryOperator] && operator !== "onEmptyFilter") {
       if (type === "boolean") {
         if (queryOperator === "equal" && value === false) {
@@ -55322,14 +55325,15 @@ var runQuery = (docs, query) => {
   }
   const match = (type, test) => (doc) => {
     for (const [key, testValue] of Object.entries(query[type] || {})) {
-      const result = test(deepGet(doc, removeKeyNumbering(key)), testValue);
+      const valueToCheck = isLogicalSearchOperator(type) ? doc : deepGet(doc, removeKeyNumbering(key));
+      const result = test(valueToCheck, testValue);
       if (query.allOr && result) {
         return true;
       } else if (!query.allOr && !result) {
         return false;
       }
     }
-    return true;
+    return !query.allOr;
   };
   const stringMatch = match(
     "string" /* STRING */,
@@ -55484,6 +55488,39 @@ var runQuery = (docs, query) => {
     }
   );
   const containsAny = match("containsAny" /* CONTAINS_ANY */, _contains("some"));
+  const and = match(
+    "$and" /* AND */,
+    (docValue, conditions) => {
+      if (!conditions.length) {
+        return false;
+      }
+      for (const condition of conditions) {
+        const matchesCondition = runQuery([docValue], condition);
+        if (!matchesCondition.length) {
+          return false;
+        }
+      }
+      return true;
+    }
+  );
+  const or = match(
+    "$or" /* OR */,
+    (docValue, conditions) => {
+      if (!conditions.length) {
+        return false;
+      }
+      for (const condition of conditions) {
+        const matchesCondition = runQuery([docValue], {
+          ...condition,
+          allOr: true
+        });
+        if (matchesCondition.length) {
+          return true;
+        }
+      }
+      return false;
+    }
+  );
   const docMatch = (doc) => {
     const filterFunctions = {
       string: stringMatch,
@@ -55496,7 +55533,9 @@ var runQuery = (docs, query) => {
       oneOf,
       contains,
       containsAny,
-      notContains
+      notContains,
+      ["$and" /* AND */]: and,
+      ["$or" /* OR */]: or
     };
     const results = Object.entries(query || {}).filter(
       ([key, value]) => !["allOr", "onEmptyFilter"].includes(key) && value && Object.keys(value).length > 0
@@ -65938,90 +65977,70 @@ var DEFINITIONS = [
 // src/features/index.ts
 var features_exports = {};
 __export(features_exports, {
-  TenantFeatureFlag: () => TenantFeatureFlag,
-  buildFeatureFlags: () => buildFeatureFlags,
-  getTenantFeatureFlags: () => getTenantFeatureFlags,
-  isEnabled: () => isEnabled,
-  processFeatureEnvVar: () => processFeatureEnvVar
+  defaultFlags: () => defaultFlags,
+  fetch: () => fetch6,
+  get: () => get4,
+  isEnabled: () => isEnabled
 });
-
-// src/features/installation.ts
-var installation_exports2 = {};
-__export(installation_exports2, {
-  processFeatureEnvVar: () => processFeatureEnvVar
-});
-function processFeatureEnvVar(fullList, featureList) {
-  let list;
-  if (!featureList) {
-    list = fullList;
-  } else {
-    list = featureList.split(",");
-  }
-  for (let feature of list) {
-    if (!fullList.includes(feature)) {
-      throw new Error(`Feature: ${feature} is not an allowed option`);
-    }
+var import_lodash2 = require("lodash");
+var Flag = class _Flag {
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
   }
-  return list;
-}
-
-// src/features/index.ts
-function buildFeatureFlags() {
-  if (!environment_default.TENANT_FEATURE_FLAGS) {
-    return;
+  static withDefault(value) {
+    return new _Flag(value);
   }
-  const tenantFeatureFlags = {};
-  environment_default.TENANT_FEATURE_FLAGS.split(",").forEach((tenantToFeatures) => {
-    const [tenantId, ...features] = tenantToFeatures.split(":");
-    features.forEach((feature) => {
-      if (!tenantFeatureFlags[tenantId]) {
-        tenantFeatureFlags[tenantId] = [];
-      }
-      tenantFeatureFlags[tenantId].push(feature);
-    });
-  });
-  return tenantFeatureFlags;
-}
-function isEnabled(featureFlag) {
-  const tenantId = getTenantId();
-  const flags = getTenantFeatureFlags(tenantId);
-  return flags.includes(featureFlag);
-}
-function getTenantFeatureFlags(tenantId) {
-  let flags = [];
-  const envFlags = buildFeatureFlags();
-  if (envFlags) {
-    const globalFlags = envFlags["*"];
-    const tenantFlags = envFlags[tenantId] || [];
-    const tenantOverrides = tenantFlags.reduce(
-      (acc, flag) => {
-        if (flag.startsWith("!")) {
-          let stripped = flag.substring(1);
-          acc.push(stripped);
-        }
-        return acc;
-      },
-      []
-    );
-    if (globalFlags) {
-      flags.push(...globalFlags);
+};
+var FLAGS = {
+  LICENSING: Flag.withDefault(false),
+  GOOGLE_SHEETS: Flag.withDefault(false),
+  USER_GROUPS: Flag.withDefault(false),
+  ONBOARDING_TOUR: Flag.withDefault(false)
+};
+var DEFAULTS = Object.keys(FLAGS).reduce((acc, key) => {
+  const typedKey = key;
+  acc[typedKey] = FLAGS[typedKey].defaultValue;
+  return acc;
+}, {});
+function defaultFlags() {
+  return (0, import_lodash2.cloneDeep)(DEFAULTS);
+}
+function isFlagName(name) {
+  return FLAGS[name] !== void 0;
+}
+async function fetch6() {
+  const currentTenantId = getTenantId();
+  const flags = defaultFlags();
+  const split = (environment_default.TENANT_FEATURE_FLAGS || "").split(",").map((x) => x.split(":"));
+  for (const [tenantId, ...features] of split) {
+    if (!tenantId || tenantId !== "*" && tenantId !== currentTenantId) {
+      continue;
     }
-    if (tenantFlags.length) {
-      flags.push(...tenantFlags);
+    for (let feature of features) {
+      let value = true;
+      if (feature.startsWith("!")) {
+        feature = feature.slice(1);
+        value = false;
+      }
+      if (!isFlagName(feature)) {
+        throw new Error(`Feature: ${feature} is not an allowed option`);
+      }
+      if (typeof flags[feature] !== "boolean") {
+        throw new Error(`Feature: ${feature} is not a boolean`);
+      }
+      flags[feature] = value;
     }
-    flags = flags.filter((flag) => {
-      return tenantOverrides.indexOf(flag) == -1 && !flag.startsWith("!");
-    });
   }
   return flags;
 }
-var TenantFeatureFlag = /* @__PURE__ */ ((TenantFeatureFlag2) => {
-  TenantFeatureFlag2["LICENSING"] = "LICENSING";
-  TenantFeatureFlag2["GOOGLE_SHEETS"] = "GOOGLE_SHEETS";
-  TenantFeatureFlag2["USER_GROUPS"] = "USER_GROUPS";
-  TenantFeatureFlag2["ONBOARDING_TOUR"] = "ONBOARDING_TOUR";
-  return TenantFeatureFlag2;
-})(TenantFeatureFlag || {});
+async function get4(name) {
+  const flags = await fetch6();
+  return flags[name];
+}
+async function isEnabled(name) {
+  const flags = await fetch6();
+  return flags[name];
+}
 
 // src/auth/index.ts
 var auth_exports = {};
@@ -68016,6 +68035,22 @@ var InternalBuilder = class {
         });
       }
     };
+    if (filters.$and) {
+      const { $and } = filters;
+      query = query.where((x) => {
+        for (const condition of $and.conditions) {
+          x = this.addFilters(x, condition, opts);
+        }
+      });
+    }
+    if (filters.$or) {
+      const { $or } = filters;
+      query = query.where((x) => {
+        for (const condition of $or.conditions) {
+          x = this.addFilters(x, { ...condition, allOr: true }, opts);
+        }
+      });
+    }
     if (filters.oneOf) {
       const fnc = allOr ? "orWhereIn" : "whereIn";
       iterate(
@@ -68686,7 +68721,6 @@ var init9 = (opts = {}) => {
   env,
   errors,
   events,
-  featureFlags,
   features,
   getPublicError,
   init,