@featurevisor/core 2.5.0 → 2.6.7

package/src/builder/buildScopedConditions.ts

@@ -0,0 +1,134 @@
+import type {
+  Condition,
+  AndCondition,
+  OrCondition,
+  NotCondition,
+  Context,
+} from "@featurevisor/types";
+import type { DatafileReader } from "@featurevisor/sdk";
+
+export function buildScopedConditions(
+  datafileReader: DatafileReader,
+  conditions: Condition | Condition[],
+  context: Context,
+): Condition | Condition[] {
+  const scoped = buildScopedCondition(datafileReader, conditions, context);
+  const removed = removeRedundantConditions(scoped);
+
+  return removed;
+}
+
+export function removeRedundantConditions(
+  conditions: Condition | Condition[],
+): Condition | Condition[] {
+  if (conditions === "*") {
+    return conditions;
+  }
+
+  if (Array.isArray(conditions)) {
+    // Recursively process each condition
+    const processed = conditions.map((c) => removeRedundantConditions(c)) as Condition[];
+
+    // Filter out "*" values
+    const filtered = processed.filter((c) => c !== "*");
+
+    // If all were "*", return "*"
+    if (filtered.length === 0) {
+      return "*";
+    }
+
+    return filtered;
+  }
+
+  if (typeof conditions === "object") {
+    if ("and" in conditions) {
+      const processed = conditions.and.map((c) => removeRedundantConditions(c)) as Condition[];
+      const filtered = processed.filter((c) => c !== "*");
+
+      // If all were "*", return "*"
+      if (filtered.length === 0) {
+        return "*";
+      }
+
+      return {
+        and: filtered,
+      } as AndCondition;
+    }
+
+    if ("or" in conditions) {
+      const processed = conditions.or.map((c) => removeRedundantConditions(c)) as Condition[];
+      const filtered = processed.filter((c) => c !== "*");
+
+      // If all were "*", return "*"
+      if (filtered.length === 0) {
+        return "*";
+      }
+
+      return {
+        or: filtered,
+      } as OrCondition;
+    }
+
+    if ("not" in conditions) {
+      const processed = conditions.not.map((c) => removeRedundantConditions(c)) as Condition[];
+      const filtered = processed.filter((c) => c !== "*");
+
+      // If all were "*", return "*"
+      if (filtered.length === 0) {
+        return "*";
+      }
+
+      return {
+        not: filtered,
+      } as NotCondition;
+    }
+  }
+
+  return conditions;
+}
+
+export function buildScopedCondition(
+  datafileReader: DatafileReader,
+  condition: Condition | Condition[],
+  context: Context,
+): Condition | Condition[] {
+  if (condition === "*") {
+    return condition;
+  }
+
+  if (Array.isArray(condition)) {
+    return condition.map((c) => buildScopedCondition(datafileReader, c, context)) as Condition[];
+  }
+
+  if (typeof condition === "object") {
+    // plain condition
+    if ("attribute" in condition) {
+      const matched = datafileReader.allConditionsAreMatched(condition, context);
+
+      if (matched) {
+        return "*";
+      }
+    }
+
+    // AND, OR, NOT conditions
+    if ("and" in condition) {
+      return {
+        and: condition.and.map((c) => buildScopedCondition(datafileReader, c, context)),
+      } as AndCondition;
+    }
+
+    if ("or" in condition) {
+      return {
+        or: condition.or.map((c) => buildScopedCondition(datafileReader, c, context)),
+      } as OrCondition;
+    }
+
+    if ("not" in condition) {
+      return {
+        not: condition.not.map((c) => buildScopedCondition(datafileReader, c, context)),
+      } as NotCondition;
+    }
+  }
+
+  return condition;
+}