Fix XPath token quoting for [%CurrentDateTime%] (GitHub issue #1)

Mendix tokens like [%CurrentDateTime%] must be single-quoted in XPath
constraints but not in Mendix expressions. Added expressionToXPath()
that quotes TokenExpr nodes for XPath context, with unit and mx check
integration tests.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ako

mdl-examples/doctype-tests/02-microflow-examples.mdl

@@ -880,6 +880,21 @@ BEGIN
 END;
 /
 
+/**
+ * Example 7.5: RETRIEVE with [%CurrentDateTime%] token in WHERE
+ *
+ * XPath tokens like [%CurrentDateTime%] must be quoted in XPath constraints.
+ * Tests fix for GitHub issue #1.
+ */
+CREATE MICROFLOW MfTest.M028_RetrieveWithDateTimeToken ()
+RETURNS List of MfTest.Order AS $OverdueOrders
+BEGIN
+  RETRIEVE $OverdueOrders FROM MfTest.Order
+    WHERE ShipDate < [%CurrentDateTime%];
+  RETURN $OverdueOrders;
+END;
+/
+
 -- MARK: Real World
 
 -- ============================================================================

mdl/executor/bugfix_test.go

@@ -337,6 +337,59 @@ func TestEnumDefaultNotDoubleQualified(t *testing.T) {
 	}
 }
 
+// TestExpressionToXPath_TokenQuoting verifies that [%CurrentDateTime%] tokens
+// are quoted in XPath context but not in Mendix expression context (GitHub issue #1).
+func TestExpressionToXPath_TokenQuoting(t *testing.T) {
+	tests := []struct {
+		name     string
+		expr     ast.Expression
+		wantExpr string // expressionToString output
+		wantXP   string // expressionToXPath output
+	}{
+		{
+			name:     "Token_CurrentDateTime",
+			expr:     &ast.TokenExpr{Token: "CurrentDateTime"},
+			wantExpr: "[%CurrentDateTime%]",
+			wantXP:   "'[%CurrentDateTime%]'",
+		},
+		{
+			name:     "Token_CurrentUser",
+			expr:     &ast.TokenExpr{Token: "CurrentUser"},
+			wantExpr: "[%CurrentUser%]",
+			wantXP:   "'[%CurrentUser%]'",
+		},
+		{
+			name: "BinaryExpr_with_token",
+			expr: &ast.BinaryExpr{
+				Left:     &ast.IdentifierExpr{Name: "DueDate"},
+				Operator: "<",
+				Right:    &ast.TokenExpr{Token: "CurrentDateTime"},
+			},
+			wantExpr: "DueDate < [%CurrentDateTime%]",
+			wantXP:   "DueDate < '[%CurrentDateTime%]'",
+		},
+		{
+			name:     "Variable_unchanged",
+			expr:     &ast.VariableExpr{Name: "MyVar"},
+			wantExpr: "$MyVar",
+			wantXP:   "$MyVar",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotExpr := expressionToString(tt.expr)
+			if gotExpr != tt.wantExpr {
+				t.Errorf("expressionToString() = %q, want %q", gotExpr, tt.wantExpr)
+			}
+			gotXP := expressionToXPath(tt.expr)
+			if gotXP != tt.wantXP {
+				t.Errorf("expressionToXPath() = %q, want %q", gotXP, tt.wantXP)
+			}
+		})
+	}
+}
+
 // validateMicroflowFromMDL parses a CREATE MICROFLOW statement and runs
 // ValidateMicroflowBody, returning any validation errors.
 func validateMicroflowFromMDL(t *testing.T, input string) []string {

mdl/executor/cmd_microflows_builder_actions.go

@@ -312,7 +312,7 @@ func (fb *flowBuilder) addRetrieveAction(s *ast.RetrieveStmt) model.ID {
 	// Convert WHERE expression if present
 	// XPath constraints are stored with square brackets in BSON: [expression]
 	if s.Where != nil {
-		source.XPathConstraint = "[" + expressionToString(s.Where) + "]"
+		source.XPathConstraint = "[" + expressionToXPath(s.Where) + "]"
 	}
 
 	// Convert SORT BY columns if present

mdl/executor/cmd_microflows_helpers.go

@@ -132,6 +132,37 @@ func expressionToString(expr ast.Expression) string {
 	}
 }
 
+// expressionToXPath converts an AST Expression to an XPath constraint string.
+// Unlike expressionToString (for Mendix expressions), XPath requires Mendix
+// tokens like [%CurrentDateTime%] to be quoted: '[%CurrentDateTime%]'.
+func expressionToXPath(expr ast.Expression) string {
+	if expr == nil {
+		return ""
+	}
+	if reflect.ValueOf(expr).IsNil() {
+		return ""
+	}
+
+	switch e := expr.(type) {
+	case *ast.TokenExpr:
+		return "'[%" + e.Token + "%]'"
+	case *ast.BinaryExpr:
+		left := expressionToXPath(e.Left)
+		right := expressionToXPath(e.Right)
+		op := strings.ToLower(e.Operator)
+		return left + " " + op + " " + right
+	case *ast.UnaryExpr:
+		operand := expressionToXPath(e.Operand)
+		op := strings.ToLower(e.Operator)
+		return op + " " + operand
+	case *ast.ParenExpr:
+		return "(" + expressionToXPath(e.Inner) + ")"
+	default:
+		// For all other expression types, the standard serialization is correct
+		return expressionToString(expr)
+	}
+}
+
 // countMicroflowActivities counts the number of meaningful activities in a microflow.
 // Excludes structural elements like StartEvent, EndEvent, and merge nodes.
 func countMicroflowActivities(mf *microflows.Microflow) int {

mdl/executor/roundtrip_mxcheck_test.go

@@ -448,6 +448,52 @@ func TestMxCheck_CE0066_Scenarios(t *testing.T) {
 	}
 }
 
+// TestMxCheck_RetrieveWithDateTimeToken validates that RETRIEVE with [%CurrentDateTime%]
+// in a WHERE clause produces correctly quoted XPath (GitHub issue #1).
+// The token must be quoted as '[%CurrentDateTime%]' in XPath constraints.
+func TestMxCheck_RetrieveWithDateTimeToken(t *testing.T) {
+	if !mxCheckAvailable() {
+		t.Skip("mx command not available")
+	}
+
+	env := setupTestEnv(t)
+	defer env.teardown()
+
+	if err := env.executeMDL(`CREATE OR MODIFY PERSISTENT ENTITY RoundtripTest.MxCheckDated (
+		Name: String(100),
+		DueDate: DateTime
+	);`); err != nil {
+		t.Fatalf("Failed to create entity: %v", err)
+	}
+
+	mfName := testModule + ".MxCheck_DateTimeToken"
+	env.registerCleanup("microflow", mfName)
+
+	createMDL := `CREATE MICROFLOW ` + mfName + ` () RETURNS Boolean
+BEGIN
+  RETRIEVE $Items FROM RoundtripTest.MxCheckDated
+    WHERE DueDate < [%CurrentDateTime%];
+  RETURN true;
+END;`
+
+	if err := env.executeMDL(createMDL); err != nil {
+		t.Fatalf("Failed to create microflow: %v", err)
+	}
+
+	env.executor.Execute(&ast.DisconnectStmt{})
+
+	output, err := runMxCheck(t, env.projectPath)
+	if err != nil {
+		if strings.Contains(output, "error") || strings.Contains(output, "Error") {
+			t.Errorf("mx check found errors:\n%s", output)
+		} else {
+			t.Logf("mx check output:\n%s", output)
+		}
+	} else {
+		t.Logf("mx check passed:\n%s", output)
+	}
+}
+
 // TestMxCheck_MicroflowWithCallParams tests microflow with CALL unified param syntax.
 func TestMxCheck_MicroflowWithCallParams(t *testing.T) {
 	if !mxCheckAvailable() {