oapi-codegen · deepmap-marcinr · Apr 1, 2021 · Mar 28, 2021 · Mar 28, 2021 · Mar 28, 2021
diff --git a/internal/test/components/components.gen.go b/internal/test/components/components.gen.go
diff --git a/internal/test/schemas/schemas.gen.go b/internal/test/schemas/schemas.gen.go
diff --git a/pkg/codegen/operations.go b/pkg/codegen/operations.go
@@ -601,6 +601,7 @@ func GenerateParamsTypes(op OperationDefinition) []TypeDefinition {
 		s.Properties = append(s.Properties, prop)
 	}
 
+	s.Description = op.Spec.Description
 	s.GoType = GenStructFromSchema(s)
 
 	td := TypeDefinition{

diff --git a/pkg/codegen/schema.go b/pkg/codegen/schema.go
@@ -23,6 +23,8 @@ type Schema struct {
 	AdditionalTypes          []TypeDefinition // We may need to generate auxiliary helper types, stored here
 
 	SkipOptionalPointer bool // Some types don't need a * in front when they're optional
+
+	Description string // The description of the element
 }
 
 func (s Schema) IsRef() bool {
@@ -98,39 +100,43 @@ func PropertiesEqual(a, b Property) bool {
 }
 
 func GenerateGoSchema(sref *openapi3.SchemaRef, path []string) (Schema, error) {
-	// If Ref is set on the SchemaRef, it means that this type is actually a reference to
-	// another type. We're not de-referencing, so simply use the referenced type.
-	var refType string
-
 	// Add a fallback value in case the sref is nil.
 	// i.e. the parent schema defines a type:array, but the array has
 	// no items defined. Therefore we have at least valid Go-Code.
 	if sref == nil {
-		return Schema{GoType: "interface{}", RefType: refType}, nil
+		return Schema{GoType: "interface{}"}, nil
 	}
 
 	schema := sref.Value
 
+	// If Ref is set on the SchemaRef, it means that this type is actually a reference to
+	// another type. We're not de-referencing, so simply use the referenced type.
 	if IsGoTypeReference(sref.Ref) {
-		var err error
 		// Convert the reference path to Go type
-		refType, err = RefPathToGoType(sref.Ref)
+		refType, err := RefPathToGoType(sref.Ref)
 		if err != nil {
 			return Schema{}, fmt.Errorf("error turning reference (%s) into a Go type: %s",
 				sref.Ref, err)
 		}
 		return Schema{
-			GoType: refType,
+			GoType:      refType,
+			Description: schema.Description,
 		}, nil
 	}
 
+	outSchema := Schema{
+		Description: schema.Description,
+	}
+
 	// We can't support this in any meaningful way
 	if schema.AnyOf != nil {
-		return Schema{GoType: "interface{}", RefType: refType}, nil
+		outSchema.GoType = "interface{}"
+		return outSchema, nil
 	}
 	// We can't support this in any meaningful way
 	if schema.OneOf != nil {
-		return Schema{GoType: "interface{}", RefType: refType}, nil
+		outSchema.GoType = "interface{}"
+		return outSchema, nil
 	}
 
 	// AllOf is interesting, and useful. It's the union of a number of other
@@ -142,14 +148,9 @@ func GenerateGoSchema(sref *openapi3.SchemaRef, path []string) (Schema, error) {
 		if err != nil {
 			return Schema{}, errors.Wrap(err, "error merging schemas")
 		}
-		mergedSchema.RefType = refType
 		return mergedSchema, nil
 	}
 
-	outSchema := Schema{
-		RefType: refType,
-	}
-
 	// Check for custom Go type extension
 	if extension, ok := schema.Extensions[extPropGoType]; ok {
 		typeName, err := extTypeName(extension)
@@ -493,6 +494,7 @@ func paramToGoType(param *openapi3.Parameter, path []string) (Schema, error) {
 	if len(param.Content) > 1 {
 		return Schema{
 			GoType: "string",
+			Description: param.Description,
 		}, nil
 	}
 
@@ -502,6 +504,7 @@ func paramToGoType(param *openapi3.Parameter, path []string) (Schema, error) {
 		// If we don't have json, it's a string
 		return Schema{
 			GoType: "string",
+			Description: param.Description,
 		}, nil
 	}
 

diff --git a/pkg/codegen/templates/templates.gen.go b/pkg/codegen/templates/templates.gen.go
diff --git a/pkg/codegen/templates/typedef.tmpl b/pkg/codegen/templates/typedef.tmpl
@@ -1,5 +1,5 @@
 {{range .Types}}
-// {{.TypeName}} defines model for {{.JsonName}}.
+// {{ with .Schema.Description }}{{ . }}{{ else }}{{.TypeName}} defines model for {{.JsonName}}.{{ end }}
 type {{.TypeName}} {{if and (opts.AliasTypes) (.CanAlias)}}={{end}} {{.Schema.TypeDecl}}
 {{- if gt (len .Schema.EnumValues) 0 }}
 // List of {{ .TypeName }}