Move IsPointer logic to FieldTypes struct.

Rather than deciding which generated fields are represented as pointers in
different places in the code, this patch adds an IsPointer() method to
TypeFields to consolidate that logic.

Author: jmcarp

internal/generate/types.go

@@ -98,6 +98,45 @@ func (f TypeFields) StructTag() string {
 	return fmt.Sprintf("`json:\"%s\" yaml:\"%s\"`", tagValue, tagValue)
 }
 
+// IsPointer returns whether this field should be a pointer type.
+// This consolidates the field-level pointer decision logic:
+//   - Required + nullable fields (Omicron API pattern) need pointers
+//   - Types in the nullable() exception list need pointers
+//
+// Note: Primitive type pointer logic (int, bool, time) is handled in
+// schemaValueToGoType() because those types can appear in nested contexts
+// (map values, array items) that don't go through TypeFields.
+func (f TypeFields) IsPointer() bool {
+	if f.Schema == nil {
+		return false
+	}
+
+	v := f.Schema.Value
+
+	// Required + nullable fields should be pointers (Omicron API pattern):
+	// they can be set to a null value, but they must not be omitted.
+	// The SDK presents these fields as optional and serializes them to
+	// `null` if not provided.
+	if f.Required && v.Nullable {
+		return true
+	}
+
+	// Check hardcoded nullable exceptions (upstream API workarounds)
+	if slices.Contains(nullable(), f.Type) {
+		return true
+	}
+
+	return false
+}
+
+// GoType returns the Go type for this field, with pointer prefix if needed.
+func (f TypeFields) GoType() string {
+	if f.IsPointer() && !strings.HasPrefix(f.Type, "*") {
+		return "*" + f.Type
+	}
+	return f.Type
+}
+
 // EnumTemplate holds the information for enum types
 type EnumTemplate struct {
 	Description string
@@ -388,7 +427,7 @@ func writeTypes(f *os.File, typeCollection []TypeTemplate, typeValidationCollect
 				if desc := ft.Description(); desc != "" {
 					fmt.Fprintf(f, "\t%s\n", splitDocString(desc))
 				}
-				fmt.Fprintf(f, "\t%s %s %s\n", ft.Name, ft.Type, ft.StructTag())
+				fmt.Fprintf(f, "\t%s %s %s\n", ft.Name, ft.GoType(), ft.StructTag())
 			}
 			fmt.Fprint(f, "}\n")
 		}
@@ -569,29 +608,15 @@ func createTypeObject(schema *openapi3.Schema, name, typeName, description strin
 			}
 		}
 
-		// Omicron includes fields that are both required and nullable:
-		// they can be set to a null value, but they must not be
-		// omitted. The sdk should present these fields to the user as
-		// optional, and serialize them to `null` if not provided.
 		isRequired := slices.Contains(required, k)
-		isRequiredNullable := v.Value.Nullable && isRequired
-		if slices.Contains(nullable(), typeName) || isRequiredNullable {
-			// We may have already decided to use a pointer. For
-			// example, convertToValidGoType always uses pointers
-			// for ints and bools. Prefix the type with "*", unless
-			// we've already made it a pointer upstream.
-			if !strings.HasPrefix(typeName, "*") {
-				typeName = fmt.Sprintf("*%s", typeName)
-			}
-		}
-
 		field := TypeFields{
 			Name:       strcase.ToCamel(k),
 			Type:       typeName,
 			MarshalKey: k,
 			Schema:     v,
 			Required:   isRequired,
 		}
+		// Note: pointer prefix is applied by TypeFields.GoType() based on IsPointer()
 
 		fields = append(fields, field)
 

internal/generate/types_test.go

@@ -188,6 +188,56 @@ func TestTypeFields_StructTag(t *testing.T) {
 	})
 }
 
+func TestTypeFields_IsPointer(t *testing.T) {
+	tests := []struct {
+		name     string
+		field    TypeFields
+		expected bool
+	}{
+		{
+			name:     "nil schema",
+			field:    TypeFields{Name: "Body", Schema: nil},
+			expected: false,
+		},
+		{
+			name: "nullable required",
+			field: TypeFields{
+				Name:     "Config",
+				Type:     "SomeConfig",
+				Schema:   &openapi3.SchemaRef{Value: &openapi3.Schema{Type: &openapi3.Types{"object"}, Nullable: true}},
+				Required: true,
+			},
+			expected: true,
+		},
+		{
+			name: "nullable not required",
+			field: TypeFields{
+				Name:     "Config",
+				Type:     "SomeConfig",
+				Schema:   &openapi3.SchemaRef{Value: &openapi3.Schema{Type: &openapi3.Types{"object"}, Nullable: true}},
+				Required: false,
+			},
+			expected: false,
+		},
+		{
+			name: "not nullable required",
+			field: TypeFields{
+				Name:     "Config",
+				Type:     "SomeConfig",
+				Schema:   &openapi3.SchemaRef{Value: &openapi3.Schema{Type: &openapi3.Types{"object"}, Nullable: false}},
+				Required: true,
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, tt.field.IsPointer())
+		})
+	}
+}
+
 func Test_createTypeObject(t *testing.T) {
 	typesSpec := openapi3.Schema{
 		Required: []string{"type"},

internal/generate/utils.go

@@ -59,19 +59,13 @@ func isNullableArray(v *openapi3.SchemaRef) bool {
 
 // formatStringType converts a string schema to a valid Go type.
 func formatStringType(t *openapi3.Schema) string {
-	var format string
 	switch t.Format {
-	case "date-time":
-		format = "*time.Time"
-	case "date":
-		format = "*time.Time"
-	case "time":
-		format = "*time.Time"
+	case "date-time", "date", "time":
+		// Time types need pointers for JSON marshaling
+		return "*time.Time"
 	default:
-		format = "string"
+		return "string"
 	}
-
-	return format
 }
 
 // toLowerFirstLetter returns the given string with the first letter converted to lower case.
@@ -201,10 +195,6 @@ func schemaValueToGoType(schemaValue *openapi3.Schema, property string) string {
 		return fmt.Sprintf("[]%v", schemaType)
 	}
 
-	if schemaValue.Type.Is("object") {
-		return "object"
-	}
-
 	fmt.Printf("[WARN] TODO: handle type %q for %q, marking as any for now\n", schemaValue.Type, property)
 	return "any"
 }