Simplify struct tag overrides

Author: mromaszewicz

experimental/Configuration.md

@@ -277,19 +277,21 @@ content-type-short-names:
   #   - "^text/xml$"
 
 # Struct tags: controls which struct tags are generated and their format.
-# Uses Go text/template syntax. If specified, completely replaces the defaults.
-# Default: json and form tags.
+# Uses Go text/template syntax with a simple 2-field context (.FieldName, .IsOptional).
+# Default: json and form tags with omitempty for optional fields.
+# User tags are merged by name: matching defaults are overridden, new tags are appended.
+# Extension-driven concerns (omitzero, json-ignore, omitempty overrides) are handled
+# automatically as post-processing — templates only need the simple context.
 struct-tags:
   tags:
-    - name: json
-      template: '{{if .JSONIgnore}}-{{else}}{{ .FieldName }}{{if .OmitEmpty}},omitempty{{end}}{{if .OmitZero}},omitzero{{end}}{{end}}'
-    - name: form
-      template: '{{if .JSONIgnore}}-{{else}}{{ .FieldName }}{{if .OmitEmpty}},omitempty{{end}}{{end}}'
-    # Add additional tags:
+    # Add additional tags (json and form defaults are kept):
     - name: yaml
-      template: '{{ .FieldName }}{{if .OmitEmpty}},omitempty{{end}}'
+      template: '{{ .FieldName }}{{if .IsOptional}},omitempty{{end}}'
     - name: db
       template: '{{ .FieldName }}'
+    # Can override the default json template too:
+    # - name: json
+    #   template: '{{ .FieldName }}'
 ```
 
 ## Struct tag template variables
@@ -298,11 +300,7 @@ The struct tag templates have access to the following fields:
 
 | Variable | Type | Description |
 |----------|------|-------------|
-| `.FieldName` | `string` | The original field name from the OpenAPI spec |
-| `.GoFieldName` | `string` | The Go identifier name after name mangling |
-| `.IsOptional` | `bool` | Whether the field is optional in the schema |
-| `.IsNullable` | `bool` | Whether the field is nullable |
-| `.IsPointer` | `bool` | Whether the field is rendered as a pointer type |
-| `.OmitEmpty` | `bool` | Whether `omitempty` should be applied (from extensions or optionality) |
-| `.OmitZero` | `bool` | Whether `omitzero` should be applied (from `x-oapi-codegen-omitzero` extension) |
-| `.JSONIgnore` | `bool` | Whether the field should be ignored in JSON (from `x-go-json-ignore` extension) |
+| `.FieldName` | `string` | The original property name from the OpenAPI spec |
+| `.IsOptional` | `bool` | Whether the field is optional (not required) |
+
+Extension-driven concerns (`x-oapi-codegen-omitzero`, `x-go-json-ignore`, `x-oapi-codegen-omitempty` overrides) are handled automatically as post-processing on the `json` and `form` tags. Templates do not need to handle these cases.

experimental/codegen/internal/output.go

@@ -178,27 +178,37 @@ func GenerateStruct(name string, fields []StructField, doc string, tagGen *Struc
 }
 
 // generateFieldTag generates the struct tag for a field.
+// All tags go through the template engine with a simple 2-field context.
+// Extension-driven overrides (JSONIgnore, OmitZero, OmitEmpty) are applied
+// as post-processing on the resulting tag map.
 func generateFieldTag(f StructField, tagGen *StructTagGenerator) string {
-	if tagGen == nil {
-		if f.JSONIgnore {
-			return "`json:\"-\"`"
+	info := StructTagInfo{
+		FieldName:  f.JSONName,
+		IsOptional: !f.Required,
+	}
+
+	// All tags through the same template engine
+	tags := tagGen.GenerateTagsMap(info)
+
+	// Extension overrides on well-known tags
+	if f.JSONIgnore {
+		tags["json"] = "-"
+		tags["form"] = "-"
+	} else {
+		// OmitEmpty extension override: if extensions explicitly set OmitEmpty
+		// differently from the schema default (!f.Required), adjust tags.
+		if f.OmitEmpty != !f.Required {
+			applyOmitEmptyOverride(tags, f.JSONName, f.OmitEmpty, "json", "form")
 		}
-		if f.OmitEmpty {
-			return fmt.Sprintf("`json:\"%s,omitempty\"`", f.JSONName)
+		// OmitZero (json-specific)
+		if f.OmitZero {
+			if v, ok := tags["json"]; ok {
+				tags["json"] = v + ",omitzero"
+			}
 		}
-		return fmt.Sprintf("`json:\"%s\"`", f.JSONName)
 	}
-	info := StructTagInfo{
-		FieldName:   f.JSONName,
-		GoFieldName: f.Name,
-		IsOptional:  !f.Required,
-		IsNullable:  f.Nullable,
-		IsPointer:   f.Pointer,
-		OmitEmpty:   f.OmitEmpty,
-		OmitZero:    f.OmitZero,
-		JSONIgnore:  f.JSONIgnore,
-	}
-	return tagGen.GenerateTags(info)
+
+	return FormatTagsMap(tags)
 }
 
 // GenerateStructWithAdditionalProps generates a struct with AdditionalProperties field

experimental/codegen/internal/structtags.go

@@ -8,32 +8,21 @@ import (
 )
 
 // StructTagInfo contains the data available to struct tag templates.
+// Extension-driven concerns (omitzero, json-ignore, omitempty overrides)
+// are applied as post-processing in generateFieldTag, not exposed here.
 type StructTagInfo struct {
 	// FieldName is the JSON/YAML field name (from the OpenAPI property name)
 	FieldName string
-	// GoFieldName is the Go struct field name
-	GoFieldName string
 	// IsOptional is true if the field is optional (not required)
 	IsOptional bool
-	// IsNullable is true if the field can be null
-	IsNullable bool
-	// IsPointer is true if the Go type is a pointer
-	IsPointer bool
-	// OmitEmpty is true if the omitempty tag option should be used
-	// (derived from IsOptional but can be overridden via extensions)
-	OmitEmpty bool
-	// OmitZero is true if the omitzero tag option should be used (Go 1.24+)
-	OmitZero bool
-	// JSONIgnore is true if the field should be excluded from JSON (json:"-")
-	JSONIgnore bool
 }
 
 // StructTagTemplate defines a single struct tag with a name and template.
 type StructTagTemplate struct {
 	// Name is the tag name (e.g., "json", "yaml", "form")
 	Name string `yaml:"name"`
 	// Template is a Go text/template that produces the tag value.
-	// Available fields: .FieldName, .GoFieldName, .IsOptional, .IsNullable, .IsPointer
+	// Available fields: .FieldName, .IsOptional
 	// Example: `{{ .FieldName }}{{if .IsOptional}},omitempty{{end}}`
 	Template string `yaml:"template"`
 }
@@ -46,29 +35,48 @@ type StructTagsConfig struct {
 }
 
 // DefaultStructTagsConfig returns the default struct tag configuration.
-// By default, json and form tags are generated.
+// By default, json and form tags are generated. Extension-driven concerns
+// (omitzero, json-ignore, omitempty overrides) are handled by post-processing
+// in generateFieldTag, not in the templates.
 func DefaultStructTagsConfig() StructTagsConfig {
 	return StructTagsConfig{
 		Tags: []StructTagTemplate{
 			{
 				Name:     "json",
-				Template: `{{if .JSONIgnore}}-{{else}}{{ .FieldName }}{{if .OmitEmpty}},omitempty{{end}}{{if .OmitZero}},omitzero{{end}}{{end}}`,
+				Template: `{{ .FieldName }}{{if .IsOptional}},omitempty{{end}}`,
 			},
 			{
 				Name:     "form",
-				Template: `{{if .JSONIgnore}}-{{else}}{{ .FieldName }}{{if .OmitEmpty}},omitempty{{end}}{{end}}`,
+				Template: `{{ .FieldName }}{{if .IsOptional}},omitempty{{end}}`,
 			},
 		},
 	}
 }
 
-// Merge merges user config on top of this config.
-// If user specifies any tags, they completely replace the defaults.
+// Merge merges user config on top of this config by name.
+// User entries override matching defaults; new entries are appended.
 func (c StructTagsConfig) Merge(other StructTagsConfig) StructTagsConfig {
-	if len(other.Tags) > 0 {
-		return other
+	if len(other.Tags) == 0 {
+		return c
 	}
-	return c
+	// Start with defaults, override/append from user config
+	merged := make(map[string]StructTagTemplate, len(c.Tags)+len(other.Tags))
+	order := make([]string, 0, len(c.Tags)+len(other.Tags))
+	for _, t := range c.Tags {
+		merged[t.Name] = t
+		order = append(order, t.Name)
+	}
+	for _, t := range other.Tags {
+		if _, exists := merged[t.Name]; !exists {
+			order = append(order, t.Name)
+		}
+		merged[t.Name] = t
+	}
+	result := StructTagsConfig{Tags: make([]StructTagTemplate, 0, len(order))}
+	for _, name := range order {
+		result.Tags = append(result.Tags, merged[name])
+	}
+	return result
 }
 
 // StructTagGenerator generates struct tags from templates.
@@ -170,3 +178,17 @@ func FormatTagsMap(tags map[string]string) string {
 
 	return "`" + strings.Join(parts, " ") + "`"
 }
+
+// applyOmitEmptyOverride rebuilds tag values when extensions override the default omitempty.
+func applyOmitEmptyOverride(tags map[string]string, fieldName string, omitEmpty bool, tagNames ...string) {
+	for _, name := range tagNames {
+		if _, ok := tags[name]; !ok {
+			continue
+		}
+		v := fieldName
+		if omitEmpty {
+			v += ",omitempty"
+		}
+		tags[name] = v
+	}
+}