fix: emit boolean case values for IF flows

Symptom: MPR validation can report duplicate output variables for values declared in mutually exclusive IF branches after exec builds the graph. A follow-up targeted audit also showed CE0079/CE0773 when the new BooleanCase values reached the writer.

Root cause: IF sequence flows used EnumerationCase values with the strings "true" and "false". Switching the builder to BooleanCase exposed a second gap: the BSON parser/writer did not handle Microflows$BooleanCase and the writer silently fell back to NoCase.

Fix: emit BooleanCase for true/false flow cases, keep EnumerationCase for real enum branch values, and teach the MPR parser/writer to roundtrip BooleanCase instead of degrading it to NoCase.

Tests: make build, make test, make lint-go.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_enum_split_test.go

@@ -111,7 +111,7 @@ func TestEnumSplitNestedEmptyThenBranchKeepsContinuationCase(t *testing.T) {
 		if flow.OriginID != nestedSplitID {
 			continue
 		}
-		if value, ok := enumCaseValue(flow); ok && value == "true" {
+		if flowCaseString(flow.CaseValue) == "true" {
 			if _, ok := objects[flow.DestinationID].(*microflows.ExclusiveMerge); ok {
 				return
 			}

mdl/executor/cmd_microflows_builder_flows.go

@@ -653,10 +653,7 @@ func newHorizontalFlow(originID, destinationID model.ID) *microflows.SequenceFlo
 // newHorizontalFlowWithCase creates a horizontal SequenceFlow with a boolean case value (for splits)
 func newHorizontalFlowWithCase(originID, destinationID model.ID, caseValue string) *microflows.SequenceFlow {
 	flow := newHorizontalFlow(originID, destinationID)
-	flow.CaseValue = microflows.EnumerationCase{
-		BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
-		Value:       caseValue, // "true" or "false" as string
-	}
+	flow.CaseValue = caseValueForFlow(caseValue)
 	return flow
 }
 
@@ -678,10 +675,27 @@ func newDownwardFlowWithCase(originID, destinationID model.ID, caseValue string)
 		DestinationID:              destinationID,
 		OriginConnectionIndex:      AnchorBottom, // Connect from bottom of origin (going down)
 		DestinationConnectionIndex: AnchorLeft,   // Connect to left side of destination
-		CaseValue: microflows.EnumerationCase{
+		CaseValue:                  caseValueForFlow(caseValue),
+	}
+}
+
+func caseValueForFlow(caseValue string) microflows.CaseValue {
+	switch caseValue {
+	case "true":
+		return microflows.BooleanCase{
 			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
-			Value:       caseValue, // "true" or "false" as string
-		},
+			Value:       true,
+		}
+	case "false":
+		return microflows.BooleanCase{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Value:       false,
+		}
+	default:
+		return microflows.EnumerationCase{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Value:       caseValue,
+		}
 	}
 }
 

mdl/executor/cmd_microflows_guard_pattern_test.go

@@ -47,17 +47,11 @@ func TestBuilder_GuardPatternPreservesFalseBranchAnchor(t *testing.T) {
 	oc := fb.buildFlowGraph(body, nil)
 
 	// Find the flow from the split to the tail log. It's the only one with
-	// an EnumerationCase Value=="false" that doesn't target an EndEvent.
+	// a BooleanCase Value==false that doesn't target an EndEvent.
 	var found *microflows.SequenceFlow
 	for _, f := range oc.Flows {
-		cv, ok := f.CaseValue.(microflows.EnumerationCase)
-		if !ok {
-			if p, okp := f.CaseValue.(*microflows.EnumerationCase); okp {
-				cv = *p
-				ok = true
-			}
-		}
-		if !ok || cv.Value != "false" {
+		cv, ok := f.CaseValue.(microflows.BooleanCase)
+		if !ok || cv.Value {
 			continue
 		}
 		// Exclude flows pointing at an EndEvent.
@@ -85,3 +79,31 @@ func TestBuilder_GuardPatternPreservesFalseBranchAnchor(t *testing.T) {
 		t.Errorf("destination: got %d, want %d (Top)", found.DestinationConnectionIndex, AnchorTop)
 	}
 }
+
+func TestCaseValueForFlowUsesBooleanCaseForBooleanBranches(t *testing.T) {
+	for _, tc := range []struct {
+		value string
+		want  bool
+	}{
+		{value: "true", want: true},
+		{value: "false", want: false},
+	} {
+		got, ok := caseValueForFlow(tc.value).(microflows.BooleanCase)
+		if !ok {
+			t.Fatalf("caseValueForFlow(%q) = %T, want BooleanCase", tc.value, caseValueForFlow(tc.value))
+		}
+		if got.Value != tc.want {
+			t.Fatalf("caseValueForFlow(%q).Value = %v, want %v", tc.value, got.Value, tc.want)
+		}
+	}
+}
+
+func TestCaseValueForFlowKeepsEnumValuesAsEnumerationCase(t *testing.T) {
+	got, ok := caseValueForFlow("Submitted").(microflows.EnumerationCase)
+	if !ok {
+		t.Fatalf("caseValueForFlow(enum) = %T, want EnumerationCase", caseValueForFlow("Submitted"))
+	}
+	if got.Value != "Submitted" {
+		t.Fatalf("enum case value = %q, want Submitted", got.Value)
+	}
+}

sdk/mpr/parser_microflow.go

@@ -223,6 +223,13 @@ func parseCaseValue(raw any) microflows.CaseValue {
 				Value:       val,
 			}
 		}
+	case "Microflows$BooleanCase":
+		if val, ok := caseMap["Value"].(bool); ok {
+			return &microflows.BooleanCase{
+				BaseElement: model.BaseElement{ID: id},
+				Value:       val,
+			}
+		}
 	}
 	return nil
 }

sdk/mpr/parser_microflow_test.go

@@ -35,6 +35,27 @@ func TestParseSequenceFlow_NewCaseValueEnumerationCase(t *testing.T) {
 	}
 }
 
+func TestParseSequenceFlow_NewCaseValueBooleanCase(t *testing.T) {
+	flow := parseSequenceFlow(map[string]any{
+		"$ID":                "flow-1",
+		"OriginPointer":      "start-1",
+		"DestinationPointer": "dest-1",
+		"NewCaseValue": primitive.D{
+			{Key: "$ID", Value: "case-1"},
+			{Key: "$Type", Value: "Microflows$BooleanCase"},
+			{Key: "Value", Value: false},
+		},
+	})
+
+	got, ok := flow.CaseValue.(*microflows.BooleanCase)
+	if !ok {
+		t.Fatalf("expected *BooleanCase, got %T", flow.CaseValue)
+	}
+	if got.Value {
+		t.Fatal("expected false branch")
+	}
+}
+
 func TestParseSequenceFlow_NewCaseValueNoCase(t *testing.T) {
 	flow := parseSequenceFlow(map[string]any{
 		"$ID":                "flow-1",

sdk/mpr/writer_microflow.go

@@ -228,6 +228,8 @@ func buildSequenceFlowCase(cv microflows.CaseValue) bson.D {
 		cv = &c
 	case microflows.NoCase:
 		cv = &c
+	case microflows.BooleanCase:
+		cv = &c
 	}
 
 	switch c := cv.(type) {
@@ -250,6 +252,16 @@ func buildSequenceFlowCase(cv microflows.CaseValue) bson.D {
 			{Key: "$ID", Value: idToBsonBinary(id)},
 			{Key: "$Type", Value: "Microflows$NoCase"},
 		}
+	case *microflows.BooleanCase:
+		id := string(c.ID)
+		if id == "" {
+			id = generateUUID()
+		}
+		return bson.D{
+			{Key: "$ID", Value: idToBsonBinary(id)},
+			{Key: "$Type", Value: "Microflows$BooleanCase"},
+			{Key: "Value", Value: c.Value},
+		}
 	}
 	// Default: synthesise a NoCase document with a fresh ID.
 	return bson.D{

sdk/mpr/writer_microflow_version_test.go

@@ -168,3 +168,17 @@ func TestBuildSequenceFlowCase_NormalisesValueReceiver(t *testing.T) {
 		t.Error("value and pointer NoCase must produce identical $Type")
 	}
 }
+
+func TestBuildSequenceFlowCase_BooleanCase(t *testing.T) {
+	doc := buildSequenceFlowCase(microflows.BooleanCase{
+		BaseElement: model.BaseElement{ID: "case-false"},
+		Value:       false,
+	})
+
+	if got := bsonGetKey(doc, "$Type"); got != "Microflows$BooleanCase" {
+		t.Fatalf("$Type = %v, want Microflows$BooleanCase", got)
+	}
+	if got := bsonGetKey(doc, "Value"); got != false {
+		t.Fatalf("Value = %v, want false", got)
+	}
+}