fix: preserve Java action microflow placeholder parameters

Symptom: Java actions with microflow-typed parameters roundtripped placeholder arguments as basic empty expressions, which Studio Pro reported as stale Java action arguments.

Root cause: the SDK/parser/writer did not model Microflows$MicroflowParameterValue, and the builder treated all ellipsis placeholders as BasicCodeActionParameterValue.

Fix: add MicroflowParameterValue support end-to-end and emit it for Java action parameters whose definition is MicroflowType, keeping ellipsis as an empty microflow reference.

Tests: added builder and parser regressions and ran make test.

Author: hjothamendix

mdl/executor/cmd_microflows_builder.go

@@ -53,7 +53,7 @@ type flowBuilder struct {
 	microflowsCacheLoaded bool
 	nanoflowsCache        []*microflows.Nanoflow
 	nanoflowsCacheLoaded  bool
-	manualLoopBackTarget model.ID
+	manualLoopBackTarget  model.ID
 }
 
 // addError records a validation error during flow building.

mdl/executor/cmd_microflows_builder_calls.go

@@ -244,10 +244,13 @@ func (fb *flowBuilder) addCallJavaActionAction(s *ast.CallJavaActionStmt) model.
 
 	// Build a map of parameter name -> param type for the Java action
 	entityTypeParams := make(map[string]bool)
+	microflowTypeParams := make(map[string]bool)
 	if jaDef != nil {
 		for _, p := range jaDef.Parameters {
 			if _, ok := p.ParameterType.(*javaactions.EntityTypeParameterType); ok {
 				entityTypeParams[p.Name] = true
+			} else if _, ok := p.ParameterType.(*javaactions.MicroflowType); ok {
+				microflowTypeParams[p.Name] = true
 			}
 		}
 	}
@@ -277,16 +280,30 @@ func (fb *flowBuilder) addCallJavaActionAction(s *ast.CallJavaActionStmt) model.
 				Entity:      entityName,
 			}
 		} else if isPlaceholderExpression(arg.Value) {
-			value = &microflows.BasicCodeActionParameterValue{
-				BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
-				Argument:    "",
+			if microflowTypeParams[arg.Name] {
+				value = &microflows.MicroflowParameterValue{
+					BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+					Microflow:   "",
+				}
+			} else {
+				value = &microflows.BasicCodeActionParameterValue{
+					BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+					Argument:    "",
+				}
 			}
 		} else {
 			// Regular parameter: expression-based value
 			valueExpr := fb.exprToString(arg.Value)
-			value = &microflows.BasicCodeActionParameterValue{
-				BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
-				Argument:    valueExpr,
+			if microflowTypeParams[arg.Name] {
+				value = &microflows.MicroflowParameterValue{
+					BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+					Microflow:   strings.Trim(valueExpr, "'"),
+				}
+			} else {
+				value = &microflows.BasicCodeActionParameterValue{
+					BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+					Argument:    valueExpr,
+				}
 			}
 		}
 

mdl/executor/cmd_microflows_builder_java_action_test.go

@@ -6,6 +6,9 @@ import (
 	"testing"
 
 	"github.com/mendixlabs/mxcli/mdl/ast"
+	"github.com/mendixlabs/mxcli/mdl/backend/mock"
+	"github.com/mendixlabs/mxcli/model"
+	"github.com/mendixlabs/mxcli/sdk/javaactions"
 	"github.com/mendixlabs/mxcli/sdk/microflows"
 )
 
@@ -57,3 +60,57 @@ func TestBuildJavaAction_PlaceholderArgumentPreservesEmptyBasicValue(t *testing.
 		t.Fatalf("boolean argument = %q, want true", value.Argument)
 	}
 }
+
+func TestBuildJavaAction_PlaceholderMicroflowArgumentUsesMicroflowParameterValue(t *testing.T) {
+	fb := &flowBuilder{
+		posX:    100,
+		posY:    100,
+		spacing: HorizontalSpacing,
+		backend: &mock.MockBackend{
+			ReadJavaActionByNameFunc: func(qualifiedName string) (*javaactions.JavaAction, error) {
+				if qualifiedName != "SampleModule.StartAsync" {
+					t.Fatalf("java action lookup = %q", qualifiedName)
+				}
+				return &javaactions.JavaAction{
+					Parameters: []*javaactions.JavaActionParameter{
+						{
+							Name: "Callback",
+							ParameterType: &javaactions.MicroflowType{
+								BaseElement: model.BaseElement{ID: "param-type"},
+							},
+						},
+					},
+				}, nil
+			},
+		},
+	}
+	stmt := &ast.CallJavaActionStmt{
+		ActionName: ast.QualifiedName{Module: "SampleModule", Name: "StartAsync"},
+		Arguments: []ast.CallArgument{
+			{Name: "Callback", Value: &ast.SourceExpr{Source: "..."}},
+		},
+	}
+
+	id := fb.addCallJavaActionAction(stmt)
+	var activity *microflows.ActionActivity
+	for _, obj := range fb.objects {
+		if obj.GetID() == id {
+			activity, _ = obj.(*microflows.ActionActivity)
+			break
+		}
+	}
+	if activity == nil {
+		t.Fatal("expected Java action activity")
+	}
+	action, ok := activity.Action.(*microflows.JavaActionCallAction)
+	if !ok {
+		t.Fatalf("action = %T, want *JavaActionCallAction", activity.Action)
+	}
+	value, ok := action.ParameterMappings[0].Value.(*microflows.MicroflowParameterValue)
+	if !ok {
+		t.Fatalf("mapping value = %T, want *MicroflowParameterValue", action.ParameterMappings[0].Value)
+	}
+	if value.Microflow != "" {
+		t.Fatalf("placeholder microflow = %q, want empty string", value.Microflow)
+	}
+}

mdl/executor/cmd_microflows_format_action.go

@@ -351,30 +351,30 @@ func formatAction(
 
 			stmt := fmt.Sprintf("retrieve $%s from %s", outputVar, entityName)
 
-		if dbSource.XPathConstraint != "" {
-			constraint := strings.TrimSpace(dbSource.XPathConstraint)
-			// XPath may contain multiple predicates like [a][b] or [a]\n[b].
-			// Split them and join with MDL 'and' so the parser sees
-			// separate xpathConstraint nodes.
-			if strings.HasPrefix(constraint, "[") && strings.HasSuffix(constraint, "]") {
-				// Split on "][" boundary (possibly separated by \n literals),
-				// then re-wrap each predicate.
-				inner := constraint[1 : len(constraint)-1]
-				// Normalise real newlines between predicates: ]\n[ → ][
-				inner = strings.ReplaceAll(inner, "]\n[", "][")
-				parts := strings.Split(inner, "][")
-				if len(parts) > 1 {
-					var wrapped []string
-					for _, p := range parts {
-						wrapped = append(wrapped, "["+strings.TrimSpace(p)+"]")
+			if dbSource.XPathConstraint != "" {
+				constraint := strings.TrimSpace(dbSource.XPathConstraint)
+				// XPath may contain multiple predicates like [a][b] or [a]\n[b].
+				// Split them and join with MDL 'and' so the parser sees
+				// separate xpathConstraint nodes.
+				if strings.HasPrefix(constraint, "[") && strings.HasSuffix(constraint, "]") {
+					// Split on "][" boundary (possibly separated by \n literals),
+					// then re-wrap each predicate.
+					inner := constraint[1 : len(constraint)-1]
+					// Normalise real newlines between predicates: ]\n[ → ][
+					inner = strings.ReplaceAll(inner, "]\n[", "][")
+					parts := strings.Split(inner, "][")
+					if len(parts) > 1 {
+						var wrapped []string
+						for _, p := range parts {
+							wrapped = append(wrapped, "["+strings.TrimSpace(p)+"]")
+						}
+						constraint = strings.Join(wrapped, "\n    ")
+					} else {
+						constraint = parts[0]
 					}
-					constraint = strings.Join(wrapped, "\n    ")
-				} else {
-					constraint = parts[0]
 				}
+				stmt += fmt.Sprintf("\n    where %s", constraint)
 			}
-			stmt += fmt.Sprintf("\n    where %s", constraint)
-		}
 
 			// Output SORT BY clause if present
 			if len(dbSource.Sorting) > 0 {
@@ -541,6 +541,10 @@ func formatAction(
 				valueStr = v.Expression
 			case *microflows.BasicCodeActionParameterValue:
 				valueStr = v.Argument
+			case *microflows.MicroflowParameterValue:
+				if v.Microflow != "" {
+					valueStr = mdlQuote(v.Microflow)
+				}
 			case *microflows.EntityTypeCodeActionParameterValue:
 				if v.Entity != "" {
 					valueStr = mdlQuote(v.Entity)

sdk/microflows/microflows_actions.go

@@ -616,6 +616,15 @@ type BasicCodeActionParameterValue struct {
 
 func (BasicCodeActionParameterValue) isCodeActionParameterValue() {}
 
+// MicroflowParameterValue is a microflow reference passed to a Java action
+// microflow parameter. An empty Microflow keeps Studio Pro's placeholder value.
+type MicroflowParameterValue struct {
+	model.BaseElement
+	Microflow string `json:"microflow,omitempty"` // BY_NAME_REFERENCE: qualified microflow name
+}
+
+func (MicroflowParameterValue) isCodeActionParameterValue() {}
+
 // EntityTypeCodeActionParameterValue is an entity type passed at a call site for a type parameter.
 type EntityTypeCodeActionParameterValue struct {
 	model.BaseElement

sdk/mpr/parser_javaactions.go

@@ -402,7 +402,7 @@ func parseCodeActionParameterType(raw map[string]any) javaactions.CodeActionPara
 		}
 		et.Enumeration = extractString(raw["Enumeration"])
 		return et
-	case "CodeActions$MicroflowType":
+	case "CodeActions$MicroflowType", "JavaActions$MicroflowJavaActionParameterType":
 		return &javaactions.MicroflowType{
 			BaseElement: model.BaseElement{ID: model.ID(extractBsonID(raw["$ID"]))},
 		}
@@ -461,6 +461,10 @@ func parseInnerParameterType(raw map[string]any) javaactions.CodeActionParameter
 		return &javaactions.DateTimeType{
 			BaseElement: model.BaseElement{ID: model.ID(extractBsonID(raw["$ID"]))},
 		}
+	case "CodeActions$MicroflowType", "JavaActions$MicroflowJavaActionParameterType":
+		return &javaactions.MicroflowType{
+			BaseElement: model.BaseElement{ID: model.ID(extractBsonID(raw["$ID"]))},
+		}
 	case "CodeActions$ConcreteEntityType", "CodeActions$EntityType":
 		et := &javaactions.EntityType{
 			BaseElement: model.BaseElement{ID: model.ID(extractBsonID(raw["$ID"]))},

sdk/mpr/parser_javaactions_test.go

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package mpr
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/sdk/javaactions"
+)
+
+func TestParseCodeActionParameterType_JavaActionMicroflowParameter(t *testing.T) {
+	value := parseCodeActionParameterType(map[string]any{
+		"$ID":   "type-1",
+		"$Type": "JavaActions$MicroflowJavaActionParameterType",
+	})
+
+	if _, ok := value.(*javaactions.MicroflowType); !ok {
+		t.Fatalf("value = %T, want *MicroflowType", value)
+	}
+}

sdk/mpr/parser_microflow_actions.go

@@ -175,6 +175,11 @@ func parseCodeActionParameterValue(raw map[string]any) microflows.CodeActionPara
 		value.ID = model.ID(extractBsonID(raw["$ID"]))
 		value.Argument = extractString(raw["Argument"])
 		return value
+	case "Microflows$MicroflowParameterValue":
+		value := &microflows.MicroflowParameterValue{}
+		value.ID = model.ID(extractBsonID(raw["$ID"]))
+		value.Microflow = extractString(raw["Microflow"])
+		return value
 	case "Microflows$EntityTypeCodeActionParameterValue":
 		value := &microflows.EntityTypeCodeActionParameterValue{}
 		value.ID = model.ID(extractBsonID(raw["$ID"]))

sdk/mpr/parser_microflow_test.go

@@ -81,3 +81,19 @@ func TestParseCommitAction_ErrorHandlingTypeDefaultsToRollback(t *testing.T) {
 		t.Errorf("expected default Rollback, got %q", action.ErrorHandlingType)
 	}
 }
+
+func TestParseCodeActionParameterValue_MicroflowParameterValue(t *testing.T) {
+	value := parseCodeActionParameterValue(map[string]any{
+		"$ID":       "value-1",
+		"$Type":     "Microflows$MicroflowParameterValue",
+		"Microflow": "SyntheticModule.Callback",
+	})
+
+	got, ok := value.(*microflows.MicroflowParameterValue)
+	if !ok {
+		t.Fatalf("value = %T, want *MicroflowParameterValue", value)
+	}
+	if got.Microflow != "SyntheticModule.Callback" {
+		t.Fatalf("microflow = %q", got.Microflow)
+	}
+}

sdk/mpr/writer_microflow_actions.go

@@ -1181,6 +1181,12 @@ func serializeCodeActionParameterValue(v microflows.CodeActionParameterValue) bs
 			{Key: "$Type", Value: "Microflows$BasicCodeActionParameterValue"},
 			{Key: "Argument", Value: value.Argument},
 		}
+	case *microflows.MicroflowParameterValue:
+		return bson.D{
+			{Key: "$ID", Value: idToBsonBinary(string(value.ID))},
+			{Key: "$Type", Value: "Microflows$MicroflowParameterValue"},
+			{Key: "Microflow", Value: value.Microflow},
+		}
 	case *microflows.EntityTypeCodeActionParameterValue:
 		return bson.D{
 			{Key: "$ID", Value: idToBsonBinary(string(value.ID))},