From 43f5ee1ca85ed3c59a2cf7ca0f3cb2b851ddcd2d Mon Sep 17 00:00:00 2001 From: engalar Date: Fri, 8 May 2026 18:16:52 +0800 Subject: [PATCH 01/18] docs: add MPK-derived widget template design spec Spec for runtime WidgetTemplate generation from .mpk files, enabling any pluggable widget in project/widgets/ to be used in MDL commands without pre-built embedded templates. Co-Authored-By: Claude Sonnet 4.6 --- ...26-05-08-mpk-template-derivation-design.md | 184 ++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 docs/superpowers/specs/2026-05-08-mpk-template-derivation-design.md diff --git a/docs/superpowers/specs/2026-05-08-mpk-template-derivation-design.md b/docs/superpowers/specs/2026-05-08-mpk-template-derivation-design.md new file mode 100644 index 00000000..3226546b --- /dev/null +++ b/docs/superpowers/specs/2026-05-08-mpk-template-derivation-design.md @@ -0,0 +1,184 @@ +# MPK-Derived Widget Templates + +**Date:** 2026-05-08 +**Status:** Approved +**Scope:** `sdk/widgets/` + +## Problem + +mxcli can only use pluggable widgets that have pre-built templates embedded in the binary (`sdk/widgets/templates/mendix-11.6/*.json`). Non-embedded widgets (e.g. third-party marketplace widgets, custom widgets like CrusherWidgets) require a manual Studio Pro extraction workflow before they can be used in `create page` MDL commands. + +## Goal + +Any pluggable widget whose `.mpk` file is present in `project/widgets/` can be used in MDL commands without pre-built templates. The derivation happens transparently at runtime when the widget is first referenced. + +## Approach + +**Approach B — new `generate.go`, parallel to `augment.go`.** + +All logic for building individual PropertyType/Property pairs from scratch already exists in `augment.go` (`createPropertyPair`, `createDefaultValueType`, `createDefaultWidgetValue`, `buildNestedObjectType`, `xmlTypeToBSONType`). `generate.go` only needs to build the outer `CustomWidgetType` + `WidgetObject` shells and call those existing functions. + +Rejected alternatives: +- **A (extend augment.go)**: mixed "patch" and "generate" semantics in one file → harder to maintain +- **C (pipeline refactor)**: highest risk, touches stable loader.go core for marginal architectural gain + +## Architecture + +### File changes + +``` +sdk/widgets/ +├── mpk/mpk.go — unchanged (ParseMPK / FindMPK already complete) +├── augment.go — unchanged (all helpers reused as-is) +├── loader.go — +25 lines: fallback path after embedded cache miss +└── generate.go — new, ~60 lines: outer shell construction +``` + +### Template resolution flow + +``` +GetTemplateBSON / GetTemplateFullBSON(widgetID, idGenerator, projectPath) + │ + └─ getOrGenerateTemplate(widgetID, projectPath) ← new internal helper + │ + ├─ 1. GetTemplate(widgetID) ← embedded cache (existing) + │ └─ found → augmentFromMPK() → return + │ + ├─ 2. generatedCache.Load(widgetID) ← session cache (new) + │ └─ found → return + │ + ├─ 3. mpk.FindMPK(projectPath, widgetID) + │ └─ not found → return nil, nil + │ + ├─ 4. mpk.ParseMPK(mpkPath) → WidgetDefinition + │ + ├─ 5. GenerateFromMPK(def) → WidgetTemplate ← new + │ + └─ 6. generatedCache.Store(widgetID, tmpl) → return +``` + +**Performance fallback (deferred):** If step 5 proves too slow for large widgets, write the generated template to `.mxcli/widgets/.json` and check that path between steps 2 and 3. This can be added without restructuring. + +## generate.go + +### API + +```go +// GenerateFromMPK builds a complete WidgetTemplate from an MPK WidgetDefinition. +// All $IDs are placeholder IDs; loader.go's collectIDs remaps them to real UUIDs +// before BSON serialization. +func GenerateFromMPK(def *mpk.WidgetDefinition) *WidgetTemplate +``` + +### Algorithm + +``` +typeID = placeholderID() +objTypeID = placeholderID() + +for each p in def.Properties: + bsonType = xmlTypeToBSONType(p.Type) + skip if bsonType == "" + pt, prop = createPropertyPair(p, bsonType) + append pt → propTypes + append prop → objProps + +type = map{ + "$ID": typeID, + "$Type": "CustomWidgets$CustomWidgetType", + "WidgetId": def.ID, + "ObjectType": map{ + "$ID": objTypeID, + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": [2, ...propTypes], + }, +} + +object = map{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetObject", + "TypePointer": typeID, + "Properties": [2, ...objProps], +} + +return &WidgetTemplate{ + WidgetID: def.ID, + Name: def.Name, + Version: def.Version, + Type: type, + Object: object, +} +``` + +### System properties + +System properties (Label, Visibility, Editability) are **not** added by `GenerateFromMPK`. Studio Pro injects them automatically when opening the project. This matches the current behaviour of `AugmentTemplate`. + +## loader.go changes + +`GetTemplate(widgetID string)` has no `projectPath` parameter; it returns `nil, nil` on cache miss. +`projectPath` is only available in `GetTemplateBSON` / `GetTemplateFullBSON`. + +**Strategy:** introduce a package-internal `getOrGenerateTemplate(widgetID, projectPath string)` called by both BSON functions instead of `GetTemplate` directly. + +```go +// getOrGenerateTemplate returns the template for widgetID, falling back to +// MPK-based generation when no embedded template exists. +func getOrGenerateTemplate(widgetID, projectPath string) (*WidgetTemplate, error) { + // 1. embedded templates (existing path) + if tmpl, err := GetTemplate(widgetID); err != nil || tmpl != nil { + return tmpl, err + } + + // 2. session cache of previously generated templates + if cached, ok := generatedCache.Load(widgetID); ok { + return cached.(*WidgetTemplate), nil + } + + // 3. derive from MPK in project/widgets/ + if projectPath == "" { + return nil, nil // no project path, can't locate MPK + } + mpkPath := mpk.FindMPK(projectPath, widgetID) + if mpkPath == "" { + return nil, nil // not found — callers treat nil as "widget unknown" + } + def, err := mpk.ParseMPK(mpkPath) + if err != nil { + return nil, fmt.Errorf("widget %q: parse MPK: %w", widgetID, err) + } + tmpl := GenerateFromMPK(def) + generatedCache.Store(widgetID, tmpl) + return tmpl, nil +} +``` + +`GetTemplateBSON` and `GetTemplateFullBSON` replace their `GetTemplate(widgetID)` call with `getOrGenerateTemplate(widgetID, projectPath)`. No other changes to those functions. + +`generatedCache` is a package-level `sync.Map` (key: widgetID string, value: `*WidgetTemplate`). The cached value is the pre-ID-remapping template, identical in lifecycle to embedded templates. + +## PropertyDef → BSON mapping + +Already fully implemented in `augment.go:xmlTypeToBSONType()`. Covers all 17 known XML property types: + +`attribute` `expression` `textTemplate` `widgets` `enumeration` `boolean` `integer` `datasource` `action` `selection` `association` `object` `string` `decimal` `icon` `image` `file` + +Unknown types are silently skipped (property omitted from generated template). + +## Tests + +| Test | File | What it checks | +|------|------|----------------| +| `TestGenerateFromMPK_BasicTypes` | `generate_test.go` | string/boolean/integer/expression/attribute → PropertyTypes and Properties counts match, TypePointers cross-reference correctly | +| `TestGenerateFromMPK_NestedObject` | `generate_test.go` | object-type property with children → nested ObjectType built correctly | +| `TestGenerateFromMPK_UnknownTypeSkipped` | `generate_test.go` | unknown XML type → no panic, property count reduced by 1 | +| `TestGenerateFromMPK_PlaceholderIDsRemapped` | `generate_test.go` | after `GetTemplateFullBSON`, no `aa000000`-prefix IDs remain | +| `TestGetTemplate_FallsBackToMPK` | `loader_test.go` | CavitySelector widget ID + CrusherWidgets.mpk fixture → valid template returned without embedded template | + +**Acceptance criterion:** `create page` MDL command referencing CavitySelector in CrusherCopilot project → Studio Pro opens without CE0463 error. + +## Out of scope + +- ALTER PAGE operations on generated widget instances (follow-on work) +- Caching generated templates to disk (deferred until performance evidence) +- `cmd/crusher-templates` CLI (superseded by this runtime approach; can be removed separately) From a6402e592c9ae473e07be20e1620569dade073ac Mon Sep 17 00:00:00 2001 From: engalar Date: Fri, 8 May 2026 18:35:26 +0800 Subject: [PATCH 02/18] docs: add MPK-derived template implementation plan 4-task plan covering multi-widget MPK support, GenerateFromMPK, loader.go fallback wiring, and end-to-end verification. Co-Authored-By: Claude Sonnet 4.6 --- .../2026-05-08-mpk-template-derivation.md | 973 ++++++++++++++++++ 1 file changed, 973 insertions(+) create mode 100644 docs/superpowers/plans/2026-05-08-mpk-template-derivation.md diff --git a/docs/superpowers/plans/2026-05-08-mpk-template-derivation.md b/docs/superpowers/plans/2026-05-08-mpk-template-derivation.md new file mode 100644 index 00000000..bc4868f6 --- /dev/null +++ b/docs/superpowers/plans/2026-05-08-mpk-template-derivation.md @@ -0,0 +1,973 @@ +# MPK-Derived Widget Templates Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Any pluggable widget whose `.mpk` file is in `project/widgets/` can be used in MDL `create page` commands without a pre-built embedded template — mxcli derives the template from the MPK at runtime, transparently. + +**Architecture:** New `sdk/widgets/generate.go` builds a `WidgetTemplate` (type + object shells) from a `mpk.WidgetDefinition` using existing `createPropertyPair` helpers from `augment.go`. A new internal `getOrGenerateTemplate` helper in `loader.go` adds a fallback path after the embedded-template cache miss, calling `mpk.FindMPK` → `mpk.ParseMPKForWidget` → `GenerateFromMPK`, with a session-scoped `sync.Map` to avoid re-parsing on every call. + +**Tech Stack:** Go, `sdk/widgets/mpk` (existing ZIP parser), `sdk/widgets/augment.go` (existing property builders), `go.mongodb.org/mongo-driver/bson` + +--- + +## File Map + +| Action | File | What changes | +|--------|------|-------------| +| Modify | `sdk/widgets/mpk/mpk.go` | Fix `FindMPK` and add `ParseMPKForWidget` for multi-widget MPKs | +| Modify | `sdk/widgets/mpk/mpk_test.go` | Tests for multi-widget MPK handling | +| **Create** | `sdk/widgets/generate.go` | `GenerateFromMPK(def) *WidgetTemplate` | +| **Create** | `sdk/widgets/generate_test.go` | Unit tests for generate.go | +| Modify | `sdk/widgets/loader.go` | `getOrGenerateTemplate`, `generatedCache`, wire into BSON functions | +| Modify | `sdk/widgets/augment_test.go` | Add loader fallback integration test | + +--- + +## Task 1: Fix multi-widget MPK support + +**Context:** `FindMPK` calls `getWidgetIDFromMPK`, which reads only `WidgetFiles[0]` from `package.xml`. `ParseMPK` also reads only the first widget file. `CrusherWidgets.mpk` bundles 5 widgets (CavitySelector, CrusherSlider, etc.) — only the first would be discoverable. This must be fixed before anything else. + +**Files:** +- Modify: `sdk/widgets/mpk/mpk.go` +- Modify: `sdk/widgets/mpk/mpk_test.go` + +- [ ] **Step 1.1: Write failing test for multi-widget FindMPK** + +In `sdk/widgets/mpk/mpk_test.go`, add after the existing helpers: + +```go +func TestFindMPK_MultiWidget(t *testing.T) { + mpkPath := filepath.Join("..", "..", "..", "D:/gh/posui/mendix/CrusherCopilot/widgets/CrusherWidgets.mpk") + if _, err := os.Stat(mpkPath); err != nil { + t.Skip("CrusherWidgets.mpk not available") + } + projectDir := filepath.Dir(mpkPath) // .../CrusherCopilot/widgets/ — wrong, use parent + projectDir = filepath.Join("..", "..", "..", "D:/gh/posui/mendix/CrusherCopilot") + if _, err := os.Stat(projectDir); err != nil { + t.Skip("CrusherCopilot project not available") + } + + widgets := []string{ + "com.mendix.widget.custom.CavitySelector.CavitySelector", + "com.mendix.widget.custom.CrusherSlider.CrusherSlider", + "com.mendix.widget.custom.PredictionBadge.PredictionBadge", + "com.mendix.widget.custom.CrusherSimCanvas.CrusherSimCanvas", + "com.mendix.widget.custom.HeatmapViz.HeatmapViz", + } + for _, wid := range widgets { + found, err := FindMPK(projectDir, wid) + if err != nil { + t.Fatalf("FindMPK(%q): %v", wid, err) + } + if found == "" { + t.Errorf("FindMPK(%q): expected MPK path, got empty string", wid) + } + } +} + +func TestParseMPKForWidget_MultiWidget(t *testing.T) { + mpkPath := filepath.Join("..", "..", "..", "D:/gh/posui/mendix/CrusherCopilot/widgets/CrusherWidgets.mpk") + if _, err := os.Stat(mpkPath); err != nil { + t.Skip("CrusherWidgets.mpk not available") + } + + widgetID := "com.mendix.widget.custom.CavitySelector.CavitySelector" + def, err := ParseMPKForWidget(mpkPath, widgetID) + if err != nil { + t.Fatalf("ParseMPKForWidget: %v", err) + } + if def == nil { + t.Fatal("ParseMPKForWidget: got nil definition") + } + if def.ID != widgetID { + t.Errorf("ID = %q, want %q", def.ID, widgetID) + } + if len(def.Properties) == 0 { + t.Error("expected at least one property") + } +} +``` + +- [ ] **Step 1.2: Run tests to confirm they fail** + +```bash +cd D:/gh/mxcli +go test ./sdk/widgets/mpk/ -run "TestFindMPK_MultiWidget|TestParseMPKForWidget_MultiWidget" -v +``` + +Expected: FAIL — `ParseMPKForWidget` is undefined; `FindMPK` returns empty for all but the first widget. + +- [ ] **Step 1.3: Add `getWidgetIDsFromMPK` (plural) and `ParseMPKForWidget` to mpk.go** + +In `sdk/widgets/mpk/mpk.go`, replace `getWidgetIDFromMPK` with a plural version and add `ParseMPKForWidget`. + +**Replace** the existing `getWidgetIDFromMPK` function (lines ~330-406) with: + +```go +// getWidgetIDsFromMPK returns ALL widget IDs declared in an .mpk package.xml. +// Multi-widget MPKs (e.g. CrusherWidgets.mpk) list multiple entries. +func getWidgetIDsFromMPK(mpkPath string) ([]string, error) { + r, err := zip.OpenReader(mpkPath) + if err != nil { + return nil, err + } + defer r.Close() + + var widgetFilePaths []string + var totalExtracted uint64 + for _, f := range r.File { + if f.Name == "package.xml" { + if f.UncompressedSize64 > maxFileSize { + return nil, fmt.Errorf("package.xml exceeds max file size (%d > %d)", f.UncompressedSize64, maxFileSize) + } + rc, err := f.Open() + if err != nil { + return nil, err + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + return nil, err + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return nil, fmt.Errorf("total extracted size exceeds limit") + } + var pkg xmlPackage + if err := xml.Unmarshal(data, &pkg); err != nil { + return nil, err + } + for _, wf := range pkg.ClientModule.WidgetFiles { + widgetFilePaths = append(widgetFilePaths, wf.Path) + } + break + } + } + + var ids []string + for _, path := range widgetFilePaths { + for _, f := range r.File { + if f.Name == path { + if f.UncompressedSize64 > maxFileSize { + continue + } + rc, err := f.Open() + if err != nil { + continue + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + continue + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return ids, fmt.Errorf("total extracted size exceeds limit") + } + var widget struct { + ID string `xml:"id,attr"` + } + if err := xml.Unmarshal(data, &widget); err != nil { + continue + } + if widget.ID != "" { + ids = append(ids, widget.ID) + } + } + } + } + return ids, nil +} + +// ParseMPKForWidget parses the widget XML for a specific widgetID from an .mpk file. +// Unlike ParseMPK (which reads the first widget), this finds the widget file whose +// parsed ID matches widgetID — needed for multi-widget .mpk packages. +func ParseMPKForWidget(mpkPath string, widgetID string) (*WidgetDefinition, error) { + // Check definition cache (ParseMPK stores by mpkPath; we use widgetID as key here) + defCacheLock.RLock() + if def, ok := defCache[mpkPath+"\x00"+widgetID]; ok { + defCacheLock.RUnlock() + return def, nil + } + defCacheLock.RUnlock() + + r, err := zip.OpenReader(mpkPath) + if err != nil { + return nil, fmt.Errorf("failed to open mpk: %w", err) + } + defer r.Close() + + // Parse package.xml to get all widget file paths and version + var pkg xmlPackage + var version string + var totalExtracted uint64 + for _, f := range r.File { + if f.Name == "package.xml" { + if f.UncompressedSize64 > maxFileSize { + return nil, fmt.Errorf("package.xml exceeds max size") + } + rc, err := f.Open() + if err != nil { + return nil, fmt.Errorf("open package.xml: %w", err) + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + return nil, fmt.Errorf("read package.xml: %w", err) + } + totalExtracted += uint64(len(data)) + if err := xml.Unmarshal(data, &pkg); err != nil { + return nil, fmt.Errorf("parse package.xml: %w", err) + } + version = pkg.ClientModule.Version + break + } + } + + // Try each widget file until we find one with a matching ID + for _, wf := range pkg.ClientModule.WidgetFiles { + for _, f := range r.File { + if f.Name != wf.Path { + continue + } + if f.UncompressedSize64 > maxFileSize { + continue + } + rc, err := f.Open() + if err != nil { + continue + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + continue + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return nil, fmt.Errorf("total extracted size exceeds limit") + } + + var widget xmlWidget + if err := xml.Unmarshal(data, &widget); err != nil { + continue + } + if widget.ID != widgetID { + continue + } + + // Found the matching widget — build definition + def := buildDefinition(&widget, version) + + cacheKey := mpkPath + "\x00" + widgetID + defCacheLock.Lock() + defCache[cacheKey] = def + defCacheLock.Unlock() + return def, nil + } + } + + return nil, nil // widget not found in this MPK +} +``` + +Note: `buildDefinition` is a helper that contains the repeated definition-building logic. Extract it from `ParseMPK` as shown in Step 1.4. + +- [ ] **Step 1.4: Refactor ParseMPK to share definition-building logic** + +In `sdk/widgets/mpk/mpk.go`, extract the widget-to-definition building from `ParseMPK` into a private `buildDefinition` function. Replace the block in `ParseMPK` starting from `def := &WidgetDefinition{...}` through the end: + +Find in `ParseMPK` the block that creates `def` and returns it. Extract it as: + +```go +// buildDefinition constructs a WidgetDefinition from a parsed xmlWidget and version string. +func buildDefinition(widget *xmlWidget, version string) *WidgetDefinition { + def := &WidgetDefinition{ + ID: widget.ID, + Name: widget.Name, + Version: version, + IsPluggable: widget.PluginWidget == "true", + } + for _, group := range widget.PropertyGroups { + collectProps(def, group, "") + } + return def +} +``` + +Then in `ParseMPK`, replace the definition-building code with: +```go +def := buildDefinition(&widget, version) +``` + +(The existing `collectProps` function in mpk.go is unchanged.) + +- [ ] **Step 1.5: Update `FindMPK` to use `getWidgetIDsFromMPK`** + +In `sdk/widgets/mpk/mpk.go`, in the `FindMPK` function, find the loop body where `getWidgetIDFromMPK` is called: + +```go +for _, mpkPath := range matches { + wid, err := getWidgetIDFromMPK(mpkPath) + if err != nil { + continue // Skip unparseable files + } + if wid != "" { + dirMap[wid] = mpkPath + } +} +``` + +Replace with: + +```go +for _, mpkPath := range matches { + wids, err := getWidgetIDsFromMPK(mpkPath) + if err != nil { + continue // Skip unparseable files + } + for _, wid := range wids { + if wid != "" { + dirMap[wid] = mpkPath + } + } +} +``` + +- [ ] **Step 1.6: Run tests to confirm they pass** + +```bash +cd D:/gh/mxcli +go test ./sdk/widgets/mpk/ -run "TestFindMPK_MultiWidget|TestParseMPKForWidget_MultiWidget" -v +``` + +Expected: PASS (or SKIP if CrusherWidgets.mpk not present). + +Also verify existing mpk tests still pass: +```bash +go test ./sdk/widgets/mpk/ -v +``` + +Expected: All PASS (or SKIP for external file tests). + +- [ ] **Step 1.7: Commit** + +```bash +cd D:/gh/mxcli +git add sdk/widgets/mpk/mpk.go sdk/widgets/mpk/mpk_test.go +git commit -m "fix: support multi-widget MPK files in FindMPK and ParseMPKForWidget" +``` + +--- + +## Task 2: Write generate.go (TDD) + +**Context:** `GenerateFromMPK` builds a `WidgetTemplate` outer shell (`CustomWidgetType` + `WidgetObject`) and populates it by calling the existing `createPropertyPair` / `xmlTypeToBSONType` helpers from `augment.go`. All `$ID` values use `placeholderID()` — `loader.go`'s `collectIDs` will remap them to real UUIDs before BSON serialisation. + +**Files:** +- Create: `sdk/widgets/generate_test.go` +- Create: `sdk/widgets/generate.go` + +- [ ] **Step 2.1: Write failing tests** + +Create `sdk/widgets/generate_test.go`: + +```go +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import ( + "strings" + "testing" + + "github.com/mendixlabs/mxcli/sdk/widgets/mpk" +) + +func TestGenerateFromMPK_BasicTypes(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Version: "1.0.0", + Properties: []mpk.PropertyDef{ + {Key: "label", Type: "string", Caption: "Label"}, + {Key: "enabled", Type: "boolean", Caption: "Enabled", DefaultValue: "true"}, + {Key: "count", Type: "integer", Caption: "Count", DefaultValue: "0"}, + {Key: "value", Type: "expression", Caption: "Value"}, + {Key: "attr", Type: "attribute", Caption: "Attribute"}, + }, + } + + tmpl := GenerateFromMPK(def) + + if tmpl == nil { + t.Fatal("GenerateFromMPK returned nil") + } + if tmpl.WidgetID != def.ID { + t.Errorf("WidgetID = %q, want %q", tmpl.WidgetID, def.ID) + } + if tmpl.Name != def.Name { + t.Errorf("Name = %q, want %q", tmpl.Name, def.Name) + } + if tmpl.Version != def.Version { + t.Errorf("Version = %q, want %q", tmpl.Version, def.Version) + } + if tmpl.Type == nil { + t.Fatal("Type is nil") + } + if tmpl.Object == nil { + t.Fatal("Object is nil") + } + + // type.$Type must be CustomWidgets$CustomWidgetType + if got := tmpl.Type["$Type"]; got != "CustomWidgets$CustomWidgetType" { + t.Errorf("Type.$Type = %v, want CustomWidgets$CustomWidgetType", got) + } + + // ObjectType must exist with PropertyTypes + objType, ok := tmpl.Type["ObjectType"].(map[string]any) + if !ok { + t.Fatal("Type.ObjectType missing or wrong type") + } + propTypes, ok := objType["PropertyTypes"].([]any) + if !ok { + t.Fatal("ObjectType.PropertyTypes missing or wrong type") + } + // First element is the Mendix array version marker (float64(2)) + nonMarkerPropTypes := 0 + for _, pt := range propTypes { + if _, isFloat := pt.(float64); !isFloat { + nonMarkerPropTypes++ + } + } + if nonMarkerPropTypes != 5 { + t.Errorf("PropertyTypes count = %d, want 5", nonMarkerPropTypes) + } + + // Object Properties must match PropertyTypes count + objProps, ok := tmpl.Object["Properties"].([]any) + if !ok { + t.Fatal("Object.Properties missing or wrong type") + } + nonMarkerProps := 0 + for _, p := range objProps { + if _, isFloat := p.(float64); !isFloat { + nonMarkerProps++ + } + } + if nonMarkerProps != 5 { + t.Errorf("Properties count = %d, want 5", nonMarkerProps) + } +} + +func TestGenerateFromMPK_TypePointerCrossReference(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + {Key: "mode", Type: "enumeration", Caption: "Mode", DefaultValue: "fast"}, + }, + } + + tmpl := GenerateFromMPK(def) + + // Collect PropertyType $IDs + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + var ptID string + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + if ptMap["PropertyKey"] == "mode" { + ptID = ptMap["$ID"].(string) + break + } + } + if ptID == "" { + t.Fatal("PropertyType for 'mode' not found") + } + + // Find Property and verify TypePointer → PropertyType.$ID + objProps := tmpl.Object["Properties"].([]any) + var propTypePointer string + for _, p := range objProps { + pMap, ok := p.(map[string]any) + if !ok { + continue + } + propTypePointer = pMap["TypePointer"].(string) + break + } + if propTypePointer != ptID { + t.Errorf("Property.TypePointer = %q, want PropertyType.$ID %q", propTypePointer, ptID) + } +} + +func TestGenerateFromMPK_NestedObject(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + { + Key: "columns", + Type: "object", + Caption: "Columns", + IsList: true, + Children: []mpk.PropertyDef{ + {Key: "header", Type: "string", Caption: "Header"}, + {Key: "attr", Type: "attribute", Caption: "Attribute"}, + }, + }, + }, + } + + tmpl := GenerateFromMPK(def) + + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + var columnsPT map[string]any + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + if ptMap["PropertyKey"] == "columns" { + columnsPT = ptMap + break + } + } + if columnsPT == nil { + t.Fatal("columns PropertyType not found") + } + + vt, ok := columnsPT["ValueType"].(map[string]any) + if !ok { + t.Fatal("ValueType missing on columns property") + } + nestedObjType, ok := vt["ObjectType"].(map[string]any) + if !ok { + t.Fatal("ObjectType missing on columns ValueType — nested object not built") + } + nestedPTs, ok := nestedObjType["PropertyTypes"].([]any) + if !ok { + t.Fatal("nested PropertyTypes missing") + } + nestedCount := 0 + for _, npt := range nestedPTs { + if _, isFloat := npt.(float64); !isFloat { + nestedCount++ + } + } + if nestedCount != 2 { + t.Errorf("nested PropertyTypes count = %d, want 2", nestedCount) + } +} + +func TestGenerateFromMPK_UnknownTypeSkipped(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + {Key: "good", Type: "string", Caption: "Good"}, + {Key: "bad", Type: "unknownXmlType", Caption: "Bad"}, + }, + } + + tmpl := GenerateFromMPK(def) + + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + count := 0 + for _, pt := range propTypes { + if _, isFloat := pt.(float64); !isFloat { + count++ + } + } + if count != 1 { + t.Errorf("PropertyTypes count = %d, want 1 (unknown type skipped)", count) + } +} + +func TestGenerateFromMPK_PlaceholderIDsRemapped(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + {Key: "label", Type: "string", Caption: "Label"}, + }, + } + + tmpl := GenerateFromMPK(def) + + // After GetTemplateFullBSON, no aa000000-prefix IDs should remain + callCount := 0 + idGen := func() string { + callCount++ + return strings.Repeat("f", 32) // deterministic non-placeholder IDs + } + + // Temporarily insert into template cache so GetTemplateFullBSON finds it + templateCacheLock.Lock() + templateCache["com.example.Widget"] = tmpl + templateCacheLock.Unlock() + defer func() { + templateCacheLock.Lock() + delete(templateCache, "com.example.Widget") + templateCacheLock.Unlock() + }() + + bsonType, bsonObj, _, _, err := GetTemplateFullBSON("com.example.Widget", idGen, "") + if err != nil { + t.Fatalf("GetTemplateFullBSON: %v", err) + } + if containsPlaceholderID(bsonType) { + t.Error("placeholder IDs leaked in bsonType") + } + if bsonObj != nil && containsPlaceholderID(bsonObj) { + t.Error("placeholder IDs leaked in bsonObj") + } +} +``` + +- [ ] **Step 2.2: Run tests to confirm they fail** + +```bash +cd D:/gh/mxcli +go test ./sdk/widgets/ -run "TestGenerateFromMPK" -v +``` + +Expected: FAIL — `GenerateFromMPK` is undefined. + +- [ ] **Step 2.3: Implement generate.go** + +Create `sdk/widgets/generate.go`: + +```go +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import "github.com/mendixlabs/mxcli/sdk/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. +func GenerateFromMPK(def *mpk.WidgetDefinition) *WidgetTemplate { + typeID := placeholderID() + objTypeID := placeholderID() + + var propTypes []any + var objProps []any + propTypes = append(propTypes, float64(2)) // Mendix array version marker + objProps = append(objProps, float64(2)) + + for _, p := range def.Properties { + bsonType := xmlTypeToBSONType(p.Type) + if bsonType == "" { + continue // unknown XML type — skip silently + } + pt, prop := createPropertyPair(p, bsonType) + if pt != nil { + propTypes = append(propTypes, pt) + } + if prop != nil { + objProps = append(objProps, prop) + } + } + + typeMap := map[string]any{ + "$ID": typeID, + "$Type": "CustomWidgets$CustomWidgetType", + "WidgetId": def.ID, + "ObjectType": map[string]any{ + "$ID": objTypeID, + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": propTypes, + }, + } + + objectMap := map[string]any{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetObject", + "TypePointer": typeID, + "Properties": objProps, + } + + return &WidgetTemplate{ + WidgetID: def.ID, + Name: def.Name, + Version: def.Version, + Type: typeMap, + Object: objectMap, + } +} +``` + +- [ ] **Step 2.4: Run tests to confirm they pass** + +```bash +cd D:/gh/mxcli +go test ./sdk/widgets/ -run "TestGenerateFromMPK" -v +``` + +Expected: All 5 tests PASS. + +- [ ] **Step 2.5: Commit** + +```bash +cd D:/gh/mxcli +git add sdk/widgets/generate.go sdk/widgets/generate_test.go +git commit -m "feat: add GenerateFromMPK — build WidgetTemplate from MPK definition" +``` + +--- + +## Task 3: Wire loader.go — transparent fallback + +**Context:** `GetTemplateBSON` and `GetTemplateFullBSON` both call `GetTemplate(widgetID)` which returns `nil, nil` on miss. We add a new `getOrGenerateTemplate(widgetID, projectPath)` helper that adds the MPK fallback path after the embedded-template miss. Both BSON functions switch to calling this helper instead. + +**Files:** +- Modify: `sdk/widgets/loader.go` + +- [ ] **Step 3.1: Write failing integration test** + +In `sdk/widgets/augment_test.go`, add at the bottom: + +```go +func TestGetTemplateFullBSON_FallsBackToMPK(t *testing.T) { + crusherProjectPath := "D:/gh/posui/mendix/CrusherCopilot" + if _, err := os.Stat(crusherProjectPath); err != nil { + t.Skip("CrusherCopilot project not available") + } + + widgetID := "com.mendix.widget.custom.CavitySelector.CavitySelector" + + // Must not be in embedded templates + embedded, err := GetTemplate(widgetID) + if err != nil { + t.Fatalf("GetTemplate: %v", err) + } + if embedded != nil { + t.Skip("CavitySelector is now an embedded template — test no longer relevant") + } + + idGen := func() string { return strings.Repeat("a", 32) } + bsonType, bsonObj, propTypeIDs, _, err := GetTemplateFullBSON(widgetID, idGen, crusherProjectPath) + if err != nil { + t.Fatalf("GetTemplateFullBSON fallback: %v", err) + } + if bsonType == nil { + t.Fatal("expected non-nil bsonType from MPK fallback") + } + if bsonObj == nil { + t.Fatal("expected non-nil bsonObj from MPK fallback") + } + if len(propTypeIDs) == 0 { + t.Error("expected non-empty propTypeIDs") + } +} +``` + +Also add the `os` and `strings` imports if missing from `augment_test.go`. + +- [ ] **Step 3.2: Run test to confirm it fails** + +```bash +cd D:/gh/mxcli +go test ./sdk/widgets/ -run "TestGetTemplateFullBSON_FallsBackToMPK" -v +``` + +Expected: FAIL — `GetTemplateFullBSON` returns `nil` for unknown widget (no fallback yet). + +- [ ] **Step 3.3: Add generatedCache and getOrGenerateTemplate to loader.go** + +In `sdk/widgets/loader.go`, add after the `templateCache` declaration block (around line 117): + +```go +// generatedCache stores MPK-derived templates for the session lifetime. +// Key: widgetID string. Value: *WidgetTemplate (placeholder IDs, not yet remapped). +var generatedCache sync.Map +``` + +Then add the new helper function. Insert before `GetTemplateBSON` (around line 208): + +```go +// getOrGenerateTemplate returns a WidgetTemplate for widgetID. It checks the embedded +// template cache first, then falls back to deriving a template from the project's .mpk +// widget file. Returns nil, nil when the widget is unknown and no MPK is available. +func getOrGenerateTemplate(widgetID, projectPath string) (*WidgetTemplate, error) { + // 1. Embedded templates (existing path) + if tmpl, err := GetTemplate(widgetID); err != nil || tmpl != nil { + return tmpl, err + } + + // 2. Session cache of previously generated templates + if cached, ok := generatedCache.Load(widgetID); ok { + return cached.(*WidgetTemplate), nil + } + + // 3. Derive from MPK in project/widgets/ + if projectPath == "" { + return nil, nil + } + mpkPath, err := mpk.FindMPK(projectPath, widgetID) + if err != nil { + return nil, fmt.Errorf("widget %q: scan MPK directory: %w", widgetID, err) + } + if mpkPath == "" { + return nil, nil // no MPK found — caller treats nil as "widget unknown" + } + def, err := mpk.ParseMPKForWidget(mpkPath, widgetID) + if err != nil { + return nil, fmt.Errorf("widget %q: parse MPK: %w", widgetID, err) + } + if def == nil { + return nil, nil + } + tmpl := GenerateFromMPK(def) + generatedCache.Store(widgetID, tmpl) + return tmpl, nil +} +``` + +- [ ] **Step 3.4: Update GetTemplateBSON to use getOrGenerateTemplate** + +In `sdk/widgets/loader.go`, in `GetTemplateBSON` (around line 208), replace: + +```go +tmpl, err := GetTemplate(widgetID) +if err != nil { + return nil, nil, err +} +if tmpl == nil { + return nil, nil, nil +} +``` + +with: + +```go +tmpl, err := getOrGenerateTemplate(widgetID, projectPath) +if err != nil { + return nil, nil, err +} +if tmpl == nil { + return nil, nil, nil +} +``` + +- [ ] **Step 3.5: Update GetTemplateFullBSON to use getOrGenerateTemplate** + +In `sdk/widgets/loader.go`, in `GetTemplateFullBSON` (around line 240), replace: + +```go +tmpl, err := GetTemplate(widgetID) +if err != nil { + return nil, nil, nil, "", err +} +if tmpl == nil { + return nil, nil, nil, "", nil +} +``` + +with: + +```go +tmpl, err := getOrGenerateTemplate(widgetID, projectPath) +if err != nil { + return nil, nil, nil, "", err +} +if tmpl == nil { + return nil, nil, nil, "", nil +} +``` + +- [ ] **Step 3.6: Run tests** + +```bash +cd D:/gh/mxcli +go test ./sdk/widgets/ -run "TestGetTemplateFullBSON_FallsBackToMPK" -v +``` + +Expected: PASS (or SKIP if CrusherCopilot not present). + +Run full widget package tests to check for regressions: +```bash +go test ./sdk/widgets/... -v 2>&1 | tail -20 +``` + +Expected: All PASS (file-dependent tests may SKIP). + +- [ ] **Step 3.7: Build and verify no compilation errors** + +```bash +cd D:/gh/mxcli +make build +``` + +Expected: Build succeeds with no errors. + +- [ ] **Step 3.8: Commit** + +```bash +cd D:/gh/mxcli +git add sdk/widgets/loader.go sdk/widgets/augment_test.go +git commit -m "feat: fall back to MPK-derived template for unknown pluggable widgets" +``` + +--- + +## Task 4: End-to-end verification + +**Context:** Confirm that a `create page` MDL command referencing a Crusher widget (which has no embedded template) succeeds without error and produces an MPR that Studio Pro accepts without CE0463. + +**Files:** No new files — run existing CLI against CrusherCopilot. + +- [ ] **Step 4.1: Run make test** + +```bash +cd D:/gh/mxcli +make test +``` + +Expected: All tests pass. + +- [ ] **Step 4.2: Smoke-test CLI against CrusherCopilot** + +```bash +cd D:/gh/mxcli +./bin/mxcli -p "D:/gh/posui/mendix/CrusherCopilot/CrusherCopilot.mpr" -c \ + "show widgets" +``` + +Expected: Output lists widget types including CavitySelector and other Crusher widgets (resolved from MPK). + +- [ ] **Step 4.3: Commit if any fixups needed, otherwise done** + +If the smoke test surfaces a BSON issue, debug using `.claude/skills/debug-bson.md`. +Final commit if any fixups were made: + +```bash +git add -p +git commit -m "fix: " +``` + +--- + +## Self-Review Notes + +- **Spec coverage:** Multi-widget MPK (Task 1) ✓ · generate.go (Task 2) ✓ · loader.go fallback (Task 3) ✓ · session cache (Task 3) ✓ · performance fallback deferred (out of scope per spec) ✓ · 5 named tests (Tasks 2+3) ✓ · acceptance criterion end-to-end (Task 4) ✓ +- **Type consistency:** `GenerateFromMPK` signature is `(def *mpk.WidgetDefinition) *WidgetTemplate` — used identically in generate.go and loader.go · `ParseMPKForWidget` signature `(mpkPath, widgetID string) (*WidgetDefinition, error)` — consistent across mpk.go and loader.go · `FindMPK` returns `(string, error)` — error correctly handled in `getOrGenerateTemplate` +- **No placeholders:** All steps contain complete code. No TBDs. From 6e66ed9febdca6408c1d5952c535ab2639991691 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 09:16:24 +0800 Subject: [PATCH 03/18] feat: support multi-widget MPK files in FindMPK and ParseMPKForWidget Replace getWidgetIDFromMPK (reads only the first WidgetFiles entry) with getWidgetIDsFromMPK which iterates all entries, so MPKs that bundle multiple widgets (e.g. CrusherWidgets.mpk) are fully indexed. Add ParseMPKForWidget(mpkPath, widgetID) with a compound cache key so callers can request any individual widget from a multi-widget MPK without re-parsing the archive. Guard against oversized package.xml with the same maxTotalSize cap used in ParseMPK. Co-Authored-By: Claude Sonnet 4.6 --- sdk/widgets/mpk/mpk.go | 177 +++++++++++++++++++++++++++--------- sdk/widgets/mpk/mpk_test.go | 48 ++++++++++ 2 files changed, 184 insertions(+), 41 deletions(-) diff --git a/sdk/widgets/mpk/mpk.go b/sdk/widgets/mpk/mpk.go index 944a6bd6..7a9bd935 100644 --- a/sdk/widgets/mpk/mpk.go +++ b/sdk/widgets/mpk/mpk.go @@ -190,17 +190,7 @@ func ParseMPK(mpkPath string) (*WidgetDefinition, error) { return nil, fmt.Errorf("failed to parse %s: %w", widgetFilePath, err) } - def := &WidgetDefinition{ - ID: widget.ID, - Name: widget.Name, - Version: version, - IsPluggable: widget.PluginWidget == "true", - } - - // Walk property groups to collect properties - for _, pg := range widget.PropertyGroups { - walkPropertyGroup(pg, "", def) - } + def := buildDefinition(&widget, version) // Cache defCacheLock.Lock() @@ -307,15 +297,18 @@ func FindMPK(projectDir string, widgetID string) (string, error) { return "", fmt.Errorf("failed to scan widgets directory: %w", err) } - // Build mapping by parsing each .mpk's package.xml and widget XML + // Build mapping by parsing each .mpk's package.xml and widget XML. + // Multi-widget MPKs list multiple widget IDs; map each one to this file. dirMap := make(map[string]string) for _, mpkPath := range matches { - wid, err := getWidgetIDFromMPK(mpkPath) + wids, err := getWidgetIDsFromMPK(mpkPath) if err != nil { continue // Skip unparseable files } - if wid != "" { - dirMap[wid] = mpkPath + for _, wid := range wids { + if wid != "" { + dirMap[wid] = mpkPath + } } } @@ -327,82 +320,184 @@ func FindMPK(projectDir string, widgetID string) (string, error) { return dirMap[widgetID], nil } -// getWidgetIDFromMPK extracts the widget ID from an .mpk file without fully parsing it. -func getWidgetIDFromMPK(mpkPath string) (string, error) { +// getWidgetIDsFromMPK returns ALL widget IDs declared in an .mpk package.xml. +// Multi-widget MPKs (e.g. CrusherWidgets.mpk) list multiple entries. +func getWidgetIDsFromMPK(mpkPath string) ([]string, error) { r, err := zip.OpenReader(mpkPath) if err != nil { - return "", err + return nil, err } defer r.Close() - // Find package.xml to get widget file path - var widgetFilePath string + var widgetFilePaths []string var totalExtracted uint64 for _, f := range r.File { if f.Name == "package.xml" { if f.UncompressedSize64 > maxFileSize { - return "", fmt.Errorf("package.xml exceeds max file size (%d > %d)", f.UncompressedSize64, maxFileSize) + return nil, fmt.Errorf("package.xml exceeds max file size (%d > %d)", f.UncompressedSize64, maxFileSize) } rc, err := f.Open() if err != nil { - return "", err + return nil, err } data, err := io.ReadAll(rc) rc.Close() if err != nil { - return "", err + return nil, err } totalExtracted += uint64(len(data)) if totalExtracted > maxTotalSize { - return "", fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + return nil, fmt.Errorf("total extracted size exceeds limit") } var pkg xmlPackage if err := xml.Unmarshal(data, &pkg); err != nil { - return "", err + return nil, err } - if len(pkg.ClientModule.WidgetFiles) > 0 { - widgetFilePath = pkg.ClientModule.WidgetFiles[0].Path + for _, wf := range pkg.ClientModule.WidgetFiles { + widgetFilePaths = append(widgetFilePaths, wf.Path) } break } } - if widgetFilePath == "" { - return "", nil + var ids []string + for _, wfPath := range widgetFilePaths { + for _, f := range r.File { + if f.Name != wfPath { + continue + } + if f.UncompressedSize64 > maxFileSize { + continue + } + rc, err := f.Open() + if err != nil { + continue + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + continue + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return ids, fmt.Errorf("total extracted size exceeds limit") + } + var widget struct { + ID string `xml:"id,attr"` + } + if err := xml.Unmarshal(data, &widget); err != nil { + continue + } + if widget.ID != "" { + ids = append(ids, widget.ID) + } + } + } + return ids, nil +} + +// buildDefinition constructs a WidgetDefinition from a parsed xmlWidget and version string. +func buildDefinition(widget *xmlWidget, version string) *WidgetDefinition { + def := &WidgetDefinition{ + ID: widget.ID, + Name: widget.Name, + Version: version, + IsPluggable: widget.PluginWidget == "true", + } + for _, pg := range widget.PropertyGroups { + walkPropertyGroup(pg, "", def) + } + return def +} + +// ParseMPKForWidget parses the widget XML for a specific widgetID from an .mpk file. +// Unlike ParseMPK (which reads only the first widget), this scans all widget files +// declared in package.xml to find the one whose ID matches widgetID. +// Needed for multi-widget .mpk packages (e.g. CrusherWidgets.mpk). +// Returns nil, nil when widgetID is not found in the MPK. +func ParseMPKForWidget(mpkPath string, widgetID string) (*WidgetDefinition, error) { + cacheKey := mpkPath + "\x00" + widgetID + defCacheLock.RLock() + if def, ok := defCache[cacheKey]; ok { + defCacheLock.RUnlock() + return def, nil } + defCacheLock.RUnlock() - // Read widget XML to get the id attribute + r, err := zip.OpenReader(mpkPath) + if err != nil { + return nil, fmt.Errorf("failed to open mpk: %w", err) + } + defer r.Close() + + var pkg xmlPackage + var version string + var totalExtracted uint64 for _, f := range r.File { - if f.Name == widgetFilePath { + if f.Name == "package.xml" { if f.UncompressedSize64 > maxFileSize { - return "", fmt.Errorf("%s exceeds max file size (%d > %d)", widgetFilePath, f.UncompressedSize64, maxFileSize) + return nil, fmt.Errorf("package.xml exceeds max size") } rc, err := f.Open() if err != nil { - return "", err + return nil, fmt.Errorf("open package.xml: %w", err) } data, err := io.ReadAll(rc) rc.Close() if err != nil { - return "", err + return nil, fmt.Errorf("read package.xml: %w", err) } totalExtracted += uint64(len(data)) if totalExtracted > maxTotalSize { - return "", fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + return nil, fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) } + if err := xml.Unmarshal(data, &pkg); err != nil { + return nil, fmt.Errorf("parse package.xml: %w", err) + } + version = pkg.ClientModule.Version + break + } + } - // Quick XML parse to just get the id attribute - var widget struct { - ID string `xml:"id,attr"` + for _, wf := range pkg.ClientModule.WidgetFiles { + for _, f := range r.File { + if f.Name != wf.Path { + continue } + if f.UncompressedSize64 > maxFileSize { + continue + } + rc, err := f.Open() + if err != nil { + continue + } + data, err := io.ReadAll(rc) + rc.Close() + if err != nil { + continue + } + totalExtracted += uint64(len(data)) + if totalExtracted > maxTotalSize { + return nil, fmt.Errorf("total extracted size exceeds limit (%d > %d)", totalExtracted, maxTotalSize) + } + + var widget xmlWidget if err := xml.Unmarshal(data, &widget); err != nil { - return "", err + continue } - return widget.ID, nil + if widget.ID != widgetID { + continue + } + + def := buildDefinition(&widget, version) + defCacheLock.Lock() + defCache[cacheKey] = def + defCacheLock.Unlock() + return def, nil } } - return "", nil + return nil, nil } // PropertyKeys returns a set of regular (non-system) property keys from the definition. diff --git a/sdk/widgets/mpk/mpk_test.go b/sdk/widgets/mpk/mpk_test.go index c2fbf222..b4668e78 100644 --- a/sdk/widgets/mpk/mpk_test.go +++ b/sdk/widgets/mpk/mpk_test.go @@ -184,6 +184,54 @@ func TestNormalizeType(t *testing.T) { } } +func TestFindMPK_MultiWidget(t *testing.T) { + ClearCache() + projectDir := filepath.Join("..", "testdata", "crushertestproject") + if _, err := os.Stat(projectDir); err != nil { + t.Skip("crusher test fixture not available") + } + + widgets := []string{ + "com.mendix.widget.custom.CavitySelector.CavitySelector", + "com.mendix.widget.custom.CrusherSlider.CrusherSlider", + "com.mendix.widget.custom.PredictionBadge.PredictionBadge", + "com.mendix.widget.custom.CrusherSimCanvas.CrusherSimCanvas", + "com.mendix.widget.custom.HeatmapViz.HeatmapViz", + } + for _, wid := range widgets { + found, err := FindMPK(projectDir, wid) + if err != nil { + t.Fatalf("FindMPK(%q): %v", wid, err) + } + if found == "" { + t.Errorf("FindMPK(%q): expected MPK path, got empty string", wid) + } + } +} + +func TestParseMPKForWidget_MultiWidget(t *testing.T) { + ClearCache() + mpkPath := filepath.Join("..", "testdata", "crushertestproject", "widgets", "CrusherWidgets.mpk") + if _, err := os.Stat(mpkPath); err != nil { + t.Skip("crusher test fixture not available") + } + + widgetID := "com.mendix.widget.custom.CavitySelector.CavitySelector" + def, err := ParseMPKForWidget(mpkPath, widgetID) + if err != nil { + t.Fatalf("ParseMPKForWidget: %v", err) + } + if def == nil { + t.Fatal("ParseMPKForWidget: got nil definition") + } + if def.ID != widgetID { + t.Errorf("ID = %q, want %q", def.ID, widgetID) + } + if len(def.Properties) == 0 { + t.Error("expected at least one property") + } +} + func fileExists(path string) bool { _, err := os.Stat(path) return err == nil From d9ed3bec5107126e1017e9be9284a5add64c20d4 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 09:16:36 +0800 Subject: [PATCH 04/18] feat: generate WidgetTemplate from MPK property definitions Add GenerateFromMPK in sdk/widgets/generate.go: given a parsed WidgetDefinition from an MPK file, build a complete WidgetTemplate with the correct BSON structure (CustomWidgets$CustomWidgetType + WidgetObjectType + WidgetObject). TypePointer on the WidgetObject references the ObjectType ID, not the CustomWidgetType ID. All $IDs use placeholder prefix so collectIDs can remap them to real UUIDs at serialisation time. Marks generated templates with Generated:true so the augment pass is skipped (the MPK is already the source of truth). Co-Authored-By: Claude Sonnet 4.6 --- sdk/widgets/generate.go | 58 ++++++++ sdk/widgets/generate_test.go | 268 +++++++++++++++++++++++++++++++++++ 2 files changed, 326 insertions(+) create mode 100644 sdk/widgets/generate.go create mode 100644 sdk/widgets/generate_test.go diff --git a/sdk/widgets/generate.go b/sdk/widgets/generate.go new file mode 100644 index 00000000..2914e2e3 --- /dev/null +++ b/sdk/widgets/generate.go @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import "github.com/mendixlabs/mxcli/sdk/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. +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 { + bsonType := xmlTypeToBSONType(p.Type) + if bsonType == "" { + continue // unknown XML type — skip silently + } + pt, prop := createPropertyPair(p, bsonType) + if pt != nil { + propTypes = append(propTypes, pt) + } + if prop != nil { + objProps = append(objProps, prop) + } + } + + typeMap := map[string]any{ + "$ID": typeID, + "$Type": "CustomWidgets$CustomWidgetType", + "WidgetId": def.ID, + "ObjectType": map[string]any{ + "$ID": objTypeID, + "$Type": "CustomWidgets$WidgetObjectType", + "PropertyTypes": propTypes, + }, + } + + objectMap := map[string]any{ + "$ID": placeholderID(), + "$Type": "CustomWidgets$WidgetObject", + "TypePointer": objTypeID, + "Properties": objProps, + } + + return &WidgetTemplate{ + WidgetID: def.ID, + Name: def.Name, + Version: def.Version, + Generated: true, + Type: typeMap, + Object: objectMap, + } +} diff --git a/sdk/widgets/generate_test.go b/sdk/widgets/generate_test.go new file mode 100644 index 00000000..3c823d93 --- /dev/null +++ b/sdk/widgets/generate_test.go @@ -0,0 +1,268 @@ +// SPDX-License-Identifier: Apache-2.0 + +package widgets + +import ( + "strings" + "testing" + + "github.com/mendixlabs/mxcli/sdk/widgets/mpk" +) + +func TestGenerateFromMPK_BasicTypes(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Version: "1.0.0", + Properties: []mpk.PropertyDef{ + {Key: "label", Type: "string", Caption: "Label"}, + {Key: "enabled", Type: "boolean", Caption: "Enabled", DefaultValue: "true"}, + {Key: "count", Type: "integer", Caption: "Count", DefaultValue: "0"}, + {Key: "value", Type: "expression", Caption: "Value"}, + {Key: "attr", Type: "attribute", Caption: "Attribute"}, + }, + } + + tmpl := GenerateFromMPK(def) + + if tmpl == nil { + t.Fatal("GenerateFromMPK returned nil") + } + if tmpl.WidgetID != def.ID { + t.Errorf("WidgetID = %q, want %q", tmpl.WidgetID, def.ID) + } + if tmpl.Name != def.Name { + t.Errorf("Name = %q, want %q", tmpl.Name, def.Name) + } + if tmpl.Version != def.Version { + t.Errorf("Version = %q, want %q", tmpl.Version, def.Version) + } + if tmpl.Type == nil { + t.Fatal("Type is nil") + } + if tmpl.Object == nil { + t.Fatal("Object is nil") + } + + if got := tmpl.Type["$Type"]; got != "CustomWidgets$CustomWidgetType" { + t.Errorf("Type.$Type = %v, want CustomWidgets$CustomWidgetType", got) + } + + objType, ok := tmpl.Type["ObjectType"].(map[string]any) + if !ok { + t.Fatal("Type.ObjectType missing or wrong type") + } + propTypes, ok := objType["PropertyTypes"].([]any) + if !ok { + t.Fatal("ObjectType.PropertyTypes missing or wrong type") + } + nonMarkerPropTypes := 0 + for _, pt := range propTypes { + if _, isFloat := pt.(float64); !isFloat { + nonMarkerPropTypes++ + } + } + if nonMarkerPropTypes != 5 { + t.Errorf("PropertyTypes count = %d, want 5", nonMarkerPropTypes) + } + + objProps, ok := tmpl.Object["Properties"].([]any) + if !ok { + t.Fatal("Object.Properties missing or wrong type") + } + nonMarkerProps := 0 + for _, p := range objProps { + if _, isFloat := p.(float64); !isFloat { + nonMarkerProps++ + } + } + if nonMarkerProps != 5 { + t.Errorf("Properties count = %d, want 5", nonMarkerProps) + } +} + +func TestGenerateFromMPK_TypePointerCrossReference(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + {Key: "mode", Type: "enumeration", Caption: "Mode", DefaultValue: "fast"}, + }, + } + + tmpl := GenerateFromMPK(def) + + objType := tmpl.Type["ObjectType"].(map[string]any) + objTypeID := objType["$ID"].(string) + propTypes := objType["PropertyTypes"].([]any) + var ptID string + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + if ptMap["PropertyKey"] == "mode" { + ptID = ptMap["$ID"].(string) + break + } + } + if ptID == "" { + t.Fatal("PropertyType for 'mode' not found") + } + + objProps := tmpl.Object["Properties"].([]any) + var propTypePointer string + for _, p := range objProps { + pMap, ok := p.(map[string]any) + if !ok { + continue + } + propTypePointer = pMap["TypePointer"].(string) + break + } + if propTypePointer != ptID { + t.Errorf("Property.TypePointer = %q, want PropertyType.$ID %q", propTypePointer, ptID) + } + + // Also verify the top-level objectMap TypePointer → WidgetObjectType.$ID + gotObjTP := tmpl.Object["TypePointer"].(string) + if gotObjTP != objTypeID { + t.Errorf("Object.TypePointer = %q, want ObjectType.$ID %q", gotObjTP, objTypeID) + } +} + +func TestGenerateFromMPK_NestedObject(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + { + Key: "columns", + Type: "object", + Caption: "Columns", + IsList: true, + Children: []mpk.PropertyDef{ + {Key: "header", Type: "string", Caption: "Header"}, + {Key: "attr", Type: "attribute", Caption: "Attribute"}, + }, + }, + }, + } + + tmpl := GenerateFromMPK(def) + + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + var columnsPT map[string]any + for _, pt := range propTypes { + ptMap, ok := pt.(map[string]any) + if !ok { + continue + } + if ptMap["PropertyKey"] == "columns" { + columnsPT = ptMap + break + } + } + if columnsPT == nil { + t.Fatal("columns PropertyType not found") + } + + vt, ok := columnsPT["ValueType"].(map[string]any) + if !ok { + t.Fatal("ValueType missing on columns property") + } + nestedObjType, ok := vt["ObjectType"].(map[string]any) + if !ok { + t.Fatal("ObjectType missing on columns ValueType — nested object not built") + } + nestedPTs, ok := nestedObjType["PropertyTypes"].([]any) + if !ok { + t.Fatal("nested PropertyTypes missing") + } + nestedCount := 0 + for _, npt := range nestedPTs { + if _, isFloat := npt.(float64); !isFloat { + nestedCount++ + } + } + if nestedCount != 2 { + t.Errorf("nested PropertyTypes count = %d, want 2", nestedCount) + } +} + +func TestGenerateFromMPK_UnknownTypeSkipped(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + {Key: "good", Type: "string", Caption: "Good"}, + {Key: "bad", Type: "unknownXmlType", Caption: "Bad"}, + }, + } + + tmpl := GenerateFromMPK(def) + + objType := tmpl.Type["ObjectType"].(map[string]any) + propTypes := objType["PropertyTypes"].([]any) + count := 0 + for _, pt := range propTypes { + if _, isFloat := pt.(float64); !isFloat { + count++ + } + } + if count != 1 { + t.Errorf("PropertyTypes count = %d, want 1 (unknown type skipped)", count) + } +} + +func TestGenerateFromMPK_PlaceholderIDsRemapped(t *testing.T) { + ResetPlaceholderCounter() + + def := &mpk.WidgetDefinition{ + ID: "com.example.Widget", + Name: "Test Widget", + Properties: []mpk.PropertyDef{ + {Key: "label", Type: "string", Caption: "Label"}, + }, + } + + tmpl := GenerateFromMPK(def) + + callCount := 0 + idGen := func() string { + callCount++ + return strings.Repeat("f", 32) + } + + templateCacheLock.Lock() + templateCache["com.example.Widget"] = tmpl + templateCacheLock.Unlock() + defer func() { + templateCacheLock.Lock() + delete(templateCache, "com.example.Widget") + templateCacheLock.Unlock() + }() + + bsonType, bsonObj, _, _, err := GetTemplateFullBSON("com.example.Widget", idGen, "") + if err != nil { + t.Fatalf("GetTemplateFullBSON: %v", err) + } + if containsPlaceholderID(bsonType) { + t.Error("placeholder IDs leaked in bsonType") + } + if bsonObj != nil && containsPlaceholderID(bsonObj) { + t.Error("placeholder IDs leaked in bsonObj") + } + if callCount == 0 { + t.Error("idGen was never called — IDs were not remapped") + } +} From 2added634d8c9a464f9cdc958043af4d144dc465 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 09:16:51 +0800 Subject: [PATCH 05/18] feat: fall back to MPK-derived template for unknown pluggable widgets MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add getOrGenerateTemplate (3-tier lookup): embedded JSON → session cache → MPK derivation. GetTemplateBSON and GetTemplateFullBSON now use this instead of GetTemplate, so any pluggable widget whose .mpk lives in the project's widgets/ directory works without a pre-built embedded template. Guard augmentFromMPK with !tmpl.Generated to avoid double-augmenting templates that were already built from MPK data. Test fixture at sdk/widgets/testdata/crushertestproject/ carries CrusherWidgets.mpk so the integration test runs without an external project. Co-Authored-By: Claude Sonnet 4.6 --- sdk/widgets/augment_test.go | 36 +++++++++ sdk/widgets/loader.go | 72 ++++++++++++++++-- .../crushertestproject/testproject.mpr | 0 .../widgets/CrusherWidgets.mpk | Bin 0 -> 375647 bytes 4 files changed, 101 insertions(+), 7 deletions(-) create mode 100644 sdk/widgets/testdata/crushertestproject/testproject.mpr create mode 100644 sdk/widgets/testdata/crushertestproject/widgets/CrusherWidgets.mpk diff --git a/sdk/widgets/augment_test.go b/sdk/widgets/augment_test.go index 05d93548..3aab03da 100644 --- a/sdk/widgets/augment_test.go +++ b/sdk/widgets/augment_test.go @@ -4,6 +4,8 @@ package widgets import ( "fmt" + "os" + "path/filepath" "testing" "github.com/mendixlabs/mxcli/sdk/widgets/mpk" @@ -662,6 +664,40 @@ func TestAugmentTemplate_NoPlaceholderLeakAfterBSONConversion(t *testing.T) { } } +func TestGetTemplateFullBSON_FallsBackToMPK(t *testing.T) { + crusherMprPath := filepath.Join("testdata", "crushertestproject", "testproject.mpr") + if _, err := os.Stat(crusherMprPath); err != nil { + t.Skip("crusher test fixture not available") + } + + ResetGeneratedCache() + + widgetID := "com.mendix.widget.custom.CavitySelector.CavitySelector" + + callCount := 0 + idGen := func() string { + callCount++ + return fmt.Sprintf("%032x", callCount) + } + + bsonType, bsonObj, propTypeIDs, _, err := GetTemplateFullBSON(widgetID, idGen, crusherMprPath) + if err != nil { + t.Fatalf("GetTemplateFullBSON: %v", err) + } + if bsonType == nil { + t.Fatal("expected non-nil bsonType") + } + if bsonObj == nil { + t.Fatal("expected non-nil bsonObj") + } + if len(propTypeIDs) == 0 { + t.Error("expected non-empty propTypeIDs") + } + if callCount == 0 { + t.Error("idGen was never called — IDs were not remapped") + } +} + // bsonTypeToXmlType is a test helper to reverse the mapping. func bsonTypeToXmlType(bsonType string) string { switch bsonType { diff --git a/sdk/widgets/loader.go b/sdk/widgets/loader.go index 0fd876f3..efaf0293 100644 --- a/sdk/widgets/loader.go +++ b/sdk/widgets/loader.go @@ -106,6 +106,7 @@ type WidgetTemplate struct { Name string `json:"name"` Version string `json:"version"` ExtractedFrom string `json:"extractedFrom"` + Generated bool `json:"-"` // true if derived from MPK, not from embedded template Type map[string]any `json:"type"` Object map[string]any `json:"object"` // WidgetObject with all property values } @@ -116,6 +117,10 @@ var ( templateCacheLock sync.RWMutex ) +// generatedCache stores MPK-derived templates for the session lifetime. +// Key: widgetID string. Value: *WidgetTemplate (placeholder IDs, not yet remapped). +var generatedCache sync.Map + // widgetTemplateIndex maps widget IDs to template filenames. // Built lazily by scanning embedded template JSON files. var ( @@ -201,12 +206,50 @@ func GetTemplate(widgetID string) (*WidgetTemplate, error) { return &tmpl, nil } +// getOrGenerateTemplate returns a WidgetTemplate for widgetID. It checks the embedded +// template cache first, then falls back to deriving a template from the project's .mpk +// widget file. Returns nil, nil when the widget is unknown and no MPK is available. +func getOrGenerateTemplate(widgetID, projectPath string) (*WidgetTemplate, error) { + // 1. Embedded templates (existing path) + if tmpl, err := GetTemplate(widgetID); err != nil || tmpl != nil { + return tmpl, err + } + + // 2. Session cache of previously generated templates + if cached, ok := generatedCache.Load(widgetID); ok { + return cached.(*WidgetTemplate), nil + } + + // 3. Derive from MPK in project/widgets/ + if projectPath == "" { + return nil, nil + } + projectDir := filepath.Dir(projectPath) + mpkPath, err := mpk.FindMPK(projectDir, widgetID) + if err != nil { + return nil, fmt.Errorf("widget %q: scan MPK directory: %w", widgetID, err) + } + if mpkPath == "" { + return nil, nil // no MPK found — caller treats nil as "widget unknown" + } + def, err := mpk.ParseMPKForWidget(mpkPath, widgetID) + if err != nil { + return nil, fmt.Errorf("widget %q: parse MPK: %w", widgetID, err) + } + if def == nil { + return nil, nil + } + tmpl := GenerateFromMPK(def) + generatedCache.Store(widgetID, tmpl) + return tmpl, nil +} + // GetTemplateBSON loads a widget template and converts its type definition to BSON. // The returned bson.D can be used directly in widget creation. // IDs in the template are regenerated with new UUIDs while preserving internal references. // If projectPath is non-empty, the template is augmented from the project's .mpk widget file. func GetTemplateBSON(widgetID string, idGenerator func() string, projectPath string) (bson.D, map[string]PropertyTypeIDEntry, error) { - tmpl, err := GetTemplate(widgetID) + tmpl, err := getOrGenerateTemplate(widgetID, projectPath) if err != nil { return nil, nil, err } @@ -214,8 +257,10 @@ func GetTemplateBSON(widgetID string, idGenerator func() string, projectPath str return nil, nil, nil } - // Deep-clone and augment from .mpk - tmpl = augmentFromMPK(tmpl, widgetID, projectPath) + // Deep-clone and augment from .mpk (skip for generated templates — already complete) + if !tmpl.Generated { + tmpl = augmentFromMPK(tmpl, widgetID, projectPath) + } // Phase 1: Collect all $ID values and create old->new ID mappings idMapping := make(map[string]string) @@ -238,7 +283,7 @@ func GetTemplateBSON(widgetID string, idGenerator func() string, projectPath str // If projectPath is non-empty, the template is augmented from the project's .mpk widget file. // Returns: (clonedType, clonedObject, propertyTypeIDs, objectTypeID, error) func GetTemplateFullBSON(widgetID string, idGenerator func() string, projectPath string) (bson.D, bson.D, map[string]PropertyTypeIDEntry, string, error) { - tmpl, err := GetTemplate(widgetID) + tmpl, err := getOrGenerateTemplate(widgetID, projectPath) if err != nil { return nil, nil, nil, "", err } @@ -246,8 +291,10 @@ func GetTemplateFullBSON(widgetID string, idGenerator func() string, projectPath return nil, nil, nil, "", nil } - // Deep-clone and augment from .mpk - tmpl = augmentFromMPK(tmpl, widgetID, projectPath) + // Deep-clone and augment from .mpk (skip for generated templates — already complete) + if !tmpl.Generated { + tmpl = augmentFromMPK(tmpl, widgetID, projectPath) + } // Phase 1: Collect all $ID values from Type and create old->new ID mappings idMapping := make(map[string]string) @@ -907,10 +954,13 @@ func augmentFromMPK(tmpl *WidgetTemplate, widgetID string, projectPath string) * return tmpl } - def, err := mpk.ParseMPK(mpkPath) + def, err := mpk.ParseMPKForWidget(mpkPath, widgetID) if err != nil { return tmpl } + if def == nil { + return tmpl + } // Deep-clone so we don't mutate the cached template clone, err := deepCloneTemplate(tmpl) @@ -926,6 +976,14 @@ func augmentFromMPK(tmpl *WidgetTemplate, widgetID string, projectPath string) * return clone } +// ResetGeneratedCache clears the MPK-derived template cache (for testing). +func ResetGeneratedCache() { + generatedCache.Range(func(k, _ any) bool { + generatedCache.Delete(k) + return true + }) +} + // ListAvailableTemplates returns a list of available widget template IDs. func ListAvailableTemplates() []string { index := getWidgetTemplateIndex() diff --git a/sdk/widgets/testdata/crushertestproject/testproject.mpr b/sdk/widgets/testdata/crushertestproject/testproject.mpr new file mode 100644 index 00000000..e69de29b diff --git a/sdk/widgets/testdata/crushertestproject/widgets/CrusherWidgets.mpk b/sdk/widgets/testdata/crushertestproject/widgets/CrusherWidgets.mpk new file mode 100644 index 0000000000000000000000000000000000000000..aeb53d4415fa548df656624667af97aff5fb9c45 GIT binary patch literal 375647 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 oI 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

?Zuuxutgut|8|p(M4)7;zcksdF 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 oI^koI(sv<!(v; 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 QfS!?qKtXB1raS2W0FNIGIRF3v literal 0 HcmV?d00001 From 823c4ca0f6cb837adeef8d3237a6f288ebb2c263 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 09:20:34 +0800 Subject: [PATCH 06/18] fix: extract-templates scans all project widgets instead of a hardcoded list Add ListAllCustomWidgetTypes() to sdk/mpr/reader_widgets.go: scans every page and snippet, collects all unique CustomWidgets$CustomWidgetType widget IDs, and returns one RawCustomWidgetType per unique ID. Rewrite cmd/mxcli/cmd_extract_templates.go to call ListAllCustomWidgetTypes so it discovers and extracts every pluggable widget in the project without a predefined list. Project-specific widgets no longer require code changes to be extractable. Co-Authored-By: Claude Sonnet 4.6 --- cmd/mxcli/cmd_extract_templates.go | 83 +++++++++++------------------- sdk/mpr/reader_widgets.go | 83 ++++++++++++++++++++++++++++++ 2 files changed, 113 insertions(+), 53 deletions(-) diff --git a/cmd/mxcli/cmd_extract_templates.go b/cmd/mxcli/cmd_extract_templates.go index 7011e78e..e74fdfd6 100644 --- a/cmd/mxcli/cmd_extract_templates.go +++ b/cmd/mxcli/cmd_extract_templates.go @@ -21,9 +21,9 @@ var extractTemplatesCmd = &cobra.Command{ Long: `Extract pluggable widget type definitions from a Mendix project and save them as JSON templates for use in mxcli. -This command searches for CustomWidgets in the project and extracts -their type definitions, which can then be embedded in mxcli for -consistent widget creation across projects. +This command scans all pages and snippets in the project for pluggable +widgets and extracts their type definitions. The resulting JSON files can +be embedded in mxcli for consistent widget creation across projects. Example: mxcli extract-templates -p app.mpr -o templates/mendix-11.6/`, @@ -38,8 +38,8 @@ func init() { rootCmd.AddCommand(extractTemplatesCmd) } -// WidgetTemplate is the JSON structure for a widget template file. -type WidgetTemplate struct { +// extractedWidgetTemplate is the JSON structure for a widget template file. +type extractedWidgetTemplate struct { WidgetID string `json:"widgetId"` Name string `json:"name"` Version string `json:"version"` @@ -52,93 +52,72 @@ func runExtractTemplates(cmd *cobra.Command, args []string) error { projectPath, _ := cmd.Flags().GetString("project") outputDir, _ := cmd.Flags().GetString("output") - // Open the project reader, err := mpr.Open(projectPath) if err != nil { return fmt.Errorf("failed to open project: %w", err) } defer reader.Close() - // Get Mendix version version, _ := reader.GetMendixVersion() fmt.Printf("Extracting templates from Mendix %s project\n", version) - // Create output directory if err := os.MkdirAll(outputDir, 0755); err != nil { return fmt.Errorf("failed to create output directory: %w", err) } - // Widget IDs to extract - widgetIDs := []struct { - id string - filename string - name string - }{ - {"com.mendix.widget.web.combobox.Combobox", "combobox.json", "Combo box"}, - {"com.mendix.widget.web.gallery.Gallery", "gallery.json", "Gallery"}, - {"com.mendix.widget.web.datagrid.Datagrid", "datagrid.json", "Data grid 2"}, - {"com.mendix.widget.web.datagridtextfilter.DatagridTextFilter", "datagrid-text-filter.json", "Text filter"}, - {"com.mendix.widget.web.datagriddatefilter.DatagridDateFilter", "datagrid-date-filter.json", "Date filter"}, - {"com.mendix.widget.web.datagriddropdownfilter.DatagridDropdownFilter", "datagrid-dropdown-filter.json", "Dropdown filter"}, - {"com.mendix.widget.web.datagridnumberfilter.DatagridNumberFilter", "datagrid-number-filter.json", "Number filter"}, - {"com.mendix.widget.web.image.Image", "image.json", "Image"}, + widgets, err := reader.ListAllCustomWidgetTypes() + if err != nil { + return fmt.Errorf("failed to scan project for widget types: %w", err) + } + if len(widgets) == 0 { + fmt.Println("No pluggable widget types found in this project.") + return nil } + fmt.Printf("Found %d widget type(s)\n", len(widgets)) extracted := 0 - for _, w := range widgetIDs { - rawWidget, err := reader.FindCustomWidgetType(w.id) - if err != nil { - fmt.Printf(" [SKIP] %s: %v\n", w.name, err) - continue - } - if rawWidget == nil { - fmt.Printf(" [SKIP] %s: not found in project\n", w.name) - continue - } - - // Convert BSON to JSON-compatible map - typeMap, err := bsonDToMap(rawWidget.RawType) + for _, w := range widgets { + typeMap, err := bsonDToMap(w.RawType) if err != nil { - fmt.Printf(" [SKIP] %s: failed to convert type BSON: %v\n", w.name, err) + fmt.Printf(" [SKIP] %s: failed to convert type BSON: %v\n", w.WidgetID, err) continue } var objectMap map[string]any - if rawWidget.RawObject != nil { - objectMap, err = bsonDToMap(rawWidget.RawObject) + if w.RawObject != nil { + objectMap, err = bsonDToMap(w.RawObject) if err != nil { - fmt.Printf(" [SKIP] %s: failed to convert object BSON: %v\n", w.name, err) + fmt.Printf(" [SKIP] %s: failed to convert object BSON: %v\n", w.WidgetID, err) continue } } - template := WidgetTemplate{ - WidgetID: w.id, - Name: w.name, + template := extractedWidgetTemplate{ + WidgetID: w.WidgetID, Version: version, - ExtractedFrom: rawWidget.UnitID, + ExtractedFrom: w.UnitID, Type: typeMap, Object: objectMap, } - // Write to file - outPath := filepath.Join(outputDir, w.filename) + filename := filenameFromWidgetID(w.WidgetID) + outPath := filepath.Join(outputDir, filename) data, err := json.MarshalIndent(template, "", " ") if err != nil { - fmt.Printf(" [SKIP] %s: failed to marshal JSON: %v\n", w.name, err) + fmt.Printf(" [SKIP] %s: failed to marshal JSON: %v\n", w.WidgetID, err) continue } if err := os.WriteFile(outPath, data, 0644); err != nil { - fmt.Printf(" [SKIP] %s: failed to write file: %v\n", w.name, err) + fmt.Printf(" [SKIP] %s: failed to write file: %v\n", w.WidgetID, err) continue } - fmt.Printf(" [OK] %s -> %s\n", w.name, w.filename) + fmt.Printf(" [OK] %s -> %s\n", w.WidgetID, filename) extracted++ } - fmt.Printf("\nExtracted %d widget templates to %s\n", extracted, outputDir) + fmt.Printf("\nExtracted %d/%d widget templates to %s\n", extracted, len(widgets), outputDir) return nil } @@ -167,7 +146,6 @@ func convertBsonValue(v any) any { } return arr case primitive.Binary: - // Convert binary IDs to hex strings return fmt.Sprintf("%x", val.Data) case []byte: return fmt.Sprintf("%x", val) @@ -176,12 +154,11 @@ func convertBsonValue(v any) any { } } -// filenameFromWidgetID generates a filename from a widget ID. +// filenameFromWidgetID generates a kebab-case filename from a widget ID. +// e.g. "com.mendix.widget.web.combobox.Combobox" -> "combobox.json" func filenameFromWidgetID(widgetID string) string { - // Extract the last part after the last dot parts := strings.Split(widgetID, ".") name := parts[len(parts)-1] - // Convert camelCase to kebab-case var result strings.Builder for i, r := range name { if i > 0 && r >= 'A' && r <= 'Z' { diff --git a/sdk/mpr/reader_widgets.go b/sdk/mpr/reader_widgets.go index 4b06051c..e2bdf527 100644 --- a/sdk/mpr/reader_widgets.go +++ b/sdk/mpr/reader_widgets.go @@ -64,6 +64,89 @@ func (r *Reader) FindCustomWidgetType(widgetID string) (*RawCustomWidgetType, er return nil, nil // Not found } +// ListAllCustomWidgetTypes scans every page and snippet in the project and returns +// one RawCustomWidgetType per unique widget ID. This is used by extract-templates to +// discover all pluggable widgets without a hardcoded list. +func (r *Reader) ListAllCustomWidgetTypes() ([]*RawCustomWidgetType, error) { + units, err := r.listUnitsByType("Forms$Page") + if err != nil { + return nil, err + } + if snippets, err := r.listUnitsByType("Forms$Snippet"); err == nil { + units = append(units, snippets...) + } + + seen := make(map[string]bool) + var results []*RawCustomWidgetType + + for _, u := range units { + contents, err := r.resolveContents(u.ID, u.Contents) + if err != nil { + continue + } + if !strings.Contains(string(contents), "CustomWidgets$CustomWidget\"") { + continue + } + var doc bson.D + if err := bson.Unmarshal(contents, &doc); err != nil { + continue + } + for _, wid := range collectCustomWidgetIDs(doc) { + if seen[wid] { + continue + } + rawType, rawObject := extractWidgetTypeAndObject(contents, wid) + if rawType == nil { + continue + } + seen[wid] = true + results = append(results, &RawCustomWidgetType{ + WidgetID: wid, + RawType: rawType, + RawObject: rawObject, + UnitID: u.ID, + }) + } + } + return results, nil +} + +// collectCustomWidgetIDs walks a BSON document and collects all unique widgetId values +// found inside CustomWidgets$CustomWidgetType elements. +func collectCustomWidgetIDs(doc bson.D) []string { + var ids []string + var walk func(v any) + walk = func(v any) { + switch val := v.(type) { + case bson.D: + var isType bool + var widgetID string + for _, e := range val { + if e.Key == "$Type" && e.Value == "CustomWidgets$CustomWidgetType" { + isType = true + } + if e.Key == "WidgetId" { + if s, ok := e.Value.(string); ok { + widgetID = s + } + } + } + if isType && widgetID != "" { + ids = append(ids, widgetID) + } + for _, e := range val { + walk(e.Value) + } + case bson.A: + for _, item := range val { + walk(item) + } + } + } + walk(doc) + return ids +} + // FindAllCustomWidgetTypes searches for ALL CustomWidgets with the given // widgetID and returns their full Type/Object definitions as raw BSON. // This allows identification of different configurations of the same widget type. From 423a687bd4bf44ac5dda7f1dc25e2ba16df9476e Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 09:50:49 +0800 Subject: [PATCH 07/18] fix: handle multi-widget MPKs in widget init and docs generation Add ParseAll(mpkPath) to the mpk package: returns all WidgetDefinitions from an MPK (single-widget and multi-widget alike) by iterating every WidgetFiles entry and calling ParseMPKForWidget per ID. Update runWidgetInit and generateWidgetDocs in cmd_widget.go to call ParseAll instead of ParseMPK so that MPKs bundling multiple widgets (e.g. CrusherWidgets.mpk with 5 widgets) generate a .def.json and docs entry for each bundled widget, not just the first one. Co-Authored-By: Claude Sonnet 4.6 --- cmd/mxcli/cmd_widget.go | 94 +++++++++++++++++++++-------------------- sdk/widgets/mpk/mpk.go | 20 +++++++++ 2 files changed, 69 insertions(+), 45 deletions(-) diff --git a/cmd/mxcli/cmd_widget.go b/cmd/mxcli/cmd_widget.go index 9be761ea..a43523ca 100644 --- a/cmd/mxcli/cmd_widget.go +++ b/cmd/mxcli/cmd_widget.go @@ -242,49 +242,51 @@ func runWidgetInit(cmd *cobra.Command, args []string) error { var extracted, skipped int for _, mpkPath := range matches { - mpkDef, err := mpk.ParseMPK(mpkPath) + defs, err := mpk.ParseAll(mpkPath) if err != nil { log.Printf("warning: skipping %s: %v", filepath.Base(mpkPath), err) skipped++ continue } - mdlName := deriveMDLName(mpkDef.ID) - filename := strings.ToLower(mdlName) + ".def.json" - outPath := filepath.Join(outputDir, filename) + for _, mpkDef := range defs { + mdlName := deriveMDLName(mpkDef.ID) + filename := strings.ToLower(mdlName) + ".def.json" + outPath := filepath.Join(outputDir, filename) + + // Skip widgets that have hand-crafted built-in definitions (e.g., COMBOBOX, GALLERY) + if builtinRegistry != nil { + if _, ok := builtinRegistry.GetByWidgetID(mpkDef.ID); ok { + skipped++ + continue + } + } - // Skip widgets that have hand-crafted built-in definitions (e.g., COMBOBOX, GALLERY) - if builtinRegistry != nil { - if _, ok := builtinRegistry.GetByWidgetID(mpkDef.ID); ok { + // Skip if already exists on disk + if _, err := os.Stat(outPath); err == nil { skipped++ continue } - } - - // Skip if already exists on disk - if _, err := os.Stat(outPath); err == nil { - skipped++ - continue - } - defJSON := generateDefJSON(mpkDef, mdlName) - data, err := json.MarshalIndent(defJSON, "", " ") - if err != nil { - log.Printf("warning: skipping %s: %v", mpkDef.ID, err) - skipped++ - continue - } - data = append(data, '\n') + defJSON := generateDefJSON(mpkDef, mdlName) + data, err := json.MarshalIndent(defJSON, "", " ") + if err != nil { + log.Printf("warning: skipping %s: %v", mpkDef.ID, err) + skipped++ + continue + } + data = append(data, '\n') - if err := os.WriteFile(outPath, data, 0644); err != nil { - return fmt.Errorf("failed to write %s: %w", outPath, err) - } - kind := "custom" - if mpkDef.IsPluggable { - kind = "pluggable" + if err := os.WriteFile(outPath, data, 0644); err != nil { + return fmt.Errorf("failed to write %s: %w", outPath, err) + } + kind := "custom" + if mpkDef.IsPluggable { + kind = "pluggable" + } + fmt.Printf(" %-12s %-20s %s\n", kind, mdlName, mpkDef.ID) + extracted++ } - fmt.Printf(" %-12s %-20s %s\n", kind, mdlName, mpkDef.ID) - extracted++ } fmt.Printf("\nExtracted: %d, Skipped: %d (existing or unparseable)\n", extracted, skipped) @@ -321,29 +323,31 @@ func generateWidgetDocs(projectDir string) error { var indexEntries []string for _, mpkPath := range matches { - mpkDef, err := mpk.ParseMPK(mpkPath) + defs, err := mpk.ParseAll(mpkPath) if err != nil { continue } - mdlName := deriveMDLName(mpkDef.ID) - filename := strings.ToLower(mdlName) + ".md" - outPath := filepath.Join(docsDir, filename) + for _, mpkDef := range defs { + mdlName := deriveMDLName(mpkDef.ID) + filename := strings.ToLower(mdlName) + ".md" + outPath := filepath.Join(docsDir, filename) - doc := generateWidgetDoc(mpkDef, mdlName) + doc := generateWidgetDoc(mpkDef, mdlName) - if err := os.WriteFile(outPath, []byte(doc), 0644); err != nil { - log.Printf("warning: failed to write %s: %v", filename, err) - continue - } + if err := os.WriteFile(outPath, []byte(doc), 0644); err != nil { + log.Printf("warning: failed to write %s: %v", filename, err) + continue + } - kind := "CUSTOMWIDGET" - if mpkDef.IsPluggable { - kind = "PLUGGABLEWIDGET" + kind := "CUSTOMWIDGET" + if mpkDef.IsPluggable { + kind = "PLUGGABLEWIDGET" + } + indexEntries = append(indexEntries, fmt.Sprintf("| `%s` | %s | `%s` | %s | %d |", + kind, mdlName, mpkDef.ID, mpkDef.Name, len(mpkDef.Properties))) + generated++ } - indexEntries = append(indexEntries, fmt.Sprintf("| `%s` | %s | `%s` | %s | %d |", - kind, mdlName, mpkDef.ID, mpkDef.Name, len(mpkDef.Properties))) - generated++ } // Write index diff --git a/sdk/widgets/mpk/mpk.go b/sdk/widgets/mpk/mpk.go index 7a9bd935..2823afbd 100644 --- a/sdk/widgets/mpk/mpk.go +++ b/sdk/widgets/mpk/mpk.go @@ -540,6 +540,26 @@ func ClearCache() { dirCacheLock.Unlock() } +// ParseAll parses every widget definition bundled in an MPK file and returns them all. +// For single-widget MPKs this returns a one-element slice. For multi-widget MPKs (where +// package.xml lists multiple entries) every widget is returned. Errors for +// individual widgets are skipped; only fatal archive errors are returned. +func ParseAll(mpkPath string) ([]*WidgetDefinition, error) { + ids, err := getWidgetIDsFromMPK(mpkPath) + if err != nil { + return nil, err + } + var result []*WidgetDefinition + for _, id := range ids { + def, err := ParseMPKForWidget(mpkPath, id) + if err != nil || def == nil { + continue + } + result = append(result, def) + } + return result, nil +} + // xmlPropertyTypeMapping maps lowercased XML property type names to their canonical camelCase forms. var xmlPropertyTypeMapping = map[string]string{ "attribute": "attribute", From f40efe256336d3fc367efae5eb3fbb627934bcea Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 11:05:55 +0800 Subject: [PATCH 08/18] docs: add widget real-time registry design spec --- ...6-05-09-widget-realtime-registry-design.md | 150 ++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 docs/superpowers/specs/2026-05-09-widget-realtime-registry-design.md diff --git a/docs/superpowers/specs/2026-05-09-widget-realtime-registry-design.md b/docs/superpowers/specs/2026-05-09-widget-realtime-registry-design.md new file mode 100644 index 00000000..71e5a27d --- /dev/null +++ b/docs/superpowers/specs/2026-05-09-widget-realtime-registry-design.md @@ -0,0 +1,150 @@ +# Widget Real-Time Registry Design + +**Date:** 2026-05-09 +**Branch:** feature/mpk-template-derivation +**Status:** Approved + +## Problem + +`mxcli widget init` pre-extracts `.def.json` files from `.mpk` widget packages into +`.mxcli/widgets/`. The command skips files that already exist on disk (no mtime or +version check), so upgrading a widget in Mendix Studio Pro silently leaves stale +definitions in place. Users must remember to delete `.def.json` files and re-run +`widget init` after every widget upgrade — a step that is easy to forget and produces +no visible error until BSON serialization produces a wrong page. + +## Goal + +Eliminate the staleness problem by making widget definition lookup real-time: when +`CREATE PAGE` references a widget that is not in the built-in registry, mxcli derives +the `WidgetDefinition` on-the-fly from the project's `widgets/*.mpk` files. No +pre-extraction step is required for normal operation. + +## Non-Goals + +- Removing support for hand-crafted `.def.json` overrides (kept as escape hatch). +- Removing the `widget init` / `widget extract` commands (repurposed, not deleted). +- Changing the BSON template derivation path (already handled on this branch). + +## Chosen Approach: Lazy MPK Derivation with Optional `.def.json` Override + +Lookup order (unchanged for built-ins, new fallback for unknowns): + +``` +MDL keyword + └─ Registry built-in (.def.json embedded at compile time) → hit: use it + └─ Registry user override (.mxcli/widgets/*.def.json) → hit: use it + └─ MPK pre-scan map (mdlName → widgetID) → hit: full-parse MPK + └─ derive WidgetDefinition, cache in-memory → use it + └─ not found → error +``` + +### Phase 1 — Session startup (project path known) + +Call `registry.SetProjectDir(projectDir)`, which triggers a **lightweight pre-scan**: + +- Glob `/widgets/*.mpk` +- For each MPK: open ZIP, read only `package.xml` (already implemented in + `mpk.getWidgetIDsFromMPK`) +- For each widgetID found: compute `deriveMDLName(widgetID)` → store in + `mpkNameMap[mdlName] = widgetID` +- Skip names already in the built-in or user-override registry (built-ins win) +- Cost: ~1–2 ms per widget; a project with 30 widgets adds ~50 ms at most + +This map is used by LSP completion to offer all available widget keywords without +requiring `widget init`. + +### Phase 2 — First use of a widget (CREATE PAGE execution) + +On `registry.Get(mdlName)` or `registry.GetByWidgetID(widgetID)` miss: + +1. Look up `widgetID` from `mpkNameMap` +2. Call `mpk.FindMPK(projectDir, widgetID)` → mpkPath +3. Call `mpk.ParseMPKForWidget(mpkPath, widgetID)` → `*mpk.WidgetDefinition` + (already cached in `mpk.defCache` after first parse) +4. Convert to `executor.WidgetDefinition` via `deriveFromMPK()` (logic moved from + `cmd_widget.go:generateDefJSON`) +5. Register in `byMDLName` and `byWidgetID` — subsequent lookups are O(1) + +### Phase 3 — Hand-crafted override (optional, for complex widgets) + +Users who need custom `Modes`, non-standard `Operation` types, or MDL name overrides +write a `.def.json` by hand (or use `widget extract` as a starting point). These +files in `.mxcli/widgets/` are loaded at startup before the pre-scan, so they win +over MPK derivation. + +## Dependency Analysis + +No circular dependency is introduced: + +``` +sdk/widgets/mpk → (stdlib only, zero mdl/ imports) +mdl/executor → sdk/widgets/definitions (existing) + → sdk/widgets/mpk (new, safe) +cmd/mxcli → mdl/executor + sdk/widgets/mpk (unchanged) +``` + +## Code Changes + +### `mdl/executor/widget_registry.go` + +Add fields: +```go +projectDir string +mpkNameMap map[string]string // mdlName (upper) → widgetID +``` + +Add methods: +- `SetProjectDir(dir string) error` — stores dir, calls `preScanWidgets` +- `preScanWidgets(dir string) error` — builds `mpkNameMap` +- `deriveFromMPK(widgetID string) (*WidgetDefinition, error)` — converts + `mpk.WidgetDefinition` to `executor.WidgetDefinition`; this is the + `generateDefJSON` logic moved here from `cmd_widget.go` + +Modify: +- `Get(name string)` — add MPK fallback after registry miss +- `GetByWidgetID(id string)` — add MPK fallback after registry miss + +New import: +- `github.com/mendixlabs/mxcli/sdk/widgets/mpk` + +### `cmd/mxcli/cmd_widget.go` + +- Remove `generateDefJSON` — replaced by `registry.deriveFromMPK` +- `widget init`: remove skip-if-exists guard; change help text to describe it as a + debugging/customization tool, not a required setup step; add `--force` flag to + overwrite existing files +- `widget extract`: unchanged + +### Executor / REPL initialization + +Wherever `executor.NewWidgetRegistry()` is called and a project path is available, +follow up with `registry.SetProjectDir(projectDir)`. Concrete locations: + +- `mdl/executor/executor.go` (or its `Context` initializer) +- `cmd/mxcli/repl.go` (REPL session start) +- Any backend init that receives a project path + +### `cmd/mxcli/cmd_widget.go` — `widget init` new help text + +``` +Extract and dump widget definitions for inspection or customization. + +mxcli widget init is no longer required for CREATE PAGE to work — definitions +are derived automatically from widgets/*.mpk at runtime. Run this command only +when you need to inspect or hand-edit a widget's property mappings. + +Flags: + --force overwrite existing .def.json files +``` + +## Testing + +- Unit test: `TestRegistryMPKFallback` — create a temp dir with a minimal MPK, + call `SetProjectDir`, verify `Get(derivedName)` returns a non-nil definition +- Unit test: `TestPreScanSkipsBuiltins` — verify that a built-in widget name (e.g. + `GALLERY`) in `mpkNameMap` is ignored in favour of the built-in registry entry +- Unit test: `TestDeriveFromMPKCached` — call `Get` twice for the same widget, + verify MPK is parsed only once (inspect `mpk.defCache`) +- Integration: existing `mdl-examples/doctype-tests/` page tests that use third-party + widgets should pass without `widget init` having been run From b9c00eaccaf7353b37cbced0ff1197ccbc709d92 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 11:32:04 +0800 Subject: [PATCH 09/18] docs: add widget real-time registry implementation plan --- .../2026-05-09-widget-realtime-registry.md | 630 ++++++++++++++++++ 1 file changed, 630 insertions(+) create mode 100644 docs/superpowers/plans/2026-05-09-widget-realtime-registry.md diff --git a/docs/superpowers/plans/2026-05-09-widget-realtime-registry.md b/docs/superpowers/plans/2026-05-09-widget-realtime-registry.md new file mode 100644 index 00000000..007debd2 --- /dev/null +++ b/docs/superpowers/plans/2026-05-09-widget-realtime-registry.md @@ -0,0 +1,630 @@ +# Widget Real-Time Registry Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Replace the `mxcli widget init` pre-extraction requirement with real-time MPK-derived widget definitions, so that `CREATE PAGE` works with project widgets without any setup step. + +**Architecture:** `WidgetRegistry` gains a `SetProjectDir` method that pre-scans `widgets/*.mpk` (building a lightweight `mdlName→widgetID` map), then falls back to on-demand MPK parsing when `Get`/`GetByWidgetID` misses. Results are cached in the registry maps so the second lookup is O(1). Hand-crafted `.def.json` overrides still take priority. + +**Tech Stack:** Go, `archive/zip` (stdlib), `sdk/widgets/mpk` (already imported nowhere in `mdl/executor/` — adding it is safe, no circular dependency). + +--- + +## File Map + +| File | Change | +|------|--------| +| `mdl/executor/widget_registry.go` | Add fields, methods, MPK fallback in Get/GetByWidgetID | +| `mdl/executor/widget_registry_mpk_test.go` | New test file (4 tests) | +| `mdl/executor/cmd_pages_builder.go` | Wire `SetProjectDir` into `initPluggableEngine` | +| `cmd/mxcli/cmd_widget.go` | Add `--force` flag, update help text, remove skip-if-exists guard | + +--- + +## Task 1: Add MPK fallback to WidgetRegistry + +**Files:** +- Modify: `mdl/executor/widget_registry.go` +- Create: `mdl/executor/widget_registry_mpk_test.go` + +- [ ] **Step 1: Write the failing tests** + +Create `mdl/executor/widget_registry_mpk_test.go`: + +```go +// SPDX-License-Identifier: Apache-2.0 + +package executor + +import ( + "archive/zip" + "bytes" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/mendixlabs/mxcli/sdk/widgets/mpk" +) + +// writeMiniMPK creates a minimal .mpk ZIP in widgetsDir with the given widget ID. +func writeMiniMPK(t *testing.T, widgetsDir, widgetID string) { + t.Helper() + var buf bytes.Buffer + w := zip.NewWriter(&buf) + + // last segment of ID becomes the XML file name + parts := strings.Split(widgetID, ".") + xmlName := parts[len(parts)-1] + ".xml" + + pkg, _ := w.Create("package.xml") + fmt.Fprintf(pkg, + ``, + xmlName, + ) + + wxml, _ := w.Create(xmlName) + fmt.Fprintf(wxml, + `Test`, + widgetID, + ) + + w.Close() + + mpkPath := filepath.Join(widgetsDir, parts[len(parts)-1]+".mpk") + if err := os.WriteFile(mpkPath, buf.Bytes(), 0644); err != nil { + t.Fatalf("write MPK: %v", err) + } +} + +func TestRegistryMPKFallbackGet(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + writeMiniMPK(t, widgetsDir, "com.test.widget.Testwidget") + + reg, err := NewWidgetRegistry() + if err != nil { + t.Fatalf("NewWidgetRegistry: %v", err) + } + if err := reg.SetProjectDir(dir); err != nil { + t.Fatalf("SetProjectDir: %v", err) + } + + def, ok := reg.Get("TESTWIDGET") + if !ok { + t.Fatal("expected TESTWIDGET via MPK fallback, got not-found") + } + if def.WidgetID != "com.test.widget.Testwidget" { + t.Errorf("WidgetID = %q, want com.test.widget.Testwidget", def.WidgetID) + } + if def.WidgetKind != "pluggable" { + t.Errorf("WidgetKind = %q, want pluggable", def.WidgetKind) + } +} + +func TestRegistryMPKFallbackGetByWidgetID(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + writeMiniMPK(t, widgetsDir, "com.test.widget.Testwidget") + + reg, _ := NewWidgetRegistry() + reg.SetProjectDir(dir) + + def, ok := reg.GetByWidgetID("com.test.widget.Testwidget") + if !ok { + t.Fatal("expected GetByWidgetID fallback to find widget") + } + if def.MDLName != "testwidget" { + t.Errorf("MDLName = %q, want testwidget", def.MDLName) + } +} + +func TestRegistryMPKFallbackCached(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + writeMiniMPK(t, widgetsDir, "com.test.widget.Testwidget") + + reg, _ := NewWidgetRegistry() + reg.SetProjectDir(dir) + + def1, ok1 := reg.Get("TESTWIDGET") + if !ok1 { + t.Fatal("first lookup failed") + } + def2, ok2 := reg.Get("TESTWIDGET") + if !ok2 { + t.Fatal("second lookup failed") + } + if def1 != def2 { + t.Error("expected same pointer on second lookup (in-registry cache)") + } +} + +func TestRegistryMPKFallbackSkipsBuiltins(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + // Write a fake MPK that would derive "GALLERY" — should be ignored + writeMiniMPK(t, widgetsDir, "com.mendix.widget.web.gallery.Gallery") + + reg, _ := NewWidgetRegistry() + builtinDef, builtinOK := reg.Get("GALLERY") + + reg.SetProjectDir(dir) + + afterDef, afterOK := reg.Get("GALLERY") + if builtinOK { + // Gallery is a builtin: SetProjectDir must not replace it + if afterDef != builtinDef { + t.Error("SetProjectDir must not override a built-in definition") + } + } else { + // Gallery not a builtin in this build: MPK fallback is fine + if !afterOK { + t.Error("expected GALLERY to be found after SetProjectDir") + } + } +} +``` + +- [ ] **Step 2: Run tests to confirm they fail** + +```bash +cd D:/gh/mxcli +go test ./mdl/executor/ -run "TestRegistryMPK" -v 2>&1 | head -40 +``` + +Expected: compilation error (`SetProjectDir` undefined) — confirms test is wired in correctly. + +- [ ] **Step 3: Implement the changes in `widget_registry.go`** + +**3a. Add the `mpk` import** — edit the import block at the top of the file: + +```go +import ( + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "strings" + + mdlerrors "github.com/mendixlabs/mxcli/mdl/errors" + "github.com/mendixlabs/mxcli/sdk/widgets/definitions" + "github.com/mendixlabs/mxcli/sdk/widgets/mpk" +) +``` + +**3b. Add two fields to `WidgetRegistry`** — replace the struct definition (lines 18-22): + +```go +type WidgetRegistry struct { + byMDLName map[string]*WidgetDefinition // keyed by uppercase MDLName + byWidgetID map[string]*WidgetDefinition // keyed by widgetId + knownOperations map[string]bool // operations accepted during validation + projectDir string // project root for MPK fallback + mpkNameMap map[string]string // uppercase MDLName → widgetID (pre-scan) +} +``` + +**3c. Initialise `mpkNameMap` in `NewWidgetRegistryWithOps`** — after `byWidgetID` (line 67 area): + +```go +reg := &WidgetRegistry{ + byMDLName: make(map[string]*WidgetDefinition), + byWidgetID: make(map[string]*WidgetDefinition), + knownOperations: ops, + mpkNameMap: make(map[string]string), +} +``` + +**3d. Modify `Get`** — replace lines 107-110: + +```go +// Get returns a widget definition by MDL name (case-insensitive). +// Falls back to real-time MPK derivation when SetProjectDir has been called. +func (r *WidgetRegistry) Get(mdlName string) (*WidgetDefinition, bool) { + name := strings.ToUpper(mdlName) + if def, ok := r.byMDLName[name]; ok { + return def, ok + } + if r.projectDir == "" { + return nil, false + } + widgetID, ok := r.mpkNameMap[name] + if !ok { + return nil, false + } + def, err := r.deriveFromMPK(widgetID) + if err != nil { + log.Printf("warning: MPK fallback for %s: %v", name, err) + return nil, false + } + if def == nil { + return nil, false + } + r.byMDLName[strings.ToUpper(def.MDLName)] = def + r.byWidgetID[def.WidgetID] = def + return def, true +} +``` + +**3e. Modify `GetByWidgetID`** — replace lines 113-116: + +```go +// GetByWidgetID returns a widget definition by its full widget ID. +// Falls back to real-time MPK derivation when SetProjectDir has been called. +func (r *WidgetRegistry) GetByWidgetID(widgetID string) (*WidgetDefinition, bool) { + if def, ok := r.byWidgetID[widgetID]; ok { + return def, ok + } + if r.projectDir == "" { + return nil, false + } + def, err := r.deriveFromMPK(widgetID) + if err != nil { + log.Printf("warning: MPK fallback for widget ID %s: %v", widgetID, err) + return nil, false + } + if def == nil { + return nil, false + } + r.byMDLName[strings.ToUpper(def.MDLName)] = def + r.byWidgetID[def.WidgetID] = def + return def, true +} +``` + +**3f. Add new methods at the end of the file** (after `validateMappings`): + +```go +// SetProjectDir enables real-time MPK fallback for this registry. +// It pre-scans widgets/*.mpk to build a lightweight mdlName→widgetID map +// (used by Get), and stores the dir for on-demand full parsing (used by both +// Get and GetByWidgetID). Safe to call multiple times; last call wins. +func (r *WidgetRegistry) SetProjectDir(projectDir string) error { + r.projectDir = projectDir + r.mpkNameMap = make(map[string]string) + return r.preScanWidgets(projectDir) +} + +// preScanWidgets does a full parse of all widgets/*.mpk files (results are +// cached by the mpk package) and records which MDL names are available. +// Built-in and user-override names already in byMDLName are skipped. +func (r *WidgetRegistry) preScanWidgets(projectDir string) error { + widgetsDir := filepath.Join(projectDir, "widgets") + matches, err := filepath.Glob(filepath.Join(widgetsDir, "*.mpk")) + if err != nil { + return fmt.Errorf("scan widgets dir: %w", err) + } + for _, mpkPath := range matches { + defs, err := mpk.ParseAll(mpkPath) + if err != nil { + log.Printf("warning: widget pre-scan skipping %s: %v", filepath.Base(mpkPath), err) + continue + } + for _, d := range defs { + name := strings.ToUpper(lastIDSegment(d.ID)) + if _, exists := r.byMDLName[name]; exists { + continue // builtin or user-override wins + } + r.mpkNameMap[name] = d.ID + } + } + return nil +} + +// deriveFromMPK parses the MPK for widgetID and returns a WidgetDefinition. +// Returns nil, nil when the widget is not found in the project's widgets/. +func (r *WidgetRegistry) deriveFromMPK(widgetID string) (*WidgetDefinition, error) { + mpkPath, err := mpk.FindMPK(r.projectDir, widgetID) + if err != nil { + return nil, fmt.Errorf("find mpk for %s: %w", widgetID, err) + } + if mpkPath == "" { + return nil, nil + } + mpkDef, err := mpk.ParseMPKForWidget(mpkPath, widgetID) + if err != nil { + return nil, fmt.Errorf("parse mpk for %s: %w", widgetID, err) + } + if mpkDef == nil { + return nil, nil + } + return buildDefinitionFromMPK(mpkDef), nil +} + +// lastIDSegment returns the last dot-separated segment of a widget ID, lowercased. +// e.g. "com.mendix.widget.web.gallery.Gallery" → "gallery" +func lastIDSegment(widgetID string) string { + parts := strings.Split(widgetID, ".") + return strings.ToLower(parts[len(parts)-1]) +} + +// buildDefinitionFromMPK converts an mpk.WidgetDefinition to an executor +// WidgetDefinition using the same inference logic as widget extract/init. +func buildDefinitionFromMPK(mpkDef *mpk.WidgetDefinition) *WidgetDefinition { + mdlName := lastIDSegment(mpkDef.ID) + widgetKind := "custom" + if mpkDef.IsPluggable { + widgetKind = "pluggable" + } + def := &WidgetDefinition{ + WidgetID: mpkDef.ID, + MDLName: mdlName, + WidgetKind: widgetKind, + TemplateFile: mdlName + ".json", + DefaultEditable: "Always", + } + + var assocMappings []PropertyMapping + for _, p := range mpkDef.Properties { + switch p.Type { + case "widgets": + container := strings.ToUpper(p.Key) + if p.Key == "content" { + container = "TEMPLATE" + } + def.ChildSlots = append(def.ChildSlots, ChildSlotMapping{ + PropertyKey: p.Key, + MDLContainer: strings.ToLower(container), + Operation: "widgets", + }) + case "datasource": + def.PropertyMappings = append(def.PropertyMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "DataSource", + Operation: "datasource", + }) + case "attribute": + def.PropertyMappings = append(def.PropertyMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "Attribute", + Operation: "attribute", + }) + case "association": + assocMappings = append(assocMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "Association", + Operation: "association", + }) + case "selection": + def.PropertyMappings = append(def.PropertyMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "Selection", + Operation: "selection", + Default: p.DefaultValue, + }) + case "boolean", "integer", "decimal", "string", "enumeration": + m := PropertyMapping{ + PropertyKey: p.Key, + Operation: "primitive", + } + if p.DefaultValue != "" { + m.Value = p.DefaultValue + } + def.PropertyMappings = append(def.PropertyMappings, m) + } + } + def.PropertyMappings = append(def.PropertyMappings, assocMappings...) + return def +} +``` + +- [ ] **Step 4: Run the tests** + +```bash +cd D:/gh/mxcli +go test ./mdl/executor/ -run "TestRegistryMPK" -v +``` + +Expected output: 4 tests PASS. + +- [ ] **Step 5: Run the full executor test suite** + +```bash +go test ./mdl/executor/ -timeout 60s +``` + +Expected: all tests pass (no regressions). + +- [ ] **Step 6: Commit** + +```bash +git add mdl/executor/widget_registry.go mdl/executor/widget_registry_mpk_test.go +git commit -m "feat: add real-time MPK fallback to WidgetRegistry" +``` + +--- + +## Task 2: Wire SetProjectDir into pageBuilder + +**Files:** +- Modify: `mdl/executor/cmd_pages_builder.go` lines 55-72 (`initPluggableEngine`) + +- [ ] **Step 1: Add `filepath` import to `cmd_pages_builder.go`** + +The file currently imports `context`, `fmt`, `log`, `strings` — check if `path/filepath` is already there. If not, add it to the import block: + +```go +import ( + "context" + "fmt" + "log" + "path/filepath" + "strings" + // ... rest unchanged +) +``` + +- [ ] **Step 2: Update `initPluggableEngine` to call `SetProjectDir`** + +Replace lines 55-72 with: + +```go +func (pb *pageBuilder) initPluggableEngine() { + if pb.pluggableEngine != nil || pb.pluggableEngineErr != nil { + return + } + registry, err := NewWidgetRegistry() + if err != nil { + pb.pluggableEngineErr = mdlerrors.NewBackend("widget registry init", err) + log.Printf("warning: %v", pb.pluggableEngineErr) + return + } + if pb.backend != nil { + if loadErr := registry.LoadUserDefinitions(pb.backend.Path()); loadErr != nil { + log.Printf("warning: loading user widget definitions: %v", loadErr) + } + projectDir := filepath.Dir(pb.backend.Path()) + if scanErr := registry.SetProjectDir(projectDir); scanErr != nil { + log.Printf("warning: widget pre-scan: %v", scanErr) + } + } + pb.widgetRegistry = registry + pb.pluggableEngine = NewPluggableWidgetEngine(pb.widgetBackend, pb) +} +``` + +- [ ] **Step 3: Build and test** + +```bash +cd D:/gh/mxcli +make build +go test ./mdl/executor/ -timeout 60s +``` + +Expected: build succeeds, tests pass. + +- [ ] **Step 4: Commit** + +```bash +git add mdl/executor/cmd_pages_builder.go +git commit -m "feat: wire SetProjectDir into pageBuilder for runtime MPK fallback" +``` + +--- + +## Task 3: Update widget init command + +**Files:** +- Modify: `cmd/mxcli/cmd_widget.go` + +- [ ] **Step 1: Add `--force` flag and update help text** + +Replace the `widgetInitCmd` declaration (lines 47-59) with: + +```go +var widgetInitCmd = &cobra.Command{ + Use: "init", + Short: "Dump widget definitions for inspection or customization", + Long: `Scan the project's widgets/ directory and write .def.json files to +.mxcli/widgets/ for each .mpk. + +Note: mxcli widget init is no longer required for CREATE PAGE to work. +Widget definitions are derived automatically at runtime from the project's +widgets/*.mpk files. Run this command only when you need to inspect or +hand-edit a widget's property mappings. + +Existing .def.json files are skipped unless --force is given. + +Requires --project (-p) to locate the project's widgets/ directory.`, + Example: ` mxcli widget init -p /path/to/app.mpr + mxcli widget init -p app.mpr --force`, + RunE: runWidgetInit, +} +``` + +- [ ] **Step 2: Register the `--force` flag in `init()`** + +In the `init()` function (around line 68), add after `widgetInitCmd.MarkFlagRequired("project")`: + +```go +widgetInitCmd.Flags().Bool("force", false, "Overwrite existing .def.json files") +``` + +- [ ] **Step 3: Use the `--force` flag in `runWidgetInit`** + +In `runWidgetInit` (line 220), read the flag right after reading `projectPath`: + +```go +func runWidgetInit(cmd *cobra.Command, args []string) error { + projectPath, _ := cmd.Flags().GetString("project") + force, _ := cmd.Flags().GetBool("force") + // ... rest of function unchanged until the skip-if-exists block +``` + +Then replace the skip-if-exists block (lines 265-269): + +```go + // Skip if already exists on disk (unless --force) + if !force { + if _, err := os.Stat(outPath); err == nil { + skipped++ + continue + } + } +``` + +- [ ] **Step 4: Build and smoke test** + +```bash +cd D:/gh/mxcli +make build +./bin/mxcli widget init --help +``` + +Expected output: shows new help text and `--force` flag listed. + +- [ ] **Step 5: Commit** + +```bash +git add cmd/mxcli/cmd_widget.go +git commit -m "feat: widget init adds --force flag, demotes to optional debug tool" +``` + +--- + +## Task 4: Full build and integration check + +- [ ] **Step 1: Full build and test** + +```bash +cd D:/gh/mxcli +make build && make test +``` + +Expected: all pass. + +- [ ] **Step 2: Verify `widget list` shows no regression** + +```bash +./bin/mxcli widget list +``` + +Expected: same built-in list as before (GALLERY, COMBOBOX, etc.). + +- [ ] **Step 3: Smoke test with a real project (if available)** + +If a `.mpr` project with a third-party widget is available: + +```bash +./bin/mxcli -p /path/to/app.mpr -c "create page TestP (layout: Atlas_Default) { dataview dv (entity: Module.Entity) { } }" +``` + +Then try referencing a project widget by its derived name. No `widget init` should be needed. + +- [ ] **Step 4: Final commit if any fixups were needed** + +```bash +git add -p +git commit -m "fix: widget registry MPK fallback fixups" +``` From 080e88ed2e4ebc387a32e99f73f253eda5f81922 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 11:37:56 +0800 Subject: [PATCH 10/18] fix: default LayoutGridColumn weight to auto-fill when DesktopWidth is unspecified BSON comparison between a Studio Pro page (AIPlayground) and an MDL-generated page (AIPlayground_MPKTest) showed that Weight=1 (one grid unit) was being written when no DesktopWidth was specified. The correct default is auto-fill (-1 in BSON), which the serializer already maps from Weight=0 via columnWeight(). Changing the initial Weight from 1 to 0 so that omitted DesktopWidth columns serialise as Weight=-1, matching Studio Pro's default new-column behaviour. Co-Authored-By: Claude Sonnet 4.6 --- mdl/executor/cmd_pages_builder_v3_layout.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mdl/executor/cmd_pages_builder_v3_layout.go b/mdl/executor/cmd_pages_builder_v3_layout.go index 020bcc99..cab9afa9 100644 --- a/mdl/executor/cmd_pages_builder_v3_layout.go +++ b/mdl/executor/cmd_pages_builder_v3_layout.go @@ -64,7 +64,7 @@ func (pb *pageBuilder) buildLayoutGridColumnV3(w *ast.WidgetV3) (*pages.LayoutGr ID: model.ID(types.GenerateID()), TypeName: "Forms$LayoutGridColumn", }, - Weight: 1, + Weight: 0, // 0 → columnWeight() maps to -1 (auto-fill) in the serializer } // Handle DesktopWidth From b33934f5cc9cf7e5a168d40d856717d0c78b33fe Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 12:20:32 +0800 Subject: [PATCH 11/18] feat: propagate DataSourceProperty through template pipeline and emit AI hints Pluggable widget properties with DataSourceProperty linkage (e.g. gridCss/gridThrow/gridTph linked to gridData) now surface that linkage through the full pipeline: - sdk/widgets/loader.go: extract DataSourceProperty from def.json ValueType objects via jsonValueToBSONWithNestedObjectType; stored in PropertyTypeIDEntry.DataSourceProperty - sdk/pages/pages_widgets_advanced.go: add DataSourceProperty field to PropertyTypeIDEntry (parallel struct used by the backend layer) - mdl/backend/mpr/widget_builder.go: copy DataSourceProperty in convertPropertyTypeIDs so the executor sees it - mdl/executor/widget_engine.go: two new AI-facing HINT log messages: (1) when a DataSource-type property is not configured via DataSource:, lists all linked attribute properties that need the datasource entity; (2) when a linked attribute references the wrong entity instead of the datasource entity. Co-Authored-By: Claude Sonnet 4.6 --- mdl/backend/mpr/widget_builder.go | 13 ++++---- mdl/executor/widget_engine.go | 52 +++++++++++++++++++++++++++++ sdk/pages/pages_widgets_advanced.go | 11 +++--- sdk/widgets/loader.go | 33 +++++++++++------- 4 files changed, 86 insertions(+), 23 deletions(-) diff --git a/mdl/backend/mpr/widget_builder.go b/mdl/backend/mpr/widget_builder.go index 6d9b826e..b08851e3 100644 --- a/mdl/backend/mpr/widget_builder.go +++ b/mdl/backend/mpr/widget_builder.go @@ -666,12 +666,13 @@ func convertPropertyTypeIDs(src map[string]widgets.PropertyTypeIDEntry) map[stri result := make(map[string]pages.PropertyTypeIDEntry) for k, v := range src { entry := pages.PropertyTypeIDEntry{ - PropertyTypeID: v.PropertyTypeID, - ValueTypeID: v.ValueTypeID, - DefaultValue: v.DefaultValue, - ValueType: v.ValueType, - Required: v.Required, - ObjectTypeID: v.ObjectTypeID, + PropertyTypeID: v.PropertyTypeID, + ValueTypeID: v.ValueTypeID, + DefaultValue: v.DefaultValue, + ValueType: v.ValueType, + Required: v.Required, + DataSourceProperty: v.DataSourceProperty, + ObjectTypeID: v.ObjectTypeID, } if len(v.NestedPropertyIDs) > 0 { entry.NestedPropertyIDs = convertPropertyTypeIDs(v.NestedPropertyIDs) diff --git a/mdl/executor/widget_engine.go b/mdl/executor/widget_engine.go index 745ca781..adc33f21 100644 --- a/mdl/executor/widget_engine.go +++ b/mdl/executor/widget_engine.go @@ -4,6 +4,7 @@ package executor import ( "fmt" + "log" "sort" "strings" @@ -130,6 +131,23 @@ func (e *PluggableWidgetEngine) Build(def *WidgetDefinition, w *ast.WidgetV3) (* } } + // 3.5 Warn about DataSource-type properties that were not configured. + // This gives AI assistants actionable feedback when they forget DataSource: + for _, m := range mappings { + if m.Source != "DataSource" { + continue + } + if w.GetDataSource() == nil { + // Collect linked attribute keys for the hint + linked := linkedPropertyKeysFor(m.PropertyKey, propertyTypeIDs) + hint := fmt.Sprintf("HINT [%s]: property '%s' is a DataSource type and was not configured.\n"+ + " Add inside this widget block: DataSource: Module.Entity [where [XPath]]\n"+ + " Linked attribute properties that draw from this datasource: %s", + w.Name, m.PropertyKey, linked) + log.Print(hint) + } + } + // 4. Auto datasource: map AST DataSource to first DataSource-type property. // This must run before child slots so that entityContext is available // for child widgets that depend on the parent's data source. @@ -286,6 +304,24 @@ func (e *PluggableWidgetEngine) Build(def *WidgetDefinition, w *ast.WidgetV3) (* if attrPath != "" { builder.SetAttribute(propName, attrPath) } + // Warn when a linked attribute appears to use the context entity instead of + // the datasource entity. Only fires when the attribute path has 2+ dots + // (fully qualified) and the entity portion matches the context entity. + if entry.DataSourceProperty != "" && strings.Count(strVal, ".") >= 2 { + parts := strings.SplitN(strVal, ".", 3) + attrEntity := parts[0] + "." + parts[1] + // Warn when the attribute entity doesn't match the datasource entity. + // After DataSource: processes gridData, entityContext is set to the + // datasource entity — linked attrs should use that same entity. + if e.pageBuilder.entityContext != "" && !strings.EqualFold(attrEntity, e.pageBuilder.entityContext) { + log.Printf("HINT [%s]: property '%s' is linked to datasource '%s'.\n"+ + " The attribute should reference the datasource entity '%s', not '%s'.\n"+ + " Correct: %s.%s (or similar) — configure DataSource: first so the entity context is set.", + w.Name, propName, entry.DataSourceProperty, + e.pageBuilder.entityContext, attrEntity, + e.pageBuilder.entityContext, parts[2]) + } + } default: // Known non-attribute types: always use primitive if entry.ValueType != "" && entry.ValueType != "Attribute" { @@ -542,6 +578,22 @@ func (e *PluggableWidgetEngine) applyChildSlots(builder backend.WidgetObjectBuil return nil } +// linkedPropertyKeysFor returns a comma-separated list of property keys whose +// DataSourceProperty field matches dsKey, drawn from the propertyTypeIDs map. +func linkedPropertyKeysFor(dsKey string, propertyTypeIDs map[string]pages.PropertyTypeIDEntry) string { + var keys []string + for k, e := range propertyTypeIDs { + if e.DataSourceProperty == dsKey { + keys = append(keys, k) + } + } + sort.Strings(keys) + if len(keys) == 0 { + return "(none)" + } + return strings.Join(keys, ", ") +} + // isBuiltinPropName returns true for property names that are handled by // dedicated MDL keywords (DataSource, Attribute, etc.) rather than by // the explicit property pass. diff --git a/sdk/pages/pages_widgets_advanced.go b/sdk/pages/pages_widgets_advanced.go index 19acef63..02c2af69 100644 --- a/sdk/pages/pages_widgets_advanced.go +++ b/sdk/pages/pages_widgets_advanced.go @@ -171,11 +171,12 @@ type CustomWidget struct { // PropertyTypeIDEntry holds the IDs for a property type from a cloned widget. type PropertyTypeIDEntry struct { - PropertyTypeID string - ValueTypeID string - DefaultValue string // Default value from the template's ValueType - ValueType string // Type of value (Boolean, Integer, String, DataSource, etc.) - Required bool // Whether this property is required + PropertyTypeID string + ValueTypeID string + DefaultValue string // Default value from the template's ValueType + ValueType string // Type of value (Boolean, Integer, String, DataSource, etc.) + Required bool // Whether this property is required + DataSourceProperty string // Non-empty when this attribute is linked to another DataSource property // For object list properties (IsList=true with ObjectType), these hold nested IDs ObjectTypeID string // ID of the nested ObjectType (for object lists like columns) NestedPropertyIDs map[string]PropertyTypeIDEntry // Property IDs within the nested ObjectType diff --git a/sdk/widgets/loader.go b/sdk/widgets/loader.go index efaf0293..be7a020a 100644 --- a/sdk/widgets/loader.go +++ b/sdk/widgets/loader.go @@ -339,6 +339,7 @@ func jsonToBSONWithMappingAndObjectType(data map[string]any, idMapping map[strin var defaultValue string var valueType string var required bool + var dataSourceProp string var nestedObjectTypeID string var nestedPropertyIDs map[string]PropertyTypeIDEntry @@ -382,7 +383,7 @@ func jsonToBSONWithMappingAndObjectType(data map[string]any, idMapping map[strin } else if key == "ValueType" && isPropertyType { // For PropertyTypes, extract ValueType info including nested ObjectType, DefaultValue, Type, Required nestedPropertyIDs = make(map[string]PropertyTypeIDEntry) - elem.Value = jsonValueToBSONWithNestedObjectType(val, idMapping, &valueTypeID, &nestedObjectTypeID, nestedPropertyIDs, &defaultValue, &valueType, &required) + elem.Value = jsonValueToBSONWithNestedObjectType(val, idMapping, &valueTypeID, &nestedObjectTypeID, nestedPropertyIDs, &defaultValue, &valueType, &required, &dataSourceProp) } else { elem.Value = jsonValueToBSONWithMappingAndObjectType(val, idMapping, propertyTypeIDs, &valueTypeID, key == "ValueType", objectTypeID) } @@ -393,11 +394,12 @@ func jsonToBSONWithMappingAndObjectType(data map[string]any, idMapping map[strin // Record PropertyType IDs if isPropertyType && propertyKey != "" { entry := PropertyTypeIDEntry{ - PropertyTypeID: propertyTypeIDVal, - ValueTypeID: valueTypeID, - DefaultValue: defaultValue, - ValueType: valueType, - Required: required, + PropertyTypeID: propertyTypeIDVal, + ValueTypeID: valueTypeID, + DefaultValue: defaultValue, + ValueType: valueType, + Required: required, + DataSourceProperty: dataSourceProp, } if nestedObjectTypeID != "" { entry.ObjectTypeID = nestedObjectTypeID @@ -410,7 +412,7 @@ func jsonToBSONWithMappingAndObjectType(data map[string]any, idMapping map[strin } // jsonValueToBSONWithNestedObjectType extracts ValueType info including nested ObjectType, DefaultValue, and Type. -func jsonValueToBSONWithNestedObjectType(val any, idMapping map[string]string, valueTypeID *string, nestedObjectTypeID *string, nestedPropertyIDs map[string]PropertyTypeIDEntry, defaultValue *string, valueType *string, required *bool) any { +func jsonValueToBSONWithNestedObjectType(val any, idMapping map[string]string, valueTypeID *string, nestedObjectTypeID *string, nestedPropertyIDs map[string]PropertyTypeIDEntry, defaultValue *string, valueType *string, required *bool, dataSourceProperty ...*string) any { switch v := val.(type) { case map[string]any: result := make(bson.D, 0, len(v)) @@ -450,6 +452,12 @@ func jsonValueToBSONWithNestedObjectType(val any, idMapping map[string]string, v *required = r } elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) + } else if key == "DataSourceProperty" && len(dataSourceProperty) > 0 && dataSourceProperty[0] != nil { + // Extract datasource linkage: non-empty when this attribute draws from a sibling datasource property + if dsp, ok := fieldVal.(string); ok { + *dataSourceProperty[0] = dsp + } + elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) } else { elem.Value = jsonValueToBSONSimple(fieldVal, idMapping) } @@ -749,11 +757,12 @@ func jsonValueToBSONObjectWithMapping(val any, idMapping map[string]string) any // PropertyTypeIDEntry holds the IDs for a property type. type PropertyTypeIDEntry struct { - PropertyTypeID string - ValueTypeID string - DefaultValue string // Default value from the template's ValueType - ValueType string // Type of value (Boolean, Integer, String, DataSource, etc.) - Required bool // Whether this property is required + PropertyTypeID string + ValueTypeID string + DefaultValue string // Default value from the template's ValueType + ValueType string // Type of value (Boolean, Integer, String, DataSource, etc.) + Required bool // Whether this property is required + DataSourceProperty string // Non-empty when this attribute is linked to another DataSource property // For object list properties (IsList=true with ObjectType), these hold nested IDs ObjectTypeID string // ID of the nested ObjectType (for object lists) NestedPropertyIDs map[string]PropertyTypeIDEntry // Property IDs within the nested ObjectType From 82b6774feeac494d7cb72d2ecb341d116535f4a4 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 12:53:19 +0800 Subject: [PATCH 12/18] fix: add missing widget type metadata and AllowedTypes to MPK-derived templates MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two root causes for CE0463/CE0572 on MPK-derived pluggable widgets: 1. Missing CustomWidgetType metadata fields (CE0572 + CE0463) GenerateFromMPK emitted only $ID/$Type/WidgetId/ObjectType. Missing: WidgetPluginWidget (false→CE0572), WidgetName, OfflineCapable, SupportedPlatform, WidgetNeedsEntityContext, WidgetDescription, HelpUrl, StudioCategory, StudioProCategory. Fix: parse these attributes from the XML element and child element; store on WidgetDefinition; emit in GenerateFromMPK's typeMap. 2. Empty AllowedTypes on attribute properties (CE0463) Studio Pro compares stored AllowedTypes against the installed widget's list. Our generated type had [1] (empty); the correct value is [1, "String"] / [1, "Decimal"] etc. Fix: parse in xmlProperty and collectNestedProperties; store as AllowedTypes []string on PropertyDef; emit in createDefaultValueType's AllowedTypes array. Co-Authored-By: Claude Sonnet 4.6 --- sdk/widgets/augment.go | 8 +++- sdk/widgets/generate.go | 20 +++++++-- sdk/widgets/mpk/mpk.go | 90 +++++++++++++++++++++++++++++++---------- 3 files changed, 92 insertions(+), 26 deletions(-) diff --git a/sdk/widgets/augment.go b/sdk/widgets/augment.go index 2542a563..b007d62d 100644 --- a/sdk/widgets/augment.go +++ b/sdk/widgets/augment.go @@ -564,12 +564,18 @@ func createPropertyPair(p mpk.PropertyDef, bsonType string) (map[string]any, map // createDefaultValueType creates a default ValueType structure for a given BSON type. func createDefaultValueType(vtID string, bsonType string, p mpk.PropertyDef) map[string]any { + // Build AllowedTypes: version marker 1 followed by allowed Mendix type names. + allowedTypes := []any{float64(1)} + for _, t := range p.AllowedTypes { + allowedTypes = append(allowedTypes, t) + } + vt := map[string]any{ "$ID": vtID, "$Type": "CustomWidgets$WidgetValueType", "ActionVariables": []any{float64(2)}, "AllowNonPersistableEntities": false, - "AllowedTypes": []any{float64(1)}, + "AllowedTypes": allowedTypes, "AssociationTypes": []any{float64(1)}, "DataSourceProperty": "", "DefaultType": "None", diff --git a/sdk/widgets/generate.go b/sdk/widgets/generate.go index 2914e2e3..93f2d8af 100644 --- a/sdk/widgets/generate.go +++ b/sdk/widgets/generate.go @@ -29,10 +29,24 @@ func GenerateFromMPK(def *mpk.WidgetDefinition) *WidgetTemplate { } } + platform := def.SupportedPlatform + if platform == "" { + platform = "Web" + } + typeMap := map[string]any{ - "$ID": typeID, - "$Type": "CustomWidgets$CustomWidgetType", - "WidgetId": def.ID, + "$ID": typeID, + "$Type": "CustomWidgets$CustomWidgetType", + "HelpUrl": def.HelpURL, + "OfflineCapable": def.OfflineCapable, + "StudioCategory": def.StudioCategory, + "StudioProCategory": def.StudioProCategory, + "SupportedPlatform": platform, + "WidgetDescription": def.Description, + "WidgetId": def.ID, + "WidgetName": def.Name, + "WidgetNeedsEntityContext": def.NeedsEntityContext, + "WidgetPluginWidget": def.IsPluggable, "ObjectType": map[string]any{ "$ID": objTypeID, "$Type": "CustomWidgets$WidgetObjectType", diff --git a/sdk/widgets/mpk/mpk.go b/sdk/widgets/mpk/mpk.go index 2823afbd..766905ad 100644 --- a/sdk/widgets/mpk/mpk.go +++ b/sdk/widgets/mpk/mpk.go @@ -27,17 +27,25 @@ type PropertyDef struct { IsList bool IsSystem bool // true for elements DataSource string // dataSource attribute reference + AllowedTypes []string // for attribute properties: Mendix type names ("String", "Decimal", etc.) Children []PropertyDef // nested properties for object-type properties } // WidgetDefinition holds the parsed definition of a pluggable widget from an .mpk file. type WidgetDefinition struct { - ID string // e.g. "com.mendix.widget.web.combobox.Combobox" - Name string // e.g. "Combo box" - Version string // from package.xml clientModule version - IsPluggable bool // true if pluginWidget="true" (React), false for legacy Dojo - Properties []PropertyDef // regular elements - SystemProps []PropertyDef // elements + ID string // e.g. "com.mendix.widget.web.combobox.Combobox" + Name string // e.g. "Combo box" + Description string // widget description from element + Version string // from package.xml clientModule version + IsPluggable bool // true if pluginWidget="true" (React), false for legacy Dojo + OfflineCapable bool // true if offlineCapable="true" + NeedsEntityContext bool // true if needsEntityContext="true" + SupportedPlatform string // "Web", "Native", "All" (empty = Web) + HelpURL string // helpUrl attribute + StudioCategory string // studioCategory attribute + StudioProCategory string // studioProCategory attribute + Properties []PropertyDef // regular elements + SystemProps []PropertyDef // elements } // --- XML structures for parsing --- @@ -61,10 +69,17 @@ type xmlWidgetFile struct { // xmlWidget represents root element in widget XML. type xmlWidget struct { - ID string `xml:"id,attr"` - PluginWidget string `xml:"pluginWidget,attr"` - Name string `xml:"name"` - 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 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"` } // xmlPropGroup represents element. @@ -75,16 +90,22 @@ type xmlPropGroup struct { SubGroups []xmlPropGroup `xml:"propertyGroup"` } +// xmlAttributeType represents element. +type xmlAttributeType struct { + Name string `xml:"name,attr"` +} + // xmlProperty represents element. type xmlProperty struct { - Key string `xml:"key,attr"` - Type string `xml:"type,attr"` - DefaultValue string `xml:"defaultValue,attr"` - Required string `xml:"required,attr"` - IsList string `xml:"isList,attr"` - DataSource string `xml:"dataSource,attr"` - Caption string `xml:"caption"` - Description string `xml:"description"` + Key string `xml:"key,attr"` + Type string `xml:"type,attr"` + DefaultValue string `xml:"defaultValue,attr"` + Required string `xml:"required,attr"` + IsList string `xml:"isList,attr"` + DataSource string `xml:"dataSource,attr"` + Caption string `xml:"caption"` + Description string `xml:"description"` + AttributeTypes []xmlAttributeType `xml:"attributeTypes>attributeType"` // Nested properties for object type NestedProps []xmlPropGroup `xml:"properties>propertyGroup"` } @@ -215,6 +236,12 @@ func walkPropertyGroup(pg xmlPropGroup, parentCategory string, def *WidgetDefini // Collect regular properties for _, p := range pg.Properties { + var allowedTypes []string + for _, at := range p.AttributeTypes { + if at.Name != "" { + allowedTypes = append(allowedTypes, at.Name) + } + } prop := PropertyDef{ Key: p.Key, Type: p.Type, @@ -225,6 +252,7 @@ func walkPropertyGroup(pg xmlPropGroup, parentCategory string, def *WidgetDefini DefaultValue: p.DefaultValue, IsList: p.IsList == "true", DataSource: p.DataSource, + AllowedTypes: allowedTypes, } // Parse nested properties for object-type properties @@ -256,6 +284,12 @@ func walkPropertyGroup(pg xmlPropGroup, parentCategory string, def *WidgetDefini // within an object-type property and appends them to the parent PropertyDef. func collectNestedProperties(pg xmlPropGroup, parent *PropertyDef) { for _, p := range pg.Properties { + var allowedTypes []string + for _, at := range p.AttributeTypes { + if at.Name != "" { + allowedTypes = append(allowedTypes, at.Name) + } + } child := PropertyDef{ Key: p.Key, Type: p.Type, @@ -265,6 +299,7 @@ func collectNestedProperties(pg xmlPropGroup, parent *PropertyDef) { DefaultValue: p.DefaultValue, IsList: p.IsList == "true", DataSource: p.DataSource, + AllowedTypes: allowedTypes, } parent.Children = append(parent.Children, child) } @@ -398,11 +433,22 @@ func getWidgetIDsFromMPK(mpkPath string) ([]string, error) { // buildDefinition constructs a WidgetDefinition from a parsed xmlWidget and version string. func buildDefinition(widget *xmlWidget, version string) *WidgetDefinition { + platform := widget.SupportedPlatform + if platform == "" { + platform = "Web" + } def := &WidgetDefinition{ - ID: widget.ID, - Name: widget.Name, - Version: version, - IsPluggable: widget.PluginWidget == "true", + ID: widget.ID, + Name: widget.Name, + Description: widget.Description, + Version: version, + IsPluggable: widget.PluginWidget == "true", + OfflineCapable: widget.OfflineCapable == "true", + NeedsEntityContext: widget.NeedsEntityContext == "true", + SupportedPlatform: platform, + HelpURL: widget.HelpURL, + StudioCategory: widget.StudioCategory, + StudioProCategory: widget.StudioProCategory, } for _, pg := range widget.PropertyGroups { walkPropertyGroup(pg, "", def) From 11876eceac41fc8aeaa07da02969e205fbaaf8e2 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 13:14:54 +0800 Subject: [PATCH 13/18] feat: support named action properties in pluggable widgets MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Allows configuring widget action-type properties (e.g. onChange, onCellClick, onPredict) using nanoflow/microflow references directly in the pluggable widget property block: onChange: nanoflow Module.NF_OnChange onCellClick: nanoflow Module.NF_HeatmapClick Grammar: add two new widgetPropertyV3 alternatives — IDENTIFIER COLON actionExprV3 keyword COLON actionExprV3 so that named action properties parse using the full actionExprV3 rule (nanoflow, microflow, save, cancel, show page, etc.). Visitor: in parseWidgetPropertyV3, try ActionExprV3 first for IDENTIFIER and keyword alternatives, storing the result as *ast.ActionV3 under the property key. Widget engine: step 4.6 now handles *ast.ActionV3 propVal types — calls buildClientActionV3 and builder.SetAction(propName, act) for any property whose ValueType is "Action". Co-Authored-By: Claude Sonnet 4.6 --- mdl/executor/widget_engine.go | 14 ++++++++++++++ mdl/grammar/domains/MDLPage.g4 | 2 ++ mdl/visitor/visitor_page_v3.go | 13 ++++++++++--- 3 files changed, 26 insertions(+), 3 deletions(-) diff --git a/mdl/executor/widget_engine.go b/mdl/executor/widget_engine.go index adc33f21..6976c68c 100644 --- a/mdl/executor/widget_engine.go +++ b/mdl/executor/widget_engine.go @@ -272,6 +272,20 @@ func (e *PluggableWidgetEngine) Build(def *WidgetDefinition, w *ast.WidgetV3) (* if !ok { continue // not a known widget property key } + + // Handle action-type properties (e.g., onChange: nanoflow Module.NF) + if actionAST, isAction := propVal.(*ast.ActionV3); isAction { + if entry.ValueType == "Action" { + act, err := e.pageBuilder.buildClientActionV3(actionAST) + if err != nil { + log.Printf("warning: widget %s property %s: %v", w.Name, propName, err) + } else { + builder.SetAction(propName, act) + } + } + continue + } + // Convert non-string values (bool, int, float) to string for property setting var strVal string switch v := propVal.(type) { diff --git a/mdl/grammar/domains/MDLPage.g4 b/mdl/grammar/domains/MDLPage.g4 index 9426fd0a..7616f1bf 100644 --- a/mdl/grammar/domains/MDLPage.g4 +++ b/mdl/grammar/domains/MDLPage.g4 @@ -282,7 +282,9 @@ widgetPropertyV3 | EDITABLE COLON xpathConstraint // Editable: [Status != 'Closed'] | EDITABLE COLON propertyValueV3 // Editable: Never | Always | TOOLTIP COLON propertyValueV3 // Tooltip: 'text' + | IDENTIFIER COLON actionExprV3 // Named action: onChange: nanoflow Module.NF | IDENTIFIER COLON propertyValueV3 // Generic: any other property + | keyword COLON actionExprV3 // Named action (keyword key): onCommit: nanoflow ... | keyword COLON propertyValueV3 // Generic: keyword as property name (for pluggable widgets) ; diff --git a/mdl/visitor/visitor_page_v3.go b/mdl/visitor/visitor_page_v3.go index d5e3704d..64e58851 100644 --- a/mdl/visitor/visitor_page_v3.go +++ b/mdl/visitor/visitor_page_v3.go @@ -597,17 +597,24 @@ func parseWidgetPropertyV3(ctx parser.IWidgetPropertyV3Context, widget *ast.Widg return } - // Generic property: Identifier: value + // Named action property: onChange: nanoflow Module.NF if id := propCtx.IDENTIFIER(); id != nil { + if actCtx := propCtx.ActionExprV3(); actCtx != nil { + widget.Properties[id.GetText()] = buildActionV3(actCtx) + return + } if valCtx := propCtx.PropertyValueV3(); valCtx != nil { widget.Properties[id.GetText()] = buildPropertyValueV3(valCtx) } return } - // Generic property with keyword name: keyword: value (for pluggable widget property keys - // that happen to be MDL keywords, e.g., type, datasource, content) + // Generic property with keyword name: keyword: value (or named action) if kw := propCtx.Keyword(); kw != nil { + if actCtx := propCtx.ActionExprV3(); actCtx != nil { + widget.Properties[kw.GetText()] = buildActionV3(actCtx) + return + } if valCtx := propCtx.PropertyValueV3(); valCtx != nil { widget.Properties[kw.GetText()] = buildPropertyValueV3(valCtx) } From 7800013c97af8c83a579d3232c550d4bb1222a1f Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 13:28:58 +0800 Subject: [PATCH 14/18] feat: add real-time MPK fallback to WidgetRegistry Co-Authored-By: Claude Sonnet 4.6 (1M context) --- mdl/executor/widget_registry.go | 168 ++++++++++++++++++++++- mdl/executor/widget_registry_mpk_test.go | 141 +++++++++++++++++++ 2 files changed, 305 insertions(+), 4 deletions(-) create mode 100644 mdl/executor/widget_registry_mpk_test.go diff --git a/mdl/executor/widget_registry.go b/mdl/executor/widget_registry.go index 701c0bd3..6453465a 100644 --- a/mdl/executor/widget_registry.go +++ b/mdl/executor/widget_registry.go @@ -12,6 +12,7 @@ import ( mdlerrors "github.com/mendixlabs/mxcli/mdl/errors" "github.com/mendixlabs/mxcli/sdk/widgets/definitions" + "github.com/mendixlabs/mxcli/sdk/widgets/mpk" ) // WidgetRegistry holds loaded widget definitions keyed by uppercase MDL name. @@ -19,6 +20,8 @@ type WidgetRegistry struct { byMDLName map[string]*WidgetDefinition // keyed by uppercase MDLName byWidgetID map[string]*WidgetDefinition // keyed by widgetId knownOperations map[string]bool // operations accepted during validation + projectDir string // project root for MPK fallback + mpkNameMap map[string]string // uppercase MDLName → widgetID (pre-scan) } // defaultKnownOperations is the set of operation names supported by the widget engine. @@ -66,6 +69,7 @@ func NewWidgetRegistryWithOps(extraOps map[string]bool) (*WidgetRegistry, error) byMDLName: make(map[string]*WidgetDefinition), byWidgetID: make(map[string]*WidgetDefinition), knownOperations: ops, + mpkNameMap: make(map[string]string), } entries, err := definitions.EmbeddedFS.ReadDir(".") @@ -105,14 +109,49 @@ func NewWidgetRegistryWithOps(extraOps map[string]bool) (*WidgetRegistry, error) // Get returns a widget definition by MDL name (case-insensitive). func (r *WidgetRegistry) Get(mdlName string) (*WidgetDefinition, bool) { - def, ok := r.byMDLName[strings.ToUpper(mdlName)] - return def, ok + name := strings.ToUpper(mdlName) + if def, ok := r.byMDLName[name]; ok { + return def, ok + } + if r.projectDir == "" { + return nil, false + } + widgetID, ok := r.mpkNameMap[name] + if !ok { + return nil, false + } + def, err := r.deriveFromMPK(widgetID) + if err != nil { + log.Printf("warning: MPK fallback for %s: %v", name, err) + return nil, false + } + if def == nil { + return nil, false + } + r.byMDLName[strings.ToUpper(def.MDLName)] = def + r.byWidgetID[def.WidgetID] = def + return def, true } // GetByWidgetID returns a widget definition by its full widget ID. func (r *WidgetRegistry) GetByWidgetID(widgetID string) (*WidgetDefinition, bool) { - def, ok := r.byWidgetID[widgetID] - return def, ok + if def, ok := r.byWidgetID[widgetID]; ok { + return def, ok + } + if r.projectDir == "" { + return nil, false + } + def, err := r.deriveFromMPK(widgetID) + if err != nil { + log.Printf("warning: MPK fallback for widget ID %s: %v", widgetID, err) + return nil, false + } + if def == nil { + return nil, false + } + r.byMDLName[strings.ToUpper(def.MDLName)] = def + r.byWidgetID[def.WidgetID] = def + return def, true } // All returns all registered definitions. @@ -273,3 +312,124 @@ func (r *WidgetRegistry) validateMappings(mappings []PropertyMapping, source, mo } return nil } + +// SetProjectDir enables real-time MPK fallback for this registry. +func (r *WidgetRegistry) SetProjectDir(projectDir string) error { + r.projectDir = projectDir + r.mpkNameMap = make(map[string]string) + return r.preScanWidgets(projectDir) +} + +func (r *WidgetRegistry) preScanWidgets(projectDir string) error { + widgetsDir := filepath.Join(projectDir, "widgets") + matches, err := filepath.Glob(filepath.Join(widgetsDir, "*.mpk")) + if err != nil { + return fmt.Errorf("scan widgets dir: %w", err) + } + for _, mpkPath := range matches { + defs, err := mpk.ParseAll(mpkPath) + if err != nil { + log.Printf("warning: widget pre-scan skipping %s: %v", filepath.Base(mpkPath), err) + continue + } + for _, d := range defs { + name := strings.ToUpper(lastIDSegment(d.ID)) + if _, exists := r.byMDLName[name]; exists { + continue // builtin or user-override wins + } + r.mpkNameMap[name] = d.ID + } + } + return nil +} + +func (r *WidgetRegistry) deriveFromMPK(widgetID string) (*WidgetDefinition, error) { + mpkPath, err := mpk.FindMPK(r.projectDir, widgetID) + if err != nil { + return nil, fmt.Errorf("find mpk for %s: %w", widgetID, err) + } + if mpkPath == "" { + return nil, nil + } + mpkDef, err := mpk.ParseMPKForWidget(mpkPath, widgetID) + if err != nil { + return nil, fmt.Errorf("parse mpk for %s: %w", widgetID, err) + } + if mpkDef == nil { + return nil, nil + } + return buildDefinitionFromMPK(mpkDef), nil +} + +// lastIDSegment returns the last dot-separated segment of a widget ID, lowercased. +func lastIDSegment(widgetID string) string { + parts := strings.Split(widgetID, ".") + return strings.ToLower(parts[len(parts)-1]) +} + +func buildDefinitionFromMPK(mpkDef *mpk.WidgetDefinition) *WidgetDefinition { + mdlName := lastIDSegment(mpkDef.ID) + widgetKind := "custom" + if mpkDef.IsPluggable { + widgetKind = "pluggable" + } + def := &WidgetDefinition{ + WidgetID: mpkDef.ID, + MDLName: mdlName, + WidgetKind: widgetKind, + TemplateFile: mdlName + ".json", + DefaultEditable: "Always", + } + + var assocMappings []PropertyMapping + for _, p := range mpkDef.Properties { + switch p.Type { + case "widgets": + container := strings.ToUpper(p.Key) + if p.Key == "content" { + container = "TEMPLATE" + } + def.ChildSlots = append(def.ChildSlots, ChildSlotMapping{ + PropertyKey: p.Key, + MDLContainer: strings.ToLower(container), + Operation: "widgets", + }) + case "datasource": + def.PropertyMappings = append(def.PropertyMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "DataSource", + Operation: "datasource", + }) + case "attribute": + def.PropertyMappings = append(def.PropertyMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "Attribute", + Operation: "attribute", + }) + case "association": + assocMappings = append(assocMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "Association", + Operation: "association", + }) + case "selection": + def.PropertyMappings = append(def.PropertyMappings, PropertyMapping{ + PropertyKey: p.Key, + Source: "Selection", + Operation: "selection", + Default: p.DefaultValue, + }) + case "boolean", "integer", "decimal", "string", "enumeration": + m := PropertyMapping{ + PropertyKey: p.Key, + Operation: "primitive", + } + if p.DefaultValue != "" { + m.Value = p.DefaultValue + } + def.PropertyMappings = append(def.PropertyMappings, m) + } + } + def.PropertyMappings = append(def.PropertyMappings, assocMappings...) + return def +} diff --git a/mdl/executor/widget_registry_mpk_test.go b/mdl/executor/widget_registry_mpk_test.go new file mode 100644 index 00000000..3b373ffe --- /dev/null +++ b/mdl/executor/widget_registry_mpk_test.go @@ -0,0 +1,141 @@ +// SPDX-License-Identifier: Apache-2.0 + +package executor + +import ( + "archive/zip" + "bytes" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/mendixlabs/mxcli/sdk/widgets/mpk" +) + +// writeMiniMPK creates a minimal .mpk ZIP in widgetsDir with the given widget ID. +func writeMiniMPK(t *testing.T, widgetsDir, widgetID string) { + t.Helper() + var buf bytes.Buffer + w := zip.NewWriter(&buf) + + // last segment of ID becomes the XML file name + parts := strings.Split(widgetID, ".") + xmlName := parts[len(parts)-1] + ".xml" + + pkg, _ := w.Create("package.xml") + fmt.Fprintf(pkg, + ``, + xmlName, + ) + + wxml, _ := w.Create(xmlName) + fmt.Fprintf(wxml, + `Test`, + widgetID, + ) + + w.Close() + + mpkPath := filepath.Join(widgetsDir, parts[len(parts)-1]+".mpk") + if err := os.WriteFile(mpkPath, buf.Bytes(), 0644); err != nil { + t.Fatalf("write MPK: %v", err) + } +} + +func TestRegistryMPKFallbackGet(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + writeMiniMPK(t, widgetsDir, "com.test.widget.Testwidget") + + reg, err := NewWidgetRegistry() + if err != nil { + t.Fatalf("NewWidgetRegistry: %v", err) + } + if err := reg.SetProjectDir(dir); err != nil { + t.Fatalf("SetProjectDir: %v", err) + } + + def, ok := reg.Get("TESTWIDGET") + if !ok { + t.Fatal("expected TESTWIDGET via MPK fallback, got not-found") + } + if def.WidgetID != "com.test.widget.Testwidget" { + t.Errorf("WidgetID = %q, want com.test.widget.Testwidget", def.WidgetID) + } + if def.WidgetKind != "pluggable" { + t.Errorf("WidgetKind = %q, want pluggable", def.WidgetKind) + } +} + +func TestRegistryMPKFallbackGetByWidgetID(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + writeMiniMPK(t, widgetsDir, "com.test.widget.Testwidget") + + reg, _ := NewWidgetRegistry() + reg.SetProjectDir(dir) + + def, ok := reg.GetByWidgetID("com.test.widget.Testwidget") + if !ok { + t.Fatal("expected GetByWidgetID fallback to find widget") + } + if def.MDLName != "testwidget" { + t.Errorf("MDLName = %q, want testwidget", def.MDLName) + } +} + +func TestRegistryMPKFallbackCached(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + writeMiniMPK(t, widgetsDir, "com.test.widget.Testwidget") + + reg, _ := NewWidgetRegistry() + reg.SetProjectDir(dir) + + def1, ok1 := reg.Get("TESTWIDGET") + if !ok1 { + t.Fatal("first lookup failed") + } + def2, ok2 := reg.Get("TESTWIDGET") + if !ok2 { + t.Fatal("second lookup failed") + } + if def1 != def2 { + t.Error("expected same pointer on second lookup (in-registry cache)") + } +} + +func TestRegistryMPKFallbackSkipsBuiltins(t *testing.T) { + mpk.ClearCache() + dir := t.TempDir() + widgetsDir := filepath.Join(dir, "widgets") + os.MkdirAll(widgetsDir, 0755) + // Write a fake MPK that would derive "GALLERY" — should be ignored + writeMiniMPK(t, widgetsDir, "com.mendix.widget.web.gallery.Gallery") + + reg, _ := NewWidgetRegistry() + builtinDef, builtinOK := reg.Get("GALLERY") + + reg.SetProjectDir(dir) + + afterDef, afterOK := reg.Get("GALLERY") + if builtinOK { + // Gallery is a builtin: SetProjectDir must not replace it + if afterDef != builtinDef { + t.Error("SetProjectDir must not override a built-in definition") + } + } else { + // Gallery not a builtin in this build: MPK fallback is fine + if !afterOK { + t.Error("expected GALLERY to be found after SetProjectDir") + } + } +} From f5245e3f344a5f26af2fd28cdbd50fb73e646e4f Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 13:38:36 +0800 Subject: [PATCH 15/18] feat: wire SetProjectDir into pageBuilder for runtime MPK fallback --- mdl/executor/cmd_pages_builder.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/mdl/executor/cmd_pages_builder.go b/mdl/executor/cmd_pages_builder.go index 6a8920c0..051637af 100644 --- a/mdl/executor/cmd_pages_builder.go +++ b/mdl/executor/cmd_pages_builder.go @@ -6,6 +6,7 @@ import ( "context" "fmt" "log" + "path/filepath" "strings" "github.com/mendixlabs/mxcli/mdl/ast" @@ -66,6 +67,10 @@ func (pb *pageBuilder) initPluggableEngine() { if loadErr := registry.LoadUserDefinitions(pb.backend.Path()); loadErr != nil { log.Printf("warning: loading user widget definitions: %v", loadErr) } + projectDir := filepath.Dir(pb.backend.Path()) + if scanErr := registry.SetProjectDir(projectDir); scanErr != nil { + log.Printf("warning: widget pre-scan: %v", scanErr) + } } pb.widgetRegistry = registry pb.pluggableEngine = NewPluggableWidgetEngine(pb.widgetBackend, pb) From 6402265c168cec3f1d7b09ee009721f3536ddc1f Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 13:55:00 +0800 Subject: [PATCH 16/18] feat: widget init adds --force flag, demotes to optional debug tool --- cmd/mxcli/cmd_widget.go | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/cmd/mxcli/cmd_widget.go b/cmd/mxcli/cmd_widget.go index a43523ca..51169899 100644 --- a/cmd/mxcli/cmd_widget.go +++ b/cmd/mxcli/cmd_widget.go @@ -46,15 +46,20 @@ var widgetListCmd = &cobra.Command{ var widgetInitCmd = &cobra.Command{ Use: "init", - Short: "Extract definitions for all project widgets", - Long: `Scan the project's widgets/ directory, extract .def.json for each .mpk, -and generate skill documentation in .claude/skills/widgets/. + Short: "Dump widget definitions for inspection or customization", + Long: `Scan the project's widgets/ directory and write .def.json files to +.mxcli/widgets/ for each .mpk. -This enables CREATE PAGE to use any project widget via the pluggable engine. +Note: mxcli widget init is no longer required for CREATE PAGE to work. +Widget definitions are derived automatically at runtime from the project's +widgets/*.mpk files. Run this command only when you need to inspect or +hand-edit a widget's property mappings. + +Existing .def.json files are skipped unless --force is given. Requires --project (-p) to locate the project's widgets/ directory.`, Example: ` mxcli widget init -p /path/to/app.mpr - mxcli widget init -p app.mpr`, + mxcli widget init -p app.mpr --force`, RunE: runWidgetInit, } @@ -73,6 +78,7 @@ func init() { widgetInitCmd.Flags().StringP("project", "p", "", "Path to .mpr project file") widgetInitCmd.MarkFlagRequired("project") + widgetInitCmd.Flags().Bool("force", false, "Overwrite existing .def.json files") widgetDocsCmd.Flags().StringP("project", "p", "", "Path to .mpr project file") widgetDocsCmd.MarkFlagRequired("project") @@ -219,6 +225,7 @@ func generateDefJSON(mpkDef *mpk.WidgetDefinition, mdlName string) *executor.Wid func runWidgetInit(cmd *cobra.Command, args []string) error { projectPath, _ := cmd.Flags().GetString("project") + force, _ := cmd.Flags().GetBool("force") projectDir := filepath.Dir(projectPath) widgetsDir := filepath.Join(projectDir, "widgets") outputDir := filepath.Join(projectDir, ".mxcli", "widgets") @@ -262,10 +269,12 @@ func runWidgetInit(cmd *cobra.Command, args []string) error { } } - // Skip if already exists on disk - if _, err := os.Stat(outPath); err == nil { - skipped++ - continue + // Skip if already exists on disk (unless --force) + if !force { + if _, err := os.Stat(outPath); err == nil { + skipped++ + continue + } } defJSON := generateDefJSON(mpkDef, mdlName) From 548d58c72259ca5b11ef16a215ded2707cb47f0c Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 14:07:26 +0800 Subject: [PATCH 17/18] fix: clarify widget init --force scope and document docs side effect --- cmd/mxcli/cmd_widget.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/cmd/mxcli/cmd_widget.go b/cmd/mxcli/cmd_widget.go index 51169899..29806a18 100644 --- a/cmd/mxcli/cmd_widget.go +++ b/cmd/mxcli/cmd_widget.go @@ -48,7 +48,8 @@ var widgetInitCmd = &cobra.Command{ Use: "init", Short: "Dump widget definitions for inspection or customization", Long: `Scan the project's widgets/ directory and write .def.json files to -.mxcli/widgets/ for each .mpk. +.mxcli/widgets/ for each .mpk. Also writes markdown reference docs to +.claude/skills/widgets/. Note: mxcli widget init is no longer required for CREATE PAGE to work. Widget definitions are derived automatically at runtime from the project's @@ -56,6 +57,10 @@ widgets/*.mpk files. Run this command only when you need to inspect or hand-edit a widget's property mappings. Existing .def.json files are skipped unless --force is given. +Built-in widget definitions (e.g. GALLERY, COMBOBOX) are always skipped; +they are not derived from project .mpk files. + +Note: --force will overwrite any hand-edits you have made to .def.json files. Requires --project (-p) to locate the project's widgets/ directory.`, Example: ` mxcli widget init -p /path/to/app.mpr From 2507881edfeadba4e6294d0d467cf6e82960df71 Mon Sep 17 00:00:00 2001 From: engalar Date: Sat, 9 May 2026 14:43:01 +0800 Subject: [PATCH 18/18] docs: teach AI real-time MPK widget discovery in custom-widgets skill --- .claude/skills/mendix/custom-widgets.md | 58 +++++++++++++++++++++---- 1 file changed, 49 insertions(+), 9 deletions(-) diff --git a/.claude/skills/mendix/custom-widgets.md b/.claude/skills/mendix/custom-widgets.md index 543c7e13..74a8e877 100644 --- a/.claude/skills/mendix/custom-widgets.md +++ b/.claude/skills/mendix/custom-widgets.md @@ -1,6 +1,6 @@ --- name: mendix-custom-widgets -description: Use when writing MDL for GALLERY, COMBOBOX, or third-party pluggable widgets in CREATE PAGE / ALTER PAGE statements. Covers built-in widget syntax, child slots (TEMPLATE/FILTER), adding new custom widgets via .def.json, and engine internals. +description: Use when writing MDL for GALLERY, COMBOBOX, or third-party pluggable widgets in CREATE PAGE / ALTER PAGE statements. Covers built-in widget syntax, child slots (TEMPLATE/FILTER), real-time MPK discovery for project widgets, and adding custom widgets via .def.json. --- # Custom & Pluggable Widgets in MDL @@ -59,7 +59,46 @@ combobox cmbCustomer ( - `CaptionAttribute` is the display attribute on the **target** entity - In association mode, mapping order matters: DataSource must resolve before Association (sets entityContext) -## Adding a Third-Party Widget +## Project Widgets (Real-Time Discovery) + +**No extraction step required.** When `mxcli` runs a `CREATE PAGE` command against a project, it automatically scans `/widgets/*.mpk` and makes every widget available by its derived MDL name — the last dot-segment of the widget ID, lowercased. + +``` +com.vendor.widget.web.MySlider.MySlider → MDL keyword: MYSLIDER +com.example.QRScanner → MDL keyword: QRSCANNER +``` + +### Using a project widget in MDL + +```sql +-- No widget init needed. Just use the widget by its derived name. +create page Module.MyPage (layout: Atlas_Default) { + dataview dv (entity: Module.Product) { + MYSLIDER slider1 (datasource: database Module.Product, attribute: Price) + } +} +``` + +If the widget has a `datasource`, `attribute`, `association`, or `widgets` property in its XML, those are auto-mapped. For properties that need custom mapping (actions, expressions, textTemplates), see the extraction workflow below. + +### Checking what's available + +```bash +# Lists all widgets: built-in + auto-discovered from project MPKs +mxcli widget list -p App.mpr +``` + +### When auto-discovery isn't enough + +Extract a `.def.json` only if you need to: +- Override the auto-inferred property mappings +- Add support for `action`, `expression`, or `textTemplate` properties +- Control the MDL keyword (the derived name doesn't match what you want) +- Share a definition globally across projects (`~/.mxcli/widgets/`) + +--- + +## Customizing a Widget (.def.json Workflow) ### Step 1 -- Extract .def.json from .mpk @@ -291,15 +330,16 @@ project/widgets/*.mpk -> FindMPK(projectDir, widgetID) -> ParseMPK() This reduces CE0463 errors from widget version drift without requiring manual template re-extraction. -### 3-Tier Registry +### 4-Tier Registry | Priority | Location | Scope | |----------|----------|-------| -| 1 (highest) | `/.mxcli/widgets/*.def.json` | Project | +| 1 (highest) | `/.mxcli/widgets/*.def.json` | Project (hand-crafted) | | 2 | `~/.mxcli/widgets/*.def.json` | Global (user) | -| 3 (lowest) | `sdk/widgets/definitions/*.def.json` (embedded) | Built-in | +| 3 | `sdk/widgets/definitions/*.def.json` (embedded) | Built-in | +| 4 (lowest) | `/widgets/*.mpk` (real-time) | Project (auto-derived) | -Higher priority definitions override lower ones with the same MDL name (case-insensitive). +Higher priority definitions override lower ones. Real-time MPK derivation only activates when no definition exists at tiers 1–3. The MDL name derived from an MPK (lowercase last ID segment) is used as the key; if a built-in or hand-crafted definition uses the same name, the MPK entry is silently skipped. ## Verify & Debug @@ -322,7 +362,7 @@ mxcli bson dump -p App.mpr --type page --object "Module.PageName" --format ndsl | Mistake | Fix | |---------|-----| | CE0463 after page creation | Template version mismatch -- extract fresh template from Studio Pro MPR, or ensure .mpk augmentation picks up new properties | -| Widget not recognized | Check `mxcli widget list`; .def.json must be in `.mxcli/widgets/` with `.def.json` extension | +| Widget not recognized | Run `mxcli widget list -p App.mpr` — project widgets are auto-discovered from `widgets/*.mpk`; if still missing, the .mpk may not exist or the widget ID differs from expected | | TEMPLATE content missing | Widget needs `childSlots` entry with `"mdlContainer": "template"` | | Association COMBOBOX shows enum behavior | Add `datasource` to trigger association mode (`hasDataSource` condition) | | Association mapping fails | Ensure DataSource mapping appears **before** Association mapping in the array | @@ -334,10 +374,10 @@ mxcli bson dump -p App.mpr --type page --object "Module.PageName" --format ndsl | File | Purpose | |------|---------| | `mdl/executor/widget_engine.go` | PluggableWidgetEngine, 6 operations, Build() pipeline | -| `mdl/executor/widget_registry.go` | 3-tier WidgetRegistry, definition validation | +| `mdl/executor/widget_registry.go` | 4-tier WidgetRegistry: `SetProjectDir` triggers real-time MPK scan; `Get`/`GetByWidgetID` fall back to MPK derivation on miss | | `sdk/widgets/loader.go` | Template loading, ID remapping, MPK augmentation | | `sdk/widgets/mpk/mpk.go` | .mpk ZIP parsing, XML property extraction | -| `cmd/mxcli/cmd_widget.go` | `mxcli widget extract/list` CLI commands | +| `cmd/mxcli/cmd_widget.go` | `mxcli widget extract/list/init` CLI commands (`init` is now optional; use `--force` to overwrite) | | `sdk/widgets/definitions/*.def.json` | Built-in widget definitions (ComboBox, Gallery) | | `sdk/widgets/templates/mendix-11.6/*.json` | Embedded BSON templates | | `mdl/executor/cmd_pages_builder_input.go` | `updateWidgetPropertyValue()` -- TypePointer matching |