misc: sort type properties before generating. (#320)

In order to support deterministic generated code, sort the keys in the
type properties map before generating.

Author: jmcarp

internal/generate/paths.go

@@ -53,12 +53,7 @@ func generatePaths(file string, spec *openapi3.T) error {
 	defer f.Close()
 
 	// Iterate over all the paths in the spec and write the methods.
-	// We want to ensure we keep the order.
-	keys := make([]string, 0)
-	for k := range spec.Paths.Map() {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	keys := sortedKeys(spec.Paths.Map())
 	for _, path := range keys {
 		p := spec.Paths.Map()[path]
 		if p.Ref != "" {

internal/generate/responses.go

@@ -6,7 +6,6 @@ package main
 
 import (
 	"fmt"
-	"sort"
 	"strings"
 
 	"github.com/getkin/kin-openapi/openapi3"
@@ -25,12 +24,7 @@ func generateResponses(file string, spec *openapi3.T) error {
 	enumCollection := make([]EnumTemplate, 0)
 	typeValidationCollection := make([]ValidationTemplate, 0)
 	// Iterate over all the responses in the spec and write the types.
-	// We want to ensure we keep the order so the diffs don't look like shit.
-	keys := make([]string, 0)
-	for k := range spec.Components.Responses {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	keys := sortedKeys(spec.Components.Responses)
 	for _, name := range keys {
 		r := spec.Components.Responses[name]
 		if r.Ref != "" {

internal/generate/types.go

@@ -81,23 +81,15 @@ func generateTypes(file string, spec *openapi3.T) error {
 func constructParamTypes(paths map[string]*openapi3.PathItem) []TypeTemplate {
 	paramTypes := make([]TypeTemplate, 0)
 
-	keys := make([]string, 0)
-	for k := range paths {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	keys := sortedKeys(paths)
 	for _, path := range keys {
 		p := paths[path]
 		if p.Ref != "" {
 			fmt.Printf("[WARN] TODO: skipping path for %q, since it is a reference\n", path)
 			continue
 		}
 		ops := p.Operations()
-		keys := make([]string, 0)
-		for k := range ops {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
+		keys := sortedKeys(ops)
 		for _, op := range keys {
 			o := ops[op]
 			requiredFields := ""
@@ -195,23 +187,15 @@ func constructParamTypes(paths map[string]*openapi3.PathItem) []TypeTemplate {
 func constructParamValidation(paths map[string]*openapi3.PathItem) []ValidationTemplate {
 	validationMethods := make([]ValidationTemplate, 0)
 
-	keys := make([]string, 0)
-	for k := range paths {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	keys := sortedKeys(paths)
 	for _, path := range keys {
 		p := paths[path]
 		if p.Ref != "" {
 			fmt.Printf("[WARN] TODO: skipping path for %q, since it is a reference\n", path)
 			continue
 		}
 		ops := p.Operations()
-		keys := make([]string, 0)
-		for k := range ops {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
+		keys := sortedKeys(ops)
 		for _, op := range keys {
 			o := ops[op]
 			if len(o.Parameters) > 0 || o.RequestBody != nil {
@@ -256,11 +240,7 @@ func constructTypes(schemas openapi3.Schemas) ([]TypeTemplate, []EnumTemplate) {
 	typeCollection := make([]TypeTemplate, 0)
 	enumCollection := make([]EnumTemplate, 0)
 
-	keys := make([]string, 0)
-	for k := range schemas {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	keys := sortedKeys(schemas)
 	for _, name := range keys {
 		s := schemas[name]
 		if s.Ref != "" {
@@ -300,12 +280,7 @@ func constructEnums(enumStrCollection map[string][]string) []EnumTemplate {
 	enumCollection := make([]EnumTemplate, 0)
 
 	// Iterate over all the enum types and add in the slices.
-	// We want to ensure we keep the order
-	keys := make([]string, 0)
-	for k := range enumStrCollection {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	keys := sortedKeys(enumStrCollection)
 	for _, name := range keys {
 		// TODO: Remove once all types are constructed through structs
 		enums := enumStrCollection[name]
@@ -445,7 +420,9 @@ func populateTypeTemplates(name string, s *openapi3.Schema, enumFieldName string
 		typeTpl = createTypeObject(s, name, typeName, formatTypeDescription(typeName, s))
 
 		// Iterate over the properties and append the types, if we need to.
-		for k, v := range s.Properties {
+		properties := sortedKeys(s.Properties)
+		for _, k := range properties {
+			v := s.Properties[k]
 			if isLocalEnum(v) {
 				tt, et := populateTypeTemplates(fmt.Sprintf("%s%s", name, strcase.ToCamel(k)), v.Value, "")
 				types = append(types, tt...)
@@ -497,13 +474,8 @@ func createTypeObject(schema *openapi3.Schema, name, typeName, description strin
 	}
 
 	schemas := schema.Properties
-	// We want to ensure we keep the order
-	keys := make([]string, 0)
-	for k := range schemas {
-		keys = append(keys, k)
-	}
 	fields := []TypeFields{}
-	sort.Strings(keys)
+	keys := sortedKeys(schemas)
 	for _, k := range keys {
 		v := schemas[k]
 		// Check if we need to generate a type for this type.
@@ -658,12 +630,7 @@ func createOneOf(s *openapi3.Schema, name, typeName string) ([]TypeTemplate, []E
 	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)
+		keys := sortedKeys(v.Value.Properties)
 
 		for _, prop := range keys {
 			p := v.Value.Properties[prop]
@@ -710,12 +677,7 @@ func createOneOf(s *openapi3.Schema, name, typeName string) ([]TypeTemplate, []E
 		var enumFieldName string
 
 		// 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)
+		keys := sortedKeys(v.Value.Properties)
 		for _, prop := range keys {
 			p := v.Value.Properties[prop]
 			// We want to collect all the unique properties to create our global oneOf type.

internal/generate/utils.go

@@ -7,8 +7,10 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"maps"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"unicode"
 
@@ -265,3 +267,9 @@ func allItemsAreSame[T comparable](a []T) bool {
 	}
 	return true
 }
+
+// sortedKeys returns a []string of sorted keys from a map. Used to ensure
+// deterministic ordering of generated code.
+func sortedKeys[T any](m map[string]T) []string {
+	return slices.Sorted(maps.Keys(m))
+}