Rewritten with reflection-based traversal

Author: guan404ming

utils/component/openapi_generator.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"reflect"
 	"strings"
 
 	"cuelang.org/go/cue"
@@ -204,188 +205,92 @@ func getResolvedManifest(manifest string) (string, error) {
 	return string(resolved), nil
 }
 
-// clearDocRefs clears $ref strings across the entire OpenAPI document.
+// clearDocRefs uses reflection to walk the entire OpenAPI document and clear
+// all $ref strings so that json.Marshal outputs fully inlined schemas.
+// It uses two tracking mechanisms:
+//   - visited: permanent set for general pointers to avoid re-processing
+//   - schemaStack: path-based set for *Schema pointers to detect circular
+//     schema references (add on enter, remove on exit), allowing the same
+//     schema to appear in multiple non-circular positions
 func clearDocRefs(doc *openapi3.T) {
-	stack := make(map[*openapi3.Schema]bool)
-	visited := make(map[*openapi3.PathItem]bool)
+	visited := make(map[uintptr]bool)
+	schemaStack := make(map[uintptr]bool)
+	walkAndClearRefs(reflect.ValueOf(doc), visited, schemaStack)
+}
 
-	if doc.Components != nil {
-		for _, sr := range doc.Components.Schemas {
-			clearSchemaRefs(sr, stack)
-		}
-		for _, pr := range doc.Components.Parameters {
-			clearParameterRefs(pr, stack, visited)
-		}
-		for _, hr := range doc.Components.Headers {
-			clearHeaderRefs(hr, stack, visited)
-		}
-		for _, rb := range doc.Components.RequestBodies {
-			clearRequestBodyRefs(rb, stack, visited)
+var schemaRefType = reflect.TypeOf((*openapi3.SchemaRef)(nil))
+
+func walkAndClearRefs(v reflect.Value, visited map[uintptr]bool, schemaStack map[uintptr]bool) {
+	switch v.Kind() {
+	case reflect.Ptr:
+		if v.IsNil() {
+			return
 		}
-		for _, rr := range doc.Components.Responses {
-			clearResponseRefs(rr, stack, visited)
+
+		// SchemaRef needs path-based cycle detection so shared (non-circular)
+		// schemas are fully expanded while true cycles are broken.
+		if v.Type() == schemaRefType {
+			sr := v.Interface().(*openapi3.SchemaRef)
+			sr.Ref = ""
+			if sr.Value == nil {
+				return
+			}
+			schemaPtr := reflect.ValueOf(sr.Value).Pointer()
+			if schemaStack[schemaPtr] {
+				sr.Value = &openapi3.Schema{}
+				return
+			}
+			schemaStack[schemaPtr] = true
+			walkAndClearRefs(reflect.ValueOf(sr.Value), visited, schemaStack)
+			delete(schemaStack, schemaPtr)
+			return
 		}
-		for _, cr := range doc.Components.Callbacks {
-			clearCallbackRefs(cr, stack, visited)
+
+		ptr := v.Pointer()
+		if visited[ptr] {
+			return
 		}
-		for _, er := range doc.Components.Examples {
-			if er != nil {
-				er.Ref = ""
+		visited[ptr] = true
+
+		elem := v.Elem()
+		if elem.Kind() == reflect.Struct {
+			if refField := elem.FieldByName("Ref"); refField.IsValid() && refField.Kind() == reflect.String {
+				refField.SetString("")
 			}
 		}
-		for _, lr := range doc.Components.Links {
-			if lr != nil {
-				lr.Ref = ""
+		walkAndClearRefs(elem, visited, schemaStack)
+
+	case reflect.Struct:
+		// Handle types with unexported map fields (Paths, Callback, Responses)
+		// accessed via a Map() method.
+		if v.CanAddr() {
+			if mapMethod := v.Addr().MethodByName("Map"); mapMethod.IsValid() {
+				results := mapMethod.Call(nil)
+				if len(results) == 1 && results[0].Kind() == reflect.Map {
+					walkAndClearRefs(results[0], visited, schemaStack)
+				}
 			}
 		}
-		for _, ssr := range doc.Components.SecuritySchemes {
-			if ssr != nil {
-				ssr.Ref = ""
+		for i := 0; i < v.NumField(); i++ {
+			field := v.Field(i)
+			if field.CanInterface() {
+				walkAndClearRefs(field, visited, schemaStack)
 			}
 		}
-	}
 
-	if doc.Paths != nil {
-		for _, pathItem := range doc.Paths.Map() {
-			clearPathItemRefs(pathItem, stack, visited)
+	case reflect.Map:
+		for _, key := range v.MapKeys() {
+			walkAndClearRefs(v.MapIndex(key), visited, schemaStack)
 		}
-	}
-}
 
-func clearContentRefs(content openapi3.Content, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	for _, mt := range content {
-		if mt != nil {
-			clearSchemaRefs(mt.Schema, stack)
+	case reflect.Slice:
+		for i := 0; i < v.Len(); i++ {
+			walkAndClearRefs(v.Index(i), visited, schemaStack)
 		}
-	}
-}
-
-func clearParameterRefs(pr *openapi3.ParameterRef, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if pr == nil {
-		return
-	}
-	pr.Ref = ""
-	if pr.Value != nil {
-		clearSchemaRefs(pr.Value.Schema, stack)
-		clearContentRefs(pr.Value.Content, stack, visited)
-	}
-}
-
-func clearHeaderRefs(hr *openapi3.HeaderRef, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if hr == nil {
-		return
-	}
-	hr.Ref = ""
-	if hr.Value != nil {
-		clearSchemaRefs(hr.Value.Schema, stack)
-		clearContentRefs(hr.Value.Content, stack, visited)
-	}
-}
 
-func clearRequestBodyRefs(rb *openapi3.RequestBodyRef, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if rb == nil {
-		return
-	}
-	rb.Ref = ""
-	if rb.Value != nil {
-		clearContentRefs(rb.Value.Content, stack, visited)
-	}
-}
-
-func clearResponseRefs(rr *openapi3.ResponseRef, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if rr == nil {
-		return
-	}
-	rr.Ref = ""
-	if rr.Value != nil {
-		clearContentRefs(rr.Value.Content, stack, visited)
-		for _, hr := range rr.Value.Headers {
-			clearHeaderRefs(hr, stack, visited)
+	case reflect.Interface:
+		if !v.IsNil() {
+			walkAndClearRefs(v.Elem(), visited, schemaStack)
 		}
 	}
 }
-
-func clearCallbackRefs(cr *openapi3.CallbackRef, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if cr == nil {
-		return
-	}
-	cr.Ref = ""
-	if cr.Value != nil {
-		for _, pathItem := range cr.Value.Map() {
-			clearPathItemRefs(pathItem, stack, visited)
-		}
-	}
-}
-
-func clearPathItemRefs(pathItem *openapi3.PathItem, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if pathItem == nil || visited[pathItem] {
-		return
-	}
-	visited[pathItem] = true
-	for _, pr := range pathItem.Parameters {
-		clearParameterRefs(pr, stack, visited)
-	}
-	for _, op := range pathItem.Operations() {
-		clearOperationRefs(op, stack, visited)
-	}
-}
-
-func clearOperationRefs(op *openapi3.Operation, stack map[*openapi3.Schema]bool, visited map[*openapi3.PathItem]bool) {
-	if op == nil {
-		return
-	}
-	for _, pr := range op.Parameters {
-		clearParameterRefs(pr, stack, visited)
-	}
-	clearRequestBodyRefs(op.RequestBody, stack, visited)
-	if op.Responses != nil {
-		for _, rr := range op.Responses.Map() {
-			clearResponseRefs(rr, stack, visited)
-		}
-	}
-	for _, cr := range op.Callbacks {
-		clearCallbackRefs(cr, stack, visited)
-	}
-}
-
-// clearSchemaRefs recursively clears $ref strings on all nested SchemaRefs
-// so that json.Marshal outputs fully inlined schemas. The stack set tracks
-// Schema values (not SchemaRef pointers) on the current recursion path to
-// detect circular references. kin-openapi resolves $refs by creating
-// different SchemaRef objects that share the same underlying Schema pointer,
-// so tracking by *Schema is necessary to catch all cycles.
-func clearSchemaRefs(sr *openapi3.SchemaRef, stack map[*openapi3.Schema]bool) {
-	if sr == nil {
-		return
-	}
-	sr.Ref = ""
-	s := sr.Value
-	if s == nil {
-		return
-	}
-	if stack[s] {
-		sr.Value = &openapi3.Schema{}
-		return
-	}
-	stack[s] = true
-	for _, child := range s.AllOf {
-		clearSchemaRefs(child, stack)
-	}
-	for _, child := range s.AnyOf {
-		clearSchemaRefs(child, stack)
-	}
-	for _, child := range s.OneOf {
-		clearSchemaRefs(child, stack)
-	}
-	clearSchemaRefs(s.Not, stack)
-	if s.Items != nil {
-		clearSchemaRefs(s.Items, stack)
-	}
-	for _, prop := range s.Properties {
-		clearSchemaRefs(prop, stack)
-	}
-	if s.AdditionalProperties.Schema != nil {
-		clearSchemaRefs(s.AdditionalProperties.Schema, stack)
-	}
-	delete(stack, s)
-}

utils/component/openapi_generator_test.go

@@ -2,6 +2,7 @@ package component
 
 import (
 	"encoding/json"
+	"reflect"
 	"strings"
 	"testing"
 
@@ -305,7 +306,7 @@ func TestGetResolvedManifest_AllOf(t *testing.T) {
 	}
 }
 
-func TestClearSchemaRefs(t *testing.T) {
+func TestWalkAndClearRefs(t *testing.T) {
 	tests := []struct {
 		name string
 		sr   *openapi3.SchemaRef
@@ -322,24 +323,26 @@ func TestClearSchemaRefs(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			visited := make(map[*openapi3.Schema]bool)
-			clearSchemaRefs(tt.sr, visited)
+			visited := make(map[uintptr]bool)
+			schemaStack := make(map[uintptr]bool)
+			walkAndClearRefs(reflect.ValueOf(tt.sr), visited, schemaStack)
 			if tt.sr != nil && tt.sr.Ref != "" {
 				t.Errorf("Ref = %q, want empty", tt.sr.Ref)
 			}
 		})
 	}
 }
 
-func TestClearSchemaRefs_Circular(t *testing.T) {
+func TestWalkAndClearRefs_Circular(t *testing.T) {
 	// Build a circular reference: A -> B -> A
 	a := &openapi3.SchemaRef{Ref: "#/components/schemas/A", Value: &openapi3.Schema{}}
 	b := &openapi3.SchemaRef{Ref: "#/components/schemas/B", Value: &openapi3.Schema{}}
 	a.Value.Properties = openapi3.Schemas{"b": b}
 	b.Value.Properties = openapi3.Schemas{"a": a}
 
-	stack := make(map[*openapi3.Schema]bool)
-	clearSchemaRefs(a, stack) // must not hang or panic
+	visited := make(map[uintptr]bool)
+	schemaStack := make(map[uintptr]bool)
+	walkAndClearRefs(reflect.ValueOf(a), visited, schemaStack) // must not hang or panic
 
 	if a.Ref != "" {
 		t.Errorf("a.Ref = %q, want empty", a.Ref)
@@ -354,15 +357,16 @@ func TestClearSchemaRefs_Circular(t *testing.T) {
 	}
 }
 
-func TestClearSchemaRefs_SelfReference(t *testing.T) {
+func TestWalkAndClearRefs_SelfReference(t *testing.T) {
 	// Schema that references itself (like JSONSchemaProps).
 	self := &openapi3.SchemaRef{Value: &openapi3.Schema{
 		Type: &openapi3.Types{"object"},
 	}}
 	self.Value.Properties = openapi3.Schemas{"nested": self}
 
-	stack := make(map[*openapi3.Schema]bool)
-	clearSchemaRefs(self, stack)
+	visited := make(map[uintptr]bool)
+	schemaStack := make(map[uintptr]bool)
+	walkAndClearRefs(reflect.ValueOf(self), visited, schemaStack)
 
 	// The self-referencing property should be replaced, breaking the cycle.
 	if _, err := json.Marshal(self); err != nil {