Refactor: consolidate field logic in struct.

Author: jmcarp

internal/generate/types.go

@@ -38,10 +38,64 @@ type TypeTemplate struct {
 
 // TypeFields holds the information for each type field
 type TypeFields struct {
-	Description       string
-	Name              string
-	Type              string
-	SerializationInfo string
+	Schema     *openapi3.SchemaRef
+	Name       string
+	Type       string
+	MarshalKey string
+	Required   bool
+
+	// FallbackDescription generates a generic description for the field when the Schema doesn't have one.
+	// TODO: Drop this, since generated descriptions don't contain useful information.
+	FallbackDescription bool
+
+	// OmitDirective overrides the derived omit directive for the field.
+	// TODO: Drop this; we should set omit directives consistently rather than using overrides.
+	OmitDirective string
+}
+
+// Description returns the formatted description comment for this field.
+func (f TypeFields) Description() string {
+	if f.Schema == nil {
+		return ""
+	}
+	if f.Schema.Value.Description != "" {
+		return fmt.Sprintf("// %s is %s", f.Name, toLowerFirstLetter(
+			strings.ReplaceAll(f.Schema.Value.Description, "\n", "\n// ")))
+	}
+	if f.FallbackDescription {
+		return fmt.Sprintf("// %s is the type definition for a %s.", f.Name, f.Name)
+	}
+	return ""
+}
+
+// StructTag returns the JSON/YAML struct tags for this field.
+func (f TypeFields) StructTag() string {
+	// Derive the omit directive.
+	var omitDirective string
+	switch {
+	case f.OmitDirective != "":
+		// Explicit override.
+		omitDirective = f.OmitDirective
+	case f.Schema == nil:
+		// Special case: no schema (e.g., Body field).
+		omitDirective = "omitempty"
+	case f.Required || isNullableArray(f.Schema):
+		// Required or nullable array: no directive (always serialize).
+		omitDirective = ""
+	case slices.Contains(omitzeroTypes(), f.Type):
+		// Special types: omitzero.
+		omitDirective = "omitzero"
+	default:
+		omitDirective = "omitempty"
+	}
+
+	// Build the tag value.
+	tagValue := f.MarshalKey
+	if omitDirective != "" {
+		tagValue = f.MarshalKey + "," + omitDirective
+	}
+
+	return fmt.Sprintf("`json:\"%s\" yaml:\"%s\"`", tagValue, tagValue)
 }
 
 // EnumTemplate holds the information for enum types
@@ -129,18 +183,18 @@ func constructParamTypes(paths map[string]*openapi3.PathItem) []TypeTemplate {
 					}
 
 					paramName := strcase.ToCamel(p.Value.Name)
+					paramType := convertToValidGoType("", "", p.Value.Schema)
 					field := TypeFields{
-						Name: paramName,
-						Type: convertToValidGoType("", "", p.Value.Schema),
+						Name:       paramName,
+						Type:       paramType,
+						MarshalKey: p.Value.Name,
+						Schema:     nil, // nil so StructTag always uses omitempty
 					}
 
 					if p.Value.Required {
 						requiredFields = requiredFields + fmt.Sprintf("\n// - %s", paramName)
 					}
 
-					serInfo := fmt.Sprintf("`json:\"%s,omitempty\" yaml:\"%s,omitempty\"`", p.Value.Name, p.Value.Name)
-					field.SerializationInfo = serInfo
-
 					fields = append(fields, field)
 				}
 				if o.RequestBody != nil {
@@ -151,17 +205,19 @@ func constructParamTypes(paths map[string]*openapi3.PathItem) []TypeTemplate {
 						// TODO: Handle other mime types in a more idiomatic way
 						if mt != "application/json" {
 							field = TypeFields{
-								Name:              "Body",
-								Type:              "io.Reader",
-								SerializationInfo: "`json:\"body,omitempty\" yaml:\"body,omitempty\"`",
+								Name:       "Body",
+								Type:       "io.Reader",
+								MarshalKey: "body",
+								Schema:     nil, // no schema for non-JSON body
 							}
 							break
 						}
 
 						field = TypeFields{
-							Name:              "Body",
-							Type:              "*" + convertToValidGoType("", "", r.Schema),
-							SerializationInfo: "`json:\"body,omitempty\" yaml:\"body,omitempty\"`",
+							Name:       "Body",
+							Type:       "*" + convertToValidGoType("", "", r.Schema),
+							MarshalKey: "body",
+							Schema:     nil, // Body uses special serialization
 						}
 					}
 					// Body is always a required field
@@ -329,10 +385,10 @@ func writeTypes(f *os.File, typeCollection []TypeTemplate, typeValidationCollect
 		if tt.Fields != nil {
 			fmt.Fprint(f, " {\n")
 			for _, ft := range tt.Fields {
-				if ft.Description != "" {
-					fmt.Fprintf(f, "\t%s\n", splitDocString(ft.Description))
+				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.SerializationInfo)
+				fmt.Fprintf(f, "\t%s %s %s\n", ft.Name, ft.Type, ft.StructTag())
 			}
 			fmt.Fprint(f, "}\n")
 		}
@@ -529,29 +585,14 @@ func createTypeObject(schema *openapi3.Schema, name, typeName, description strin
 			}
 		}
 
-		field := TypeFields{}
-		if v.Value.Description != "" {
-			desc := fmt.Sprintf("// %s is %s", strcase.ToCamel(k), toLowerFirstLetter(strings.ReplaceAll(v.Value.Description, "\n", "\n// ")))
-			field.Description = desc
-		}
-
-		field.Name = strcase.ToCamel(k)
-		field.Type = typeName
-
-		// Configure json/yaml struct tags. By default, omit empty/zero
-		// values, but retain them for required fields.
-		//
-		// TODO: Use `omitzero` rather than `omitempty` on all relevant
-		// fields: https://github.com/oxidecomputer/oxide.go/issues/290
-		serInfo := fmt.Sprintf("`json:\"%s,omitempty\" yaml:\"%s,omitempty\"`", k, k)
-		if isNullableArray(v) || isRequired {
-			serInfo = fmt.Sprintf("`json:\"%s\" yaml:\"%s\"`", k, k)
-		} else if slices.Contains(omitzeroTypes(), typeName) {
-			serInfo = fmt.Sprintf("`json:\"%s,omitzero\" yaml:\"%s,omitzero\"`", k, k)
+		field := TypeFields{
+			Name:       strcase.ToCamel(k),
+			Type:       typeName,
+			MarshalKey: k,
+			Schema:     v,
+			Required:   isRequired,
 		}
 
-		field.SerializationInfo = serInfo
-
 		fields = append(fields, field)
 
 	}
@@ -720,21 +761,24 @@ func createOneOf(s *openapi3.Schema, name, typeName string) ([]TypeTemplate, []E
 
 			// Avoids duplication for every enum
 			if !containsMatchFirstWord(parsedProperties, propertyName) {
-				field := TypeFields{
-					Description:       formatTypeDescription(propertyName, p.Value),
-					Name:              propertyName,
-					Type:              propertyType,
-					SerializationInfo: fmt.Sprintf("`json:\"%s,omitempty\" yaml:\"%s,omitempty\"`", prop, prop),
-				}
-
 				// We set the type of a field as "any" if every element of the oneOf property isn't the same
 				if slices.Contains(genericTypes, prop) {
-					field.Type = "any"
+					propertyType = "any"
 				}
 
-				// Check if the field is nullable and use omitzero instead of omitempty.
+				// Determine omit directive: nullable fields in oneOf use omitzero.
+				var omitDirective string
 				if p.Value != nil && p.Value.Nullable {
-					field.SerializationInfo = fmt.Sprintf("`json:\"%s,omitzero\" yaml:\"%s,omitzero\"`", prop, prop)
+					omitDirective = "omitzero"
+				}
+
+				field := TypeFields{
+					Name:                propertyName,
+					Type:                propertyType,
+					MarshalKey:          prop,
+					Schema:              p,
+					FallbackDescription: true,
+					OmitDirective:       omitDirective,
 				}
 
 				fields = append(fields, field)