Fix OneOf type templates when property types differ (#234)

## Overview

A few of our OpenAPI OneOf types contain properties that are of
different types. These were not handled properly, as the generator would
take the first property type only and set that as the expected type.
Sadly this impacted only a single type as the others had been set as
`string` which the JSON decoder happily used. This commit contains a fix
for said situation.

## Fix

All struct field types that have different property types in the OpenAPI
spec have now been set to `any`.

## Manual testing

I have tested manually against a rack by running the following code

```go
func main() {
	client, err := oxide.NewClient(nil)
	if err != nil {
		panic(err)
	}

	startTime, err := time.Parse(time.RFC3339, "2024-09-17T06:25:23.696Z")
	if err != nil {
		panic(err)
	}

	endTime := time.Now()

	ctx := context.Background()
	params := oxide.DiskMetricsListParams{
		Disk:      oxide.NameOrId("5cea3d86-cb2a-43b1-bd3a-2a487b048f44"),
		Metric:    oxide.DiskMetricNameReadBytes,
		Limit:     3,
		StartTime: &startTime,
		EndTime:   &endTime,
	}

	resp, err := client.DiskMetricsList(ctx, params)
	if err != nil {
		panic(err)
	}

	fmt.Printf("%+v\n", resp)
}
```

The results were as expected

```console
$ go run main.go
&{Items:[{Datum:{Datum:map[start_time:2024-09-18T06:24:22.956977316Z value:1.41800448e+08] Type:cumulative_i64} Timestamp:2024-09-18 06:24:53.186026344 +0000 UTC} {Datum:{Datum:map[start_time:2024-09-18T06:24:22.956977316Z value:1.4213632e+08] Type:cumulative_i64} Timestamp:2024-09-18 06:25:23.187327342 +0000 UTC} {Datum:{Datum:map[start_time:2024-09-18T06:24:22.956977316Z value:1.4213632e+08] Type:cumulative_i64} Timestamp:2024-09-18 06:25:53.188840965 +0000 UTC}] NextPage:eyJ2IjoidjEiLCJwYWdlX3N0YXJ0Ijp7InN0YXJ0X3RpbWUiOiIyMDI0LTA5LTE4VDA2OjI1OjUzLjE4ODg0MDk2NVoiLCJlbmRfdGltZSI6IjIwMjQtMDktMThUMDY6NTM6MDJaIiwib3JkZXIiOm51bGx9fQ==}
```


Closes: #233

Author: karencfv

.changelog/v0.1.0-beta9.toml

@@ -1,6 +1,6 @@
 [[breaking]]
-title = ""
-description = ""
+title = "OneOf generic types"
+description = "All struct field types that have different property types in the OpenAPI spec have now been set to `any`. [#234](https://github.com/oxidecomputer/oxide.go/pull/234)"
 
 [[features]]
 title = ""
@@ -11,5 +11,5 @@ title = ""
 description = ""
 
 [[bugs]]
-title = ""
-description = ""
+title = "Fix for fields of type `time.Time`"
+description = "Change encoding of time parameters to RFC3339. [232](https://github.com/oxidecomputer/oxide.go/pull/232)"

internal/generate/types.go

@@ -632,10 +632,60 @@ func createAllOf(s *openapi3.Schema, stringEnums map[string][]string, name, type
 }
 
 func createOneOf(s *openapi3.Schema, name, typeName string) ([]TypeTemplate, []EnumTemplate) {
+	var parsedProperties []string
 	var properties []string
+	var genericTypes []string
 	enumTpls := make([]EnumTemplate, 0)
 	typeTpls := make([]TypeTemplate, 0)
 	fields := make([]TypeFields, 0)
+	for _, v := range s.OneOf {
+		// Iterate over all the schema components in the spec and write the types.
+		// We want to ensure we keep the order.
+		keys := make([]string, 0)
+		for k := range v.Value.Properties {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+
+		for _, prop := range keys {
+			p := v.Value.Properties[prop]
+			// We want to collect all the unique properties to create our global oneOf type.
+			propertyType := convertToValidGoType(prop, p)
+			properties = append(properties, prop+"="+propertyType)
+		}
+	}
+
+	// When dealing with oneOf sometimes property types will not be the same, we want to
+	// catch these to set them as "any" when we generate the type.
+	typeKeys := []string{}
+	// First we gather all unique properties
+	for _, v := range properties {
+		parts := strings.Split(v, "=")
+		key := parts[0]
+		if !sliceContains(typeKeys, key) {
+			typeKeys = append(typeKeys, key)
+		}
+	}
+
+	// For each of the properties above we gather all possible types
+	// and gather all of those that are not. We will be setting those
+	// as a generic type
+	for _, k := range typeKeys {
+		values := []string{}
+		for _, v := range properties {
+			parts := strings.Split(v, "=")
+			key := parts[0]
+			value := parts[1]
+			if key == k {
+				values = append(values, value)
+			}
+		}
+
+		if !allItemsAreSame(values) {
+			genericTypes = append(genericTypes, k)
+		}
+	}
+
 	for _, v := range s.OneOf {
 		// We want to iterate over the properties of the embedded object
 		// and find the type that is a string.
@@ -661,16 +711,22 @@ func createOneOf(s *openapi3.Schema, name, typeName string) ([]TypeTemplate, []E
 
 			propertyName := strcase.ToCamel(prop)
 			// Avoids duplication for every enum
-			if !containsMatchFirstWord(properties, propertyName) {
+			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 sliceContains(genericTypes, prop) {
+					field.Type = "any"
+				}
+
 				fields = append(fields, field)
 
-				properties = append(properties, propertyName)
+				parsedProperties = append(parsedProperties, propertyName)
 			}
 
 			if p.Value.Enum != nil {

internal/generate/utils.go

@@ -214,3 +214,12 @@ func sliceContains[T comparable](s []T, str T) bool {
 	}
 	return false
 }
+
+func allItemsAreSame[T comparable](a []T) bool {
+	for _, v := range a {
+		if v != a[0] {
+			return false
+		}
+	}
+	return true
+}