From a6df4e2ab30268584fcef7ae4e6b5e57694d9f5e Mon Sep 17 00:00:00 2001 From: Michael van Tellingen Date: Mon, 26 Jul 2021 14:55:25 +0200 Subject: [PATCH 1/2] Implement generator for generating JSON schemas --- languages/jsonschema/build.gradle | 5 + .../jsonschema/model/JsonSchemaBaseTypes.kt | 20 ++ .../jsonschema/model/JsonSchemaExtensions.kt | 5 + .../jsonschema/model/JsonSchemaModelModule.kt | 20 ++ .../jsonschema/model/JsonSchemaRenderer.kt | 306 ++++++++++++++++++ .../model/JsonSchemaVrapExtensions.kt | 14 + settings.gradle | 1 + tools/cli-application/build.gradle | 1 + .../rmf/codegen/cli/GenerateSubcommand.kt | 9 +- tools/codegen-gradle-plugin/build.gradle | 1 + 10 files changed, 381 insertions(+), 1 deletion(-) create mode 100644 languages/jsonschema/build.gradle create mode 100644 languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaBaseTypes.kt create mode 100644 languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaExtensions.kt create mode 100644 languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaModelModule.kt create mode 100644 languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt create mode 100644 languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaVrapExtensions.kt diff --git a/languages/jsonschema/build.gradle b/languages/jsonschema/build.gradle new file mode 100644 index 000000000..5e2b15cf7 --- /dev/null +++ b/languages/jsonschema/build.gradle @@ -0,0 +1,5 @@ +dependencies { + implementation 'org.json:json:20200518' + implementation project(':codegen-renderers') + implementation orgkotlin.stdlib +} diff --git a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaBaseTypes.kt b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaBaseTypes.kt new file mode 100644 index 000000000..5d082ce1b --- /dev/null +++ b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaBaseTypes.kt @@ -0,0 +1,20 @@ +package io.vrap.codegen.languages.jsonschema.model + +import io.vrap.rmf.codegen.types.LanguageBaseTypes +import io.vrap.rmf.codegen.types.VrapScalarType + +object JsonSchemaBaseTypes : LanguageBaseTypes( + anyType = nativeJsonSchemaType("any"), + objectType = nativeJsonSchemaType("object"), + integerType = nativeJsonSchemaType("integer"), + longType = nativeJsonSchemaType("integer"), + doubleType = nativeJsonSchemaType("number"), + stringType = nativeJsonSchemaType("string"), + booleanType = nativeJsonSchemaType("boolean"), + dateTimeType = nativeJsonSchemaType("date-time"), + dateOnlyType = nativeJsonSchemaType("date"), + timeOnlyType = nativeJsonSchemaType("time"), + file = nativeJsonSchemaType("string") +) + +fun nativeJsonSchemaType(typeName: String): VrapScalarType = VrapScalarType(typeName) diff --git a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaExtensions.kt b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaExtensions.kt new file mode 100644 index 000000000..4b3b0c3be --- /dev/null +++ b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaExtensions.kt @@ -0,0 +1,5 @@ +package io.vrap.codegen.languages.jsonschema.model + +fun create_schema_id (identifier: String): String { + return "https://api.commercetools.com/${identifier}" +} diff --git a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaModelModule.kt b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaModelModule.kt new file mode 100644 index 000000000..3d3d0713a --- /dev/null +++ b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaModelModule.kt @@ -0,0 +1,20 @@ +package io.vrap.codegen.languages.jsonschema.model + +import io.vrap.rmf.codegen.di.RamlGeneratorModule +import io.vrap.rmf.codegen.di.Module +import io.vrap.rmf.codegen.rendering.CodeGenerator +import io.vrap.rmf.codegen.rendering.FileGenerator + +object JsonSchemaModelModule : Module { + override fun configure(generatorModule: RamlGeneratorModule) = setOf( + FileGenerator( + setOf( + + JsonSchemaRenderer( + generatorModule.vrapTypeProvider(), + generatorModule.allAnyTypes() + ) + ) + ) + ) +} diff --git a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt new file mode 100644 index 000000000..eddbb5769 --- /dev/null +++ b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt @@ -0,0 +1,306 @@ +package io.vrap.codegen.languages.jsonschema.model +import io.vrap.codegen.languages.extensions.discriminatorProperty +import io.vrap.codegen.languages.extensions.isPatternProperty +import io.vrap.rmf.codegen.di.AllAnyTypes +import io.vrap.rmf.codegen.io.TemplateFile +import io.vrap.rmf.codegen.rendering.FileProducer +import io.vrap.rmf.codegen.types.VrapEnumType +import io.vrap.rmf.codegen.types.VrapNilType +import io.vrap.rmf.codegen.types.VrapObjectType +import io.vrap.rmf.codegen.types.VrapScalarType +import io.vrap.rmf.codegen.types.VrapType +import io.vrap.rmf.codegen.types.VrapTypeProvider +import io.vrap.rmf.raml.model.types.AnyType +import io.vrap.rmf.raml.model.types.ArrayType +import io.vrap.rmf.raml.model.types.BooleanType +import io.vrap.rmf.raml.model.types.DateOnlyType +import io.vrap.rmf.raml.model.types.DateTimeType +import io.vrap.rmf.raml.model.types.IntegerType +import io.vrap.rmf.raml.model.types.NumberType +import io.vrap.rmf.raml.model.types.ObjectType +import io.vrap.rmf.raml.model.types.Property +import io.vrap.rmf.raml.model.types.StringInstance +import io.vrap.rmf.raml.model.types.StringType +import io.vrap.rmf.raml.model.types.TimeOnlyType +import org.eclipse.emf.ecore.EObject +import org.json.JSONObject + + +class JsonSchemaRenderer constructor( + val vrapTypeProvider: VrapTypeProvider, + @AllAnyTypes var allAnyTypes: List +) : FileProducer { + + override fun produceFiles(): List { + var produced = allAnyTypes + .map { + when (it) { + is ObjectType -> createObjectSchema(it) + is StringType -> createStringSchema(it) + else -> null + } + } + .filterNotNull() + .toList() + + return produced + } + + private fun createObjectSchema(type: ObjectType): TemplateFile { + val schema = LinkedHashMap() + + schema.put("${"$"}schema", "http://json-schema.org/draft/2020-12/schema") + schema.put("${"$"}id", create_schema_id(type.filename())) + schema.put("title", type.name) + if (type.description != null) { + schema.put("description", type.description.value.trim()) + } + schema.put("type", "object") + + val obj = LinkedHashMap() + obj.put("properties", type.getObjectProperties()) + + val patterns = type.getPatternProperties() + if (!patterns.isNullOrEmpty()) { + obj.put("patternProperties", patterns) + } + + val required = type.getRequiredPropertyNames() + if (!required.isNullOrEmpty()) { + obj.put("required", required) + } + + obj.put("additionalProperties", false) + + val discriminatorProperty = type.discriminatorProperty() + if (discriminatorProperty != null && type.discriminatorValue.isNullOrEmpty()) { + schema.put( + "discriminator", + mapOf( + "propertyName" to discriminatorProperty.name + ) + ) + schema.put( + "oneOf", + allAnyTypes.getTypeInheritance(type) + .filterIsInstance() + .map { + mapOf("${"$"}ref" to create_schema_id(it.filename())) + } + ) + } + + obj.forEach { (key, value) -> schema.put(key, value) } + + return TemplateFile(JSONObject(schema).toString(2), type.filename()) + } + + private fun createStringSchema(type: StringType): TemplateFile? { + val vrap = type.toVrapType() + if (vrap !is VrapEnumType) { + return null + } + + val schema = mutableMapOf( + "${"$"}schema" to "http://json-schema.org/draft-07/schema#", + "${"$"}id" to create_schema_id(type.filename()), + "title" to type.name, + "type" to "string", + "enum" to type.enumValues() + ) + + if (type.description != null) { + schema.put("description", type.description.value.trim()) + } + return TemplateFile(JSONObject(schema).toString(2), type.filename()) + } + + private fun ObjectType.getObjectProperties(): LinkedHashMap { + val result = LinkedHashMap() + this.allProperties + .filter { + !it.isPatternProperty() + } + .forEach { + result.put(it.name, it.type.toSchemaProperty(this, it)) + } + return result + } + + private fun ObjectType.getPatternProperties(): LinkedHashMap { + val result = LinkedHashMap() + this.allProperties + .filter { + it.isPatternProperty() + } + .forEach { + result.put(it.name.trim('/'), it.type.toSchemaProperty(this, it)) + } + return result + } + + private fun ObjectType.getRequiredPropertyNames(): List { + return this.allProperties + .filter { + !it.isPatternProperty() && it.required + } + .map { + it.name + } + } + + private fun AnyType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + + if (parent.discriminatorValue != null && parent.discriminatorProperty() == property) { + return mapOf( + "enum" to listOf(parent.discriminatorValue) + ) + } + + val vrap = this.toVrapType() + + if (vrap is VrapEnumType && this is StringType) { + return mapOf( + "${"$"}ref" to vrap.filename() + ) + } + + return when (this) { + is ObjectType -> this.toSchemaProperty(parent, property) + is ArrayType -> this.toSchemaProperty(parent, property) + is StringType -> this.toSchemaProperty(parent, property) + is NumberType -> this.toSchemaProperty(parent, property) + is BooleanType -> this.toSchemaProperty(parent, property) + is DateTimeType -> this.toSchemaProperty(parent, property) + is IntegerType -> this.toSchemaProperty(parent, property) + is AnyType -> mapOf( + "type" to listOf("number", "string", "boolean", "object", "array", "null") + ) + else -> { + println("Missing case for " + this + property) + + return mapOf( + "type" to listOf("number", "string", "boolean", "object", "array", "null") + ) + } + } + } + + private fun ObjectType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + + val dProperty = this.discriminatorProperty() + if (dProperty != null && !this.discriminatorValue.isNullOrEmpty()) { + return mapOf( + "${"$"}ref" to this.filename() + ) + } + + if (this.toVrapType() !is VrapObjectType) { + // println(this.properties) + return mapOf( + "type" to "object" + ) + } else { + return mapOf( + "${"$"}ref" to this.filename() + ) + } + } + + private fun StringType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + val vrapType = this.toVrapType() + if (vrapType !is VrapScalarType) { + throw Exception("Expected scalar") + } + val result = when (vrapType.scalarType) { + "any" -> mapOf( + "type" to listOf("number", "string", "boolean", "object", "array", "null") + ) + else -> mapOf( + "type" to vrapType.scalarType + ) + } + return result + } + + private fun IntegerType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + "type" to "number", + "format" to "integer" + ) + + private fun BooleanType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + "type" to "boolean" + ) + + private fun DateTimeType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + "type" to "string", + "format" to "date-time" + ) + + private fun DateOnlyType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + "type" to "string", + "format" to "date" + ) + + private fun TimeOnlyType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + "type" to "string", + "format" to "time" + ) + + private fun NumberType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + "type" to "number" + ) + + private fun ArrayType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + return mapOf( + "type" to "array", + "items" to this.items.toSchemaProperty(parent, property) + ) + } + + private fun Property.isPatternProperty() = this.name.startsWith("/") && this.name.endsWith("/") + + fun EObject?.toVrapType(): VrapType { + val vrapType = if (this != null) vrapTypeProvider.doSwitch(this) else VrapNilType() + return vrapType + } + + fun ObjectType.filename(): String { + val type = this.toVrapType() + if (type !is VrapObjectType) { + return "unknown.json" + } + return type.filename() + } + + fun StringType.filename(): String { + val type = this.toVrapType() + if (type !is VrapEnumType) { + return "unknown.json" + } + return type.filename() + } + + fun VrapObjectType.filename(): String { + return this.simpleClassName + ".schema.json" + } + + fun VrapEnumType.filename(): String { + return this.simpleClassName + "Enum.schema.json" + } + + fun List.getTypeInheritance(type: AnyType): List { + return this + .filter { it.type != null && it.type.name == type.name } + // TODO: Shouldn't this be necessary? + // .plus( + // this + // .filter { it.type != null && it.type.name == type.name } + // .flatMap { this.getTypeInheritance(it.type) } + // ) + } + + fun StringType.enumValues(): List = enum.filterIsInstance() + .map { it.value } + .filterNotNull() +} diff --git a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaVrapExtensions.kt b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaVrapExtensions.kt new file mode 100644 index 000000000..a4cd22875 --- /dev/null +++ b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaVrapExtensions.kt @@ -0,0 +1,14 @@ +package io.vrap.codegen.languages.jsonschema.model + +import io.vrap.rmf.codegen.types.* + +fun VrapType.simpleTypeName(): String { + return when (this) { + is VrapAnyType -> this.baseType + is VrapScalarType -> this.scalarType + is VrapEnumType -> this.simpleClassName + is VrapObjectType -> this.simpleClassName + is VrapArrayType -> "${this.itemType.simpleTypeName()}[]" + is VrapNilType -> this.name + } +} diff --git a/settings.gradle b/settings.gradle index d3b9541a7..0da696fb5 100644 --- a/settings.gradle +++ b/settings.gradle @@ -11,6 +11,7 @@ include 'languages:postman' include 'languages:typescript' include 'languages:python' include 'languages:go' +include 'languages:jsonschema' include 'languages:ramldoc' include 'ctp-validators' diff --git a/tools/cli-application/build.gradle b/tools/cli-application/build.gradle index 39cf6fa16..fb57fb151 100644 --- a/tools/cli-application/build.gradle +++ b/tools/cli-application/build.gradle @@ -79,6 +79,7 @@ String dir = "${buildDir.toString()}/gensrc/main/kotlin/io/vrap/rmf/codegen/cli/ dependencies { implementation project(':languages:javalang:builder-renderer:java-builder-client') + implementation project(':languages:jsonschema') implementation project(':languages:typescript') implementation project(':languages:postman') implementation project(':languages:python') diff --git a/tools/cli-application/src/main/kotlin/io/vrap/rmf/codegen/cli/GenerateSubcommand.kt b/tools/cli-application/src/main/kotlin/io/vrap/rmf/codegen/cli/GenerateSubcommand.kt index d9535e09e..a6c05a6f5 100644 --- a/tools/cli-application/src/main/kotlin/io/vrap/rmf/codegen/cli/GenerateSubcommand.kt +++ b/tools/cli-application/src/main/kotlin/io/vrap/rmf/codegen/cli/GenerateSubcommand.kt @@ -32,6 +32,8 @@ import io.vrap.codegen.languages.typescript.test.TypescriptTestModule import io.vrap.codegen.languages.go.GoBaseTypes import io.vrap.codegen.languages.go.model.GoModelModule import io.vrap.codegen.languages.go.client.GoClientModule +import io.vrap.codegen.languages.jsonschema.model.JsonSchemaBaseTypes +import io.vrap.codegen.languages.jsonschema.model.JsonSchemaModelModule import io.vrap.rmf.codegen.CodeGeneratorConfig import io.vrap.rmf.codegen.di.* import io.vrap.rmf.codegen.toSeconds @@ -66,8 +68,9 @@ enum class GenerationTarget { CSHARP_TEST, OAS, PYTHON_CLIENT, + JSON_SCHEMA, } -const val ValidTargets = "JAVA_CLIENT, JAVA_TEST, TYPESCRIPT_CLIENT, TYPESCRIPT_TEST, CSHARP_CLIENT, CSHARP_TEST, PHP_CLIENT, PHP_BASE, PHP_TEST, POSTMAN, RAML_DOC, OAS, PYTHON_CLIENT" +const val ValidTargets = "JAVA_CLIENT, JAVA_TEST, TYPESCRIPT_CLIENT, TYPESCRIPT_TEST, CSHARP_CLIENT, CSHARP_TEST, PHP_CLIENT, PHP_BASE, PHP_TEST, POSTMAN, RAML_DOC, OAS, PYTHON_CLIENT, JSON_SCHEMA" @CommandLine.Command(name = "generate",description = ["Generate source code from a RAML specification."]) class GenerateSubcommand : Callable { @@ -268,6 +271,10 @@ class GenerateSubcommand : Callable { val generatorModule = RamlGeneratorModule(apiProvider, generatorConfig, GoBaseTypes) RamlGeneratorComponent(generatorModule, GoModelModule, GoClientModule) } + GenerationTarget.JSON_SCHEMA -> { + val generatorModule = RamlGeneratorModule(apiProvider, generatorConfig, JsonSchemaBaseTypes) + RamlGeneratorComponent(generatorModule, JsonSchemaModelModule) + } } } else { val apiProvider = OasProvider(fileLocation) diff --git a/tools/codegen-gradle-plugin/build.gradle b/tools/codegen-gradle-plugin/build.gradle index a689f8b84..25038399f 100644 --- a/tools/codegen-gradle-plugin/build.gradle +++ b/tools/codegen-gradle-plugin/build.gradle @@ -6,6 +6,7 @@ apply plugin: 'com.github.johnrengelman.shadow' dependencies { implementation project(':languages:javalang:java-renderer') implementation project(':languages:javalang:builder-renderer:java-builder-client') + implementation project(':languages:jsonschema') implementation project(':languages:typescript') implementation project(':languages:postman') implementation project(':languages:python') From afbbd9cf8d489c3e76c40f858ca17b74ffb61605 Mon Sep 17 00:00:00 2001 From: Michael van Tellingen Date: Fri, 29 Jul 2022 11:17:07 +0200 Subject: [PATCH 2/2] Update to generate validate draft 2020-12 schema --- .../jsonschema/model/JsonSchemaRenderer.kt | 67 ++++++++++++------- 1 file changed, 41 insertions(+), 26 deletions(-) diff --git a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt index eddbb5769..c646554e8 100644 --- a/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt +++ b/languages/jsonschema/src/main/kotlin/io/vrap/codegen/languages/jsonschema/model/JsonSchemaRenderer.kt @@ -47,33 +47,35 @@ class JsonSchemaRenderer constructor( } private fun createObjectSchema(type: ObjectType): TemplateFile { - val schema = LinkedHashMap() + val schema = linkedMapOf( + "${"$"}schema" to "https://json-schema.org/draft/2020-12/schema#", + "${"$"}id" to create_schema_id(type.filename()), + "title" to type.name, + "type" to "object", + ) - schema.put("${"$"}schema", "http://json-schema.org/draft/2020-12/schema") - schema.put("${"$"}id", create_schema_id(type.filename())) - schema.put("title", type.name) if (type.description != null) { schema.put("description", type.description.value.trim()) } - schema.put("type", "object") val obj = LinkedHashMap() - obj.put("properties", type.getObjectProperties()) + schema.put("properties", type.getObjectProperties()) val patterns = type.getPatternProperties() if (!patterns.isNullOrEmpty()) { - obj.put("patternProperties", patterns) + schema.put("patternProperties", patterns) } val required = type.getRequiredPropertyNames() if (!required.isNullOrEmpty()) { - obj.put("required", required) + schema.put("required", required) } - obj.put("additionalProperties", false) + schema.put("additionalProperties", false) val discriminatorProperty = type.discriminatorProperty() if (discriminatorProperty != null && type.discriminatorValue.isNullOrEmpty()) { + schema.put( "discriminator", mapOf( @@ -90,7 +92,7 @@ class JsonSchemaRenderer constructor( ) } - obj.forEach { (key, value) -> schema.put(key, value) } + // obj.forEach { (key, value) -> schema.put(key, value) } return TemplateFile(JSONObject(schema).toString(2), type.filename()) } @@ -102,7 +104,7 @@ class JsonSchemaRenderer constructor( } val schema = mutableMapOf( - "${"$"}schema" to "http://json-schema.org/draft-07/schema#", + "${"$"}schema" to "https://json-schema.org/draft/2020-12/schema#", "${"$"}id" to create_schema_id(type.filename()), "title" to type.name, "type" to "string", @@ -142,18 +144,32 @@ class JsonSchemaRenderer constructor( private fun ObjectType.getRequiredPropertyNames(): List { return this.allProperties .filter { - !it.isPatternProperty() && it.required + !it.isPatternProperty() && (it.required || this.discriminatorProperty() == it) } .map { it.name } } - private fun AnyType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + private fun AnyType.toSchemaProperty(parent: ObjectType, property: Property): Map { + + if ( parent.discriminatorProperty() == property) { + var subTypes = if (property.type != null) { + allAnyTypes.getTypeInheritance(parent) + .filterIsInstance() + .map { + it.discriminatorValue + } + } else { + listOf() + } + + if (parent.discriminatorValue != null) { + subTypes = subTypes.plus(parent.discriminatorValue) + } - if (parent.discriminatorValue != null && parent.discriminatorProperty() == property) { return mapOf( - "enum" to listOf(parent.discriminatorValue) + "enum" to subTypes ) } @@ -186,7 +202,7 @@ class JsonSchemaRenderer constructor( } } - private fun ObjectType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + private fun ObjectType.toSchemaProperty(parent: ObjectType, property: Property): Map { val dProperty = this.discriminatorProperty() if (dProperty != null && !this.discriminatorValue.isNullOrEmpty()) { @@ -196,7 +212,6 @@ class JsonSchemaRenderer constructor( } if (this.toVrapType() !is VrapObjectType) { - // println(this.properties) return mapOf( "type" to "object" ) @@ -207,7 +222,7 @@ class JsonSchemaRenderer constructor( } } - private fun StringType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + private fun StringType.toSchemaProperty(parent: ObjectType, property: Property): Map { val vrapType = this.toVrapType() if (vrapType !is VrapScalarType) { throw Exception("Expected scalar") @@ -223,35 +238,35 @@ class JsonSchemaRenderer constructor( return result } - private fun IntegerType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + private fun IntegerType.toSchemaProperty(parent: ObjectType, property: Property) = mapOf( "type" to "number", - "format" to "integer" + // "format" to "integer" ) - private fun BooleanType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + private fun BooleanType.toSchemaProperty(parent: ObjectType, property: Property) = mapOf( "type" to "boolean" ) - private fun DateTimeType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + private fun DateTimeType.toSchemaProperty(parent: ObjectType, property: Property) = mapOf( "type" to "string", "format" to "date-time" ) - private fun DateOnlyType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + private fun DateOnlyType.toSchemaProperty(parent: ObjectType, property: Property) = mapOf( "type" to "string", "format" to "date" ) - private fun TimeOnlyType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + private fun TimeOnlyType.toSchemaProperty(parent: ObjectType, property: Property) = mapOf( "type" to "string", "format" to "time" ) - private fun NumberType.toSchemaProperty(parent: ObjectType, property: Property?) = mapOf( + private fun NumberType.toSchemaProperty(parent: ObjectType, property: Property) = mapOf( "type" to "number" ) - private fun ArrayType.toSchemaProperty(parent: ObjectType, property: Property?): Map { + private fun ArrayType.toSchemaProperty(parent: ObjectType, property: Property): Map { return mapOf( "type" to "array", "items" to this.items.toSchemaProperty(parent, property)