#45, wrap "nullable" object properties

Author: hauner

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

@@ -6,6 +6,7 @@
 package io.openapiprocessor.core.converter
 
 import io.openapiprocessor.core.converter.mapping.*
+import io.openapiprocessor.core.converter.wrapper.NullDataTypeWrapper
 import io.openapiprocessor.core.model.DataTypeCollector
 import io.openapiprocessor.core.model.DataTypes
 import io.openapiprocessor.core.model.datatypes.*
@@ -17,7 +18,8 @@ import kotlin.collections.LinkedHashMap
  */
 class DataTypeConverter(
     private val options: ApiOptions,
-    private val finder: MappingFinder = MappingFinder(options.typeMappings)
+    private val finder: MappingFinder = MappingFinder(options.typeMappings),
+    private val nullWrapper: NullDataTypeWrapper = NullDataTypeWrapper(options, finder)
 ) {
     private val current: Deque<SchemaInfo> = LinkedList()
 
@@ -142,7 +144,6 @@ class DataTypeConverter(
                 constraints,
                 schemaInfo.getDeprecated()
             )
-            return mappedDataType
         }
 
         return ArrayDataType(item, constraints, schemaInfo.getDeprecated())
@@ -155,7 +156,12 @@ class DataTypeConverter(
     private fun createObjectDataType(schemaInfo: SchemaInfo, dataTypes: DataTypes): DataType {
         val properties = LinkedHashMap<String, DataType>()
         schemaInfo.eachProperty { propName: String, propSchemaInfo: SchemaInfo ->
-            properties[propName] = convert(propSchemaInfo, dataTypes)
+            var propDataType = convert(propSchemaInfo, dataTypes)
+
+            if (propSchemaInfo.getNullable()) {
+                propDataType = nullWrapper.wrap(propDataType, schemaInfo)
+            }
+            properties[propName] = propDataType
         }
 
         val targetType = getMappedDataType(schemaInfo)

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

@@ -0,0 +1,78 @@
+/*
+ * Copyright © 2020 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.converter.mapping.EndpointTypeMapping
+import io.openapiprocessor.core.converter.mapping.TypeMapping
+import io.openapiprocessor.core.model.DataTypes
+import io.openapiprocessor.core.model.HttpMethod
+import io.openapiprocessor.core.model.datatypes.ObjectDataType
+import io.openapiprocessor.core.support.getBodySchemaInfo
+import io.openapiprocessor.core.support.parse
+
+class DataTypeConverterNullSpec: StringSpec({
+
+    val dataTypes = DataTypes()
+
+    "wraps object property in a null wrapper if a null mappings exists" {
+        val openApi = parse("""
+           openapi: 3.0.2
+           info:
+             title: API
+             version: 1.0.0
+           
+           paths:
+             /foo:
+               patch:
+                 requestBody:
+                   content:
+                     application/json:
+                       schema:
+                         ${'$'}ref: '#/components/schemas/Foo'
+                 responses:
+                   '204':
+                     description: empty
+           
+           components:
+             schemas:
+           
+               Foo:
+                 description: a Foo
+                 type: object
+                 properties:
+                   foo:
+                     nullable: true
+                     type: string
+                 
+        """.trimIndent())
+
+
+        val options = ApiOptions()
+        options.typeMappings = listOf(
+            EndpointTypeMapping("/foo", listOf(
+                TypeMapping(
+                    "null",
+                    "org.openapitools.jackson.nullable.JsonNullable"
+                )))
+            )
+
+        val schemaInfo = openApi.getBodySchemaInfo("Foo",
+            "/foo", HttpMethod.PATCH, "application/json")
+
+        // when:
+        val converter = DataTypeConverter(options)
+        val datatype = converter.convert(schemaInfo, dataTypes)
+
+        // then:
+        datatype.shouldBeInstanceOf<ObjectDataType>()
+        val fooDataType = datatype.getObjectProperty("foo")
+        fooDataType.getName().shouldBe("JsonNullable<String>")
+    }
+
+})

src/test/kotlin/io/openapiprocessor/core/support/OpenApiSchema.kt

@@ -43,6 +43,37 @@ fun OpenApi.getSchema(path: String, method: HttpMethod, status: String, mediaTyp
     return media?.getSchema()!!
 }
 
+/**
+ * extracts a specific request body Schema from an [OpenApi] object created by [parse()][parse].
+ *
+ * @param path the endpoint path
+ * @param method the http method
+ * @return the [Schema]
+ */
+fun OpenApi.getBodySchema(path: String, method: HttpMethod, mediaType: String): Schema {
+    val endpoint = this.getPaths()[path]
+    if (endpoint == null) {
+        println("unknown path '$path' !")
+    }
+
+    val operation = endpoint?.getOperations()?.find { it.getMethod() == method }
+    if (operation == null) {
+        println("unknown method '$method' ($path)!")
+    }
+
+    val body = operation?.getRequestBody()
+    if (body == null) {
+        println("no body ($path $method)!")
+    }
+
+    val media = body?.getContent()?.get(mediaType)
+    if (media == null) {
+        println("unknown media type '$mediaType' ($path $method)!")
+    }
+
+    return media?.getSchema()!!
+}
+
 /**
  * extracts a specific response Schema from an [OpenApi] object created by [parse()][parse] and
  * creates a [SchemaInfo] for the schema.
@@ -58,3 +89,19 @@ fun OpenApi.getSchemaInfo(name: String, path: String, method: HttpMethod, status
     val schema = getSchema(path, method, status, mediaType)
     return SchemaInfo(path, name, mediaType, schema, getRefResolver())
 }
+
+/**
+ * extracts a specific body Schema from an [OpenApi] object created by [parse()][parse] and
+ * creates a [SchemaInfo] for the schema.
+ *
+ * @param name name of schema info, i.e the datatype name
+ * @param path the endpoint path
+ * @param method the http method
+ * @return the [SchemaInfo]
+ */
+fun OpenApi.getBodySchemaInfo(name: String, path: String, method: HttpMethod, mediaType: String)
+: SchemaInfo {
+    val schema = getBodySchema(path, method, mediaType)
+    return SchemaInfo(path, path.substring(1).capitalize() + "RequestBody",
+        mediaType, schema, getRefResolver())
+}