flagsmith-sql-flag-engine 0.1.0__tar.gz → 0.1.2__tar.gz

{flagsmith_sql_flag_engine-0.1.0 → flagsmith_sql_flag_engine-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flagsmith-sql-flag-engine
-Version: 0.1.0
+Version: 0.1.2
 Summary: SQL translator for Flagsmith segment predicates.
 Author: Flagsmith
 Author-email: Flagsmith <engineering@flagsmith.com>

{flagsmith_sql_flag_engine-0.1.0 → flagsmith_sql_flag_engine-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flagsmith-sql-flag-engine"
-version = "0.1.0"
+version = "0.1.2"
 description = "SQL translator for Flagsmith segment predicates."
 readme = "README.md"
 authors = [{ name = "Flagsmith", email = "engineering@flagsmith.com" }]

{flagsmith_sql_flag_engine-0.1.0 → flagsmith_sql_flag_engine-0.1.2}/src/flagsmith_sql_flag_engine/translator.py

@@ -435,19 +435,13 @@ def translate_condition(cond: SegmentCondition, ctx: TranslateContext) -> str |
         identity: dict[str, object] = ctx.evaluation_context.get("identity") or {}  # type: ignore[assignment]
         kind = classification.kind
         if not prop:
-            # Implicit `$.identity.key` — engine returns False when no
-            # identity, or when the identity lacks `key`. The engine
-            # never synthesises one from env+identifier.
-            if not identity.get("key"):
-                return "FALSE"
+            # In traditional engine implementations, this branch implies
+            # an identity-less context, which makes no sense for the SQL engine.
+            # Assume identity key.
             value_expr = ctx.dialect.cast_string(ctx.identity_key_expr)
         elif kind == "key":
-            if not identity.get("key"):
-                return "FALSE"
             value_expr = ctx.dialect.cast_string(ctx.jsonpath_expr("$.identity.key"))
         elif kind == "identifier":
-            if not identity.get("identifier"):
-                return "FALSE"
             value_expr = ctx.dialect.cast_string(ctx.jsonpath_expr("$.identity.identifier"))
         elif kind == "identity_object":
             # PERCENTAGE_SPLIT on `$.identity` — the whole dict. Engine
@@ -517,26 +511,33 @@ def translate_condition(cond: SegmentCondition, ctx: TranslateContext) -> str |
 
 
 def translate_rule(rule: SegmentRule, ctx: TranslateContext) -> str | None:
-    children: list[str] = []
+    cond_children: list[str] = []
     for cond in rule.get("conditions") or []:
         sql = translate_condition(cond, ctx)
         if sql is None:
             return None
-        children.append(f"({sql})")
+        cond_children.append(f"({sql})")
+    rule_children: list[str] = []
     for nested in rule.get("rules") or []:
         sql = translate_rule(nested, ctx)
         if sql is None:
             return None
-        children.append(f"({sql})")
-
-    assert children, "segment rule must have at least one condition or nested rule"
-    match rule["type"]:
-        case "ALL":
-            return " AND ".join(children)
-        case "ANY":
-            return " OR ".join(children)
-        case "NONE":
-            return f"NOT ({' OR '.join(children)})"
+        rule_children.append(f"({sql})")
+
+    # Mirror the engine's `context_matches_rule`: conditions and nested rules
+    # are two independent groups AND-ed together, each vacuously true when
+    # empty.
+    op = {"ALL": " AND ", "ANY": " OR ", "NONE": " OR "}[rule["type"]]
+    groups = [
+        f"NOT ({op.join(c)})" if rule["type"] == "NONE" else op.join(c)
+        for c in (cond_children, rule_children)
+        if c
+    ]
+    if not groups:
+        return "TRUE"
+    if len(groups) == 1:
+        return groups[0]
+    return " AND ".join(f"({g})" for g in groups)
 
 
 def translate_segment(segment: SegmentContext, ctx: TranslateContext) -> str | None: