fix: avoid stack overflow errors when using heavily recursive types (oapi-codegen#1377)

As noted in oapi-codegen#1373, we have cases where a heavily recursive `allOf` could
lead to a stack overflow error.

To avoid this, we can track the references that we've seen, and not
recurse further if we have already traversed that ref.

Closes oapi-codegen#1373.

Co-authored-by: Jamie Tanna <jamie.tanna@elastic.co>

Author: yoshikipom

internal/test/issues/issue-1373/config.yaml

@@ -0,0 +1,4 @@
+package: issue1373
+generate:
+  models: true
+output: issue.gen.go

internal/test/issues/issue-1373/generate.go

@@ -0,0 +1,3 @@
+package issue1373
+
+//go:generate go run github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --config=config.yaml spec.yaml

internal/test/issues/issue-1373/issue.gen.go

@@ -0,0 +1,32 @@
+openapi: 3.0.2
+info:
+  version: '0.0.1'
+  title: example
+  description: |
+    Make sure that recursive $ref in allOf are handled properly
+paths:
+  /example:
+    get:
+      operationId: exampleGet
+      responses:
+        '200':
+          description: "OK"
+          content:
+            'application/json':
+              schema:
+                $ref: '#/components/schemas/RecursiveObject'
+
+components:
+  schemas:
+    RecursiveObject:
+      allOf:
+        - $ref: "#/components/schemas/NonRecursiveObject"
+        - $ref: "#/components/schemas/RecursiveObject"
+        - properties:
+            FieldInRecursive::
+              type: string
+
+    NonRecursiveObject:
+      properties:
+        FieldInNonRecursive:
+          type: string

internal/test/issues/issue-1373/spec.yaml

@@ -38,7 +38,12 @@ func mergeSchemas(allOf []*openapi3.SchemaRef, path []string) (Schema, error) {
 		if err != nil {
 			return Schema{}, err
 		}
-		schema, err = mergeOpenapiSchemas(schema, oneOfSchema, true)
+
+		seenSchemaRef := make(map[string]bool)
+		if allOf[i].Ref != "" {
+			seenSchemaRef[allOf[i].Ref] = true
+		}
+		schema, err = mergeOpenapiSchemas(schema, oneOfSchema, true, seenSchemaRef)
 		if err != nil {
 			return Schema{}, fmt.Errorf("error merging schemas for AllOf: %w", err)
 		}
@@ -71,11 +76,17 @@ func valueWithPropagatedRef(ref *openapi3.SchemaRef) (openapi3.Schema, error) {
 	return schema, nil
 }
 
-func mergeAllOf(allOf []*openapi3.SchemaRef) (openapi3.Schema, error) {
+func mergeAllOf(allOf []*openapi3.SchemaRef, seenSchemaRef map[string]bool) (openapi3.Schema, error) {
 	var schema openapi3.Schema
 	for _, schemaRef := range allOf {
 		var err error
-		schema, err = mergeOpenapiSchemas(schema, *schemaRef.Value, true)
+		if schemaRef.Ref != "" && seenSchemaRef[schemaRef.Ref] {
+			continue
+		}
+		if schemaRef.Ref != "" {
+			seenSchemaRef[schemaRef.Ref] = true
+		}
+		schema, err = mergeOpenapiSchemas(schema, *schemaRef.Value, true, seenSchemaRef)
 		if err != nil {
 			return openapi3.Schema{}, fmt.Errorf("error merging schemas for AllOf: %w", err)
 		}
@@ -85,7 +96,7 @@ func mergeAllOf(allOf []*openapi3.SchemaRef) (openapi3.Schema, error) {
 
 // mergeOpenapiSchemas merges two openAPI schemas and returns the schema
 // all of whose fields are composed.
-func mergeOpenapiSchemas(s1, s2 openapi3.Schema, allOf bool) (openapi3.Schema, error) {
+func mergeOpenapiSchemas(s1, s2 openapi3.Schema, allOf bool, seenSchemaRef map[string]bool) (openapi3.Schema, error) {
 	var result openapi3.Schema
 
 	result.Extensions = make(map[string]any, len(s1.Extensions)+len(s2.Extensions))
@@ -100,15 +111,15 @@ func mergeOpenapiSchemas(s1, s2 openapi3.Schema, allOf bool) (openapi3.Schema, e
 	var err error
 	if s1.AllOf != nil {
 		var merged openapi3.Schema
-		merged, err = mergeAllOf(s1.AllOf)
+		merged, err = mergeAllOf(s1.AllOf, seenSchemaRef)
 		if err != nil {
 			return openapi3.Schema{}, fmt.Errorf("error transitive merging AllOf on schema 1")
 		}
 		s1 = merged
 	}
 	if s2.AllOf != nil {
 		var merged openapi3.Schema
-		merged, err = mergeAllOf(s2.AllOf)
+		merged, err = mergeAllOf(s2.AllOf, seenSchemaRef)
 		if err != nil {
 			return openapi3.Schema{}, fmt.Errorf("error transitive merging AllOf on schema 2")
 		}

pkg/codegen/merge_schemas.go

@@ -17,7 +17,7 @@ func TestMergeOpenapiSchemas_DiscriminatorPropagation(t *testing.T) {
 		s1 := openapi3.Schema{Discriminator: disc}
 		s2 := openapi3.Schema{}
 
-		result, err := mergeOpenapiSchemas(s1, s2, true)
+		result, err := mergeOpenapiSchemas(s1, s2, true, make(map[string]bool))
 		require.NoError(t, err)
 		assert.Equal(t, disc, result.Discriminator)
 	})
@@ -26,7 +26,7 @@ func TestMergeOpenapiSchemas_DiscriminatorPropagation(t *testing.T) {
 		s1 := openapi3.Schema{}
 		s2 := openapi3.Schema{Discriminator: disc}
 
-		result, err := mergeOpenapiSchemas(s1, s2, true)
+		result, err := mergeOpenapiSchemas(s1, s2, true, make(map[string]bool))
 		require.NoError(t, err)
 		assert.Equal(t, disc, result.Discriminator)
 	})
@@ -36,7 +36,7 @@ func TestMergeOpenapiSchemas_DiscriminatorPropagation(t *testing.T) {
 		s1 := openapi3.Schema{Discriminator: disc}
 		s2 := openapi3.Schema{Discriminator: disc2}
 
-		_, err := mergeOpenapiSchemas(s1, s2, true)
+		_, err := mergeOpenapiSchemas(s1, s2, true, make(map[string]bool))
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "discriminators")
 	})
@@ -45,7 +45,7 @@ func TestMergeOpenapiSchemas_DiscriminatorPropagation(t *testing.T) {
 		s1 := openapi3.Schema{}
 		s2 := openapi3.Schema{}
 
-		result, err := mergeOpenapiSchemas(s1, s2, true)
+		result, err := mergeOpenapiSchemas(s1, s2, true, make(map[string]bool))
 		require.NoError(t, err)
 		assert.Nil(t, result.Discriminator)
 	})
@@ -54,15 +54,15 @@ func TestMergeOpenapiSchemas_DiscriminatorPropagation(t *testing.T) {
 		s1 := openapi3.Schema{Discriminator: disc}
 		s2 := openapi3.Schema{}
 
-		_, err := mergeOpenapiSchemas(s1, s2, false)
+		_, err := mergeOpenapiSchemas(s1, s2, false, make(map[string]bool))
 		require.Error(t, err)
 	})
 
 	t.Run("non-allOf with discriminator on s2 errors", func(t *testing.T) {
 		s1 := openapi3.Schema{}
 		s2 := openapi3.Schema{Discriminator: disc}
 
-		_, err := mergeOpenapiSchemas(s1, s2, false)
+		_, err := mergeOpenapiSchemas(s1, s2, false, make(map[string]bool))
 		require.Error(t, err)
 	})
 }