fix(widgets): reconcile generated-widget definitions to close Chart CE0463 in v2

claude · ako · commit 91b054bbdee7 · 2026-07-21T21:48:23.000-07:00
Charts (Pie/Column/Line/Bar/Area) have no embedded template, so they are built by GenerateFromMPK. That path drifted from mxbuild's WidgetType in three ways, all checked by CE0463, so every chart instance failed mx check in an MPR v2 project (only mx update-widgets cleared it, downgrading v2->v1): 1. It omitted the widget's declared <systemProperty> entries (Name, TabIndex, Visibility). Now emitted in their declared document position as System-typed PropertyTypes (via the .mpk's AllTopLevel order), with no Object WidgetProperty. 2. It left each ValueType's schema-derived fields empty (enum option sets, expression returnType, selectionTypes, multiline). GenerateFromMPK now runs the same .mpk reconciliation augment applies to template-based widgets. 3. The .mpk parser read helpUrl/studioCategory as XML attributes; Mendix declares them as elements. Also parse the multiline attr and <selectionType> elements. Result: the emitted WidgetType is byte-identical to update-widgets output for Pie/Column/Line/Bar/Area on Mendix 11.12.1 — 0 CE0463, MPR v2 preserved. No regression on template-based widgets (ComboBox, DataGrid2) or the reconcile path. Known remaining: TimeSeries has a nested-series textTemplate that serializes as an empty ClientTemplate instead of null (object-side, same class as the Timeline visibility nulling but nested in an object-list item) — separate follow-up. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JXnEgoc2NQP1Y2TWMCMXC4
diff --git a/mdl-examples/bug-tests/chart-widget-ce0463-v2.mdl b/mdl-examples/bug-tests/chart-widget-ce0463-v2.mdl
@@ -0,0 +1,56 @@
+-- ============================================================================
+-- Bug: Chart widgets (Pie / Column / …) trip CE0463 in MPR v2 projects
+-- ============================================================================
+--
+-- Symptom:
+--   A PieChart or ColumnChart authored via MDL persisted its series properties
+--   correctly but every instance failed `mx check` with:
+--     [CE0463] "The definition of this widget has changed. Update this widget…"
+--   The only thing that cleared it was `mx update-widgets`, which downgrades an
+--   MPR v2 project to v1 (drops mprcontents/). So charts could not ship in v2.
+--   By contrast the Image widget (which has an embedded template) authored cleanly.
+--
+-- Root cause:
+--   Charts have no embedded template, so they are built by GenerateFromMPK. That
+--   path (a) omitted the widget's declared <systemProperty> entries (Name,
+--   TabIndex, Visibility) that mxbuild emits into the WidgetType; (b) left each
+--   ValueType's schema-derived fields (enum option sets, expression returnType,
+--   selectionTypes, multiline) empty; and (c) parsed helpUrl/studioCategory as XML
+--   attributes when Mendix declares them as elements. All three are checked by
+--   CE0463, so the generated WidgetType drifted from the installed widget.
+--
+-- Fix:
+--   GenerateFromMPK now emits system PropertyTypes in their declared position and
+--   runs the same .mpk reconciliation augment uses on template-based widgets; the
+--   .mpk parser reads helpUrl/studioCategory as elements and parses multiline +
+--   <selectionType>. Result: the emitted WidgetType is byte-identical to
+--   update-widgets output — no CE0463, MPR v2 preserved.
+--
+-- Verify:
+--   mxcli exec mdl-examples/bug-tests/chart-widget-ce0463-v2.mdl -p app.mpr
+--   mx check app.mpr    # 0 errors (v2 preserved)
+-- Requires: Charts .mpk installed in the project's widgets/.
+-- ============================================================================
+
+create module ChartBug;
+/
+create entity ChartBug.Sales ( Region: String, Total: Decimal );
+/
+create or replace page ChartBug.Home ( layout: Atlas_Core.Atlas_Default ) {
+  -- Pie chart: single implicit series (widget-level DataSource/ValueAttribute).
+  pluggablewidget 'com.mendix.widget.web.piechart.PieChart' pie1 (
+    DataSource: database from ChartBug.Sales,
+    ValueAttribute: Total,
+    SeriesName: 'Sales by Region'
+  )
+  -- Column chart: an explicit `series` object-list.
+  pluggablewidget 'com.mendix.widget.web.columnchart.ColumnChart' col1 {
+    series s (
+      DataSet: 'static',
+      DataSource: database from ChartBug.Sales,
+      StaticXAttribute: Region,
+      StaticYAttribute: Total,
+      StaticName: 'Revenue'
+    )
+  }
+}
diff --git a/modelsdk/widgets/augment.go b/modelsdk/widgets/augment.go
@@ -385,8 +385,10 @@ func reconcileValueTypesFromMPK(tmpl *WidgetTemplate, byKey map[string]mpk.Prope
 							}
 							vt["Required"] = pd.Required
 							vt["IsList"] = pd.IsList
+							vt["Multiline"] = pd.Multiline
 							vt["DefaultValue"] = pd.DefaultValue
 							vt["AllowedTypes"] = buildAllowedTypesArray(pd.AllowedTypes)
+							vt["SelectionTypes"] = buildSelectionTypesArray(pd.SelectionTypes)
 							vt["DataSourceProperty"] = pd.DataSource
 							// Normalize the mutually-exclusive type-specific fields to the
 							// authoritative .mpk type. A ValueType cloned from a wrong-typed
@@ -533,6 +535,18 @@ func buildAllowedTypesArray(types []string) []any {
 	return arr
 }
 
+// buildSelectionTypesArray builds a ValueType.SelectionTypes list (leading Mendix
+// array marker 1 followed by the selection type names, e.g. "None"/"Single") from a
+// .mpk selection property's declared <selectionType> elements. Empty (marker only)
+// when the property declares none.
+func buildSelectionTypesArray(names []string) []any {
+	arr := []any{float64(1)}
+	for _, n := range names {
+		arr = append(arr, n)
+	}
+	return arr
+}
+
 // mpkEnumValuesByKey indexes a widget's enumeration option sets by property key,
 // across both top-level and nested (object-list) properties.
 func mpkEnumValuesByKey(def *mpk.WidgetDefinition) map[string][]mpk.EnumValue {
diff --git a/modelsdk/widgets/generate.go b/modelsdk/widgets/generate.go
@@ -7,15 +7,32 @@ import "github.com/mendixlabs/mxcli/modelsdk/widgets/mpk"
 // GenerateFromMPK builds a complete WidgetTemplate from a parsed MPK WidgetDefinition.
 // All $IDs are placeholder IDs (aa000000... prefix). loader.go's collectIDs remaps them
 // to real UUIDs before BSON serialisation — matching the lifecycle of embedded templates.
-// System properties (Label, Visibility, Editability) are not added; Studio Pro injects them.
+//
+// System properties (<systemProperty> — Name, TabIndex, Visibility, Label,
+// Editability) ARE emitted, in their declared document position, as System-typed
+// PropertyTypes with no corresponding Object WidgetProperty (they map to the outer
+// CustomWidget's Name/TabIndex/visibility fields). mxbuild's update-widgets emits
+// them and CE0463 checks the Type's PropertyTypes, so a generated widget that omits
+// them (e.g. any Charts widget, which has no embedded template) drifts → CE0463.
 func GenerateFromMPK(def *mpk.WidgetDefinition) *WidgetTemplate {
 	typeID := placeholderID()
 	objTypeID := placeholderID()
 
 	propTypes := []any{float64(2)} // Mendix array version marker
 	objProps := []any{float64(2)}
 
-	for _, p := range def.Properties {
+	// Iterate the full declared order (regular + system interleaved) so system
+	// PropertyTypes land at their .mpk-declared position; fall back to the regular
+	// list if the ordered view is unavailable.
+	source := def.AllTopLevel
+	if len(source) == 0 {
+		source = def.Properties
+	}
+	for _, p := range source {
+		if p.IsSystem {
+			propTypes = append(propTypes, createSystemPropertyType(p))
+			continue // system props have no Object WidgetProperty
+		}
 		bsonType := xmlTypeToBSONType(p.Type)
 		if bsonType == "" {
 			continue // unknown XML type — skip silently
@@ -61,12 +78,73 @@ func GenerateFromMPK(def *mpk.WidgetDefinition) *WidgetTemplate {
 		"Properties":  objProps,
 	}
 
-	return &WidgetTemplate{
+	tmpl := &WidgetTemplate{
 		WidgetID:  def.ID,
 		Name:      def.Name,
 		Version:   def.Version,
 		Generated: true,
 		Type:      typeMap,
 		Object:    objectMap,
 	}
+
+	// createDefaultValueType emits a minimal ValueType (empty enum/returnType/etc.)
+	// — for template-based widgets augment's reconcile pass fills these in from the
+	// .mpk, but a generated widget skips augment. Run the same reconciliation here so
+	// each PropertyType's schema-derived fields (enum option sets, expression
+	// returnType, ValueType scalars) match the installed widget; otherwise a
+	// generated widget (e.g. any Charts widget) drifts within-key → CE0463.
+	byKey := mpkPropDefsByKey(def)
+	reconcileEnumValues(tmpl.Type, mpkEnumValuesByKey(def))
+	reconcilePropertyMetadata(tmpl.Type, byKey)
+	reconcileValueTypesFromMPK(tmpl, byKey)
+	completeValueTypeEnvelope(tmpl.Type)
+
+	return tmpl
+}
+
+// createSystemPropertyType builds a System-typed CustomWidgets$WidgetPropertyType for
+// a <systemProperty> (Name/TabIndex/Visibility/Label/Editability), matching mxbuild's
+// output: Caption "<system:Key>", Category from the enclosing group chain, and a
+// ValueType with Type "System" and the standard empty envelope (array markers as
+// Studio Pro emits them). The placeholder $IDs are remapped by the loader's ID phase.
+func createSystemPropertyType(p mpk.PropertyDef) map[string]any {
+	return map[string]any{
+		"$ID":         placeholderID(),
+		"$Type":       "CustomWidgets$WidgetPropertyType",
+		"Caption":     "<system:" + p.Key + ">",
+		"Category":    p.Category,
+		"Description": "",
+		"IsDefault":   false,
+		"PropertyKey": p.Key,
+		"ValueType": map[string]any{
+			"$ID":                         placeholderID(),
+			"$Type":                       "CustomWidgets$WidgetValueType",
+			"ActionVariables":             []any{float64(2)},
+			"AllowNonPersistableEntities": false,
+			"AllowUpload":                 false,
+			"AllowedTypes":                []any{float64(1)},
+			"AssociationTypes":            []any{float64(1)},
+			"DataSourceProperty":          "",
+			"DefaultType":                 "None",
+			"DefaultValue":                "",
+			"EntityProperty":              "",
+			"EnumerationValues":           []any{float64(2)},
+			"IsLinked":                    false,
+			"IsList":                      false,
+			"IsMetaData":                  false,
+			"IsPath":                      "No",
+			"Multiline":                   false,
+			"ObjectType":                  nil,
+			"OnChangeProperty":            "",
+			"ParameterIsList":             false,
+			"PathType":                    "None",
+			"Required":                    false,
+			"ReturnType":                  nil,
+			"SelectableObjectsProperty":   "",
+			"SelectionTypes":              []any{float64(1)},
+			"SetLabel":                    false,
+			"Translations":                []any{float64(2)},
+			"Type":                        "System",
+		},
+	}
 }
diff --git a/modelsdk/widgets/mpk/mpk.go b/modelsdk/widgets/mpk/mpk.go
@@ -17,17 +17,19 @@ import (
 
 // PropertyDef describes a single property from a widget XML definition.
 type PropertyDef struct {
-	Key          string // e.g. "staticDataSourceCaption"
-	Type         string // XML type: "attribute", "expression", "textTemplate", "widgets", etc.
-	Caption      string
-	Description  string
-	Category     string // from enclosing propertyGroup captions, joined with "::"
-	Required     bool
-	DefaultValue string // for enumeration/boolean/integer types
-	IsList       bool
-	IsSystem     bool   // true for <systemProperty> elements
-	DataSource   string // dataSource attribute reference
-	ReturnType   string // for expression properties: the <returnType type="..."/> Mendix type
+	Key            string // e.g. "staticDataSourceCaption"
+	Type           string // XML type: "attribute", "expression", "textTemplate", "widgets", etc.
+	Caption        string
+	Description    string
+	Category       string // from enclosing propertyGroup captions, joined with "::"
+	Required       bool
+	DefaultValue   string // for enumeration/boolean/integer types
+	IsList         bool
+	Multiline      bool     // for string/textTemplate: multiline="true"
+	SelectionTypes []string // for selection properties: <selectionType name="..."/>
+	IsSystem       bool     // true for <systemProperty> elements
+	DataSource     string   // dataSource attribute reference
+	ReturnType     string   // for expression properties: the <returnType type="..."/> Mendix type
 	// ReturnTypeAssignableTo is the <returnType assignableTo="..."/> reference (e.g.
 	// "../staticAttribute"), when the expression's return type is derived from another
 	// property rather than a concrete type. mxbuild emits Type "None" with this set.
@@ -94,17 +96,19 @@ type xmlWidgetFile struct {
 
 // xmlWidget represents <widget> root element in widget XML.
 type xmlWidget struct {
-	ID                 string         `xml:"id,attr"`
-	PluginWidget       string         `xml:"pluginWidget,attr"`
-	OfflineCapable     string         `xml:"offlineCapable,attr"`
-	NeedsEntityContext string         `xml:"needsEntityContext,attr"`
-	SupportedPlatform  string         `xml:"supportedPlatform,attr"`
-	HelpURL            string         `xml:"helpUrl,attr"`
-	StudioCategory     string         `xml:"studioCategory,attr"`
-	StudioProCategory  string         `xml:"studioProCategory,attr"`
-	Name               string         `xml:"name"`
-	Description        string         `xml:"description"`
-	PropertyGroups     []xmlPropGroup `xml:"properties>propertyGroup"`
+	ID                 string `xml:"id,attr"`
+	PluginWidget       string `xml:"pluginWidget,attr"`
+	OfflineCapable     string `xml:"offlineCapable,attr"`
+	NeedsEntityContext string `xml:"needsEntityContext,attr"`
+	SupportedPlatform  string `xml:"supportedPlatform,attr"`
+	// helpUrl, studioCategory, studioProCategory are child ELEMENTS in Mendix
+	// widget XML (e.g. <studioProCategory>Charts</studioProCategory>), not attributes.
+	HelpURL           string         `xml:"helpUrl"`
+	StudioCategory    string         `xml:"studioCategory"`
+	StudioProCategory string         `xml:"studioProCategory"`
+	Name              string         `xml:"name"`
+	Description       string         `xml:"description"`
+	PropertyGroups    []xmlPropGroup `xml:"properties>propertyGroup"`
 }
 
 // xmlPropGroup represents <propertyGroup caption="..."> element.
@@ -198,17 +202,24 @@ type xmlProperty struct {
 	DefaultValue   string             `xml:"defaultValue,attr"`
 	Required       string             `xml:"required,attr"`
 	IsList         string             `xml:"isList,attr"`
+	Multiline      string             `xml:"multiline,attr"`
 	DataSource     string             `xml:"dataSource,attr"`
 	Caption        string             `xml:"caption"`
 	Description    string             `xml:"description"`
 	AttributeTypes []xmlAttributeType `xml:"attributeTypes>attributeType"`
 	EnumValues     []xmlEnumValue     `xml:"enumerationValues>enumerationValue"`
+	SelectionTypes []xmlSelectionType `xml:"selectionTypes>selectionType"`
 	ReturnType     xmlReturnType      `xml:"returnType"`
 	Translations   []xmlTranslation   `xml:"translations>translation"`
 	// Nested properties for object type
 	NestedProps []xmlPropGroup `xml:"properties>propertyGroup"`
 }
 
+// xmlSelectionType represents <selectionType name="..."/> on a selection property.
+type xmlSelectionType struct {
+	Name string `xml:"name,attr"`
+}
+
 // xmlReturnType represents <returnType type="..."/> or
 // <returnType assignableTo="../otherProp"/> on an expression property. A widget may
 // declare either a concrete Mendix type or an assignableTo reference (the expression
@@ -382,6 +393,8 @@ func walkPropertyGroup(pg xmlPropGroup, parentCategory string, def *WidgetDefini
 			Required:               p.Required != "false",
 			DefaultValue:           p.DefaultValue,
 			IsList:                 p.IsList == "true",
+			Multiline:              p.Multiline == "true",
+			SelectionTypes:         toSelectionTypes(p.SelectionTypes),
 			DataSource:             p.DataSource,
 			ReturnType:             p.ReturnType.Type,
 			ReturnTypeAssignableTo: p.ReturnType.AssignableTo,
@@ -452,6 +465,8 @@ func collectNestedProperties(pg xmlPropGroup, parent *PropertyDef, parentCategor
 			Required:               p.Required != "false",
 			DefaultValue:           p.DefaultValue,
 			IsList:                 p.IsList == "true",
+			Multiline:              p.Multiline == "true",
+			SelectionTypes:         toSelectionTypes(p.SelectionTypes),
 			DataSource:             p.DataSource,
 			ReturnType:             p.ReturnType.Type,
 			ReturnTypeAssignableTo: p.ReturnType.AssignableTo,
@@ -473,6 +488,21 @@ func collectNestedProperties(pg xmlPropGroup, parent *PropertyDef, parentCategor
 	}
 }
 
+// toSelectionTypes converts parsed <selectionType> XML elements to a name list
+// (e.g. ["None","Single"]), the ValueType.SelectionTypes a selection property carries.
+func toSelectionTypes(xs []xmlSelectionType) []string {
+	if len(xs) == 0 {
+		return nil
+	}
+	out := make([]string, 0, len(xs))
+	for _, x := range xs {
+		if x.Name != "" {
+			out = append(out, x.Name)
+		}
+	}
+	return out
+}
+
 // toTranslations converts parsed <translation> XML elements to Translation records,
 // trimming caption whitespace (the XML pretty-prints chardata with indentation).
 func toTranslations(xts []xmlTranslation) []Translation {
@@ -721,7 +751,7 @@ func buildDefinition(widget *xmlWidget, version string) *WidgetDefinition {
 		byKey[def.Properties[i].Key] = &def.Properties[i]
 	}
 	for _, pg := range widget.PropertyGroups {
-		collectTopLevelOrder(pg, def, byKey)
+		collectTopLevelOrder(pg, "", def, byKey)
 	}
 	return def
 }
@@ -732,17 +762,26 @@ func buildDefinition(widget *xmlWidget, version string) *WidgetDefinition {
 // PropertyDef (via byKey); system entries are recorded as Key + IsSystem. It does
 // not descend into an object property's nested properties — only the top-level
 // PropertyType order is reproduced here.
-func collectTopLevelOrder(pg xmlPropGroup, def *WidgetDefinition, byKey map[string]*PropertyDef) {
+func collectTopLevelOrder(pg xmlPropGroup, parentCategory string, def *WidgetDefinition, byKey map[string]*PropertyDef) {
+	category := pg.Caption
+	if parentCategory != "" && category != "" {
+		category = parentCategory + "::" + category
+	} else if parentCategory != "" {
+		category = parentCategory
+	}
 	for _, c := range pg.Children {
 		switch {
 		case c.Property != nil:
 			if pd := byKey[c.Property.Key]; pd != nil {
 				def.AllTopLevel = append(def.AllTopLevel, *pd)
 			}
 		case c.SystemProp != nil:
-			def.AllTopLevel = append(def.AllTopLevel, PropertyDef{Key: c.SystemProp.Key, IsSystem: true})
+			// Category is the enclosing group chain (e.g. "General::Common"),
+			// mirroring walkPropertyGroup; GenerateFromMPK emits it on the System
+			// PropertyType so a generated widget matches mxbuild's definition.
+			def.AllTopLevel = append(def.AllTopLevel, PropertyDef{Key: c.SystemProp.Key, IsSystem: true, Category: category})
 		case c.SubGroup != nil:
-			collectTopLevelOrder(*c.SubGroup, def, byKey)
+			collectTopLevelOrder(*c.SubGroup, category, def, byKey)
 		}
 	}
 }
