Parameterize content types for models

Allow users to control which content types are included in
model generation for requests, responses.

Author: deepmap-marcinr

experimental/README.md

@@ -175,6 +175,16 @@ import-mapping:
   https://example.com/specs/shared.yaml: github.com/org/shared
   # Use "-" to indicate types should stay in the current package
   ./local-types.yaml: "-"
+
+# Content types: filter which media types generate models (regexp patterns)
+# Only request/response bodies with matching content types will have types generated.
+# Defaults to JSON types if not specified.
+content-types:
+  - "^application/json$"
+  - "^application/.*\\+json$"
+  # Add custom patterns as needed:
+  # - "^application/xml$"
+  # - "^text/plain$"
 ```
 
 ### External References

experimental/internal/codegen/codegen.go

@@ -15,8 +15,11 @@ import (
 func Generate(doc libopenapi.Document, cfg Configuration) (string, error) {
 	cfg.ApplyDefaults()
 
+	// Create content type matcher for filtering request/response bodies
+	contentTypeMatcher := NewContentTypeMatcher(cfg.ContentTypes)
+
 	// Pass 1: Gather all schemas that need types
-	schemas, err := GatherSchemas(doc)
+	schemas, err := GatherSchemas(doc, contentTypeMatcher)
 	if err != nil {
 		return "", fmt.Errorf("gathering schemas: %w", err)
 	}

experimental/internal/codegen/configuration.go

@@ -3,6 +3,7 @@ package codegen
 import (
 	"crypto/sha256"
 	"encoding/hex"
+	"regexp"
 	"sort"
 )
 
@@ -21,12 +22,57 @@ type Configuration struct {
 	// Example: {"../common/api.yaml": "github.com/org/project/common"}
 	// Use "-" as the value to indicate types should be in the current package.
 	ImportMapping map[string]string `yaml:"import-mapping,omitempty"`
+	// ContentTypes is a list of regexp patterns for media types to generate models for.
+	// Only request/response bodies with matching content types will have types generated.
+	// Defaults to common JSON and YAML types if not specified.
+	ContentTypes []string `yaml:"content-types,omitempty"`
+}
+
+// DefaultContentTypes returns the default list of content type patterns.
+// These match common JSON and YAML media types.
+func DefaultContentTypes() []string {
+	return []string{
+		`^application/json$`,
+		`^application/.*\+json$`,
+	}
 }
 
 // ApplyDefaults merges user configuration on top of default values.
 func (c *Configuration) ApplyDefaults() {
 	c.TypeMapping = DefaultTypeMapping.Merge(c.TypeMapping)
 	c.NameMangling = DefaultNameMangling().Merge(c.NameMangling)
+	if len(c.ContentTypes) == 0 {
+		c.ContentTypes = DefaultContentTypes()
+	}
+}
+
+// ContentTypeMatcher checks if content types match configured patterns.
+type ContentTypeMatcher struct {
+	patterns []*regexp.Regexp
+}
+
+// NewContentTypeMatcher creates a matcher from a list of regexp patterns.
+// Invalid patterns are silently ignored.
+func NewContentTypeMatcher(patterns []string) *ContentTypeMatcher {
+	m := &ContentTypeMatcher{
+		patterns: make([]*regexp.Regexp, 0, len(patterns)),
+	}
+	for _, p := range patterns {
+		if re, err := regexp.Compile(p); err == nil {
+			m.patterns = append(m.patterns, re)
+		}
+	}
+	return m
+}
+
+// Matches returns true if the content type matches any of the configured patterns.
+func (m *ContentTypeMatcher) Matches(contentType string) bool {
+	for _, re := range m.patterns {
+		if re.MatchString(contentType) {
+			return true
+		}
+	}
+	return false
 }
 
 // ExternalImport represents an external package import with its alias.

experimental/internal/codegen/configuration_test.go

@@ -0,0 +1,66 @@
+package codegen
+
+import "testing"
+
+func TestContentTypeMatcher(t *testing.T) {
+	tests := []struct {
+		name        string
+		patterns    []string
+		contentType string
+		want        bool
+	}{
+		// Default patterns - JSON only (YAML not supported without custom unmarshalers)
+		{"json exact", DefaultContentTypes(), "application/json", true},
+		{"json+suffix", DefaultContentTypes(), "application/vnd.api+json", true},
+		{"problem+json", DefaultContentTypes(), "application/problem+json", true},
+
+		// YAML not in defaults (would need custom unmarshalers)
+		{"yaml not default", DefaultContentTypes(), "application/yaml", false},
+		{"text/yaml not default", DefaultContentTypes(), "text/yaml", false},
+
+		// Non-matching
+		{"text/plain", DefaultContentTypes(), "text/plain", false},
+		{"text/html", DefaultContentTypes(), "text/html", false},
+		{"application/xml", DefaultContentTypes(), "application/xml", false},
+		{"application/octet-stream", DefaultContentTypes(), "application/octet-stream", false},
+		{"multipart/form-data", DefaultContentTypes(), "multipart/form-data", false},
+		{"image/png", DefaultContentTypes(), "image/png", false},
+
+		// Custom patterns
+		{"custom xml", []string{`^application/xml$`}, "application/xml", true},
+		{"custom xml no match", []string{`^application/xml$`}, "application/json", false},
+		{"custom wildcard", []string{`^text/.*`}, "text/plain", true},
+		{"custom wildcard html", []string{`^text/.*`}, "text/html", true},
+		{"custom yaml", []string{`^application/yaml$`}, "application/yaml", true},
+
+		// Empty patterns
+		{"empty patterns", []string{}, "application/json", false},
+
+		// Invalid pattern (silently ignored)
+		{"invalid pattern", []string{`[invalid`}, "application/json", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := NewContentTypeMatcher(tt.patterns)
+			got := m.Matches(tt.contentType)
+			if got != tt.want {
+				t.Errorf("Matches(%q) = %v, want %v", tt.contentType, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDefaultContentTypes(t *testing.T) {
+	defaults := DefaultContentTypes()
+	if len(defaults) == 0 {
+		t.Error("DefaultContentTypes() returned empty slice")
+	}
+
+	// Verify all patterns are valid regexps
+	m := NewContentTypeMatcher(defaults)
+	if len(m.patterns) != len(defaults) {
+		t.Errorf("Some default patterns failed to compile: got %d patterns, want %d",
+			len(m.patterns), len(defaults))
+	}
+}

experimental/internal/codegen/gather.go

@@ -9,7 +9,7 @@ import (
 )
 
 // GatherSchemas traverses an OpenAPI document and collects all schemas into a list.
-func GatherSchemas(doc libopenapi.Document) ([]*SchemaDescriptor, error) {
+func GatherSchemas(doc libopenapi.Document, contentTypeMatcher *ContentTypeMatcher) ([]*SchemaDescriptor, error) {
 	model, errs := doc.BuildV3Model()
 	if len(errs) > 0 {
 		return nil, fmt.Errorf("building v3 model: %v", errs[0])
@@ -19,15 +19,17 @@ func GatherSchemas(doc libopenapi.Document) ([]*SchemaDescriptor, error) {
 	}
 
 	g := &gatherer{
-		schemas: make([]*SchemaDescriptor, 0),
+		schemas:            make([]*SchemaDescriptor, 0),
+		contentTypeMatcher: contentTypeMatcher,
 	}
 
 	g.gatherFromDocument(&model.Model)
 	return g.schemas, nil
 }
 
 type gatherer struct {
-	schemas []*SchemaDescriptor
+	schemas            []*SchemaDescriptor
+	contentTypeMatcher *ContentTypeMatcher
 }
 
 func (g *gatherer) gatherFromDocument(doc *v3.Document) {
@@ -141,6 +143,10 @@ func (g *gatherer) gatherFromRequestBody(rb *v3.RequestBody, basePath SchemaPath
 
 	for pair := rb.Content.First(); pair != nil; pair = pair.Next() {
 		contentType := pair.Key()
+		// Skip content types that don't match the configured patterns
+		if g.contentTypeMatcher != nil && !g.contentTypeMatcher.Matches(contentType) {
+			continue
+		}
 		mediaType := pair.Value()
 		g.gatherFromMediaType(mediaType, basePath.Append("content", contentType))
 	}
@@ -154,6 +160,10 @@ func (g *gatherer) gatherFromResponse(response *v3.Response, basePath SchemaPath
 	if response.Content != nil {
 		for pair := response.Content.First(); pair != nil; pair = pair.Next() {
 			contentType := pair.Key()
+			// Skip content types that don't match the configured patterns
+			if g.contentTypeMatcher != nil && !g.contentTypeMatcher.Matches(contentType) {
+				continue
+			}
 			mediaType := pair.Value()
 			g.gatherFromMediaType(mediaType, basePath.Append("content", contentType))
 		}