feat: serialize object-list child blocks to BSON (Phase 1 Layer 3 executor)

Refs: mendixlabs#538

Closes the gap between the def.json `objectLists` metadata (Layer 1+2) and
end-to-end MDL → BSON for pluggable widgets that have list-of-object
properties (Accordion groups, PopupMenu basicItems / customItems, AreaChart
series, Maps markers / dynamicMarkers).

Backend (mdl/backend/mutation.go, mdl/backend/mpr/widget_builder.go):

- New ObjectListItemSpec / ObjectListItemProperty types describe one item
  of an object-list property, with operation-dispatched scalar fields
  (primitive / attribute / expression / texttemplate / datasource / action)
  plus a ChildWidgets map for widgets-typed sub-properties.

- New WidgetObjectBuilder.SetObjectList(propertyKey, items) interface
  method, implemented in mpr backend by walking the parent property's
  NestedPropertyIDs to build each item's BSON: per sub-property, take the
  template default and overlay the spec value (PrimitiveValue / Expression
  / TextTemplate / AttributeRef / DataSource / Action / Widgets).

Executor (mdl/executor/widget_engine.go):

- New PluggableWidgetEngine.applyObjectLists step matches each AST child
  whose Type equals an objectLists[].MDLContainer (e.g. GROUP, ITEM,
  CUSTOMITEM, SERIES, MARKER) and builds an ObjectListItemSpec from the
  child's properties (via ItemProperties dispatch) and inner widgets (via
  ItemSlots dispatch + a "default content slot" heuristic).

- applyChildSlots and the Phase 1/2 auto-widgets-discovery passes now
  receive a set of object-list keywords and skip those children, so the
  generic builder doesn't try to convert `item` / `group` AST nodes into
  navlist items.

End-to-end verification on a Mendix 11.9 project (test5-app):

- Accordion with two text-header groups: groups serialize correctly,
  headerText "First Section" / "Second Section" appear in the BSON,
  `mx check` passes (no widget errors).

- All 7 test cases in 32-pluggable-widget-object-lists-v010.test.mdl
  execute without error and pass `mx check` (only pre-existing OData
  errors unrelated to this work remain).

Limitations / follow-ups:

- DESCRIBE doesn't yet read object-list items back from BSON. The grammar
  parses the syntax but the round-trip MDL → BSON → MDL still drops the
  list items. Reader-side parser work needed.

- Object-list sub-properties of kind datasource and action are skipped at
  the visitor/engine boundary because widgetPropertyV3 doesn't yet allow
  `database from X` / action expressions in arbitrary sub-property
  positions. Affects AreaChart series and Maps dynamicMarkers — the
  fixture has TODO markers calling this out.

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

Author: ako

mdl/backend/mpr/widget_builder.go

@@ -203,6 +203,179 @@ func (ob *mprWidgetObjectBuilder) SetAction(propertyKey string, action pages.Cli
 	})
 }
 
+// SetObjectList sets a list of structured items on an object-list property
+// (e.g. Accordion `groups`, PopupMenu `basicItems`). Each item is built from
+// the template's nested PropertyTypeIDs, with spec values overlaid onto the
+// matching sub-properties. Sub-properties not mentioned in the spec keep the
+// template's default values (via createDefaultWidgetProperty).
+//
+// This is the generic implementation used by the pluggable widget engine for
+// .def.json `objectLists` mappings. The DataGrid columns path keeps its own
+// hand-coded builder (datagrid_builder.go) for backward compatibility.
+func (ob *mprWidgetObjectBuilder) SetObjectList(propertyKey string, items []backend.ObjectListItemSpec) {
+	if len(items) == 0 {
+		return
+	}
+	entry, ok := ob.propertyTypeIDs[propertyKey]
+	if !ok || entry.ObjectTypeID == "" || len(entry.NestedPropertyIDs) == 0 {
+		return
+	}
+
+	objects := bson.A{int32(2)}
+	for _, item := range items {
+		objects = append(objects, buildObjectListItemBSON(entry, item))
+	}
+
+	ob.object = updateWidgetPropertyValue(ob.object, ob.propertyTypeIDs, propertyKey, func(val bson.D) bson.D {
+		result := make(bson.D, 0, len(val))
+		for _, elem := range val {
+			if elem.Key == "Objects" {
+				result = append(result, bson.E{Key: "Objects", Value: objects})
+			} else {
+				result = append(result, elem)
+			}
+		}
+		return result
+	})
+}
+
+// buildObjectListItemBSON constructs the BSON for one item of an object-list
+// property. Walks the nested PropertyTypeIDs, applies spec overrides where
+// the spec mentions a sub-property, and falls back to template defaults
+// otherwise.
+func buildObjectListItemBSON(parentEntry pages.PropertyTypeIDEntry, item backend.ObjectListItemSpec) bson.D {
+	// Index spec scalar properties by key for fast lookup.
+	specByKey := make(map[string]backend.ObjectListItemProperty, len(item.Properties))
+	for _, p := range item.Properties {
+		specByKey[p.PropertyKey] = p
+	}
+
+	propsArr := bson.A{int32(2)}
+	// Sort keys for deterministic output.
+	nestedKeys := make([]string, 0, len(parentEntry.NestedPropertyIDs))
+	for k := range parentEntry.NestedPropertyIDs {
+		nestedKeys = append(nestedKeys, k)
+	}
+	sort.Strings(nestedKeys)
+
+	for _, k := range nestedKeys {
+		nestedEntry := parentEntry.NestedPropertyIDs[k]
+		spec, hasSpec := specByKey[k]
+		childWidgets := item.ChildWidgets[k]
+
+		var prop bson.D
+		switch {
+		case hasSpec:
+			prop = buildItemSubProperty(nestedEntry, spec)
+		case len(childWidgets) > 0:
+			prop = buildItemChildWidgetsProperty(nestedEntry, childWidgets)
+		default:
+			prop = createDefaultWidgetProperty(nestedEntry)
+		}
+		propsArr = append(propsArr, prop)
+	}
+
+	return bson.D{
+		{Key: "$ID", Value: types.UUIDToBlob(types.GenerateID())},
+		{Key: "$Type", Value: "CustomWidgets$WidgetObject"},
+		{Key: "TypePointer", Value: types.UUIDToBlob(parentEntry.ObjectTypeID)},
+		{Key: "Properties", Value: propsArr},
+	}
+}
+
+// buildItemSubProperty builds one sub-property (a scalar value: primitive,
+// attribute, expression, etc.) of an object-list item, starting from the
+// template default value and overlaying the spec.
+func buildItemSubProperty(entry pages.PropertyTypeIDEntry, spec backend.ObjectListItemProperty) bson.D {
+	value := createDefaultWidgetValue(entry)
+	value = overlayItemValue(value, entry, spec)
+	return bson.D{
+		{Key: "$ID", Value: types.UUIDToBlob(types.GenerateID())},
+		{Key: "$Type", Value: "CustomWidgets$WidgetProperty"},
+		{Key: "TypePointer", Value: types.UUIDToBlob(entry.PropertyTypeID)},
+		{Key: "Value", Value: value},
+	}
+}
+
+// overlayItemValue mutates the template-default WidgetValue BSON to apply the
+// spec's value, dispatched by Operation. Returns the updated value.
+func overlayItemValue(value bson.D, entry pages.PropertyTypeIDEntry, spec backend.ObjectListItemProperty) bson.D {
+	switch spec.Operation {
+	case "primitive":
+		value = setBSONField(value, "PrimitiveValue", spec.PrimitiveVal)
+	case "attribute":
+		if spec.AttributePath != "" {
+			value = setAttributeRefField(value, spec.AttributePath)
+		}
+	case "expression":
+		value = setBSONField(value, "Expression", spec.Expression)
+		value = setBSONField(value, "PrimitiveValue", "")
+	case "texttemplate":
+		text := spec.TextTemplate
+		if text == "" {
+			text = " "
+		}
+		tmpl := createClientTemplateBSONWithParams(text, spec.EntityContext)
+		value = setBSONField(value, "TextTemplate", tmpl)
+	case "datasource":
+		if spec.DataSource != nil {
+			value = setDataSource(value, spec.DataSource)
+		}
+	case "action":
+		if spec.Action != nil {
+			actionBSON := mpr.SerializeClientAction(spec.Action)
+			value = setBSONField(value, "Action", actionBSON)
+		}
+	}
+	return value
+}
+
+// buildItemChildWidgetsProperty builds an item sub-property whose value type is
+// Widgets — populates the Widgets array with serialized child widgets.
+func buildItemChildWidgetsProperty(entry pages.PropertyTypeIDEntry, children []pages.Widget) bson.D {
+	value := createDefaultWidgetValue(entry)
+	widgetsArr := bson.A{int32(2)}
+	for _, w := range children {
+		widgetsArr = append(widgetsArr, mpr.SerializeWidget(w))
+	}
+	value = setBSONField(value, "Widgets", widgetsArr)
+	return bson.D{
+		{Key: "$ID", Value: types.UUIDToBlob(types.GenerateID())},
+		{Key: "$Type", Value: "CustomWidgets$WidgetProperty"},
+		{Key: "TypePointer", Value: types.UUIDToBlob(entry.PropertyTypeID)},
+		{Key: "Value", Value: value},
+	}
+}
+
+// setBSONField returns a copy of the bson.D with the named key's value
+// replaced. If the key is absent, the original is returned unchanged.
+func setBSONField(doc bson.D, key string, val any) bson.D {
+	result := make(bson.D, len(doc))
+	for i, elem := range doc {
+		if elem.Key == key {
+			result[i] = bson.E{Key: key, Value: val}
+		} else {
+			result[i] = elem
+		}
+	}
+	return result
+}
+
+// setAttributeRefField sets the AttributeRef field on a WidgetValue BSON to
+// reference the given fully-qualified attribute path (Module.Entity.Attr).
+func setAttributeRefField(value bson.D, attributePath string) bson.D {
+	parts := strings.Split(attributePath, ".")
+	if len(parts) < 2 {
+		return value
+	}
+	attrRef := bson.D{
+		{Key: "$ID", Value: types.UUIDToBlob(types.GenerateID())},
+		{Key: "$Type", Value: "CustomWidgets$AttributeRef"},
+		{Key: "Attribute", Value: parts[len(parts)-1]},
+	}
+	return setBSONField(value, "AttributeRef", attrRef)
+}
+
 func (ob *mprWidgetObjectBuilder) SetAttributeObjects(propertyKey string, attributePaths []string) {
 	if len(attributePaths) == 0 {
 		return

mdl/backend/mutation.go

@@ -273,6 +273,13 @@ type WidgetObjectBuilder interface {
 	SetAction(propertyKey string, action pages.ClientAction)
 	SetAttributeObjects(propertyKey string, attributePaths []string)
 
+	// SetObjectList sets a list of structured items on an object-list property
+	// (e.g. Accordion `groups`, PopupMenu `basicItems`, DataGrid `columns` —
+	// for widgets routed through the generic pluggable engine, not the dedicated
+	// DataGrid builder). The backend uses the template's nested PropertyTypeIDs
+	// to convert each spec entry into the correct BSON shape.
+	SetObjectList(propertyKey string, items []ObjectListItemSpec)
+
 	// --- Template metadata ---
 
 	// PropertyTypeIDs returns the property type metadata for the loaded template.
@@ -295,6 +302,38 @@ type WidgetObjectBuilder interface {
 	Finalize(id model.ID, name string, label string, editable string) *pages.CustomWidget
 }
 
+// ObjectListItemSpec describes one item of an object-list property (e.g. one
+// Accordion group, one PopupMenu basicItem, one Maps marker). The backend
+// applies these specs to the template's nested PropertyTypeIDs to produce
+// item BSON.
+//
+// Each property in the item is dispatched by Operation. Only the field
+// matching Operation is used; others are ignored. Operations correspond to
+// the same names as the engine's top-level operations (primitive, attribute,
+// datasource, texttemplate, expression, action) — see PluggablePropertyOp.
+type ObjectListItemSpec struct {
+	Properties []ObjectListItemProperty
+	// ChildWidgets carries pre-built widgets for Widgets-typed sub-properties
+	// of the item (e.g. Accordion group's headerContent / content). Keyed by
+	// the sub-property's key (matching the def.json itemSlots[].propertyKey).
+	ChildWidgets map[string][]pages.Widget
+}
+
+// ObjectListItemProperty describes one scalar property within an
+// ObjectListItemSpec. Mirrors the engine's PluggablePropertyContext but
+// scoped to a list item's sub-properties.
+type ObjectListItemProperty struct {
+	PropertyKey   string
+	Operation     string // primitive | attribute | datasource | texttemplate | expression | action
+	PrimitiveVal  string
+	AttributePath string
+	DataSource    pages.DataSource
+	TextTemplate  string
+	Expression    string
+	Action        pages.ClientAction
+	EntityContext string // for texttemplate operations needing param resolution
+}
+
 // DataGridColumnSpec carries pre-resolved column data for DataGrid2 construction.
 // All attribute paths are fully qualified. Child widgets are already built as
 // domain objects; the backend serializes them to storage format internally.