Generate a parameter for the Accept header when a response code has multiple content types

Author: Oliver Kahrmann

gen/_template/mediatypes.tmpl

@@ -0,0 +1,11 @@
+{{ define "mediatypes" }}
+{{- /*gotype: github.com/ogen-go/ogen/gen.TemplateConfig*/ -}}
+{{ template "header" $ }}
+
+const (
+	{{- range $op := $.MediaTypes }}
+	MediaType{{ $op.Name }} string = {{ quote $op.Value }}
+	{{- end }}
+)
+
+{{ end }}

gen/gen_operation.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ogen-go/ogen/gen/ir"
 	"github.com/ogen-go/ogen/internal/xslices"
+	"github.com/ogen-go/ogen/jsonschema"
 	"github.com/ogen-go/ogen/openapi"
 )
 
@@ -47,6 +48,54 @@ func (g *Generator) generateOperation(ctx *genctx, webhookName string, spec *ope
 		return nil, errors.Wrap(err, "parameters")
 	}
 
+	// If there is no manual specification of the Accept parameter
+	if _, ok := xslices.FindFunc(op.Params, func(param *ir.Parameter) bool { return param.Spec.In.Header() && param.Spec.Name == "Accept" }); !ok {
+		supportsMultipleMediaTypes := false
+		// And at least one operation defines multiple media types
+		for _, statusCode := range spec.Responses.StatusCode {
+			if len(statusCode.Content) > 1 {
+				supportsMultipleMediaTypes = true
+				break
+			}
+		}
+		if supportsMultipleMediaTypes {
+			mediaTypes := map[string]any{}
+			for _, statusCode := range spec.Responses.StatusCode {
+				for mediaType := range statusCode.Content {
+					mediaTypes[mediaType] = nil
+				}
+			}
+
+			mediaTypeType, ok := ctx.global.types["AcceptHeader"]
+			if !ok {
+				mediaTypeType = &ir.Type{
+					Doc:  "Auto-generated parameter for the Accept header",
+					Kind: ir.KindStruct,
+					Name: "ht.AcceptHeader",
+				}
+			}
+
+			acceptParam := &ir.Parameter{
+				Name: "Accept",
+				Type: mediaTypeType,
+				Spec: &openapi.Parameter{
+					Name:        "Accept",
+					Description: "Auto-generated parameter for the Accept header",
+					Schema: &jsonschema.Schema{
+						Type: jsonschema.String,
+					},
+					In: openapi.LocationHeader,
+				},
+			}
+
+			// acceptParam, err := g.generateParameter(ctx, op.Name)
+			// if err != nil {
+			// 	return nil, errors.Wrap(err, "parameters")
+			// }
+			op.Params = append(op.Params, acceptParam)
+		}
+	}
+
 	// Convert []openapi.PathPart to []*ir.PathPart
 	op.PathParts = convertPathParts(op.Spec.Path, op.Params)
 

gen/generator.go

@@ -30,6 +30,7 @@ type Generator struct {
 	defaultOperations []*ir.Operation // Operations without an operation group.
 	operationGroups   []*ir.OperationGroup
 	webhooks          []*ir.Operation
+	mediaTypes        map[ir.ContentType]*ir.MediaType
 	securities        map[string]*ir.Security
 	tstorage          *tstorage
 	errType           *ir.Response
@@ -98,6 +99,7 @@ func NewGenerator(spec *ogen.Spec, opts Options) (*Generator, error) {
 		servers:       nil,
 		operations:    nil,
 		webhooks:      nil,
+		mediaTypes:    map[ir.ContentType]*ir.MediaType{},
 		securities:    map[string]*ir.Security{},
 		tstorage:      newTStorage(),
 		errType:       nil,
@@ -187,6 +189,21 @@ func (g *Generator) makeOps(ops []*openapi.Operation) error {
 			return err
 		}
 
+		// Collect all media types used in responses to generate constants
+		for _, response := range op.Responses.StatusCode {
+			for contentType := range response.Contents {
+				if _, ok := g.mediaTypes[contentType]; !ok {
+					constantName, err := pascalNonEmpty(string(contentType))
+					if err != nil {
+						return errors.Wrap(err, "gather media types")
+					}
+					g.mediaTypes[contentType] = &ir.MediaType{
+						Name:  constantName,
+						Value: contentType,
+					}
+				}
+			}
+		}
 		g.operations = append(g.operations, op)
 	}
 
@@ -282,6 +299,12 @@ func sortOperations(ops []*ir.Operation) {
 	})
 }
 
+func sortMediaTypes(types []*ir.MediaType) {
+	slices.SortStableFunc(types, func(a, b *ir.MediaType) int {
+		return strings.Compare(a.Name, b.Name)
+	})
+}
+
 func groupOperations(ops []*ir.Operation) (
 	defaultOperations []*ir.Operation,
 	operationGroups []*ir.OperationGroup,
@@ -320,6 +343,16 @@ func (g *Generator) Operations() []*ir.Operation {
 	return g.operations
 }
 
+// MediaTypes returns generated media type constants.
+func (g *Generator) MediaTypes() []*ir.MediaType {
+	mediaTypesSorted := make([]*ir.MediaType, 0, len(g.mediaTypes))
+	for _, mt := range g.mediaTypes {
+		mediaTypesSorted = append(mediaTypesSorted, mt)
+	}
+	sortMediaTypes(mediaTypesSorted)
+	return mediaTypesSorted
+}
+
 // Webhooks returns generated webhooks.
 func (g *Generator) Webhooks() []*ir.Operation {
 	return g.webhooks

gen/ir/operation.go

@@ -34,6 +34,11 @@ type OperationGroup struct {
 	Operations []*Operation
 }
 
+type MediaType struct {
+	Name  string      // Generated constant name
+	Value ContentType // Actual media type, e.g. application/xml
+}
+
 // OTELAttribute represents OpenTelemetry attribute defined by otelogen package.
 type OTELAttribute struct {
 	// Key is a name of the attribute constructor in otelogen package.

gen/write.go

@@ -27,6 +27,7 @@ type TemplateConfig struct {
 	DefaultOperations []*ir.Operation
 	OperationGroups   []*ir.OperationGroup
 	Webhooks          []*ir.Operation
+	MediaTypes        []*ir.MediaType
 	Types             map[string]*ir.Type
 	Interfaces        map[string]*ir.Type
 	Error             *ir.Response
@@ -257,6 +258,7 @@ func (g *Generator) WriteSource(fs FileSystem, pkgName string) error {
 		DefaultOperations:         g.defaultOperations,
 		OperationGroups:           g.operationGroups,
 		Webhooks:                  g.webhooks,
+		MediaTypes:                g.MediaTypes(),
 		Types:                     types,
 		Interfaces:                interfaces,
 		Error:                     g.errType,
@@ -335,6 +337,7 @@ func (g *Generator) WriteSource(fs FileSystem, pkgName string) error {
 		{"unimplemented", features.Has(OgenUnimplemented) && genServer},
 		{"labeler", features.Has(OgenOtel) && genServer},
 		{"operations", (genClient || genServer)},
+		{"mediatypes", (genClient || genServer)},
 	} {
 		t := t
 		if !t.enabled {

http/accept_header.go

@@ -0,0 +1,47 @@
+package http
+
+import (
+	"slices"
+	"strings"
+
+	"github.com/go-faster/errors"
+	"github.com/ogen-go/ogen/uri"
+)
+
+// Represents the content of an HTTP Accept Header.
+// Supports multiple content types (comma separated) and wild cards.
+// Does NOT support q-factor weighting (these values are stripped and ignored).
+type AcceptHeader []string
+
+// MarshalText implements encoding.TextMarshaler.
+func (s AcceptHeader) MarshalText() ([]byte, error) {
+	return []byte(strings.Join(s, ", ")), nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (s *AcceptHeader) UnmarshalText(data []byte) error {
+	*s = strings.Split(string(data), ",")
+	for i, segment := range *s {
+		// Remove q-factor weighting
+		if semicolonIndex := strings.IndexByte(segment, ';'); semicolonIndex >= 0 {
+			segment = segment[:semicolonIndex]
+		}
+		// Trim spaces to clean up leftovers from comma separation above (spaces are optional there)
+		(*s)[i] = strings.TrimSpace(segment)
+	}
+	return nil
+}
+
+func (s AcceptHeader) MatchesContentType(contentType string) bool {
+	return slices.ContainsFunc(s, func(pattern string) bool {
+		return MatchContentType(pattern, contentType)
+	})
+}
+
+func (s *AcceptHeader) DecodeURI(d uri.Decoder) error {
+	val, err := d.DecodeValue()
+	if err != nil {
+		return errors.Wrap(err, "decode accept header")
+	}
+	return s.UnmarshalText([]byte(val))
+}