fix: bulk-create OData navigation associations between external entities (mendixlabs#143)

After all entities are created, walk every entity type's nav properties
and emit a Mendix association for each one whose target also exists in
the project. The association uses Rest\$ODataRemoteAssociationSource
with the OData property name in RemoteParentNavigationProperty.

For TripPin this produces 8 associations (Friends, Photo, From, To,
Airline, Photos, PlanItems, Airline) — matching Studio Pro's reference.

Fixes:
- ContainsTarget=true nav properties (e.g. Person.Trips) are skipped:
  contained entities are reached through the parent, not by association
  (CE0001 fix).
- Persistable→non-persistable associations are skipped (Mendix forbids
  them; Studio Pro doesn't create them either when target is stored as
  Rest\$ODataEntityTypeSource).
- Association name collisions with entity names get a numeric suffix
  (e.g. Trip.Photos → Photos_2 to avoid clash with the Photos entity)
  (CE0065 fix).
- Defaults for CreatableFromParent/UpdatableFromParent set to true.

Writer/parser additions:
- serializeAssociation now emits Source as Rest\$ODataRemoteAssociationSource
  carrying RemoteParentNavigationProperty, Navigability2, and Creatable/
  UpdatableFromParent/Child flags.
- parseAssociation round-trips the same fields.

mx check: 17 → 7 errors, all remaining are CE6630 from unparsed OData
Capabilities annotations (Phase B-3).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ako

mdl/executor/cmd_contract.go

@@ -613,12 +613,182 @@ func (e *Executor) createExternalEntities(s *ast.CreateExternalEntitiesStmt) err
 		}
 	}
 
+	// Second pass: walk navigation properties and create associations between
+	// the entities we just created. Re-read the domain model so we get fresh
+	// entity IDs (CreateEntity reloads the dm internally on each call).
+	dm, err = e.reader.GetDomainModel(module.ID)
+	if err == nil {
+		assocsCreated := e.createNavigationAssociations(dm, doc, typeByQualified, esMap, serviceRef)
+		if assocsCreated > 0 {
+			fmt.Fprintf(e.output, "Created %d navigation associations\n", assocsCreated)
+		}
+	}
+
 	fmt.Fprintf(e.output, "\nFrom %s into %s: %d created, %d updated, %d skipped, %d failed\n",
 		svcQN, targetModule, created, updated, skipped, failed)
 
 	return nil
 }
 
+// assocKey is a (parentEntityName, associationName) pair used to detect
+// duplicate associations across passes.
+type assocKey struct {
+	parent, name string
+}
+
+// createNavigationAssociations walks the navigation properties of every entity
+// type in the schema and creates a corresponding Mendix association for each
+// one whose target also exists as an entity in this domain model. Inherited
+// navigation properties from BaseType chains are walked too.
+//
+// Each association uses Rest$ODataRemoteAssociationSource so Studio Pro can
+// map it back to the OData navigation property.
+func (e *Executor) createNavigationAssociations(
+	dm *domainmodel.DomainModel,
+	doc *mpr.EdmxDocument,
+	typeByQualified map[string]*mpr.EdmEntityType,
+	esMap map[string]string,
+	serviceRef string,
+) int {
+	// Build a lookup from EDMX type qualified name → existing Mendix entity.
+	// An entity type matches by its EntitySet name when present, otherwise by
+	// its bare type name.
+	mendixByType := make(map[string]*domainmodel.Entity)
+	for qn, et := range typeByQualified {
+		entitySetName := esMap[qn]
+		mendixName := et.Name
+		if entitySetName != "" {
+			mendixName = entitySetName
+		}
+		for _, ent := range dm.Entities {
+			if ent.Name == mendixName {
+				mendixByType[qn] = ent
+				break
+			}
+		}
+	}
+
+	// Track associations we've already created to avoid duplicates from
+	// inherited nav properties.
+	existingAssocs := make(map[assocKey]bool)
+	for _, a := range dm.Associations {
+		// Find parent entity name for this association
+		for _, ent := range dm.Entities {
+			if ent.ID == a.ParentID {
+				existingAssocs[assocKey{ent.Name, a.Name}] = true
+				break
+			}
+		}
+	}
+
+	count := 0
+	for _, schema := range doc.Schemas {
+		for _, et := range schema.EntityTypes {
+			parentQN := schema.Namespace + "." + et.Name
+			parentEnt := mendixByType[parentQN]
+			if parentEnt == nil {
+				continue
+			}
+
+			for _, np := range et.NavigationProperties {
+				// ContainsTarget=true navigation properties refer to OData
+				// contained entities (e.g. Person.Trips). Studio Pro doesn't
+				// create an association for these — the contained entities
+				// are reached via the parent entity, not by association.
+				if np.ContainsTarget {
+					continue
+				}
+
+				// Resolve target type qualified name
+				targetTypeName := np.Type
+				isMany := false
+				if strings.HasPrefix(targetTypeName, "Collection(") && strings.HasSuffix(targetTypeName, ")") {
+					targetTypeName = targetTypeName[len("Collection(") : len(targetTypeName)-1]
+					isMany = true
+				}
+				childEnt := mendixByType[targetTypeName]
+				if childEnt == nil {
+					continue // target type isn't in our project
+				}
+
+				// Mendix forbids associations from a persistable entity to a
+				// non-persistable entity (CE0001). Skip these for now —
+				// Studio Pro doesn't create them either when the target is
+				// stored as Rest$ODataEntityTypeSource (Persistable=false).
+				if parentEnt.Persistable && !childEnt.Persistable {
+					continue
+				}
+
+				// An association name must be unique within a module and may
+				// not collide with any entity name (CE0065). When the OData
+				// nav property name collides with an existing entity, append
+				// a numeric suffix.
+				assocName := uniqueAssocName(np.Name, dm, existingAssocs)
+
+				assocType := domainmodel.AssociationTypeReference
+				if isMany {
+					assocType = domainmodel.AssociationTypeReferenceSet
+				}
+
+				assoc := &domainmodel.Association{
+					Name:                           assocName,
+					ParentID:                       parentEnt.ID,
+					ChildID:                        childEnt.ID,
+					Type:                           assocType,
+					Owner:                          domainmodel.AssociationOwnerDefault,
+					StorageFormat:                  domainmodel.StorageFormatColumn,
+					Source:                         "Rest$ODataRemoteAssociationSource",
+					RemoteParentNavigationProperty: np.Name,
+					Navigability2:                  "ParentToChild",
+					// TODO: parse Org.OData.Capabilities.V1 annotations to
+					// derive these per-association. Defaults match TripPin's
+					// most common case.
+					CreatableFromParent: true,
+					UpdatableFromParent: true,
+				}
+				assoc.ID = model.ID(mpr.GenerateID())
+
+				if err := e.writer.CreateAssociation(dm.ID, assoc); err != nil {
+					fmt.Fprintf(e.output, "  ASSOC FAILED: %s.%s — %v\n", parentEnt.Name, assocName, err)
+					continue
+				}
+				existingAssocs[assocKey{parentEnt.Name, assocName}] = true
+				count++
+			}
+		}
+	}
+	return count
+}
+
+// uniqueAssocName returns a Mendix-safe association name for an OData nav
+// property. If the requested name collides with an existing entity name OR an
+// already-created association name, append a numeric suffix.
+func uniqueAssocName(base string, dm *domainmodel.DomainModel, existingAssocs map[assocKey]bool) string {
+	collides := func(name string) bool {
+		for _, ent := range dm.Entities {
+			if ent.Name == name {
+				return true
+			}
+		}
+		for k := range existingAssocs {
+			if k.name == name {
+				return true
+			}
+		}
+		return false
+	}
+	if !collides(base) {
+		return base
+	}
+	for i := 2; i < 100; i++ {
+		candidate := fmt.Sprintf("%s_%d", base, i)
+		if !collides(candidate) {
+			return candidate
+		}
+	}
+	return base
+}
+
 // applyExternalEntityFields stamps the Source/RemoteServiceName/Key/Attributes
 // fields on a domain model entity, choosing the right BSON source type based on
 // whether the entity has its own entity set.

sdk/domainmodel/domainmodel.go

@@ -337,6 +337,19 @@ type Association struct {
 	// Delete behavior
 	ParentDeleteBehavior *DeleteBehavior `json:"parentDeleteBehavior,omitempty"`
 	ChildDeleteBehavior  *DeleteBehavior `json:"childDeleteBehavior,omitempty"`
+
+	// External association source (for OData remote associations between
+	// external entities). When Source = "Rest$ODataRemoteAssociationSource",
+	// the writer emits a Source block carrying the OData navigation property
+	// names instead of leaving the association as a plain persistent one.
+	Source                         string `json:"source,omitempty"`
+	RemoteParentNavigationProperty string `json:"remoteParentNavigationProperty,omitempty"`
+	RemoteChildNavigationProperty  string `json:"remoteChildNavigationProperty,omitempty"`
+	CreatableFromParent            bool   `json:"creatableFromParent,omitempty"`
+	CreatableFromChild             bool   `json:"creatableFromChild,omitempty"`
+	UpdatableFromParent            bool   `json:"updatableFromParent,omitempty"`
+	UpdatableFromChild             bool   `json:"updatableFromChild,omitempty"`
+	Navigability2                  string `json:"navigability2,omitempty"` // "ParentToChild" or "BothDirections"
 }
 
 // GetName returns the association's name.

sdk/mpr/parser_domainmodel.go

@@ -429,6 +429,20 @@ func parseAssociation(raw map[string]any) *domainmodel.Association {
 		}
 	}
 
+	// Parse OData remote association source
+	if sourceMap, ok := raw["Source"].(map[string]any); ok {
+		if extractString(sourceMap["$Type"]) == "Rest$ODataRemoteAssociationSource" {
+			assoc.Source = "Rest$ODataRemoteAssociationSource"
+			assoc.RemoteParentNavigationProperty = extractString(sourceMap["RemoteParentNavigationProperty"])
+			assoc.RemoteChildNavigationProperty = extractString(sourceMap["RemoteChildNavigationProperty"])
+			assoc.CreatableFromParent = extractBool(sourceMap["CreatableFromParent"], false)
+			assoc.CreatableFromChild = extractBool(sourceMap["CreatableFromChild"], false)
+			assoc.UpdatableFromParent = extractBool(sourceMap["UpdatableFromParent"], false)
+			assoc.UpdatableFromChild = extractBool(sourceMap["UpdatableFromChild"], false)
+			assoc.Navigability2 = extractString(sourceMap["Navigability2"])
+		}
+	}
+
 	return assoc
 }
 

sdk/mpr/writer_domainmodel.go

@@ -1065,7 +1065,7 @@ func serializeAssociation(a *domainmodel.Association) bson.M {
 	if storageFormat == "" {
 		storageFormat = "Column"
 	}
-	return bson.M{
+	doc := bson.M{
 		"$ID":              idToBsonBinary(string(a.ID)),
 		"$Type":            "DomainModels$Association",
 		"Name":             a.Name,
@@ -1079,9 +1079,28 @@ func serializeAssociation(a *domainmodel.Association) bson.M {
 		"ParentConnection": "0;50",
 		"ChildConnection":  "100;50",
 		"StorageFormat":    storageFormat,
-		"Source":           nil,
 		"DeleteBehavior":   serializeDeleteBehavior(a.ParentDeleteBehavior, a.ChildDeleteBehavior),
 	}
+	if a.Source == "Rest$ODataRemoteAssociationSource" {
+		nav := a.Navigability2
+		if nav == "" {
+			nav = "ParentToChild"
+		}
+		doc["Source"] = bson.M{
+			"$ID":                            idToBsonBinary(generateUUID()),
+			"$Type":                          "Rest$ODataRemoteAssociationSource",
+			"CreatableFromChild":             a.CreatableFromChild,
+			"CreatableFromParent":            a.CreatableFromParent,
+			"Navigability2":                  nav,
+			"RemoteChildNavigationProperty":  a.RemoteChildNavigationProperty,
+			"RemoteParentNavigationProperty": a.RemoteParentNavigationProperty,
+			"UpdatableFromChild":             a.UpdatableFromChild,
+			"UpdatableFromParent":            a.UpdatableFromParent,
+		}
+	} else {
+		doc["Source"] = nil
+	}
+	return doc
 }
 
 func serializeCrossAssociation(ca *domainmodel.CrossModuleAssociation) bson.M {