Fall back to original schema if correction fails (#210)

for whatever reason. Correcting a previously erased type should be a
best effort and should not block generation of the entire model. Users
may not have always have control over the case classes they feed the
model converter

Author: SamTheisens

src/main/scala/com/github/swagger/scala/converter/SwaggerScalaModelConverter.scala

@@ -209,7 +209,7 @@ class SwaggerScalaModelConverter extends ModelResolver(SwaggerScalaModelConverte
               schemaProperties.get(propertyName).foreach { property =>
                 Option(PrimitiveType.fromType(erasedType)).foreach { primitiveType =>
                   if (isOptional) {
-                    schema.addProperty(propertyName, correctSchema(property, primitiveType))
+                    schema.addProperty(propertyName, tryCorrectSchema(property, primitiveType))
                   }
                   if (isIterable(propertyClass) && !isMap(propertyClass)) {
                     schema.addProperty(propertyName, updateTypeOnItemsSchema(primitiveType, property))
@@ -288,23 +288,26 @@ class SwaggerScalaModelConverter extends ModelResolver(SwaggerScalaModelConverte
   }
 
   private def updateTypeOnItemsSchema(primitiveType: PrimitiveType, propertySchema: Schema[_]) = {
-    val updatedSchema = correctSchema(propertySchema.getItems, primitiveType)
+    val updatedSchema = tryCorrectSchema(propertySchema.getItems, primitiveType)
     propertySchema.setItems(updatedSchema)
     propertySchema
   }
 
-  private def correctSchema(itemSchema: Schema[_], primitiveType: PrimitiveType) = {
-    val primitiveProperty = primitiveType.createProperty()
-    val propAsString = objectMapper.writeValueAsString(itemSchema)
-    val correctedSchema = objectMapper.readValue(propAsString, primitiveProperty.getClass)
-    correctedSchema.setType(primitiveProperty.getType)
-    Option(itemSchema.getFormat) match {
-      case Some(_) =>
-      case _ => correctedSchema.setFormat(primitiveProperty.getFormat)
-    }
-    correctedSchema
+  private[converter] def tryCorrectSchema(itemSchema: Schema[_], primitiveType: PrimitiveType): Schema[_] = {
+    Try {
+      val primitiveProperty = primitiveType.createProperty()
+      val propAsString = objectMapper.writeValueAsString(itemSchema)
+      val correctedSchema = objectMapper.readValue(propAsString, primitiveProperty.getClass)
+      correctedSchema.setType(primitiveProperty.getType)
+      Option(itemSchema.getFormat) match {
+        case Some(_) =>
+        case _ => correctedSchema.setFormat(primitiveProperty.getFormat)
+      }
+      correctedSchema
+    }.toOption.getOrElse(itemSchema)
   }
 
+
   private def getRequiredSettings(annotatedType: AnnotatedType): Seq[Boolean] = annotatedType match {
     case _: AnnotatedTypeForOption => Seq.empty
     case _ => getRequiredSettings(nullSafeSeq(annotatedType.getCtxAnnotations))

src/test/scala/com/github/swagger/scala/converter/ModelPropertyParserTest.scala

@@ -1,7 +1,7 @@
 package com.github.swagger.scala.converter
 
 import io.swagger.v3.core.converter._
-import io.swagger.v3.core.util.Json
+import io.swagger.v3.core.util.{Json, PrimitiveType}
 import io.swagger.v3.oas.models.media._
 import models.NestingObject.{NestedModelWOptionInt, NoProperties}
 import models._
@@ -467,6 +467,20 @@ class ModelPropertyParserTest extends AnyFlatSpec with BeforeAndAfterEach with M
     Json.mapper().writeValueAsString(model.value)
   }
 
+  it should "default to supplied schema if it can't be corrected" in new PropertiesScope[ModelWMapStringCaseClass] {
+    schemas should have size 2
+
+    val mapField = model.value.getProperties.get("maybeMapStringCaseClass")
+    mapField shouldBe a[MapSchema]
+    mapField.getAdditionalProperties shouldBe a[Schema[_]]
+    mapField.getAdditionalProperties.asInstanceOf[Schema[_]].get$ref() shouldBe "#/components/schemas/SomeCaseClass"
+
+
+    val caseClassField = schemas("SomeCaseClass")
+    caseClassField shouldBe a[Schema[_]]
+    caseClassField.getProperties.get("field") shouldBe an[IntegerSchema]
+  }
+
   it should "process Model with Scala Seq" in new PropertiesScope[ModelWSeqString] {
     schemas should have size 1
     val stringsField = model.value.getProperties.get("strings")

src/test/scala/models/ModelWSeqString.scala

@@ -8,4 +8,8 @@ case class ModelWJavaListString(strings: java.util.List[String])
 
 case class ModelWMapString(strings: Map[String, String])
 
+case class SomeCaseClass(field: Int)
+
+case class ModelWMapStringCaseClass(maybeMapStringCaseClass: Option[Map[String, SomeCaseClass]])
+
 case class ModelWJavaMapString(strings: java.util.Map[String, String])