fix: CREATE ENTITY rejects unknown attribute type names (#392)

The visitor parses any unrecognised type token as TypeEnumeration (the
TypeEnumeration vs TypeEntity ambiguity documented in CLAUDE.md).
convertDataType then blindly stored it as EnumerationAttributeType with
an unresolvable ref, producing a corrupt model that Studio Pro flags.

Added a pre-pass before the attribute-build loop: for every TypeEnumeration
attribute, attempt to resolve the ref against known enumerations (findEnumeration)
and known entities (findEntity). If neither resolves, return a validation error
naming the attribute and the unrecognised type.

Valid qualified enum and entity refs (e.g. MyModule.MyEnum) are still accepted.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: ako

mdl/executor/cmd_entities.go

@@ -98,6 +98,28 @@ func execCreateEntity(ctx *ExecContext, s *ast.CreateEntityStmt) error {
 		}
 	}
 
+	// Validate TypeEnumeration attribute refs before writing anything.
+	// The visitor uses TypeEnumeration for both enum and entity type references
+	// (TypeEnumeration vs TypeEntity ambiguity). Accept the ref when it resolves
+	// to either a known enumeration or a known entity; reject unknown names fast
+	// so typos don't silently produce corrupt models.
+	for _, a := range s.Attributes {
+		if a.Type.Kind != ast.TypeEnumeration || a.Type.EnumRef == nil {
+			continue
+		}
+		refModule := a.Type.EnumRef.Module
+		refName := a.Type.EnumRef.Name
+		if findEnumeration(ctx, refModule, refName) != nil {
+			continue
+		}
+		if _, err := findEntity(ctx, refModule, refName); err == nil {
+			continue
+		}
+		return mdlerrors.NewValidationf(
+			"attribute '%s': unknown type '%s' — not a primitive, enumeration, or entity",
+			a.Name, a.Type.EnumRef.String())
+	}
+
 	// Create attributes and build name-to-ID map for validation rules and indexes
 	// Also detect pseudo-types (AutoOwner, AutoChangedBy, etc.) and set entity flags
 	var storeOwner, storeChangedBy, storeCreatedDate, storeChangedDate bool

mdl/executor/cmd_entities_mock_test.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/mendixlabs/mxcli/mdl/ast"
 	"github.com/mendixlabs/mxcli/mdl/backend/mock"
 	"github.com/mendixlabs/mxcli/model"
 	"github.com/mendixlabs/mxcli/sdk/domainmodel"
@@ -82,6 +83,40 @@ func TestShowEntities_BackendError(t *testing.T) {
 	assertError(t, listEntities(ctx, ""))
 }
 
+// Issue #392 — CREATE ENTITY must reject attribute types that don't resolve
+// to a known primitive, enumeration, or entity.
+func TestCreateEntity_UnknownAttributeType_Issue392(t *testing.T) {
+	mod := mkModule("M")
+	dm := mkDomainModel(mod.ID)
+
+	mb := &mock.MockBackend{
+		IsConnectedFunc:      func() bool { return true },
+		ListModulesFunc:      func() ([]*model.Module, error) { return []*model.Module{mod}, nil },
+		ListDomainModelsFunc: func() ([]*domainmodel.DomainModel, error) { return []*domainmodel.DomainModel{dm}, nil },
+		GetDomainModelFunc:   func(id model.ID) (*domainmodel.DomainModel, error) { return dm, nil },
+		ListEnumerationsFunc: func() ([]*model.Enumeration, error) { return nil, nil },
+	}
+	h := mkHierarchy(mod)
+	withContainer(h, dm.ID, mod.ID)
+
+	ctx, _ := newMockCtx(t, withBackend(mb), withHierarchy(h))
+	err := execCreateEntity(ctx, &ast.CreateEntityStmt{
+		Name: ast.QualifiedName{Module: "M", Name: "E"},
+		Kind: ast.EntityPersistent,
+		Attributes: []ast.Attribute{
+			{
+				Name: "Field1",
+				Type: ast.DataType{
+					Kind:    ast.TypeEnumeration,
+					EnumRef: &ast.QualifiedName{Name: "invalidtype"},
+				},
+			},
+		},
+	})
+	assertError(t, err)
+	assertContainsStr(t, err.Error(), "invalidtype")
+}
+
 func TestShowEntities_JSON(t *testing.T) {
 	mod := mkModule("App")
 	ent := mkEntity(mod.ID, "Item")