perf(show modules): eliminate BSON decode for type-based counting

show modules was decoding ALL page, microflow, nanoflow, snippet,
enumeration, constant and Java action documents (via listPagesWithContainerGen,
listMicroflowsWithContainerGen, etc.) just to produce count columns.
The unitCache already carries type strings from the BSON $Type field —
no document decoding is needed for counting.

Replace the multi-function approach with a single pass over ListUnits()
using a switch on types.UnitTypeXxx constants. Entity counts still require
domain-model decoding (entities are sub-objects, not standalone units).

Also add mdl/types/unit_types.go with exported BSON type name constants
(types.UnitTypePage, types.UnitTypeMicroflow, etc.) shared across executor
and backend layers, replacing scattered hard-coded string literals.

Expected speedup: eliminates ~9 domain-model decodes + all page/microflow/
snippet/nanoflow/enumeration/constant decodes per show modules invocation.

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

Author: engalar

mdl/executor/cmd_modules.go

@@ -446,26 +446,45 @@ func listModules(ctx *ExecContext) error {
 	bizEventCounts := make(map[model.ID]int)
 	extDbCounts := make(map[model.ID]int)
 
-	// Count from units by type prefix (efficient single pass)
+	// Single-pass over unit metadata using mdl/types constants: all
+	// type-based counts are derived from the unitCache type strings —
+	// no BSON decoding required. This is the dominant performance path.
 	for _, u := range units {
 		modID := h.FindModuleID(u.ContainerID)
-		switch {
-		case strings.HasPrefix(u.Type, "Rest$PublishedRestService"):
+		switch u.Type {
+		case types.UnitTypePage:
+			pageCounts[modID]++
+		case types.UnitTypeSnippet:
+			snippetCounts[modID]++
+		case types.UnitTypeMicroflow:
+			microflowCounts[modID]++
+		case types.UnitTypeNanoflow:
+			nanoflowCounts[modID]++
+		case types.UnitTypeEnumeration:
+			enumCounts[modID]++
+		case types.UnitTypeConstant:
+			constantCounts[modID]++
+		case types.UnitTypeJavaAction:
+			javaActionCounts[modID]++
+		case types.UnitTypePublishedRestService:
 			pubRestCounts[modID]++
-		case strings.HasPrefix(u.Type, "ODataPublish$PublishedODataService"):
+		case types.UnitTypePublishedODataService:
 			pubODataCounts[modID]++
-		case strings.HasPrefix(u.Type, "Rest$ConsumedODataService"):
+		case types.UnitTypeConsumedODataService:
 			conODataCounts[modID]++
-		case strings.HasPrefix(u.Type, "BusinessEvents$"):
-			bizEventCounts[modID]++
-		case strings.HasPrefix(u.Type, "Workflows$Workflow"):
+		case types.UnitTypeWorkflow:
 			workflowCounts[modID]++
-		case strings.HasPrefix(u.Type, "DatabaseConnector$DatabaseConnection"):
+		case types.UnitTypeDatabaseConnection:
 			extDbCounts[modID]++
+		default:
+			if strings.HasPrefix(u.Type, types.UnitTypeBusinessEvent) {
+				bizEventCounts[modID]++
+			}
 		}
 	}
 
-	// Count entities from domain models (Stage 3.3.4 C2.c — gen path).
+	// Entity counts still require domain-model decoding: entities are sub-objects
+	// of domain model units, not standalone units with their own unitCache entries.
 	if pairs, err := listDomainModelsWithContainerGen(ctx); err == nil {
 		for _, p := range pairs {
 			if p.DM == nil {
@@ -476,62 +495,6 @@ func listModules(ctx *ExecContext) error {
 		}
 	}
 
-	// Count enumerations
-	if enums, err := ctx.Backend.ListEnumerations(); err == nil {
-		for _, enum := range enums {
-			modID := h.FindModuleID(enum.ContainerID)
-			enumCounts[modID]++
-		}
-	}
-
-	// Count pages
-	if pagePairs, err := listPagesWithContainerGen(ctx); err == nil {
-		for _, pair := range pagePairs {
-			modID := h.FindModuleID(model.ID(pair.ContainerID))
-			pageCounts[modID]++
-		}
-	}
-
-	// Count snippets
-	if snippetPairs, err := listSnippetsWithContainerGen(ctx); err == nil {
-		for _, pair := range snippetPairs {
-			modID := h.FindModuleID(model.ID(pair.ContainerID))
-			snippetCounts[modID]++
-		}
-	}
-
-	// Count microflows
-	if mfs, err := listMicroflowsWithContainerGen(ctx); err == nil {
-		for _, item := range mfs {
-			modID := h.FindModuleID(item.ContainerUUID)
-			microflowCounts[modID]++
-		}
-	}
-
-	// Count nanoflows
-	if nfs, err := listNanoflowsWithContainerGen(ctx); err == nil {
-		for _, item := range nfs {
-			modID := h.FindModuleID(item.ContainerUUID)
-			nanoflowCounts[modID]++
-		}
-	}
-
-	// Count constants
-	if constants, err := ctx.Backend.ListConstants(); err == nil {
-		for _, c := range constants {
-			modID := h.FindModuleID(c.ContainerID)
-			constantCounts[modID]++
-		}
-	}
-
-	// Count Java actions (gen-typed)
-	if pairs, err := listJavaActionsWithContainerGen(ctx); err == nil {
-		for _, p := range pairs {
-			modID := h.FindModuleID(model.ID(p.ContainerID))
-			javaActionCounts[modID]++
-		}
-	}
-
 	// Sort modules alphabetically by name
 	sort.Slice(modules, func(i, j int) bool {
 		return strings.ToLower(modules[i].Name) < strings.ToLower(modules[j].Name)

mdl/types/unit_types.go

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package types
+
+// Unit type name constants for MPR BSON $Type fields.
+// These are the storage names used by Mendix Studio Pro — not the SDK
+// qualified names. Use these constants instead of raw string literals
+// when switching on UnitInfo.Type or unitCache entries.
+const (
+	// Core project structure
+	UnitTypeModule       = "Projects$ModuleImpl"
+	UnitTypeModuleSettings = "Projects$ModuleSettings"
+	UnitTypeFolder       = "Projects$Folder"
+	UnitTypeProjectSettings = "Settings$ProjectSettings"
+
+	// Domain model
+	UnitTypeDomainModel  = "DomainModels$DomainModel"
+	UnitTypeEnumeration  = "Enumerations$Enumeration"
+	UnitTypeConstant     = "Constants$Constant"
+
+	// Flows
+	UnitTypeMicroflow    = "Microflows$Microflow"
+	UnitTypeNanoflow     = "Microflows$Nanoflow"
+	UnitTypeRule         = "Microflows$Rule"
+
+	// Pages / UI
+	UnitTypePage         = "Forms$Page"
+	UnitTypeLayout       = "Forms$Layout"
+	UnitTypeSnippet      = "Forms$Snippet"
+
+	// Java / JavaScript actions
+	UnitTypeJavaAction       = "JavaActions$JavaAction"
+	UnitTypeJavaScriptAction = "JavaActions$JavaScriptAction"
+
+	// Workflows
+	UnitTypeWorkflow     = "Workflows$Workflow"
+
+	// REST / OData / Business events
+	UnitTypePublishedRestService = "Rest$PublishedRestService"
+	UnitTypePublishedODataService = "ODataPublish$PublishedODataService"
+	UnitTypeConsumedODataService  = "Rest$ConsumedODataService"
+	UnitTypeBusinessEvent         = "BusinessEvents$" // prefix — multiple sub-types
+
+	// Database connector
+	UnitTypeDatabaseConnection = "DatabaseConnector$DatabaseConnection"
+
+	// Images
+	UnitTypeImageCollection = "Images$ImageCollection"
+)