regen

Author: cubahno

pkg/codegen/schema_merge.go

@@ -713,11 +713,13 @@ func mergeOpenapiSchemas(s1, s2 *base.Schema) (*base.Schema, error) {
 	// Required. We merge these.
 	result.Required = append(s1.Required, s2.Required...)
 
-	// We merge all properties. When both schemas declare a property with
-	// the same name, the typed declaration wins over an untyped one
-	// (which usually only carries annotations like example or
-	// description). Without this, the later schema silently overwrote
-	// the earlier one and any type/enum/constraint it carried was lost.
+	// We merge all properties. When both schemas declare a property
+	// with the same name, an annotation-only override (carrying only
+	// fields like `example` or `description`) must not overwrite a
+	// sibling that actually shapes the Go type. Otherwise we keep the
+	// previous "s2 wins" behavior, since both sides genuinely shape
+	// the type and the second declaration is the more specific one in
+	// an allOf chain.
 	//
 	// We deliberately pick one of the original SchemaProxies rather
 	// than fabricating a merged proxy via CreateSchemaProxy: downstream
@@ -735,13 +737,9 @@ func mergeOpenapiSchemas(s1, s2 *base.Schema) (*base.Schema, error) {
 		}
 
 		if existing, exists := result.Properties.Get(k); exists {
-			if len(getSchemaType(existing.Schema())) == 0 && len(getSchemaType(v.Schema())) > 0 {
-				result.Properties.Set(k, v)
+			if isAnnotationOnlySchema(v.Schema()) && !isAnnotationOnlySchema(existing.Schema()) {
+				continue
 			}
-			// Otherwise the existing (s1's) property keeps its place;
-			// either it already has a type and we don't want to drop it,
-			// or neither side has a type and the choice is moot.
-			continue
 		}
 		result.Properties.Set(k, v)
 	}
@@ -809,6 +807,45 @@ func getSchemaType(schema *base.Schema) []string {
 	return nil
 }
 
+// isAnnotationOnlySchema reports whether a schema has no fields that
+// influence the generated Go type. Schemas like `{ example: cancelled }`
+// or `{ description: "..." }` are annotation-only and must not be
+// allowed to overwrite a sibling declaration that actually carries a
+// type, enum, or sub-schema in an allOf merge.
+func isAnnotationOnlySchema(s *base.Schema) bool {
+	if s == nil {
+		return true
+	}
+	if len(s.Type) > 0 {
+		return false
+	}
+	if len(s.AllOf) > 0 || len(s.OneOf) > 0 || len(s.AnyOf) > 0 {
+		return false
+	}
+	if s.If != nil || s.Then != nil || s.Else != nil || s.Not != nil {
+		return false
+	}
+	if s.Properties != nil && s.Properties.Len() > 0 {
+		return false
+	}
+	if s.PatternProperties != nil && s.PatternProperties.Len() > 0 {
+		return false
+	}
+	if s.Items != nil {
+		return false
+	}
+	if len(s.Enum) > 0 {
+		return false
+	}
+	if s.AdditionalProperties != nil {
+		return false
+	}
+	if s.Const != nil {
+		return false
+	}
+	return true
+}
+
 // mergeNullable merges two nullable pointers using a union (more permissive) approach.
 // If either is true, the result is true. If both are false or nil, the result is nil.
 // This allows merging schemas where one specifies nullable and another doesn't.