avoid stack overflow on $ref loops

Author: hauner

src/main/groovy/com/github/hauner/openapi/spring/converter/DataTypeConverter.groovy

@@ -42,6 +42,7 @@ import com.github.hauner.openapi.spring.model.datatypes.IntegerDataType
 import com.github.hauner.openapi.spring.model.datatypes.LongDataType
 import com.github.hauner.openapi.spring.model.datatypes.NoneDataType
 import com.github.hauner.openapi.spring.model.datatypes.OffsetDateTimeDataType
+import com.github.hauner.openapi.spring.model.datatypes.LazyDataType
 import com.github.hauner.openapi.spring.model.datatypes.SetDataType
 import com.github.hauner.openapi.spring.model.datatypes.StringDataType
 import com.github.hauner.openapi.spring.model.datatypes.StringEnumDataType
@@ -55,9 +56,12 @@ import com.github.hauner.openapi.spring.model.datatypes.StringEnumDataType
 class DataTypeConverter {
 
     private ApiOptions options
+    private List<SchemaInfo> current
+
 
     DataTypeConverter(ApiOptions options) {
         this.options = options
+        this.current = []
     }
 
     DataType none() {
@@ -74,19 +78,28 @@ class DataTypeConverter {
      * @return the resulting java data type
      */
     DataType convert (SchemaInfo dataTypeInfo, DataTypes dataTypes) {
+        if (isLoop (dataTypeInfo)) {
+            return new LazyDataType (info: dataTypeInfo, dataTypes: dataTypes)
+        }
+
+        push (dataTypeInfo)
 
+        DataType result
         if (dataTypeInfo.isRefObject ()) {
-            createRefDataType(dataTypeInfo, dataTypes)
+            result = createRefDataType(dataTypeInfo, dataTypes)
 
         } else if (dataTypeInfo.isArray ()) {
-            createArrayDataType (dataTypeInfo, dataTypes)
+            result = createArrayDataType (dataTypeInfo, dataTypes)
 
         } else if (dataTypeInfo.isObject ()) {
-            createObjectDataType (dataTypeInfo, dataTypes)
+            result = createObjectDataType (dataTypeInfo, dataTypes)
 
         } else {
-            createSimpleDataType (dataTypeInfo, dataTypes)
+            result = createSimpleDataType (dataTypeInfo, dataTypes)
         }
+
+        pop ()
+        result
     }
 
     private DataType createArrayDataType (SchemaInfo schemaInfo, DataTypes dataTypes) {
@@ -250,7 +263,7 @@ class DataTypeConverter {
         enumType
     }
 
-    TargetType getMappedDataType (SchemaType schemaType) {
+    private TargetType getMappedDataType (SchemaType schemaType) {
         // check endpoint mappings
         List<Mapping> endpointMatches = schemaType.matchEndpointMapping (options.typeMappings)
         if (!endpointMatches.empty) {
@@ -293,4 +306,40 @@ class DataTypeConverter {
         return match.targetType
     }
 
+    /**
+     * push the current schema info.
+     *
+     * Pushes the given {@code info} onto the in-progress data type stack. It is used to detect
+     * $ref loops.
+     *
+     * @param info the schema info that is currently processed
+     */
+    private void push (SchemaInfo info) {
+        current.push (info)
+    }
+
+    /**
+     * pop the current schema info.
+     *
+     */
+    private void pop () {
+        current.pop ()
+    }
+
+    /**
+     * detect $ref loop.
+     *
+     * returns true if the given {@code info} is currently processed, false otherwise. True indicates
+     * a $ref loop.
+     *
+     * @param info the schema info that is currently processed
+     * @return
+     */
+    private boolean isLoop (SchemaInfo info) {
+        def found = current.find {
+            it.name == info.name
+        }
+        found != null
+    }
+
 }

src/main/groovy/com/github/hauner/openapi/spring/model/datatypes/LazyDataType.groovy

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.model.datatypes
+
+import com.github.hauner.openapi.spring.converter.schema.SchemaInfo
+import com.github.hauner.openapi.spring.model.DataTypes
+
+/**
+ * OpenAPI $ref type that is lazily evaluated. It is used to break loops in the schema definitions.
+ *
+ * @autor Martin Hauner
+ */
+class LazyDataType implements DataType {
+
+    private DataTypes dataTypes
+    private SchemaInfo info
+
+    @Override
+    String getName () {
+        dataType.name
+    }
+
+    @Override
+    String getPackageName () {
+        dataType.packageName
+    }
+
+    @Override
+    Set<String> getImports () {
+        dataType.imports
+    }
+
+    @Override
+    Set<String> getReferencedImports () {
+        dataType.referencedImports
+    }
+
+    private DataType getDataType () {
+        dataTypes.find (info.name)
+    }
+
+}

src/test/groovy/com/github/hauner/openapi/spring/converter/DataTypeConverterLoopSpec.groovy

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.converter
+
+import com.github.hauner.openapi.spring.model.datatypes.LazyDataType
+import com.github.hauner.openapi.spring.model.datatypes.ObjectDataType
+import spock.lang.Specification
+
+import static com.github.hauner.openapi.spring.support.OpenApiParser.parse
+
+
+class DataTypeConverterLoopSpec extends Specification {
+
+    void "handles \$ref loops"() {
+        def openApi = parse (
+"""\
+openapi: 3.0.2
+info:
+  title: test \$ref loop
+  version: 1.0.0
+
+paths:
+
+  /self-reference:
+    get:
+      responses:
+        '200':
+          description: none
+          content:
+            application/json:
+                schema:
+                  \$ref: '#/components/schemas/Self'
+
+components:
+  schemas:
+
+    Self:
+      type: object
+      properties:
+        self:
+          \$ref: '#/components/schemas/Self'
+""")
+
+        when:
+        def api = new ApiConverter (new ApiOptions()).convert (openApi)
+
+        then:
+        def itf = api.interfaces.first ()
+        def ep = itf.endpoints.first ()
+        def rp = ep.getFirstResponse ('200')
+        def rt = rp.responseType
+        def sf = rt.objectProperties.self
+        rt instanceof ObjectDataType
+        sf instanceof LazyDataType
+        sf.name == 'Self'
+        sf.packageName == 'generatr.model'
+        sf.imports == ['generatr.model.Self'] as Set
+        sf.referencedImports == ['generatr.model.Self'] as Set
+    }
+
+}