#78, detect oneOf to interface condition

Author: hauner

src/main/kotlin/io/openapiprocessor/core/converter/ApiOptions.kt

@@ -47,6 +47,12 @@ class ApiOptions {
      */
     var modelNameSuffix = String.Empty
 
+    /**
+     * enable/disable generation of a common interface for an `oneOf` list of objects. All objects
+     * implement that interface.
+     */
+    var oneOfInterface = false
+
     /**
      * enable/disable the code formatter (optional).
      */

src/main/kotlin/io/openapiprocessor/core/converter/DataTypeConverter.kt

@@ -105,10 +105,28 @@ class DataTypeConverter(
 
             objectType = AllOfObjectDataType(
                 DataTypeName(schemaInfo.getName(), getTypeNameWithSuffix(schemaInfo.getName())),
-                listOf(options.packageName, "model").joinToString ("."),
+                listOf(options.packageName, "model").joinToString("."),
                 items,
                 schemaInfo.getDeprecated()
             )
+        } else if (shouldGenerateOneOfInterface(items) && schemaInfo.isComposedOneOf()) {
+            val constraints = DataTypeConstraints(
+                nullable = schemaInfo.getNullable(),
+                required = schemaInfo.getRequired()
+            )
+
+            objectType = InterfaceDataType (
+                DataTypeName(schemaInfo.getName(), getTypeNameWithSuffix(schemaInfo.getName())),
+                listOf(options.packageName, "model").joinToString("."),
+                items,
+                constraints,
+                schemaInfo.getDeprecated(),
+                Documentation(description = schemaInfo.description)
+            )
+
+            items.forEach {
+                (it as ModelDataType).implementsDataType = objectType
+            }
         } else {
             objectType = AnyOneOfObjectDataType(
                 schemaInfo.getName(),
@@ -124,6 +142,11 @@ class DataTypeConverter(
         return objectType
     }
 
+    private fun shouldGenerateOneOfInterface(items: List<DataType>): Boolean {
+        return options.oneOfInterface
+            && items.size == items.filterIsInstance<ModelDataType>().count()
+    }
+
     private fun createArrayDataType(schemaInfo: SchemaInfo, dataTypes: DataTypes): DataType {
         val itemSchemaInfo = schemaInfo.buildForItem()
         val item = convert(itemSchemaInfo, dataTypes)

src/main/kotlin/io/openapiprocessor/core/converter/SchemaInfo.kt

@@ -340,6 +340,10 @@ open class SchemaInfo(
         return itemOf().equals("allOf")
     }
 
+    fun isComposedOneOf(): Boolean {
+        return itemOf().equals("oneOf")
+    }
+
     fun isTypeLess(): Boolean {
         return schema?.getType() == null
     }

src/main/kotlin/io/openapiprocessor/core/model/DataTypeCollector.kt

@@ -56,6 +56,12 @@ class DataTypeCollector(
             is PropertyDataType -> {
                 collect(dataType.dataType)
             }
+            is InterfaceDataType -> {
+                dataTypes.addRef(dataType.getName())
+                dataType.items.forEach {
+                    collect(it)
+                }
+            }
         }
     }
 

src/main/kotlin/io/openapiprocessor/core/model/datatypes/AllOfObjectDataType.kt

@@ -13,7 +13,8 @@ class AllOfObjectDataType(
     private val pkg: String,
     private val items: List<DataType> = emptyList(),
     override val deprecated: Boolean = false
-): DataType, ModelDataType {
+): ModelDataType {
+    override var implementsDataType: InterfaceDataType? = null
 
     override fun getName(): String {
         return name.id

src/main/kotlin/io/openapiprocessor/core/model/datatypes/InterfaceDataType.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 https://github.com/openapi-processor/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.model.datatypes
+
+import io.openapiprocessor.core.model.Documentation
+
+/**
+ * represents an OpenAPI object that is generated as interface.
+ *
+ * only used with onOf elements are all objects. It will represent the common interface that all
+ * items implement.
+ */
+class InterfaceDataType(
+    private val name: DataTypeName,
+    private val pkg: String,
+    val items: List<DataType> = emptyList(),
+    override val constraints: DataTypeConstraints? = null,
+    override val deprecated: Boolean = false,
+    override val documentation: Documentation? = null
+): DataType {
+
+    override fun getName(): String {
+        return name.id
+    }
+
+    override fun getTypeName(): String {
+        return name.type
+    }
+
+    override fun getPackageName(): String {
+        return pkg
+    }
+
+    override fun getImports(): Set<String> {
+        return setOf("${getPackageName()}.${getTypeName()}")
+    }
+}

src/main/kotlin/io/openapiprocessor/core/model/datatypes/ModelDataType.kt

@@ -6,6 +6,10 @@
 package io.openapiprocessor.core.model.datatypes
 
 interface ModelDataType: DataType {
+    /**
+     * implements this interface.
+     */
+    var implementsDataType: InterfaceDataType?
 
     /**
      * loop object properties.

src/main/kotlin/io/openapiprocessor/core/model/datatypes/ObjectDataType.kt

@@ -18,7 +18,8 @@ open class ObjectDataType(
     override val constraints: DataTypeConstraints? = null,
     override val deprecated: Boolean = false,
     override val documentation: Documentation? = null
-): DataType, ModelDataType {
+): ModelDataType {
+    override var implementsDataType: InterfaceDataType? = null
 
     override fun getName(): String {
         return name.id
@@ -38,10 +39,7 @@ open class ObjectDataType(
 
     override val referencedImports: Set<String>
         get() {
-            return properties.values
-                .map { it.getImports() }
-                .flatten()
-                .toSet()
+            return propertiesImports + implementsImports
         }
 
     fun addObjectProperty(name: String, type: PropertyDataType) {
@@ -64,4 +62,16 @@ open class ObjectDataType(
         for (p in properties) action(p.key, p.value)
     }
 
+    private val propertiesImports: Set<String>
+        get() {
+            return properties.values
+                .map { it.getImports() }
+                .flatten()
+                .toSet()
+        }
+
+    private val implementsImports: Set<String>
+        get() {
+            return implementsDataType?.referencedImports ?: emptySet()
+        }
 }

src/test/kotlin/io/openapiprocessor/core/converter/DataTypeConverterOneOfSpec.kt

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2022 https://github.com/openapi-processor/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import io.openapiprocessor.core.model.DataTypes
+import io.openapiprocessor.core.model.HttpMethod
+import io.openapiprocessor.core.model.datatypes.InterfaceDataType
+import io.openapiprocessor.core.model.datatypes.ModelDataType
+import io.openapiprocessor.core.support.getBodySchemaInfo
+import io.openapiprocessor.core.support.parse
+
+class DataTypeConverterOneOfSpec: StringSpec({
+
+    "creates interface and implementing model classes for oneOf with objects" {
+        val dataTypes = DataTypes()
+        val options = ApiOptions()
+        options.oneOfInterface = true
+
+        val openApi = parse("""
+           openapi: 3.0.2
+           info:
+             title: API
+             version: 1.0.0
+           
+           paths:
+             /foo:
+               post:
+                 requestBody:
+                   content:
+                     application/json:
+                       schema:
+                         ${'$'}ref: '#/components/schemas/Foo'
+                 responses:
+                   '204':
+                     description: empty
+           
+           components:
+             schemas:
+           
+                Foo:
+                  type: object
+                  properties:
+                    myProperties:
+                      ${'$'}ref: '#/components/schemas/GenericProperties'
+                      
+                GenericProperties:
+                  oneOf:
+                    - ${'$'}ref: '#/components/schemas/SpecificPropertiesOne'
+                    - ${'$'}ref: '#/components/schemas/SpecificPropertiesTwo'
+                
+                SpecificPropertiesOne:
+                  type: object
+                  properties:
+                    foo:
+                      type: string
+                      maxLength: 200
+                
+                SpecificPropertiesTwo:
+                  type: object
+                  properties:
+                    bar:
+                      type: string
+                      maxLength: 100
+                 
+        """.trimIndent())
+
+        val schemaInfo = openApi.getBodySchemaInfo("Foo",
+            "/foo", HttpMethod.POST, "application/json")
+
+        // when:
+        val converter = DataTypeConverter(options)
+        val datatype = converter.convert(schemaInfo, dataTypes)
+
+        // then:
+        val ifDataType = dataTypes.find("GenericProperties")
+        ifDataType.shouldBeInstanceOf<InterfaceDataType>()
+        ifDataType.items.size shouldBe 2
+        ifDataType.items.forEach {
+            (it as ModelDataType).implementsDataType shouldBe ifDataType
+        }
+    }
+
+})