Merge pull request #362 from hjotha/submit/add-expression-to-list

feat: allow expressions in add-to-list statements

Author: ako

.claude/skills/mendix/write-microflows.md

@@ -420,6 +420,18 @@ commit $Product with events refresh;
 
 **Best Practice**: Use `with events` when you want before/after commit event handlers to execute. Use `refresh` when the committed object is displayed in the client and you want the UI to update immediately.
 
+## List Operations
+
+```mdl
+-- Existing variable form
+add $Item to $Items;
+
+-- Expression-valued add, useful when round-tripping Studio Pro list-add values
+add head($SourceItems) to $Items;
+```
+
+Use expression-valued `add` only when the expression returns an object compatible with the target list element type.
+
 ## Database Operations
 
 ### RETRIEVE Statement

docs/01-project/MDL_QUICK_REFERENCE.md

@@ -224,6 +224,7 @@ authentication basic, session
 | Rollback | `rollback $entity [refresh];` | Reverts uncommitted changes |
 | Retrieve (DB) | `retrieve $Var from Module.Entity [where condition];` | Database XPath retrieve |
 | Retrieve (Assoc) | `retrieve $list from $Parent/Module.AssocName;` | Retrieve by association |
+| Add to list | `add expression to $list;` | Also accepts existing `add $item to $list;` form |
 | Call microflow | `$Result = call microflow Module.Name (Param = $value);` | |
 | Call nanoflow | `$Result = call nanoflow Module.Name (Param = $value);` | |
 | Call JS action | `$Result = call javascript action Module.Name (Param = $value);` | JavaScript action (nanoflow/microflow) |

docs/11-proposals/PROPOSAL_microflow_add_expression_to_list.md

@@ -0,0 +1,33 @@
+# Proposal: Microflow ADD Expression To List
+
+Status: Draft
+
+## Summary
+
+Allow `add` microflow statements to use any expression as the value being added to a list:
+
+```mdl
+add if $UseFirst then $FirstItem else $SecondItem to $TargetList;
+```
+
+The existing variable-only form remains valid:
+
+```mdl
+add $Item to $TargetList;
+```
+
+## Motivation
+
+Studio Pro stores the value of a list-add action as an expression string. Existing models can therefore contain a list-add value that is not a bare variable. MDL previously parsed only `add $Item to $List`, so describe/exec round-trips could not preserve expression-valued list additions.
+
+## Semantics
+
+The parser stores the add value as an expression. For compatibility, a bare variable expression also populates the legacy `Item` field in the AST. The builder writes the expression source to the Mendix `ChangeListAction.Value` field and falls back to the legacy item variable only when no expression is present.
+
+## Tests And Examples
+
+`mdl-examples/doctype-tests/add_expression_to_list.mdl` demonstrates adding an object-valued conditional expression to another list. Go regression tests cover parser behavior and builder output for both expression and simple-variable forms.
+
+## Open Questions
+
+- Should validation infer the list element type and reject expressions that cannot produce an object compatible with the target list?

docs/11-proposals/README.md

@@ -53,6 +53,7 @@ BSON schema Registry ◄──── multi-version Support
 | [XPath Gaps](xpath-gaps-proposal.md) | Partial | XPath constraint support gap analysis. ~85% complete, association paths and nested predicates remain | — |
 | [Microflow ENUM SPLIT Statement](PROPOSAL_microflow_enum_split_statement.md) | Implemented | Enumeration decision splits via `case $Var when Value then … end case;` | — |
 | [Microflow CHANGE Refresh Modifier](PROPOSAL_microflow_change_refresh_modifier.md) | Draft | Preserve `RefreshInClient` on change-object actions | — |
+| [Microflow ADD Expression To List](PROPOSAL_microflow_add_expression_to_list.md) | Draft | Preserve expression-valued list-add actions in microflow round-trips | — |
 | [LLM MDL Assistance](PROPOSAL_llm_mdl_assistance.md) | Proposed | Enhanced error messages with examples, reorganized skills by use case | — |
 
 ### Testing & Evaluation

mdl-examples/doctype-tests/add_expression_to_list.mdl

@@ -0,0 +1,19 @@
+create module AddListExample;
+
+create persistent entity AddListExample.Item (
+  Name: string
+);
+/
+
+create microflow AddListExample.AddChosenItem (
+  $UseFirst: Boolean
+)
+returns list of AddListExample.Item as $Items
+begin
+  $First = create AddListExample.Item (Name = 'first');
+  $Second = create AddListExample.Item (Name = 'second');
+  $Items = create list of AddListExample.Item;
+  add if $UseFirst then $First else $Second to $Items;
+  return $Items;
+end;
+/

mdl/ast/ast_microflow.go

@@ -583,9 +583,10 @@ type CreateListStmt struct {
 
 func (s *CreateListStmt) isMicroflowStatement() {}
 
-// AddToListStmt represents: ADD $Item TO $List
+// AddToListStmt represents: ADD expr TO $List
 type AddToListStmt struct {
-	Item        string               // Item variable to add
+	Item        string               // Item variable to add, kept for simple $Var compatibility
+	Value       Expression           // Item expression to add
 	List        string               // Target list variable
 	Annotations *ActivityAnnotations // Optional @position, @caption, @color, @annotation
 }

mdl/executor/cmd_microflows_builder_actions.go

@@ -1080,11 +1080,15 @@ func (fb *flowBuilder) addCreateListAction(s *ast.CreateListStmt) model.ID {
 
 // addAddToListAction creates an ADD TO list statement.
 func (fb *flowBuilder) addAddToListAction(s *ast.AddToListStmt) model.ID {
+	value := fb.exprToString(s.Value)
+	if value == "" && s.Item != "" {
+		value = "$" + s.Item
+	}
 	action := &microflows.ChangeListAction{
 		BaseElement:    model.BaseElement{ID: model.ID(types.GenerateID())},
 		Type:           microflows.ChangeListTypeAdd,
 		ChangeVariable: s.List,
-		Value:          "$" + s.Item,
+		Value:          value,
 	}
 
 	activity := &microflows.ActionActivity{

mdl/executor/cmd_microflows_builder_add_to_list_test.go

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package executor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+	"github.com/mendixlabs/mxcli/sdk/microflows"
+)
+
+func TestAddToListBuilderUsesExpressionValue(t *testing.T) {
+	fb := &flowBuilder{}
+
+	fb.addAddToListAction(&ast.AddToListStmt{
+		Value: &ast.AttributePathExpr{
+			Variable: "Order",
+			Path:     []string{"Number"},
+		},
+		List: "Numbers",
+	})
+
+	action := lastChangeListAction(t, fb)
+	if action.Value != "$Order/Number" {
+		t.Fatalf("Value = %q, want $Order/Number", action.Value)
+	}
+}
+
+func TestAddToListBuilderKeepsSimpleVariableFallback(t *testing.T) {
+	fb := &flowBuilder{}
+
+	fb.addAddToListAction(&ast.AddToListStmt{
+		Item: "Order",
+		List: "Orders",
+	})
+
+	action := lastChangeListAction(t, fb)
+	if action.Value != "$Order" {
+		t.Fatalf("Value = %q, want $Order", action.Value)
+	}
+}
+
+func TestCollectObjectInputVariablesSeesAddExpressionValue(t *testing.T) {
+	inputs := collectObjectInputVariables([]ast.MicroflowStatement{
+		&ast.AddToListStmt{
+			Value: &ast.FunctionCallExpr{
+				Name: "head",
+				Arguments: []ast.Expression{
+					&ast.VariableExpr{Name: "SourceItems"},
+				},
+			},
+			List: "Items",
+		},
+	})
+
+	if !inputs["SourceItems"] {
+		t.Fatalf("SourceItems was not collected from add expression: %#v", inputs)
+	}
+}
+
+func TestErrorHandlerStatementVarRefsSeesAddExpressionValue(t *testing.T) {
+	stmt := &ast.AddToListStmt{
+		Value: &ast.FunctionCallExpr{
+			Name: "head",
+			Arguments: []ast.Expression{
+				&ast.VariableExpr{Name: "SourceItems"},
+			},
+		},
+		List: "Items",
+	}
+
+	refs := errorHandlerStatementVarRefs(stmt)
+
+	seenSource := false
+	seenList := false
+	for _, r := range refs {
+		if r == "SourceItems" {
+			seenSource = true
+		}
+		if r == "Items" {
+			seenList = true
+		}
+	}
+	if !seenSource {
+		t.Errorf("expected $SourceItems to be tracked from add expression: %v", refs)
+	}
+	if !seenList {
+		t.Errorf("expected $Items (list) to be tracked: %v", refs)
+	}
+}
+
+func lastChangeListAction(t *testing.T, fb *flowBuilder) *microflows.ChangeListAction {
+	t.Helper()
+
+	if len(fb.objects) == 0 {
+		t.Fatal("Expected builder to create an action activity")
+	}
+	activity, ok := fb.objects[len(fb.objects)-1].(*microflows.ActionActivity)
+	if !ok {
+		t.Fatalf("Last object = %T, want ActionActivity", fb.objects[len(fb.objects)-1])
+	}
+	action, ok := activity.Action.(*microflows.ChangeListAction)
+	if !ok {
+		t.Fatalf("Action = %T, want ChangeListAction", activity.Action)
+	}
+	return action
+}

mdl/executor/cmd_microflows_builder_flows.go

@@ -607,7 +607,12 @@ func errorHandlerStatementVarRefs(stmt ast.MicroflowStatement) []string {
 			refs = append(refs, exprVarRefs(arg)...)
 		}
 	case *ast.AddToListStmt:
-		refs = append(refs, s.Item, s.List)
+		if s.Value != nil {
+			refs = append(refs, exprVarRefs(s.Value)...)
+		} else if s.Item != "" {
+			refs = append(refs, s.Item)
+		}
+		refs = append(refs, s.List)
 	case *ast.RemoveFromListStmt:
 		refs = append(refs, s.Item, s.List)
 	}

mdl/executor/cmd_microflows_builder_graph.go

@@ -330,7 +330,11 @@ func collectObjectInputVariables(stmts []ast.MicroflowStatement) map[string]bool
 			case *ast.AggregateListStmt:
 				walkExpr(s.Expression)
 			case *ast.AddToListStmt:
-				if s.Item != "" {
+				if s.Value != nil {
+					for _, ref := range exprVarRefs(s.Value) {
+						inputs[ref] = true
+					}
+				} else if s.Item != "" {
 					inputs[s.Item] = true
 				}
 			case *ast.CallMicroflowStmt: