fix: propagate OData capability annotations to external entity flags (#201)

CREATE EXTERNAL ENTITIES now matches Studio Pro's conservative defaults:
top-level entities and their attributes default to Creatable=false /
Updatable=false when the service metadata is silent, rather than
optimistically true. Per-property overrides from
InsertRestrictions/NonInsertableProperties, UpdateRestrictions/
NonUpdatableProperties, Core.Computed, and Core.Immutable are applied.
Also drops a spurious Updatable field from Rest$ODataRemoteEntitySource
BSON — Studio Pro never emits it.

Verified against test3's ODataClient (Mendix-published service with
full annotations) and TripPin (silent metadata) — generated BSON
matches Studio Pro byte-for-byte for entity, attribute, and primary
association flags.

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

Author: ako

mdl/executor/cmd_contract.go

@@ -550,20 +550,36 @@ func (e *Executor) createExternalEntities(s *ast.CreateExternalEntitiesStmt) err
 				})
 			}
 
-			// Default Updatable for attributes follows the entity-set's
-			// UpdateRestrictions when available; otherwise falls back to true
-			// for non-top-level entities and false for top-level (matching
-			// TripPin's pattern where attributes are read-only on writable
-			// entity sets but mutable on contained types).
-			defaultUpdatable := !isTopLevel
-			if entitySet != nil && entitySet.Updatable != nil {
-				defaultUpdatable = *entitySet.Updatable
+			// Default Creatable / Updatable for attributes. For top-level
+			// entities the default follows the entity set's Insert/Update
+			// restrictions — missing annotations mean read-only (Mendix
+			// Studio Pro applies the same conservative default, and
+			// mxbuild treats silent metadata as non-writable). For
+			// non-top-level (contained/derived) entities both default to
+			// true, matching Studio Pro's output where contained types are
+			// mutated via their parent's write flow.
+			defaultCreatable := false
+			defaultUpdatable := false
+			if !isTopLevel {
+				defaultCreatable = true
+				defaultUpdatable = true
 			}
-			// Default Creatable for attributes follows InsertRestrictions.
-			defaultCreatable := true
 			if entitySet != nil && entitySet.Insertable != nil {
 				defaultCreatable = *entitySet.Insertable
 			}
+			if entitySet != nil && entitySet.Updatable != nil {
+				defaultUpdatable = *entitySet.Updatable
+			}
+			nonInsertable := make(map[string]bool)
+			nonUpdatable := make(map[string]bool)
+			if entitySet != nil {
+				for _, name := range entitySet.NonInsertableProperties {
+					nonInsertable[name] = true
+				}
+				for _, name := range entitySet.NonUpdatableProperties {
+					nonUpdatable[name] = true
+				}
+			}
 
 			// Build attributes from merged properties
 			var attrs []*domainmodel.Attribute
@@ -584,6 +600,15 @@ func (e *Executor) createExternalEntities(s *ast.CreateExternalEntitiesStmt) err
 					continue
 				}
 
+				creatable := defaultCreatable
+				updatable := defaultUpdatable
+				if nonInsertable[p.Name] || p.Computed {
+					creatable = false
+				}
+				if nonUpdatable[p.Name] || p.Computed || p.Immutable {
+					updatable = false
+				}
+
 				attrName := attrNameForOData(p.Name, et.Name)
 				attr := &domainmodel.Attribute{
 					Name:       attrName,
@@ -592,8 +617,8 @@ func (e *Executor) createExternalEntities(s *ast.CreateExternalEntitiesStmt) err
 					RemoteType: p.Type,
 					Filterable: true,
 					Sortable:   true,
-					Creatable:  defaultCreatable,
-					Updatable:  defaultUpdatable,
+					Creatable:  creatable,
+					Updatable:  updatable,
 				}
 				attr.ID = model.ID(mpr.GenerateID())
 				attrs = append(attrs, attr)
@@ -1059,14 +1084,15 @@ func applyExternalEntityFields(
 		ent.Persistable = true
 		ent.RemoteEntitySet = entitySet.Name
 		ent.Countable = true
-		// Capabilities default to true unless the entity set's annotations
-		// say otherwise.
-		ent.Creatable = entitySet.Insertable == nil || *entitySet.Insertable
-		ent.Updatable = entitySet.Updatable == nil || *entitySet.Updatable
-		// Deletable defaults to false in TripPin and most read-mostly OData
-		// services, so default to the annotation value when present and to
-		// false otherwise.
+		// Capabilities default to false when the entity set's Capabilities
+		// annotations are absent. Silent metadata means the service doesn't
+		// advertise write support, so Mendix treats it as read-only — this
+		// matches Studio Pro's behaviour and mxbuild's validation rules.
+		// Rest$ODataRemoteEntitySource has no Updatable field; updatability
+		// is expressed per attribute via Rest$ODataMappedValue.
+		ent.Creatable = entitySet.Insertable != nil && *entitySet.Insertable
 		ent.Deletable = entitySet.Deletable != nil && *entitySet.Deletable
+		ent.Updatable = false
 		ent.SkipSupported = true
 		ent.TopSupported = true
 		ent.CreateChangeLocally = false

sdk/mpr/edmx.go

@@ -44,6 +44,13 @@ type EdmProperty struct {
 	Nullable  *bool  // nil = not specified (default true)
 	MaxLength string // e.g. "200", "max"
 	Scale     string // e.g. "variable"
+
+	// Capability annotations (OData Core V1). When true, the property is not
+	// settable by the client:
+	//   Computed  = server-computed, not settable on create or update.
+	//   Immutable = settable on create, but not on update.
+	Computed  bool
+	Immutable bool
 }
 
 // EdmNavigationProperty represents a navigation property (association).
@@ -75,6 +82,12 @@ type EdmEntitySet struct {
 	// Org.OData.Capabilities.V1.{Insert,Update}Restrictions/Non*NavigationProperties.
 	NonInsertableNavigationProperties []string
 	NonUpdatableNavigationProperties  []string
+
+	// Property names listed under
+	// Org.OData.Capabilities.V1.{Insert,Update}Restrictions/Non*Properties.
+	// Structural properties named here cannot be set on insert / update.
+	NonInsertableProperties []string
+	NonUpdatableProperties  []string
 }
 
 // EdmAction represents an OData4 action or OData3 function import.
@@ -279,6 +292,14 @@ func parseXmlEntityType(et *xmlEntityType) *EdmEntityType {
 			v := p.Nullable != "false"
 			prop.Nullable = &v
 		}
+		for _, ann := range p.Annotations {
+			switch ann.Term {
+			case "Org.OData.Core.V1.Computed":
+				prop.Computed = ann.Bool == "" || ann.Bool == "true"
+			case "Org.OData.Core.V1.Immutable":
+				prop.Immutable = ann.Bool == "" || ann.Bool == "true"
+			}
+		}
 		entityType.Properties = append(entityType.Properties, prop)
 	}
 
@@ -326,6 +347,10 @@ func applyCapabilityAnnotations(es *EdmEntitySet, annotations []xmlCapabilitiesA
 					if pv.Collection != nil {
 						es.NonInsertableNavigationProperties = pv.Collection.NavigationPropertyPaths
 					}
+				case "NonInsertableProperties":
+					if pv.Collection != nil {
+						es.NonInsertableProperties = pv.Collection.PropertyPaths
+					}
 				}
 			}
 		case "Org.OData.Capabilities.V1.UpdateRestrictions":
@@ -340,6 +365,10 @@ func applyCapabilityAnnotations(es *EdmEntitySet, annotations []xmlCapabilitiesA
 					if pv.Collection != nil {
 						es.NonUpdatableNavigationProperties = pv.Collection.NavigationPropertyPaths
 					}
+				case "NonUpdatableProperties":
+					if pv.Collection != nil {
+						es.NonUpdatableProperties = pv.Collection.PropertyPaths
+					}
 				}
 			}
 		case "Org.OData.Capabilities.V1.DeleteRestrictions":
@@ -458,7 +487,7 @@ type xmlEntitySet struct {
 // <PropertyValue Property="NonInsertableNavigationProperties"><Collection>
 // <NavigationPropertyPath>Trips</NavigationPropertyPath></Collection></PropertyValue>.
 type xmlCapabilitiesAnnotation struct {
-	Term   string                  `xml:"Term,attr"`
+	Term   string                 `xml:"Term,attr"`
 	Record *xmlCapabilitiesRecord `xml:"Record"`
 }
 
@@ -467,13 +496,14 @@ type xmlCapabilitiesRecord struct {
 }
 
 type xmlCapabilitiesPropertyValue struct {
-	Property               string                              `xml:"Property,attr"`
-	Bool                   string                              `xml:"Bool,attr"`
-	Collection             *xmlCapabilitiesCollection          `xml:"Collection"`
+	Property   string                     `xml:"Property,attr"`
+	Bool       string                     `xml:"Bool,attr"`
+	Collection *xmlCapabilitiesCollection `xml:"Collection"`
 }
 
 type xmlCapabilitiesCollection struct {
 	NavigationPropertyPaths []string `xml:"NavigationPropertyPath"`
+	PropertyPaths           []string `xml:"PropertyPath"`
 }
 
 type xmlFunctionImport struct {

sdk/mpr/edmx_test.go

@@ -242,6 +242,149 @@ func TestParseEdmxEmpty(t *testing.T) {
 	}
 }
 
+const testCapabilitiesMetadata = `<?xml version="1.0" encoding="utf-8"?>
+<edmx:Edmx Version="4.0" xmlns:edmx="http://docs.oasis-open.org/odata/ns/edmx">
+  <edmx:DataServices>
+    <Schema Namespace="DefaultNamespace" xmlns="http://docs.oasis-open.org/odata/ns/edm">
+      <EntityType Name="Order">
+        <Key><PropertyRef Name="OrderId" /></Key>
+        <Property Name="OrderId" Type="Edm.Int64" Nullable="false">
+          <Annotation Term="Org.OData.Core.V1.Computed" Bool="true" />
+        </Property>
+        <Property Name="OrderNumber" Type="Edm.String" MaxLength="32">
+          <Annotation Term="Org.OData.Core.V1.Immutable" Bool="true" />
+        </Property>
+        <Property Name="CustomerName" Type="Edm.String" MaxLength="200" />
+      </EntityType>
+      <EntityType Name="OrderLine">
+        <Key><PropertyRef Name="LineId" /></Key>
+        <Property Name="LineId" Type="Edm.Int64" Nullable="false" />
+      </EntityType>
+      <EntityContainer Name="Container">
+        <EntitySet Name="Orders" EntityType="DefaultNamespace.Order">
+          <Annotation Term="Org.OData.Capabilities.V1.InsertRestrictions">
+            <Record>
+              <PropertyValue Property="Insertable" Bool="true" />
+              <PropertyValue Property="NonInsertableProperties">
+                <Collection>
+                  <PropertyPath>OrderId</PropertyPath>
+                </Collection>
+              </PropertyValue>
+              <PropertyValue Property="NonInsertableNavigationProperties">
+                <Collection>
+                  <NavigationPropertyPath>Lines</NavigationPropertyPath>
+                </Collection>
+              </PropertyValue>
+            </Record>
+          </Annotation>
+          <Annotation Term="Org.OData.Capabilities.V1.UpdateRestrictions">
+            <Record>
+              <PropertyValue Property="Updatable" Bool="true" />
+              <PropertyValue Property="NonUpdatableProperties">
+                <Collection>
+                  <PropertyPath>OrderId</PropertyPath>
+                  <PropertyPath>OrderNumber</PropertyPath>
+                </Collection>
+              </PropertyValue>
+            </Record>
+          </Annotation>
+          <Annotation Term="Org.OData.Capabilities.V1.DeleteRestrictions">
+            <Record><PropertyValue Property="Deletable" Bool="true" /></Record>
+          </Annotation>
+        </EntitySet>
+        <EntitySet Name="OrderLines" EntityType="DefaultNamespace.OrderLine" />
+      </EntityContainer>
+    </Schema>
+  </edmx:DataServices>
+</edmx:Edmx>`
+
+func TestParseEdmxCapabilityAnnotations(t *testing.T) {
+	doc, err := ParseEdmx(testCapabilitiesMetadata)
+	if err != nil {
+		t.Fatalf("ParseEdmx failed: %v", err)
+	}
+
+	// Find the Orders entity set.
+	var orders *EdmEntitySet
+	for _, es := range doc.EntitySets {
+		if es.Name == "Orders" {
+			orders = es
+		}
+	}
+	if orders == nil {
+		t.Fatal("Orders entity set not found")
+	}
+
+	if orders.Insertable == nil || !*orders.Insertable {
+		t.Errorf("Orders.Insertable = %v, want true", orders.Insertable)
+	}
+	if orders.Updatable == nil || !*orders.Updatable {
+		t.Errorf("Orders.Updatable = %v, want true", orders.Updatable)
+	}
+	if orders.Deletable == nil || !*orders.Deletable {
+		t.Errorf("Orders.Deletable = %v, want true", orders.Deletable)
+	}
+
+	wantNonIns := []string{"OrderId"}
+	if !stringSliceEqual(orders.NonInsertableProperties, wantNonIns) {
+		t.Errorf("NonInsertableProperties = %v, want %v", orders.NonInsertableProperties, wantNonIns)
+	}
+	wantNonUpd := []string{"OrderId", "OrderNumber"}
+	if !stringSliceEqual(orders.NonUpdatableProperties, wantNonUpd) {
+		t.Errorf("NonUpdatableProperties = %v, want %v", orders.NonUpdatableProperties, wantNonUpd)
+	}
+	wantNonInsNav := []string{"Lines"}
+	if !stringSliceEqual(orders.NonInsertableNavigationProperties, wantNonInsNav) {
+		t.Errorf("NonInsertableNavigationProperties = %v, want %v", orders.NonInsertableNavigationProperties, wantNonInsNav)
+	}
+
+	// OrderLines has no annotations → all flags unset.
+	var lines *EdmEntitySet
+	for _, es := range doc.EntitySets {
+		if es.Name == "OrderLines" {
+			lines = es
+		}
+	}
+	if lines == nil {
+		t.Fatal("OrderLines entity set not found")
+	}
+	if lines.Insertable != nil || lines.Updatable != nil || lines.Deletable != nil {
+		t.Errorf("OrderLines should have nil capability flags, got Insertable=%v Updatable=%v Deletable=%v",
+			lines.Insertable, lines.Updatable, lines.Deletable)
+	}
+
+	// Per-property Computed/Immutable annotations.
+	order := doc.FindEntityType("DefaultNamespace.Order")
+	if order == nil {
+		t.Fatal("Order entity type not found")
+	}
+	propByName := map[string]*EdmProperty{}
+	for _, p := range order.Properties {
+		propByName[p.Name] = p
+	}
+	if !propByName["OrderId"].Computed {
+		t.Errorf("OrderId.Computed = false, want true")
+	}
+	if !propByName["OrderNumber"].Immutable {
+		t.Errorf("OrderNumber.Immutable = false, want true")
+	}
+	if propByName["CustomerName"].Computed || propByName["CustomerName"].Immutable {
+		t.Errorf("CustomerName should have no capability flags")
+	}
+}
+
+func stringSliceEqual(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
 func TestResolveNavType(t *testing.T) {
 	tests := []struct {
 		input    string

sdk/mpr/writer_domainmodel.go

@@ -928,7 +928,6 @@ func serializeODataRemoteEntitySource(e *domainmodel.Entity) bson.D {
 		bson.E{Key: "SkipSupported", Value: e.SkipSupported},
 		bson.E{Key: "SourceDocument", Value: e.RemoteServiceName},
 		bson.E{Key: "TopSupported", Value: e.TopSupported},
-		bson.E{Key: "Updatable", Value: e.Updatable},
 	)
 	return doc
 }