feat: support primitive page parameters (String, Integer, etc.)

Page parameters previously only supported entity types. Now primitive
types (String, Integer, Long, Decimal, Boolean, DateTime) are parsed,
serialized, and round-tripped correctly.

Changes across the full stack:
- AST: PageParameter now carries DataType alongside EntityType
- Visitor: uses buildDataType() for full type parsing
- Executor: maps primitive DataType to BSON type, skips entity resolution
- Writer: emits DataTypes$StringType etc. instead of hardcoded ObjectType
- Parser: reads $Type from ParameterType to detect primitives
- DESCRIBE: outputs "Integer", "String" etc. for primitive params

Closes #139

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

Author: ako

mdl/ast/ast_page.go

@@ -6,10 +6,12 @@ package ast
 // Page Statements
 // ============================================================================
 
-// PageParameter represents a page parameter: $Name: EntityType
+// PageParameter represents a page parameter: $Name: Type
+// Type can be an entity (Module.Entity) or a primitive (String, Integer, etc.).
 type PageParameter struct {
 	Name       string        // Parameter name (without $ prefix)
-	EntityType QualifiedName // Entity type
+	EntityType QualifiedName // Entity type (for backward compatibility; empty for primitives)
+	Type       DataType      // Full data type (primitives + entities)
 }
 
 // PageVariable represents a page variable: $Name: DataType = 'defaultExpression'

mdl/executor/cmd_pages_builder_v3.go

@@ -86,8 +86,12 @@ func (pb *pageBuilder) buildPageV3(s *ast.CreatePageStmtV3) (*pages.Page, error)
 			IsRequired:  true, // Page parameters are required by default
 		}
 
-		// Resolve entity type
-		if param.EntityType.Name != "" {
+		// Check if this is a primitive type or entity type
+		if bsonType := pageParamBSONType(param.Type); bsonType != "" {
+			// Primitive type parameter
+			pageParam.TypeName = bsonType
+		} else if param.EntityType.Name != "" {
+			// Entity type parameter
 			entityID, err := pb.resolveEntity(param.EntityType)
 			if err != nil {
 				return nil, fmt.Errorf("failed to resolve entity %s: %w", param.EntityType.String(), err)
@@ -968,6 +972,27 @@ func (pb *pageBuilder) getEntityNameByID(entityID model.ID) (string, error) {
 	return "", fmt.Errorf("entity not found by ID: %s", entityID)
 }
 
+// pageParamBSONType maps a DataType to the BSON $Type string for primitive page parameters.
+// Returns empty string for entity/enum types (which use DataTypes$ObjectType instead).
+func pageParamBSONType(dt ast.DataType) string {
+	switch dt.Kind {
+	case ast.TypeString:
+		return "DataTypes$StringType"
+	case ast.TypeInteger:
+		return "DataTypes$IntegerType"
+	case ast.TypeLong:
+		return "DataTypes$LongType"
+	case ast.TypeDecimal:
+		return "DataTypes$DecimalType"
+	case ast.TypeBoolean:
+		return "DataTypes$BooleanType"
+	case ast.TypeDateTime:
+		return "DataTypes$DateTimeType"
+	default:
+		return ""
+	}
+}
+
 // resolveNanoflowByName resolves a nanoflow qualified name to its ID.
 func (pb *pageBuilder) resolveNanoflowByName(nfName string) (model.ID, error) {
 	parts := strings.Split(nfName, ".")

mdl/executor/cmd_pages_describe.go

@@ -103,11 +103,8 @@ func (e *Executor) describePage(name ast.QualifiedName) error {
 	if len(foundPage.Parameters) > 0 {
 		params := []string{}
 		for _, p := range foundPage.Parameters {
-			entityName := p.EntityName
-			if entityName == "" {
-				entityName = string(p.EntityID)
-			}
-			params = append(params, fmt.Sprintf("$%s: %s", p.Name, entityName))
+			typeName := pageParamTypeMDL(p)
+			params = append(params, fmt.Sprintf("$%s: %s", p.Name, typeName))
 		}
 		props = append(props, fmt.Sprintf("Params: { %s }", strings.Join(params, ", ")))
 	}
@@ -721,3 +718,30 @@ func wrapStringLiteralExpression(value string) string {
 	// Otherwise wrap in single quotes as a string literal
 	return "'" + value + "'"
 }
+
+// pageParamTypeMDL returns the MDL type string for a page parameter.
+// Primitive params return "String", "Integer", etc.; entity params return the qualified name.
+func pageParamTypeMDL(p *pages.PageParameter) string {
+	if p.TypeName != "" {
+		switch p.TypeName {
+		case "DataTypes$StringType":
+			return "String"
+		case "DataTypes$IntegerType":
+			return "Integer"
+		case "DataTypes$LongType":
+			return "Long"
+		case "DataTypes$DecimalType":
+			return "Decimal"
+		case "DataTypes$BooleanType":
+			return "Boolean"
+		case "DataTypes$DateTimeType":
+			return "DateTime"
+		default:
+			return p.TypeName
+		}
+	}
+	if p.EntityName != "" {
+		return p.EntityName
+	}
+	return string(p.EntityID)
+}

mdl/visitor/visitor_page.go

@@ -43,7 +43,10 @@ func buildPageParameters(ctx parser.IPageParameterListContext) []ast.PageParamet
 			name = strings.TrimPrefix(v.GetText(), "$")
 		}
 		var entityType ast.QualifiedName
+		var dataType ast.DataType
 		if dt := paramCtx.DataType(); dt != nil {
+			dataType = buildDataType(dt)
+			// For backward compatibility, also populate EntityType for entity/enum refs
 			dtCtx := dt.(*parser.DataTypeContext)
 			if qn := dtCtx.QualifiedName(); qn != nil {
 				entityType = buildQualifiedName(qn)
@@ -52,6 +55,7 @@ func buildPageParameters(ctx parser.IPageParameterListContext) []ast.PageParamet
 		params = append(params, ast.PageParameter{
 			Name:       name,
 			EntityType: entityType,
+			Type:       dataType,
 		})
 	}
 	return params

sdk/mpr/parser_page.go

@@ -162,38 +162,41 @@ func parsePageParameter(raw map[string]any) *pages.PageParameter {
 		param.EntityID = model.ID(entityID)
 	}
 
-	// Parse ParameterType to get entity name
+	// Parse ParameterType to get entity name and/or primitive type
 	// ParameterType can be a map/bson.D (single object) or array (with version marker)
-	if paramType, ok := raw["ParameterType"].(bson.D); ok {
-		// Direct bson.D format
-		for _, elem := range paramType {
-			if elem.Key == "Entity" {
+	parseParamTypeDoc := func(doc bson.D) {
+		for _, elem := range doc {
+			switch elem.Key {
+			case "$Type":
+				if typeName, ok := elem.Value.(string); ok && typeName != "DataTypes$ObjectType" {
+					param.TypeName = typeName
+				}
+			case "Entity":
 				if entity, ok := elem.Value.(string); ok {
 					param.EntityName = entity
 				}
 			}
 		}
-	} else if paramType, ok := raw["ParameterType"].(map[string]any); ok {
-		// Direct map format: {"$Type": "DataTypes$ObjectType", "Entity": "..."}
-		if entity, ok := paramType["Entity"].(string); ok {
+	}
+	parseParamTypeMap := func(m map[string]any) {
+		if typeName, ok := m["$Type"].(string); ok && typeName != "DataTypes$ObjectType" {
+			param.TypeName = typeName
+		}
+		if entity, ok := m["Entity"].(string); ok {
 			param.EntityName = entity
 		}
+	}
+
+	if paramType, ok := raw["ParameterType"].(bson.D); ok {
+		parseParamTypeDoc(paramType)
+	} else if paramType, ok := raw["ParameterType"].(map[string]any); ok {
+		parseParamTypeMap(paramType)
 	} else if paramTypeArr, ok := raw["ParameterType"].(bson.A); ok {
-		// Array format: [{...}] or [version, {...}]
 		for _, item := range paramTypeArr {
 			if typeDoc, ok := item.(bson.D); ok {
-				for _, elem := range typeDoc {
-					if elem.Key == "Entity" {
-						if entity, ok := elem.Value.(string); ok {
-							param.EntityName = entity
-						}
-					}
-				}
+				parseParamTypeDoc(typeDoc)
 			} else if typeMap, ok := item.(map[string]any); ok {
-				if entity, ok := typeMap["Entity"].(string); ok {
-					param.EntityName = entity
-					break
-				}
+				parseParamTypeMap(typeMap)
 			}
 		}
 	}

sdk/mpr/writer_pages.go

@@ -188,12 +188,23 @@ func (w *Writer) serializePage(page *pages.Page) ([]byte, error) {
 			paramID = generateUUID()
 		}
 
-		// Build ParameterType with DataTypes$ObjectType (as bson.D, not wrapped in bson.A)
+		// Build ParameterType — entity params use DataTypes$ObjectType,
+		// primitive params use DataTypes$StringType, DataTypes$IntegerType, etc.
 		paramTypeID := generateUUID()
-		paramType := bson.D{
-			{Key: "$ID", Value: idToBsonBinary(paramTypeID)},
-			{Key: "$Type", Value: "DataTypes$ObjectType"},
-			{Key: "Entity", Value: p.EntityName},
+		var paramType bson.D
+		if p.TypeName != "" {
+			// Primitive type parameter
+			paramType = bson.D{
+				{Key: "$ID", Value: idToBsonBinary(paramTypeID)},
+				{Key: "$Type", Value: p.TypeName},
+			}
+		} else {
+			// Entity type parameter (default)
+			paramType = bson.D{
+				{Key: "$ID", Value: idToBsonBinary(paramTypeID)},
+				{Key: "$Type", Value: "DataTypes$ObjectType"},
+				{Key: "Entity", Value: p.EntityName},
+			}
 		}
 
 		paramDoc := bson.D{

sdk/pages/pages_parameters.go

@@ -28,6 +28,7 @@ type PageParameter struct {
 	Name         string   `json:"name"`
 	EntityID     model.ID `json:"entityId,omitempty"`
 	EntityName   string   `json:"entityName,omitempty"`   // Qualified entity name (e.g., "Module.Entity")
+	TypeName     string   `json:"typeName,omitempty"`     // BSON $Type for ParameterType (e.g., "DataTypes$StringType")
 	DefaultValue string   `json:"defaultValue,omitempty"` // Default value expression
 	IsRequired   bool     `json:"isRequired"`             // Whether the parameter is required
 }