fix(go-server): allow zero values for required request body fields (#20496)

Validate required properties by JSON key presence in UnmarshalJSON instead
of rejecting primitive zero values via IsZeroValue, aligning with go-client.

Author: halfcrazy

.github/workflows/samples-go.yaml

@@ -27,6 +27,7 @@ jobs:
           - samples/server/petstore/go-chi-server/
           - samples/server/others/go-server/no-body-path-params/
           - samples/server/others/go-server/optional-body/
+          - samples/server/others/go-server/required-zero-value/
     steps:
       - uses: actions/checkout@v7
       - uses: actions/setup-go@v6

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/GoServerCodegen.java

@@ -31,6 +31,7 @@
 
 import java.io.File;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static org.openapitools.codegen.utils.StringUtils.camelize;
 
@@ -296,6 +297,88 @@ public void processOpts() {
                 .doNotOverwrite());
     }
 
+    @Override
+    public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs) {
+        objs = super.postProcessAllModels(objs);
+
+        for (ModelsMap modelsMap : objs.values()) {
+            List<Map<String, String>> imports = modelsMap.getImports();
+            if (imports == null) {
+                imports = new ArrayList<>();
+                modelsMap.setImports(imports);
+            }
+            for (ModelMap modelMap : modelsMap.getModels()) {
+                configureModelRequiredValidation(modelMap.getModel(), imports);
+            }
+        }
+
+        return objs;
+    }
+
+    /**
+     * Configures UnmarshalJSON presence checks and AssertRequired helpers for request-body models.
+     * Runs in {@link #postProcessAllModels} so {@code parentModel} is populated for allOf embedding.
+     */
+    private void configureModelRequiredValidation(CodegenModel model, List<Map<String, String>> imports) {
+        if (model == null || model.isEnum || !model.hasRequired) {
+            return;
+        }
+
+        Set<String> structFieldBaseNames = model.vars.stream()
+                .filter(v -> !v.isReadOnly)
+                .map(v -> v.baseName)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+
+        boolean hasEmbeddedParent = model.parentModel != null;
+        if (hasEmbeddedParent) {
+            model.vendorExtensions.put("x-go-embed-parent-classname", model.parentModel.classname);
+            for (CodegenProperty v : model.parentModel.vars) {
+                if (!v.isReadOnly) {
+                    structFieldBaseNames.add(v.baseName);
+                }
+            }
+        }
+
+        List<CodegenProperty> presenceCheckRequiredVars = new ArrayList<>();
+        for (CodegenProperty v : model.vars) {
+            if (v.required && !v.isReadOnly) {
+                presenceCheckRequiredVars.add(v);
+            }
+        }
+        if (hasEmbeddedParent) {
+            for (CodegenProperty v : model.parentModel.vars) {
+                if (v.required && !v.isReadOnly) {
+                    presenceCheckRequiredVars.add(v);
+                }
+            }
+        }
+
+        model.vendorExtensions.put("presenceCheckRequiredVars", presenceCheckRequiredVars);
+        boolean hasPresenceCheckRequiredVars = !presenceCheckRequiredVars.isEmpty();
+        model.vendorExtensions.put("hasPresenceCheckRequiredVars", hasPresenceCheckRequiredVars);
+
+        if (hasPresenceCheckRequiredVars) {
+            imports.add(createMapping("import", "bytes"));
+            imports.add(createMapping("import", "encoding/json"));
+        }
+
+        List<String> allowedJsonKeys = new ArrayList<>(structFieldBaseNames);
+        model.vendorExtensions.put("allowedJsonKeys", allowedJsonKeys);
+        model.vendorExtensions.put("x-go-has-parent", hasEmbeddedParent);
+
+        boolean hasRequiredAssertVars = model.vars.stream()
+                .anyMatch(v -> v.required && !v.isReadOnly && !v.isNullable
+                        && (v.isModel || v.isArray || v.isMap));
+        model.vendorExtensions.put("hasRequiredAssertVars", hasRequiredAssertVars);
+        if (hasRequiredAssertVars) {
+            List<CodegenProperty> assertRequiredVars = model.vars.stream()
+                    .filter(v -> v.required && !v.isReadOnly && !v.isNullable
+                            && (v.isModel || v.isArray || v.isMap))
+                    .collect(Collectors.toList());
+            model.vendorExtensions.put("assertRequiredVars", assertRequiredVars);
+        }
+    }
+
     @Override
     public ModelsMap postProcessModels(ModelsMap objs) {
         // The superclass determines the list of required golang imports. The actual list of imports

modules/openapi-generator/src/main/resources/go-server/controller-api.mustache

@@ -5,9 +5,9 @@ package {{packageName}}
 import (
 	{{#hasBodyParams}}
 	"encoding/json"
+	"errors"
 	{{/hasBodyParams}}
 	{{#hasOptionalBodyParams}}
-	"errors"
 	"io"
 	{{/hasOptionalBodyParams}}
 	"net/http"
@@ -614,6 +614,11 @@ func (c *{{classname}}Controller) {{operationId}}(w http.ResponseWriter, r *http
 	d.DisallowUnknownFields()
 	{{/isAdditionalPropertiesTrue}}
 	if err := d.Decode(&{{paramName}}Param); err != nil {{^required}}&& !errors.Is(err, io.EOF) {{/required}}{
+		var requiredErr *RequiredError
+		if errors.As(err, &requiredErr) {
+			c.errorHandler(w, r, err, nil)
+			return
+		}
 		c.errorHandler(w, r, &ParsingError{Err: err}, nil)
 		return
 	}

modules/openapi-generator/src/main/resources/go-server/error.mustache

@@ -36,7 +36,7 @@ type RequiredError struct {
 }
 
 func (e *RequiredError) Error() string {
-	return fmt.Sprintf("required field '%s' is zero value.", e.Field)
+	return fmt.Sprintf("required field '%s' is missing.", e.Field)
 }
 
 // ErrorHandler defines the required method for handling error. You may implement it and inject this into a controller if

modules/openapi-generator/src/main/resources/go-server/model.mustache

@@ -57,48 +57,46 @@ func New{{{classname}}}FromValue(v {{{format}}}{{^format}}{{dataType}}{{/format}
 {{/isEnum}}{{^isEnum}}{{#description}}
 // {{classname}} - {{{description}}}{{/description}}
 type {{classname}} struct {
-{{#parent}}
-{{^isMap}}
-{{^isArray}}
-	{{{parent}}}
-{{/isArray}}
-{{/isMap}}
-{{#isArray}}
-	Items {{{parent}}}
-{{/isArray}}
-{{/parent}}
+{{#vendorExtensions.x-go-embed-parent-classname}}
+	{{{.}}}
+{{/vendorExtensions.x-go-embed-parent-classname}}
 {{#vars}}{{#description}}
 	// {{{.}}}{{/description}}
 	{{#deprecated}}
 	// Deprecated
 	{{/deprecated}}
 	{{name}} {{#isNullable}}*{{/isNullable}}{{{dataType}}} `json:"{{baseName}}{{^required}},omitempty{{/required}}"{{#vendorExtensions.x-go-custom-tag}} {{{.}}}{{/vendorExtensions.x-go-custom-tag}}`
 {{/vars}}
-}{{/isEnum}}
+}
+{{#vendorExtensions.hasPresenceCheckRequiredVars}}
+{{>model_unmarshal_json_presence}}
+{{/vendorExtensions.hasPresenceCheckRequiredVars}}
+{{/isEnum}}
 
-// Assert{{classname}}Required checks if the required fields are not zero-ed
+// Assert{{classname}}Required checks complex required fields (models, arrays, maps) and embedded parents.
+// Primitive required fields are validated for JSON request bodies in UnmarshalJSON so zero values remain valid.
 func Assert{{classname}}Required(obj {{classname}}) error {
 {{#hasRequired}}
+{{#vendorExtensions.hasRequiredAssertVars}}
 	elements := map[string]interface{}{
-{{#requiredVars}}{{^isReadOnly}}		"{{baseName}}": obj.{{name}},
-{{/isReadOnly}}{{/requiredVars}}	}
+{{#vendorExtensions.assertRequiredVars}}
+		"{{baseName}}": obj.{{name}},
+{{/vendorExtensions.assertRequiredVars}}
+	}
 	for name, el := range elements {
 		if isZero := IsZeroValue(el); isZero {
 			return &RequiredError{Field: name}
 		}
 	}
 
+{{/vendorExtensions.hasRequiredAssertVars}}
 {{/hasRequired}}
-{{#parent}}
-	{{^isMap}}
-		{{^isArray}}
-	if err := Assert{{{parent}}}Required(obj.{{{parent}}}); err != nil {
+{{#vendorExtensions.x-go-embed-parent-classname}}
+	if err := Assert{{vendorExtensions.x-go-embed-parent-classname}}Required(obj.{{vendorExtensions.x-go-embed-parent-classname}}); err != nil {
 		return err
 	}
 
-		{{/isArray}}
-	{{/isMap}}
-{{/parent}}
+{{/vendorExtensions.x-go-embed-parent-classname}}
 {{#Vars}}
 {{^isReadOnly}}
 	{{#isNullable}}

modules/openapi-generator/src/main/resources/go-server/model_unmarshal_json_presence.mustache

@@ -0,0 +1,85 @@
+type _{{classname}} {{classname}}
+
+// UnmarshalJSON validates required property keys then unmarshals into {{classname}}
+func (o *{{classname}}) UnmarshalJSON(data []byte) (err error) {
+	// Presence is checked against required fields that exist on this struct (own fields
+	// and embedded allOf parent fields). Only keys that map to struct fields are passed
+	// to the strict decoder.
+	requiredProperties := []string{
+{{#vendorExtensions.presenceCheckRequiredVars}}
+		"{{baseName}}",
+{{/vendorExtensions.presenceCheckRequiredVars}}
+	}
+
+	requiredNullableProperties := map[string]bool{
+{{#vendorExtensions.presenceCheckRequiredVars}}
+		"{{baseName}}": {{#isNullable}}true{{/isNullable}}{{^isNullable}}false{{/isNullable}},
+{{/vendorExtensions.presenceCheckRequiredVars}}
+	}
+
+	{{^vendorExtensions.x-go-has-parent}}
+	allowedJsonKeys := []string{
+{{#vendorExtensions.allowedJsonKeys}}
+		"{{.}}",
+{{/vendorExtensions.allowedJsonKeys}}
+	}
+
+	{{/vendorExtensions.x-go-has-parent}}
+	allProperties := make(map[string]interface{})
+
+	err = json.Unmarshal(data, &allProperties)
+
+	if err != nil {
+		return err
+	}
+
+	for _, requiredProperty := range requiredProperties {
+		value, exists := allProperties[requiredProperty]
+		if !exists {
+			return &RequiredError{Field: requiredProperty}
+		}
+		if value == nil && !requiredNullableProperties[requiredProperty] {
+			return &RequiredError{Field: requiredProperty}
+		}
+	}
+
+	var filteredData []byte
+	{{#vendorExtensions.x-go-has-parent}}
+	// Parent struct fields are embedded; the strict decoder already knows them.
+	filteredData, err = json.Marshal(allProperties)
+	{{/vendorExtensions.x-go-has-parent}}
+	{{^vendorExtensions.x-go-has-parent}}
+	{{#isAdditionalPropertiesTrue}}
+	filteredData, err = json.Marshal(allProperties)
+	{{/isAdditionalPropertiesTrue}}
+	{{^isAdditionalPropertiesTrue}}
+	filteredProperties := make(map[string]interface{})
+	for _, allowedKey := range allowedJsonKeys {
+		if value, exists := allProperties[allowedKey]; exists {
+			filteredProperties[allowedKey] = value
+		}
+	}
+
+	filteredData, err = json.Marshal(filteredProperties)
+	{{/isAdditionalPropertiesTrue}}
+	{{/vendorExtensions.x-go-has-parent}}
+	if err != nil {
+		return err
+	}
+
+	var{{classname}} := _{{classname}}{}
+
+	decoder := json.NewDecoder(bytes.NewReader(filteredData))
+	{{^isAdditionalPropertiesTrue}}
+	decoder.DisallowUnknownFields()
+	{{/isAdditionalPropertiesTrue}}
+	err = decoder.Decode(&var{{classname}})
+
+	if err != nil {
+		return err
+	}
+
+	*o = {{classname}}(var{{classname}})
+
+	return nil
+}