Merge pull request #356 from hjotha/submit/retrieve-reverse-association-compact-form

fix: preserve compact reverse-association retrieves

Author: ako

mdl-examples/bug-tests/352-retrieve-compact-reverse-association.mdl

@@ -0,0 +1,56 @@
+-- ============================================================================
+-- Bug #352 (part): Compact reverse-association retrieve formatter
+-- ============================================================================
+--
+-- Symptom (before fix):
+--   Some Mendix models store a compact association retrieve as a
+--   `DatabaseRetrieveSource` with a single XPath predicate of the form
+--     [Module.Association = $Variable]
+--   and `Range = All`. When described, the formatter emitted the verbose
+--   shape
+--     retrieve $Domains from Module.Domain
+--       where Module.Domain_Runtime = $Runtime;
+--   On `mxcli exec`, that verbose shape is rebuilt as XPath. Studio Pro
+--   then accepts it but `describe → exec → describe` is no longer a
+--   fixpoint, and tooling that expects the compact form sees drift.
+--
+-- After fix:
+--   When the source is a database retrieve over a single equality
+--   predicate against a known association whose other side matches the
+--   start variable's type, and `Range = All`, the formatter emits the
+--   compact form `retrieve $Out from $Var/Module.Association`.
+--
+-- Usage:
+--   mxcli exec mdl-examples/bug-tests/352-retrieve-compact-reverse-association.mdl -p app.mpr
+--   mxcli -p app.mpr -c "describe microflow BugTest352a.MF_FetchDomains"
+--   The describe output must use the compact `from $Runtime/Mod.Assoc`
+--   form, and `mx check` must report 0 errors.
+-- ============================================================================
+
+create module BugTest352a;
+
+create entity BugTest352a.Runtime (
+  Name : string(100)
+);
+/
+
+create entity BugTest352a.Domain (
+  Name : string(100)
+);
+/
+
+create association BugTest352a.Domain_Runtime
+  from BugTest352a.Domain
+  to BugTest352a.Runtime;
+/
+
+-- Compact reverse-association retrieve. Describe → exec → describe must
+-- preserve the `from $Runtime/BugTest352a.Domain_Runtime` shape.
+create microflow BugTest352a.MF_FetchDomains (
+  $Runtime: BugTest352a.Runtime
+)
+returns list of BugTest352a.Domain as $Domains
+begin
+  retrieve $Domains from $Runtime/BugTest352a.Domain_Runtime;
+end;
+/

mdl/executor/cmd_microflows_builder_actions.go

@@ -303,6 +303,8 @@ func (fb *flowBuilder) addRetrieveAction(s *ast.RetrieveStmt) model.ID {
 		}
 
 		if assocInfo != nil && assocInfo.Type == domainmodel.AssociationTypeReference &&
+			assocInfo.Owner != domainmodel.AssociationOwnerBoth &&
+			assocInfo.parentPersistable &&
 			assocInfo.childEntityQN != "" && startVarType == assocInfo.childEntityQN {
 			// Reverse traversal on Reference: child → parent (one-to-many)
 			// Use DatabaseRetrieveSource with XPath to get a list of parent entities
@@ -330,6 +332,18 @@ func (fb *flowBuilder) addRetrieveAction(s *ast.RetrieveStmt) model.ID {
 						otherEntity = assocInfo.parentEntityQN
 					}
 					fb.varTypes[s.Variable] = otherEntity
+				} else if assocInfo != nil && assocInfo.Type == domainmodel.AssociationTypeReferenceSet {
+					// ReferenceSet traversal returns a list of the entity on the other side,
+					// not a list typed as the association itself.
+					otherEntity := assocInfo.childEntityQN
+					if startVarType == assocInfo.childEntityQN {
+						otherEntity = assocInfo.parentEntityQN
+					}
+					if otherEntity != "" {
+						fb.varTypes[s.Variable] = "List of " + otherEntity
+					} else {
+						fb.varTypes[s.Variable] = "List of " + assocQN
+					}
 				} else {
 					// ReferenceSet or unknown: returns a list
 					fb.varTypes[s.Variable] = "List of " + assocQN
@@ -865,9 +879,12 @@ func resolveMemberChangeFallback(mc *microflows.MemberChange, memberName string,
 
 // assocLookupResult holds resolved association metadata.
 type assocLookupResult struct {
-	Type           domainmodel.AssociationType
-	parentEntityQN string // Qualified name of the parent (FROM/owner) entity
-	childEntityQN  string // Qualified name of the child (TO/referenced) entity
+	Type              domainmodel.AssociationType
+	Owner             domainmodel.AssociationOwner
+	parentEntityQN    string // Qualified name of the parent (FROM/owner) entity
+	childEntityQN     string // Qualified name of the child (TO/referenced) entity
+	parentPersistable bool
+	childPersistable  bool
 }
 
 // lookupAssociation finds an association by module and name, returning its type
@@ -888,16 +905,21 @@ func (fb *flowBuilder) lookupAssociation(moduleName, assocName string) *assocLoo
 
 	// Build entity ID → qualified name map
 	entityNames := make(map[model.ID]string, len(dm.Entities))
+	entityPersistable := make(map[model.ID]bool, len(dm.Entities))
 	for _, e := range dm.Entities {
 		entityNames[e.ID] = moduleName + "." + e.Name
+		entityPersistable[e.ID] = e.Persistable
 	}
 
 	for _, a := range dm.Associations {
 		if a.Name == assocName {
 			return &assocLookupResult{
-				Type:           a.Type,
-				parentEntityQN: entityNames[a.ParentID],
-				childEntityQN:  entityNames[a.ChildID],
+				Type:              a.Type,
+				Owner:             a.Owner,
+				parentEntityQN:    entityNames[a.ParentID],
+				childEntityQN:     entityNames[a.ChildID],
+				parentPersistable: entityPersistable[a.ParentID],
+				childPersistable:  entityPersistable[a.ChildID],
 			}
 		}
 	}

mdl/executor/cmd_microflows_builder_retrieve_reverse_test.go

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package executor
+
+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/domainmodel"
+	"github.com/mendixlabs/mxcli/sdk/microflows"
+)
+
+func TestAddRetrieveAction_ReverseReferenceOwnerBothUsesAssociationSource(t *testing.T) {
+	fb := newRetrieveAssociationFlowBuilder(domainmodel.AssociationOwnerBoth)
+	fb.varTypes["Child"] = "Sample.Child"
+
+	fb.addRetrieveAction(&ast.RetrieveStmt{
+		Variable:      "Parent",
+		StartVariable: "Child",
+		Source:        ast.QualifiedName{Module: "Sample", Name: "Parent_Child"},
+	})
+
+	action := onlyRetrieveAction(t, fb)
+	source, ok := action.Source.(*microflows.AssociationRetrieveSource)
+	if !ok {
+		t.Fatalf("owner-both reverse retrieve source = %T, want AssociationRetrieveSource", action.Source)
+	}
+	if source.StartVariable != "Child" || source.AssociationQualifiedName != "Sample.Parent_Child" {
+		t.Fatalf("association source = %#v", source)
+	}
+	if got := fb.varTypes["Parent"]; got != "Sample.Parent" {
+		t.Fatalf("result var type = %q, want Sample.Parent", got)
+	}
+}
+
+func TestAddRetrieveAction_ReverseReferenceDefaultOwnerUsesDatabaseSource(t *testing.T) {
+	fb := newRetrieveAssociationFlowBuilder(domainmodel.AssociationOwnerDefault)
+	fb.varTypes["Child"] = "Sample.Child"
+
+	fb.addRetrieveAction(&ast.RetrieveStmt{
+		Variable:      "Parents",
+		StartVariable: "Child",
+		Source:        ast.QualifiedName{Module: "Sample", Name: "Parent_Child"},
+	})
+
+	action := onlyRetrieveAction(t, fb)
+	source, ok := action.Source.(*microflows.DatabaseRetrieveSource)
+	if !ok {
+		t.Fatalf("default-owner reverse retrieve source = %T, want DatabaseRetrieveSource", action.Source)
+	}
+	if source.EntityQualifiedName != "Sample.Parent" || source.XPathConstraint != "[Sample.Parent_Child = $Child]" {
+		t.Fatalf("database source = %#v", source)
+	}
+	if got := fb.varTypes["Parents"]; got != "List of Sample.Parent" {
+		t.Fatalf("result var type = %q, want List of Sample.Parent", got)
+	}
+}
+
+func TestAddRetrieveAction_ReverseReferenceNonPersistableParentUsesAssociationSource(t *testing.T) {
+	fb := newRetrieveAssociationFlowBuilderWithPersistability(domainmodel.AssociationOwnerDefault, false, true)
+	fb.varTypes["Child"] = "Sample.Child"
+
+	fb.addRetrieveAction(&ast.RetrieveStmt{
+		Variable:      "Parents",
+		StartVariable: "Child",
+		Source:        ast.QualifiedName{Module: "Sample", Name: "Parent_Child"},
+	})
+
+	action := onlyRetrieveAction(t, fb)
+	source, ok := action.Source.(*microflows.AssociationRetrieveSource)
+	if !ok {
+		t.Fatalf("non-persistable reverse retrieve source = %T, want AssociationRetrieveSource", action.Source)
+	}
+	if source.StartVariable != "Child" || source.AssociationQualifiedName != "Sample.Parent_Child" {
+		t.Fatalf("association source = %#v", source)
+	}
+	if got := fb.varTypes["Parents"]; got != "Sample.Parent" {
+		t.Fatalf("result var type = %q, want Sample.Parent", got)
+	}
+}
+
+func TestAddRetrieveAction_ReferenceSetRegistersOtherEntityListType(t *testing.T) {
+	fb := newRetrieveAssociationFlowBuilderWithType(domainmodel.AssociationTypeReferenceSet, domainmodel.AssociationOwnerBoth, true, true)
+	fb.varTypes["Parent"] = "Sample.Parent"
+
+	fb.addRetrieveAction(&ast.RetrieveStmt{
+		Variable:      "Children",
+		StartVariable: "Parent",
+		Source:        ast.QualifiedName{Module: "Sample", Name: "Parent_Child"},
+	})
+
+	action := onlyRetrieveAction(t, fb)
+	source, ok := action.Source.(*microflows.AssociationRetrieveSource)
+	if !ok {
+		t.Fatalf("reference-set retrieve source = %T, want AssociationRetrieveSource", action.Source)
+	}
+	if source.StartVariable != "Parent" || source.AssociationQualifiedName != "Sample.Parent_Child" {
+		t.Fatalf("association source = %#v", source)
+	}
+	if got := fb.varTypes["Children"]; got != "List of Sample.Child" {
+		t.Fatalf("result var type = %q, want List of Sample.Child", got)
+	}
+}
+
+func newRetrieveAssociationFlowBuilder(owner domainmodel.AssociationOwner) *flowBuilder {
+	return newRetrieveAssociationFlowBuilderWithPersistability(owner, true, true)
+}
+
+func newRetrieveAssociationFlowBuilderWithPersistability(owner domainmodel.AssociationOwner, parentPersistable, childPersistable bool) *flowBuilder {
+	return newRetrieveAssociationFlowBuilderWithType(domainmodel.AssociationTypeReference, owner, parentPersistable, childPersistable)
+}
+
+func newRetrieveAssociationFlowBuilderWithType(associationType domainmodel.AssociationType, owner domainmodel.AssociationOwner, parentPersistable, childPersistable bool) *flowBuilder {
+	moduleID := model.ID("sample-module")
+	parentID := model.ID("parent-entity")
+	childID := model.ID("child-entity")
+	return &flowBuilder{
+		varTypes: map[string]string{},
+		backend: &mock.MockBackend{
+			GetModuleByNameFunc: func(name string) (*model.Module, error) {
+				if name != "Sample" {
+					return nil, nil
+				}
+				return &model.Module{BaseElement: model.BaseElement{ID: moduleID}, Name: name}, nil
+			},
+			GetDomainModelFunc: func(id model.ID) (*domainmodel.DomainModel, error) {
+				if id != moduleID {
+					return nil, nil
+				}
+				return &domainmodel.DomainModel{
+					ContainerID: moduleID,
+					Entities: []*domainmodel.Entity{
+						{BaseElement: model.BaseElement{ID: parentID}, Name: "Parent", Persistable: parentPersistable},
+						{BaseElement: model.BaseElement{ID: childID}, Name: "Child", Persistable: childPersistable},
+					},
+					Associations: []*domainmodel.Association{
+						{
+							Name:     "Parent_Child",
+							ParentID: parentID,
+							ChildID:  childID,
+							Type:     associationType,
+							Owner:    owner,
+						},
+					},
+				}, nil
+			},
+		},
+	}
+}
+
+func onlyRetrieveAction(t *testing.T, fb *flowBuilder) *microflows.RetrieveAction {
+	t.Helper()
+	if len(fb.objects) != 1 {
+		t.Fatalf("got %d objects, want 1", len(fb.objects))
+	}
+	activity, ok := fb.objects[0].(*microflows.ActionActivity)
+	if !ok {
+		t.Fatalf("got object %T, want *microflows.ActionActivity", fb.objects[0])
+	}
+	action, ok := activity.Action.(*microflows.RetrieveAction)
+	if !ok {
+		t.Fatalf("got action %T, want *microflows.RetrieveAction", activity.Action)
+	}
+	return action
+}