diff --git a/README.md b/README.md index 7dcc25c1..78190c29 100644 --- a/README.md +++ b/README.md @@ -61,6 +61,7 @@ Include in your `pom.xml`: * generateExamples: generate example objects for the model, based on example and default values (default `false`) * generateAuthentication: generate Àuthentication into controller interfaces if response code 401 is present (default `false`) * sealed: generate sealed interfaces (default `true`) +* record: generate records instead of pojos (default `false`) For examples see [integration tests](src/it). diff --git a/gen/main/java/testmodel/micronaut_record/AdditionalPropertiesModel.java b/gen/main/java/testmodel/micronaut_record/AdditionalPropertiesModel.java new file mode 100644 index 00000000..9342a0b1 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/AdditionalPropertiesModel.java @@ -0,0 +1,12 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record AdditionalPropertiesModel( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ID) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String id) { + + public static final java.lang.String JSON_PROPERTY_ID = "id"; +} diff --git a/gen/main/java/testmodel/micronaut_record/AdditionalPropertiesModelValue.java b/gen/main/java/testmodel/micronaut_record/AdditionalPropertiesModelValue.java new file mode 100644 index 00000000..2d9dd248 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/AdditionalPropertiesModelValue.java @@ -0,0 +1,9 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.DEDUCTION, visible = true) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = PropertyTypeOne.class), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = PropertyTypeTwo.class) +}) +public sealed interface AdditionalPropertiesModelValue permits PropertyTypeOne, PropertyTypeTwo {} diff --git a/gen/main/java/testmodel/micronaut_record/EnumerationInteger.java b/gen/main/java/testmodel/micronaut_record/EnumerationInteger.java new file mode 100644 index 00000000..2583e23a --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/EnumerationInteger.java @@ -0,0 +1,40 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +public enum EnumerationInteger { + + NUMBER_MINUS_2147483648(-2147483648), + NUMBER_MINUS_1(-1), + NUMBER_0(0), + NUMBER_1(1), + NUMBER_2147483647(2147483647); + + public static final java.lang.Integer NUMBER_MINUS_2147483648_VALUE = -2147483648; + public static final java.lang.Integer NUMBER_MINUS_1_VALUE = -1; + public static final java.lang.Integer NUMBER_0_VALUE = 0; + public static final java.lang.Integer NUMBER_1_VALUE = 1; + public static final java.lang.Integer NUMBER_2147483647_VALUE = 2147483647; + + private final java.lang.Integer value; + + private EnumerationInteger(java.lang.Integer value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static EnumerationInteger toEnum(java.lang.Integer value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.Integer value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.Integer getValue() { + return value; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/EnumerationModel.java b/gen/main/java/testmodel/micronaut_record/EnumerationModel.java new file mode 100644 index 00000000..f128edc8 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/EnumerationModel.java @@ -0,0 +1,91 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record EnumerationModel( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_STRING) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + EnumerationString string, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_STRING_DEFAULT) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + EnumerationStringDefault stringDefault, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_EMBEDDED) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + Embedded embedded, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_EMBEDDED_DEFAULT) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + EmbeddedDefault embeddedDefault) { + + public static final java.lang.String JSON_PROPERTY_STRING = "string"; + public static final java.lang.String JSON_PROPERTY_STRING_DEFAULT = "string-default"; + public static final java.lang.String JSON_PROPERTY_EMBEDDED = "embedded"; + public static final java.lang.String JSON_PROPERTY_EMBEDDED_DEFAULT = "embedded-default"; + +public enum Embedded { + + FIRST("first"), + SECOND("second"); + + public static final java.lang.String FIRST_VALUE = "first"; + public static final java.lang.String SECOND_VALUE = "second"; + + private final java.lang.String value; + + private Embedded(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static Embedded toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} + +public enum EmbeddedDefault { + + THREE("three"), + FOUR("four"); + + public static final java.lang.String THREE_VALUE = "three"; + public static final java.lang.String FOUR_VALUE = "four"; + + private final java.lang.String value; + + private EmbeddedDefault(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static EmbeddedDefault toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} +} diff --git a/gen/main/java/testmodel/micronaut_record/EnumerationNumber.java b/gen/main/java/testmodel/micronaut_record/EnumerationNumber.java new file mode 100644 index 00000000..847e5525 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/EnumerationNumber.java @@ -0,0 +1,36 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +public enum EnumerationNumber { + + NUMBER_MINUS_1(-1D), + NUMBER_0(0D), + NUMBER_1(1D); + + public static final java.lang.Double NUMBER_MINUS_1_VALUE = -1D; + public static final java.lang.Double NUMBER_0_VALUE = 0D; + public static final java.lang.Double NUMBER_1_VALUE = 1D; + + private final java.lang.Double value; + + private EnumerationNumber(java.lang.Double value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static EnumerationNumber toEnum(java.lang.Double value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.Double value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.Double getValue() { + return value; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/EnumerationString.java b/gen/main/java/testmodel/micronaut_record/EnumerationString.java new file mode 100644 index 00000000..8f559d4d --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/EnumerationString.java @@ -0,0 +1,34 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +public enum EnumerationString { + + ONE("one"), + TWO("two"); + + public static final java.lang.String ONE_VALUE = "one"; + public static final java.lang.String TWO_VALUE = "two"; + + private final java.lang.String value; + + private EnumerationString(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static EnumerationString toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/EnumerationStringDefault.java b/gen/main/java/testmodel/micronaut_record/EnumerationStringDefault.java new file mode 100644 index 00000000..76c8bbaa --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/EnumerationStringDefault.java @@ -0,0 +1,34 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +public enum EnumerationStringDefault { + + THREE("three"), + FOUR("four"); + + public static final java.lang.String THREE_VALUE = "three"; + public static final java.lang.String FOUR_VALUE = "four"; + + private final java.lang.String value; + + private EnumerationStringDefault(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static EnumerationStringDefault toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/FirstModel.java b/gen/main/java/testmodel/micronaut_record/FirstModel.java new file mode 100644 index 00000000..73f3763b --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/FirstModel.java @@ -0,0 +1,23 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record FirstModel( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_TYPE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String type, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_FIRST) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String first, + + @jakarta.validation.Valid + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_SECOND_LEVEL) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + SecondLevelModel secondLevel) implements OneOfModel { + + public static final java.lang.String JSON_PROPERTY_TYPE = "type"; + public static final java.lang.String JSON_PROPERTY_FIRST = "first"; + public static final java.lang.String JSON_PROPERTY_SECOND_LEVEL = "secondLevel"; +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceExtended.java b/gen/main/java/testmodel/micronaut_record/InheritanceExtended.java new file mode 100644 index 00000000..900ba162 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceExtended.java @@ -0,0 +1,18 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceExtended( + + @jakarta.validation.constraints.NotNull + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_FOO) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.lang.String foo, + + @jakarta.validation.constraints.NotNull + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_BAR) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.lang.String bar) implements InheritanceSimple { + + public static final java.lang.String JSON_PROPERTY_BAR = "bar"; +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceSimple.java b/gen/main/java/testmodel/micronaut_record/InheritanceSimple.java new file mode 100644 index 00000000..814f27b0 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceSimple.java @@ -0,0 +1,13 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.databind.annotation.JsonDeserialize(as = InheritanceSimpleDefault.class) +public sealed interface InheritanceSimple permits InheritanceExtended, InheritanceSimpleDefault { + + java.lang.String JSON_PROPERTY_FOO = "foo"; + + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_FOO) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.lang.String foo(); +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceSimpleDefault.java b/gen/main/java/testmodel/micronaut_record/InheritanceSimpleDefault.java new file mode 100644 index 00000000..e5f93d2d --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceSimpleDefault.java @@ -0,0 +1,12 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceSimpleDefault( + + @jakarta.validation.constraints.NotNull + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_FOO) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.lang.String foo) implements InheritanceSimple { + +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType.java new file mode 100644 index 00000000..dacb2a82 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType.java @@ -0,0 +1,16 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.NAME, include = com.fasterxml.jackson.annotation.JsonTypeInfo.As.EXISTING_PROPERTY, property = InheritanceWithEnumType.JSON_DISCRIMINATOR) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithEnumType1.class, name = "Inheritance1"), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithEnumType2.class, name = "Inheritance2"), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithEnumType3.class, name = "Inheritance3") +}) +public sealed interface InheritanceWithEnumType permits InheritanceWithEnumType1, InheritanceWithEnumType2, InheritanceWithEnumType3 { + + java.lang.String JSON_DISCRIMINATOR = "type"; + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_DISCRIMINATOR) + InheritanceWithEnumTypeEnum type(); +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType1.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType1.java new file mode 100644 index 00000000..33be17f4 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType1.java @@ -0,0 +1,17 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithEnumType1( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_D) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String d) implements InheritanceWithEnumType { + + public static final java.lang.String JSON_PROPERTY_D = "d"; + + @Override + public InheritanceWithEnumTypeEnum type() { + return InheritanceWithEnumTypeEnum.INHERITANCE1; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType2.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType2.java new file mode 100644 index 00000000..f9fb9fb5 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType2.java @@ -0,0 +1,17 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithEnumType2( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_E) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String e) implements InheritanceWithEnumType { + + public static final java.lang.String JSON_PROPERTY_E = "e"; + + @Override + public InheritanceWithEnumTypeEnum type() { + return InheritanceWithEnumTypeEnum.INHERITANCE2; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType3.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType3.java new file mode 100644 index 00000000..116deb56 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumType3.java @@ -0,0 +1,12 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithEnumType3() implements InheritanceWithEnumType { + + + @Override + public InheritanceWithEnumTypeEnum type() { + return InheritanceWithEnumTypeEnum.INHERITANCE3; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumTypeEnum.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumTypeEnum.java new file mode 100644 index 00000000..c5355497 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithEnumTypeEnum.java @@ -0,0 +1,36 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +public enum InheritanceWithEnumTypeEnum { + + INHERITANCE1("Inheritance1"), + INHERITANCE2("Inheritance2"), + INHERITANCE3("Inheritance3"); + + public static final java.lang.String INHERITANCE1_VALUE = "Inheritance1"; + public static final java.lang.String INHERITANCE2_VALUE = "Inheritance2"; + public static final java.lang.String INHERITANCE3_VALUE = "Inheritance3"; + + private final java.lang.String value; + + private InheritanceWithEnumTypeEnum(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static InheritanceWithEnumTypeEnum toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType.java new file mode 100644 index 00000000..c83c6bf0 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType.java @@ -0,0 +1,21 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.NAME, include = com.fasterxml.jackson.annotation.JsonTypeInfo.As.EXISTING_PROPERTY, property = InheritanceWithStringType.JSON_DISCRIMINATOR) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithStringType1.class, name = "Inheritance1"), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithStringType2.class, name = "Inheritance2") +}) +public sealed interface InheritanceWithStringType permits InheritanceWithStringType1, InheritanceWithStringType2 { + + java.lang.String JSON_DISCRIMINATOR = "type"; + java.lang.String JSON_PROPERTY_A = "a"; + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_DISCRIMINATOR) + java.lang.String type(); + + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_A) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String a(); +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType1.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType1.java new file mode 100644 index 00000000..4de519cd --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType1.java @@ -0,0 +1,21 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithStringType1( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_A) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String a, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_B) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String b) implements InheritanceWithStringType { + + public static final java.lang.String JSON_PROPERTY_B = "b"; + + @Override + public java.lang.String type() { + return "Inheritance1"; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType2.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType2.java new file mode 100644 index 00000000..551e8b25 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithStringType2.java @@ -0,0 +1,21 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithStringType2( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_A) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String a, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_C) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String c) implements InheritanceWithStringType { + + public static final java.lang.String JSON_PROPERTY_C = "c"; + + @Override + public java.lang.String type() { + return "Inheritance2"; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType.java new file mode 100644 index 00000000..30e7c78e --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType.java @@ -0,0 +1,21 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.NAME, include = com.fasterxml.jackson.annotation.JsonTypeInfo.As.EXISTING_PROPERTY, property = InheritanceWithoutType.JSON_DISCRIMINATOR) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithoutType1.class, name = "Inheritance1"), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = InheritanceWithoutType2.class, name = "Inheritance2") +}) +public sealed interface InheritanceWithoutType permits InheritanceWithoutType1, InheritanceWithoutType2 { + + java.lang.String JSON_DISCRIMINATOR = "type"; + java.lang.String JSON_PROPERTY_E = "e"; + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_DISCRIMINATOR) + java.lang.String type(); + + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_E) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String e(); +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType1.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType1.java new file mode 100644 index 00000000..b21f5694 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType1.java @@ -0,0 +1,21 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithoutType1( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_E) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String e, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_F) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String f) implements InheritanceWithoutType { + + public static final java.lang.String JSON_PROPERTY_F = "f"; + + @Override + public java.lang.String type() { + return "Inheritance1"; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType2.java b/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType2.java new file mode 100644 index 00000000..c5188c18 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/InheritanceWithoutType2.java @@ -0,0 +1,21 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record InheritanceWithoutType2( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_E) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String e, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_G) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String g) implements InheritanceWithoutType { + + public static final java.lang.String JSON_PROPERTY_G = "g"; + + @Override + public java.lang.String type() { + return "Inheritance2"; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/Model.java b/gen/main/java/testmodel/micronaut_record/Model.java new file mode 100644 index 00000000..dc42131b --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/Model.java @@ -0,0 +1,168 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record Model( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ID) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Integer id, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ID_WITH_EXAMPLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Integer idWithExample, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ID_WITH_DEFAULT) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Integer idWithDefault, + + @jakarta.validation.constraints.NotNull + @jakarta.validation.constraints.Size(max = 36) + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NAME) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.lang.String name, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NAME_WITH_EXAMPLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String nameWithExample, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NAME_WITH_DEFAULT) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String nameWithDefault, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DATE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.time.LocalDate date, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DATE_WITH_EXAMPLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.time.LocalDate dateWithExample, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DATE_TIME) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.time.Instant dateTime, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DATE_TIME_WITH_EXAMPLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.time.Instant dateTimeWithExample, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NUMBER) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Double number, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_BINARY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + byte[] binary, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_BYTES) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + byte[] bytes, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ANY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_ABSENT) + java.lang.Object any, + + @jakarta.validation.constraints.NotNull + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ARRAY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.util.List array, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ARRAY_WITH_EXAMPLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.util.List arrayWithExample, + + @jakarta.validation.constraints.NotNull + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_SET) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.util.Set set, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_SET_WITH_EXAMPLES) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.util.Set setWithExamples, + + @jakarta.validation.constraints.NotNull + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_MAP) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS) + java.util.Map map, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_MAP_WITH_EXAMPLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.util.Map mapWithExample, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_OPTIONAL_ARRAY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.util.List optionalArray, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_OPTIONAL_SET) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.util.Set optionalSet, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_OPTIONAL_MAP) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.util.Map optionalMap, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NULLABLE_STRING) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_ABSENT) + java.lang.String nullableString, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NULLABLE_ARRAY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_ABSENT) + java.util.List nullableArray, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_NULLABLE_SET) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_ABSENT) + java.util.Set nullableSet, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DEFAULT_STRING) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String defaultString, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DEFAULT_INTEGER) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Integer defaultInteger, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DEFAULT_LONG) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Long defaultLong, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_DEFAULT_NULLABLE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_ABSENT) + java.lang.String defaultNullable, + + @jakarta.validation.Valid + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_REFERENED_MODEL) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + EnumerationModel referenedModel) { + + public static final java.lang.String JSON_PROPERTY_ID = "id"; + public static final java.lang.String JSON_PROPERTY_ID_WITH_EXAMPLE = "idWithExample"; + public static final java.lang.String JSON_PROPERTY_ID_WITH_DEFAULT = "idWithDefault"; + public static final java.lang.String JSON_PROPERTY_NAME = "name"; + public static final java.lang.String JSON_PROPERTY_NAME_WITH_EXAMPLE = "nameWithExample"; + public static final java.lang.String JSON_PROPERTY_NAME_WITH_DEFAULT = "nameWithDefault"; + public static final java.lang.String JSON_PROPERTY_DATE = "date"; + public static final java.lang.String JSON_PROPERTY_DATE_WITH_EXAMPLE = "dateWithExample"; + public static final java.lang.String JSON_PROPERTY_DATE_TIME = "date-time"; + public static final java.lang.String JSON_PROPERTY_DATE_TIME_WITH_EXAMPLE = "date-timeWithExample"; + public static final java.lang.String JSON_PROPERTY_NUMBER = "number"; + public static final java.lang.String JSON_PROPERTY_BINARY = "binary"; + public static final java.lang.String JSON_PROPERTY_BYTES = "bytes"; + public static final java.lang.String JSON_PROPERTY_ANY = "any"; + public static final java.lang.String JSON_PROPERTY_ARRAY = "array"; + public static final java.lang.String JSON_PROPERTY_ARRAY_WITH_EXAMPLE = "arrayWithExample"; + public static final java.lang.String JSON_PROPERTY_SET = "set"; + public static final java.lang.String JSON_PROPERTY_SET_WITH_EXAMPLES = "setWithExamples"; + public static final java.lang.String JSON_PROPERTY_MAP = "map"; + public static final java.lang.String JSON_PROPERTY_MAP_WITH_EXAMPLE = "mapWithExample"; + public static final java.lang.String JSON_PROPERTY_OPTIONAL_ARRAY = "optionalArray"; + public static final java.lang.String JSON_PROPERTY_OPTIONAL_SET = "optionalSet"; + public static final java.lang.String JSON_PROPERTY_OPTIONAL_MAP = "optionalMap"; + public static final java.lang.String JSON_PROPERTY_NULLABLE_STRING = "nullableString"; + public static final java.lang.String JSON_PROPERTY_NULLABLE_ARRAY = "nullableArray"; + public static final java.lang.String JSON_PROPERTY_NULLABLE_SET = "nullableSet"; + public static final java.lang.String JSON_PROPERTY_DEFAULT_STRING = "defaultString"; + public static final java.lang.String JSON_PROPERTY_DEFAULT_INTEGER = "defaultInteger"; + public static final java.lang.String JSON_PROPERTY_DEFAULT_LONG = "defaultLong"; + public static final java.lang.String JSON_PROPERTY_DEFAULT_NULLABLE = "defaultNullable"; + public static final java.lang.String JSON_PROPERTY_REFERENED_MODEL = "referenedModel"; +} diff --git a/gen/main/java/testmodel/micronaut_record/OneOfImplementor1.java b/gen/main/java/testmodel/micronaut_record/OneOfImplementor1.java new file mode 100644 index 00000000..0ad3a4b0 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/OneOfImplementor1.java @@ -0,0 +1,17 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record OneOfImplementor1( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_PROPERTY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String property) implements OneOfInterface { + + public static final java.lang.String JSON_PROPERTY_PROPERTY = "property"; + + @Override + public java.lang.String type() { + return "Implementation1"; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/OneOfImplementor2.java b/gen/main/java/testmodel/micronaut_record/OneOfImplementor2.java new file mode 100644 index 00000000..3ec443e0 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/OneOfImplementor2.java @@ -0,0 +1,17 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record OneOfImplementor2( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_PROPERTY) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.Double property) implements OneOfInterface { + + public static final java.lang.String JSON_PROPERTY_PROPERTY = "property"; + + @Override + public java.lang.String type() { + return "Implementation2"; + } +} diff --git a/gen/main/java/testmodel/micronaut_record/OneOfInterface.java b/gen/main/java/testmodel/micronaut_record/OneOfInterface.java new file mode 100644 index 00000000..56531ca7 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/OneOfInterface.java @@ -0,0 +1,15 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.NAME, include = com.fasterxml.jackson.annotation.JsonTypeInfo.As.EXISTING_PROPERTY, property = OneOfInterface.JSON_DISCRIMINATOR) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = OneOfImplementor1.class, name = "Implementation1"), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = OneOfImplementor2.class, name = "Implementation2"), +}) +public sealed interface OneOfInterface permits OneOfImplementor1, OneOfImplementor2 { + + java.lang.String JSON_DISCRIMINATOR = "type"; + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_DISCRIMINATOR) + java.lang.String type(); +} diff --git a/gen/main/java/testmodel/micronaut_record/OneOfModel.java b/gen/main/java/testmodel/micronaut_record/OneOfModel.java new file mode 100644 index 00000000..250e52b2 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/OneOfModel.java @@ -0,0 +1,9 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.DEDUCTION, visible = true) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = FirstModel.class), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = SecondLevelModel.class) +}) +public sealed interface OneOfModel permits FirstModel, SecondLevelModel {} diff --git a/gen/main/java/testmodel/micronaut_record/PropertyTypeOne.java b/gen/main/java/testmodel/micronaut_record/PropertyTypeOne.java new file mode 100644 index 00000000..96b9f37e --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/PropertyTypeOne.java @@ -0,0 +1,42 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record PropertyTypeOne( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_TYPE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + Type type) implements AdditionalPropertiesModelValue { + + public static final java.lang.String JSON_PROPERTY_TYPE = "type"; + +public enum Type { + + ONE("one"); + + public static final java.lang.String ONE_VALUE = "one"; + + private final java.lang.String value; + + private Type(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static Type toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} +} diff --git a/gen/main/java/testmodel/micronaut_record/PropertyTypeTwo.java b/gen/main/java/testmodel/micronaut_record/PropertyTypeTwo.java new file mode 100644 index 00000000..265493e1 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/PropertyTypeTwo.java @@ -0,0 +1,42 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record PropertyTypeTwo( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_TYPE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + Type type) implements AdditionalPropertiesModelValue { + + public static final java.lang.String JSON_PROPERTY_TYPE = "type"; + +public enum Type { + + TWO("two"); + + public static final java.lang.String TWO_VALUE = "two"; + + private final java.lang.String value; + + private Type(java.lang.String value) { + this.value = value; + } + + @com.fasterxml.jackson.annotation.JsonCreator + public static Type toEnum(java.lang.String value) { + return toOptional(value).orElseThrow(() -> new IllegalArgumentException("Unknown value '" + value + "'.")); + } + + public static java.util.Optional toOptional(java.lang.String value) { + return java.util.Arrays + .stream(values()) + .filter(e -> e.value.equals(value)) + .findAny(); + } + + @com.fasterxml.jackson.annotation.JsonValue + public java.lang.String getValue() { + return value; + } +} +} diff --git a/gen/main/java/testmodel/micronaut_record/SecondLevelModel.java b/gen/main/java/testmodel/micronaut_record/SecondLevelModel.java new file mode 100644 index 00000000..ba0cee1c --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/SecondLevelModel.java @@ -0,0 +1,9 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.DEDUCTION, visible = true) +@com.fasterxml.jackson.annotation.JsonSubTypes({ + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = SecondLevelOneModel.class), + @com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = SecondLevelTwoModel.class) +}) +public sealed interface SecondLevelModel extends OneOfModel permits SecondLevelOneModel, SecondLevelTwoModel {} diff --git a/gen/main/java/testmodel/micronaut_record/SecondLevelOneModel.java b/gen/main/java/testmodel/micronaut_record/SecondLevelOneModel.java new file mode 100644 index 00000000..5213faf2 --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/SecondLevelOneModel.java @@ -0,0 +1,17 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record SecondLevelOneModel( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_TYPE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String type, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_ONE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String one) implements SecondLevelModel { + + public static final java.lang.String JSON_PROPERTY_TYPE = "type"; + public static final java.lang.String JSON_PROPERTY_ONE = "one"; +} diff --git a/gen/main/java/testmodel/micronaut_record/SecondLevelTwoModel.java b/gen/main/java/testmodel/micronaut_record/SecondLevelTwoModel.java new file mode 100644 index 00000000..d114082c --- /dev/null +++ b/gen/main/java/testmodel/micronaut_record/SecondLevelTwoModel.java @@ -0,0 +1,17 @@ +package testmodel.micronaut_record; + +@jakarta.annotation.Generated("org.openapitools.codegen.languages.MicronautCodegen") +@io.micronaut.serde.annotation.Serdeable +public record SecondLevelTwoModel( + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_TYPE) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String type, + + @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_TWO) + @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) + java.lang.String two) implements SecondLevelModel { + + public static final java.lang.String JSON_PROPERTY_TYPE = "type"; + public static final java.lang.String JSON_PROPERTY_TWO = "two"; +} diff --git a/src/it/test-api-records/pom.xml b/src/it/test-api-records/pom.xml new file mode 100644 index 00000000..ebfe7224 --- /dev/null +++ b/src/it/test-api-records/pom.xml @@ -0,0 +1,116 @@ + + + 4.0.0 + + + @project.groupId@ + @project.artifactId@-it + LOCAL-SNAPSHOT + + + @project.artifactId@-it-test-api-records + + + + + + io.micronaut + micronaut-http-client + + + io.micronaut + micronaut-http-server-netty + runtime + + + io.micronaut.serde + micronaut-serde-jackson + + + io.micronaut.validation + micronaut-validation + + + io.micronaut.xml + micronaut-jackson-xml + runtime + + + + + io.micronaut.test + micronaut-test-junit5 + test + + + + + + + + + + org.apache.maven.plugins + maven-resources-plugin + + + initialize + + copy-resources + + + + + ${project.basedir}/../test-api/src + + **/MediaTypeControllerController.java + **/ParameterController.java + **/ResponseController.java + **/*ClientTest.java + **/MediaTypeControllerControllerTest.java + **/ParameterControllerTest.java + **/ValidationControllerTest.java + + + + ${project.basedir}/src + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + + io.micronaut + micronaut-inject-java + ${version.io.micronaut.platform} + + + io.micronaut.serde + micronaut-serde-processor + ${version.io.micronaut.serde} + + + + + + + + org.openapitools + openapi-generator-maven-plugin + + @project.basedir@/src/test/resources/openapi/test-api.yaml + + true + + + + + + + diff --git a/src/it/test-api-records/src/main/java/codegen/server/MediaTypeController.java b/src/it/test-api-records/src/main/java/codegen/server/MediaTypeController.java new file mode 100644 index 00000000..db83d001 --- /dev/null +++ b/src/it/test-api-records/src/main/java/codegen/server/MediaTypeController.java @@ -0,0 +1,59 @@ +package codegen.server; + +import java.io.IOException; + +import codegen.Multipart; +import codegen.StringModel; +import io.micronaut.http.HttpResponse; +import io.micronaut.http.HttpStatus; +import io.micronaut.http.MediaType; +import io.micronaut.http.annotation.Controller; +import io.micronaut.http.exceptions.HttpStatusException; +import io.micronaut.http.multipart.CompletedFileUpload; + +@Controller +public class MediaTypeController implements MediatypeApi { + + @Override + public HttpResponse mediatypeConsumesOctetStream(byte[] body) { + return HttpResponse.ok(new StringModel(new String(body))); + } + + @Override + public HttpResponse mediatypeConsumesAndProduces(byte[] body) { + return HttpResponse.ok(new StringModel(new String(body))); + } + + @Override + public HttpResponse mediatypeConsumesMultipartWithFileUpload( + Integer orderId, Integer userId, CompletedFileUpload file) { + try { + return HttpResponse.ok(new Multipart(orderId, userId, file.getFilename(), file.getBytes())); + } catch (IOException e) { + throw new HttpStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage()); + } + } + + @Override + public HttpResponse mediatypeConsumesMultipartWithoutFileUpload(Integer orderId, Integer userId) { + return HttpResponse.ok(new Multipart(orderId, userId, null, null)); + } + + @Override + public HttpResponse mediatypeConsumesPlain(String body) { + return HttpResponse.ok(new StringModel(body)); + } + + @Override + public HttpResponse mediatypeProducesSameModel(String value) { + return HttpResponse.ok(new StringModel(value)); + } + + @Override + public HttpResponse mediatypeProducesDifferentModel(String value, Boolean plain) { + var response = HttpResponse.status(HttpStatus.OK); + return plain + ? response.contentType(MediaType.TEXT_PLAIN).body(value) + : response.contentType(MediaType.APPLICATION_JSON).body(new StringModel(value)); + } +} diff --git a/src/it/test-api-records/src/main/java/codegen/server/ParameterController.java b/src/it/test-api-records/src/main/java/codegen/server/ParameterController.java new file mode 100644 index 00000000..27078ef2 --- /dev/null +++ b/src/it/test-api-records/src/main/java/codegen/server/ParameterController.java @@ -0,0 +1,195 @@ +package codegen.server; + +import java.time.Instant; +import java.time.LocalDate; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +import codegen.ParameterModel; +import io.micronaut.core.annotation.Nullable; +import io.micronaut.http.HttpResponse; +import io.micronaut.http.annotation.Controller; + +@Controller +public class ParameterController implements ParameterApi { + + @Override + public HttpResponse paramPathWithMaxLength(String string) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_WITH_MAX_LENGTH, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathWithPattern(String string) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_WITH_PATTERN, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathWithUuid(UUID udid) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_WITH_UUID, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathWithBoolean(Boolean bool) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_WITH_BOOLEAN, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathWithInteger(Integer value) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_WITH_INTEGER, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathWithLong(Long value) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_WITH_LONG, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathOverlayWithString(String string) { + return HttpResponse.ok(new ParameterModel(null, PATH_PARAM_PATH_OVERLAY_WITH_STRING, null, null, null, null, + null, null, null, null)); + } + + @Override + public HttpResponse paramPathOverlayWithUuid(UUID uuid) { + return HttpResponse.ok(new ParameterModel( + null, PATH_PARAM_PATH_OVERLAY_WITH_UUID, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathRequiredWithDefault(String string) { + return HttpResponse.ok(new ParameterModel( + null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramPathRequiredWithoutDefault(String string) { + return HttpResponse.ok(new ParameterModel( + null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramBodyOptional(@Nullable Optional parameterModel) { + return HttpResponse.ok(Optional.ofNullable(parameterModel).flatMap(t -> t).orElseGet(() -> new ParameterModel( + null, null, null, null, null, null, null, null, null, null))); + } + + @Override + public HttpResponse paramBodyRequired(ParameterModel parameterModel) { + return HttpResponse.ok(parameterModel); + } + + @Override + public HttpResponse paramQueryMultipleLists( + Optional> a, + Optional> b, + Optional> c) { + return HttpResponse.ok(new ParameterModel(null, null, null, null, null, null, null, + a.orElse(List.of()), + b.orElse(List.of()), + c.orElse(List.of()))); + } + + @Override + public HttpResponse paramQueryDate(Optional date) { + return HttpResponse.ok(new ParameterModel( + null, null, null, null, null, date.orElse(null), null, null, null, null)); + } + + @Override + public HttpResponse paramQueryDateTime(Optional dateTime) { + return HttpResponse.ok(new ParameterModel( + null, null, null, null, null, null, dateTime.orElse(null), null, null, null)); + } + + @Override + public HttpResponse paramQueryNumber(Optional number) { + return HttpResponse.ok(new ParameterModel( + null, null, number.orElse(null), null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramQueryUuid(Optional uuid) { + return HttpResponse.ok(new ParameterModel( + null, null, null, null, uuid.orElse(null), null, null, null, null, null)); + } + + @Override + public HttpResponse paramQueryOptionalWithDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramQueryOptionalWithoutDefault(Optional string) { + return HttpResponse.ok(new ParameterModel( + null, string.orElse(null), null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramQueryRequiredWithDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramQueryRequiredWithoutDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramHeaderOptionalWithDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramHeaderOptionalWithoutDefault(Optional string) { + return HttpResponse.ok(new ParameterModel( + null, string.orElse(null), null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramHeaderRequiredWithDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramHeaderRequiredWithoutDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramCookieOptionalWithDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramCookieOptionalWithoutDefault(Optional string) { + return HttpResponse.ok(new ParameterModel( + null, string.orElse(null), null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramCookieRequiredWithDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramCookieRequiredWithoutDefault(String string) { + return HttpResponse.ok(new ParameterModel(null, string, null, null, null, null, null, null, null, null)); + } + + @Override + public HttpResponse paramAll( + String path, + UUID uuid, + Optional date, + Optional integer) { + return HttpResponse.ok(new ParameterModel( + null, path, null, integer.orElse(null), uuid, date.orElse(null), null, null, null, null)); + } +} diff --git a/src/it/test-api-records/src/main/java/codegen/server/ResponseController.java b/src/it/test-api-records/src/main/java/codegen/server/ResponseController.java new file mode 100644 index 00000000..ae5b1b19 --- /dev/null +++ b/src/it/test-api-records/src/main/java/codegen/server/ResponseController.java @@ -0,0 +1,115 @@ +package codegen.server; + +import java.util.List; + +import codegen.NumberModel; +import codegen.StringModel; +import io.micronaut.http.HttpResponse; +import io.micronaut.http.HttpStatus; +import io.micronaut.http.annotation.Controller; + +@Controller +public class ResponseController implements ResponseApi { + + public static final Double DOUBLE = 1234D; + public static final String STRING1 = "string1"; + public static final String STRING2 = "string2"; + public static final StringModel MODEL_STRING1 = new StringModel(STRING1); + public static final StringModel MODEL_STRING2 = new StringModel(STRING2); + public static final NumberModel MODEL_NUMBER = new NumberModel(DOUBLE); + public static final List ARRAY_SIMPLE = List.of("a", "b"); + public static final List ARRAY_COMPLEX = List.of(new StringModel(STRING1), new StringModel(STRING2)); + + @Override + public HttpResponse voidFound() { + return HttpResponse.noContent(); + } + + @Override + public HttpResponse voidNotFound(Boolean found) { + return found + ? HttpResponse.noContent() + : HttpResponse.notFound(); + } + + @Override + public HttpResponse single() { + return HttpResponse.ok(STRING1); + } + + @Override + public HttpResponse optional(Boolean found) { + return found + ? HttpResponse.ok(STRING1) + : HttpResponse.notFound(); + } + + @Override + public HttpResponse header() { + return HttpResponse.ok().header("foo", String.valueOf(DOUBLE)); + } + + @Override + public HttpResponse> arraySimple() { + return HttpResponse.ok(ARRAY_SIMPLE); + } + + @Override + public HttpResponse> arraySimpleEmpty() { + return HttpResponse.ok(List.of()); + } + + @Override + public HttpResponse> arraySimpleNotFound(Boolean found) { + return found + ? HttpResponse.ok(ARRAY_SIMPLE) + : HttpResponse.notFound(); + } + + @Override + public HttpResponse> arrayComplex() { + return HttpResponse.ok(ARRAY_COMPLEX); + } + + @Override + public HttpResponse> arrayComplexNotFound(Boolean found) { + return found + ? HttpResponse.ok(ARRAY_COMPLEX) + : HttpResponse.notFound(); + } + + @Override + public HttpResponse multipleDataTypes(Boolean redirect) { + return redirect + ? HttpResponse.status(HttpStatus.MULTIPLE_CHOICES).body(MODEL_NUMBER) + : HttpResponse.ok(MODEL_STRING1); + } + + @Override + public HttpResponse multipleDataTypesNotFound(Boolean redirect, Boolean found) { + if (!found) { + return HttpResponse.notFound(); + } + return multipleDataTypes(redirect); + } + + @Override + public HttpResponse multipleResponseCodes(Boolean redirect) { + return redirect + ? HttpResponse.status(HttpStatus.MULTIPLE_CHOICES).body(MODEL_STRING2) + : HttpResponse.ok(MODEL_STRING1); + } + + @Override + public HttpResponse multipleResponseCodesNotFound(Boolean redirect, Boolean found) { + if (!found) { + return HttpResponse.notFound(); + } + return multipleResponseCodes(redirect); + } + + @Override + public HttpResponse withDefault() { + return HttpResponse.noContent(); + } +} diff --git a/src/it/test-api-records/src/test/java/codegen/server/MediatypeControllerTest.java b/src/it/test-api-records/src/test/java/codegen/server/MediatypeControllerTest.java new file mode 100644 index 00000000..fe485686 --- /dev/null +++ b/src/it/test-api-records/src/test/java/codegen/server/MediatypeControllerTest.java @@ -0,0 +1,102 @@ +package codegen.server; + +import static codegen.HttpResponseAssertions.assert200; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Optional; +import java.util.UUID; + +import org.junit.jupiter.api.Test; + +import codegen.Multipart; +import codegen.StringModel; +import io.micronaut.http.HttpRequest; +import io.micronaut.http.MediaType; +import io.micronaut.http.client.HttpClient; +import io.micronaut.http.client.annotation.Client; +import io.micronaut.http.client.multipart.MultipartBody; +import io.micronaut.test.extensions.junit5.annotation.MicronautTest; +import jakarta.inject.Inject; + +@MicronautTest +public class MediatypeControllerTest implements MediatypeApiTestSpec { + + private final String STRING = UUID.randomUUID().toString(); + private final byte[] BYTES = STRING.getBytes(); + + @Inject + MediatypeApiTestClient client; + @Inject + @Client("/") + HttpClient rawClient; + + @Test + @Override + public void mediatypeConsumesAndProduces200() { + var expected = new StringModel(STRING); + assertEquals(expected, assert200(() -> client.mediatypeConsumesAndProduces(BYTES)).body()); + var response = assert200(() -> rawClient.toBlocking().exchange(HttpRequest + .POST(MediatypeApi.PATH_MEDIATYPE_CONSUMES_AND_PRODUCES, BYTES) + .contentType(MediaType.APPLICATION_OCTET_STREAM) + .accept(MediaType.APPLICATION_XML), StringModel.class)); + assertEquals(MediaType.APPLICATION_XML_TYPE, response.getContentType().get(), "content"); + assertEquals(expected, response.body(), "body"); + assertEquals("\n " + STRING + "\n\n", + response.getBody(String.class).get(), "raw"); + } + + @Test + @Override + public void mediatypeConsumesMultipartWithFileUpload200() { + var expected = new Multipart(1, 2, "uuid.txt", BYTES); + var body = MultipartBody.builder() + .addPart("orderId", String.valueOf(expected.orderId())) + .addPart("userId", String.valueOf(expected.userId())) + .addPart("file", expected.fileName(), BYTES) + .build(); + var actual = assert200(() -> client.mediatypeConsumesMultipartWithFileUpload(body)).body(); + assertEquals(expected.orderId(), actual.orderId()); + assertEquals(expected.userId(), actual.userId()); + assertEquals(expected.fileName(), actual.fileName()); + assertArrayEquals(expected.file(), actual.file()); + } + + @Test + @Override + public void mediatypeConsumesMultipartWithoutFileUpload200() { + var expected = new Multipart(1, 2, null, null); + var body = MultipartBody.builder() + .addPart("orderId", String.valueOf(expected.orderId())) + .addPart("userId", String.valueOf(expected.userId())) + .build(); + assertEquals(expected, assert200(() -> client.mediatypeConsumesMultipartWithoutFileUpload(body)).body()); + } + + @Test + @Override + public void mediatypeConsumesOctetStream200() { + assertEquals(STRING, assert200(() -> client.mediatypeConsumesOctetStream(BYTES)).body().foo()); + } + + @Test + @Override + public void mediatypeConsumesPlain200() { + assertEquals(STRING, assert200(() -> client.mediatypeConsumesPlain(STRING)).body().foo()); + } + + @Test + @Override + public void mediatypeProducesSameModel200() { + assertEquals(STRING, assert200(() -> client.mediatypeProducesSameModel(STRING)).body().foo()); + } + + @Test + @Override + public void mediatypeProducesDifferentModel200() { + assertEquals(Optional.of(STRING), assert200( + () -> client.mediatypeProducesDifferentModel(STRING, true)).getBody(String.class)); + assertEquals(Optional.of(new StringModel(STRING)), assert200( + () -> client.mediatypeProducesDifferentModel(STRING, false)).getBody(StringModel.class)); + } +} diff --git a/src/it/test-api-records/src/test/java/codegen/server/ParameterControllerTest.java b/src/it/test-api-records/src/test/java/codegen/server/ParameterControllerTest.java new file mode 100644 index 00000000..bee3929e --- /dev/null +++ b/src/it/test-api-records/src/test/java/codegen/server/ParameterControllerTest.java @@ -0,0 +1,303 @@ +package codegen.server; + +import static codegen.HttpResponseAssertions.assert400; +import static codegen.HttpResponseAssertions.assert404; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.time.Instant; +import java.time.LocalDate; +import java.util.List; +import java.util.UUID; +import java.util.function.Consumer; + +import org.junit.jupiter.api.Test; + +import codegen.ParameterModel; +import io.micronaut.http.HttpRequest; +import io.micronaut.http.client.HttpClient; +import io.micronaut.http.client.annotation.Client; +import io.micronaut.http.uri.UriBuilder; +import io.micronaut.test.extensions.junit5.annotation.MicronautTest; +import jakarta.inject.Inject; + +@MicronautTest +public class ParameterControllerTest implements ParameterApiTestSpec { + + private final String STRING = UUID.randomUUID().toString(); + private final String STRING_DEFAULT = "this-is-default"; + + @Inject + ParameterApiTestClient client; + @Inject + @Client("/") + HttpClient rawClient; + + @Test + @Override + public void paramPathOverlayWithString200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_OVERLAY_WITH_STRING, + client.paramPathOverlayWithString("221313").body().string()); + } + + @Test + @Override + public void paramPathOverlayWithUuid200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_OVERLAY_WITH_UUID, + client.paramPathOverlayWithUuid(UUID.randomUUID()).body().string()); + } + + @Test + @Override + public void paramPathRequiredWithDefault200() { + assertEquals(STRING, client.paramPathRequiredWithDefault(STRING).body().string()); + } + + @Test + @Override + public void paramPathRequiredWithoutDefault200() { + assertEquals(STRING, client.paramPathRequiredWithoutDefault(STRING).body().string()); + } + + @Test + @Override + public void paramPathWithBoolean200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_BOOLEAN, client.paramPathWithBoolean(true).body().string()); + } + + @Test + @Override + public void paramPathWithInteger200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_INTEGER, client.paramPathWithInteger(-1).body().string()); + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_INTEGER, client.paramPathWithInteger(0).body().string()); + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_INTEGER, client.paramPathWithInteger(1).body().string()); + } + + @Test + @Override + public void paramPathWithLong200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_LONG, client.paramPathWithLong(-1L).body().string()); + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_LONG, client.paramPathWithLong(0L).body().string()); + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_LONG, client.paramPathWithLong(1L).body().string()); + } + + @Test + @Override + public void paramPathWithMaxLength200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_MAX_LENGTH, + client.paramPathWithMaxLength("12345").body().string()); + assert404(() -> client.paramPathWithMaxLength("123456")); + } + + @Test + @Override + public void paramPathWithPattern200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_PATTERN, client.paramPathWithPattern("4f").body().string()); + assert404(() -> client.paramPathWithPattern("f4")); + } + + @Test + @Override + public void paramPathWithUuid200() { + assertEquals(ParameterApi.PATH_PARAM_PATH_WITH_UUID, + client.paramPathWithUuid(UUID.randomUUID()).body().string()); + } + + @Test + @Override + public void paramBodyOptional200() { + var expected = new ParameterModel(null, "test", null, 5, UUID.randomUUID(), null, null, null, null, null); + assertEquals(expected, client.paramBodyOptional(expected).body()); + expected = new ParameterModel(null, null, null, null, null, null, null, null, null, null); + assertEquals(expected, client.paramBodyOptional(null).body()); + } + + @Test + @Override + public void paramBodyRequired200() { + var expected = new ParameterModel(null, "test", null, 5, UUID.randomUUID(), null, null, null, null, null); + assertEquals(expected, client.paramBodyRequired(expected).body()); + } + + @Test + @Override + public void paramBodyRequired400() { + assert400(() -> client.paramBodyRequired(null)); + } + + @Test + @Override + public void paramQueryMultipleLists200() { + Consumer equals = expected -> { + assertEquals(expected, client + .paramQueryMultipleLists(expected.a(), expected.b(), expected.c()).body()); + assertEquals(expected, rawClient.toBlocking().exchange(HttpRequest.GET(UriBuilder + .of(ParameterApi.PATH_PARAM_QUERY_MULTIPLE_LISTS) + .queryParam("a", expected.a().toArray()) + .queryParam("b", expected.b().toArray()) + .queryParam("c", expected.c().toArray()) + .build()), ParameterModel.class).body()); + }; + equals.accept(new ParameterModel(null, null, null, null, null, null, null, + List.of(), List.of(), List.of())); + equals.accept(new ParameterModel(null, null, null, null, null, null, null, + List.of("a"), List.of(UUID.randomUUID()), List.of(123))); + equals.accept(new ParameterModel(null, null, null, null, null, null, null, + List.of("a", "b", "c"), List.of(UUID.randomUUID(), UUID.randomUUID()), List.of(123, 456))); + } + + @Test + @Override + public void paramQueryDate200() { + var expected = new ParameterModel(null, null, null, null, null, LocalDate.now(), null, null, null, null); + assertEquals(expected, client.paramQueryDate(expected.date()).body()); + assertEquals(expected, rawClient.toBlocking().retrieve(UriBuilder + .of(ParameterApi.PATH_PARAM_QUERY_DATE) + .queryParam("date", expected.date().toString()) + .build().toString(), ParameterModel.class)); + } + + @Test + @Override + public void paramQueryDateTime200() { + var expected = new ParameterModel(null, null, null, null, null, null, Instant.now(), null, null, null); + assertEquals(expected, client.paramQueryDateTime(expected.dateTime()).body()); + assertEquals(expected, rawClient.toBlocking().retrieve(UriBuilder + .of(ParameterApi.PATH_PARAM_QUERY_DATE_TIME) + .queryParam("date", expected.dateTime().toString()) + .build().toString(), ParameterModel.class)); + } + + @Test + @Override + public void paramQueryNumber200() { + var expected = new ParameterModel(null, null, 12.34, null, null, null, null, null, null, null); + assertEquals(expected, client.paramQueryNumber(expected.number()).body()); + } + + @Test + @Override + public void paramQueryUuid200() { + var expected = new ParameterModel(null, null, null, null, UUID.randomUUID(), null, null, null, null, null); + assertEquals(expected, client.paramQueryUuid(expected.uuid()).body()); + } + + @Test + @Override + public void paramQueryOptionalWithDefault200() { + assertEquals(STRING, client.paramQueryOptionalWithDefault(STRING).body().string()); + assertEquals(STRING_DEFAULT, client.paramQueryOptionalWithDefault(null).body().string()); + } + + @Test + @Override + public void paramQueryOptionalWithoutDefault200() { + assertEquals(STRING, client.paramHeaderOptionalWithoutDefault(STRING).body().string()); + assertEquals(null, client.paramHeaderOptionalWithoutDefault(null).body().string()); + } + + @Test + @Override + public void paramQueryRequiredWithDefault200() { + assertEquals(STRING, client.paramQueryRequiredWithDefault(STRING).body().string()); + assertEquals(STRING_DEFAULT, client.paramQueryRequiredWithDefault(null).body().string()); + } + + @Test + @Override + public void paramQueryRequiredWithoutDefault200() { + assertEquals(STRING, client.paramQueryRequiredWithoutDefault(STRING).body().string()); + } + + @Test + @Override + public void paramQueryRequiredWithoutDefault400() { + assert400(() -> client.paramQueryRequiredWithoutDefault(null)); + } + + @Test + @Override + public void paramHeaderOptionalWithDefault200() { + assertEquals(STRING, client.paramHeaderOptionalWithDefault(STRING).body().string()); + assertEquals(STRING_DEFAULT, client.paramHeaderOptionalWithDefault(null).body().string()); + } + + @Test + @Override + public void paramHeaderOptionalWithoutDefault200() { + assertEquals(STRING, client.paramHeaderOptionalWithoutDefault(STRING).body().string()); + assertEquals(null, client.paramHeaderOptionalWithoutDefault(null).body().string()); + } + + @Test + @Override + public void paramHeaderRequiredWithDefault200() { + assertEquals(STRING, client.paramHeaderRequiredWithDefault(STRING).body().string()); + assertEquals(STRING_DEFAULT, client.paramHeaderRequiredWithDefault(null).body().string()); + } + + @Test + @Override + public void paramHeaderRequiredWithoutDefault200() { + assertEquals(STRING, client.paramHeaderRequiredWithoutDefault(STRING).body().string()); + } + + @Test + @Override + public void paramHeaderRequiredWithoutDefault400() { + assert400(() -> client.paramHeaderRequiredWithoutDefault(null)); + } + + @Test + @Override + public void paramCookieOptionalWithDefault200() { + assertEquals(STRING, client.paramCookieOptionalWithDefault(STRING).body().string()); + assertEquals(STRING_DEFAULT, client.paramCookieOptionalWithDefault(null).body().string()); + } + + @Test + @Override + public void paramCookieOptionalWithoutDefault200() { + assertEquals(STRING, client.paramCookieOptionalWithoutDefault(STRING).body().string()); + assertEquals(null, client.paramCookieOptionalWithoutDefault(null).body().string()); + } + + @Test + @Override + public void paramCookieRequiredWithDefault200() { + assertEquals(STRING, client.paramCookieRequiredWithDefault(STRING).body().string()); + assertEquals(STRING_DEFAULT, client.paramCookieRequiredWithDefault(null).body().string()); + } + + @Test + @Override + public void paramCookieRequiredWithoutDefault200() { + assertEquals(STRING, client.paramCookieRequiredWithoutDefault(STRING).body().string()); + } + + @Test + @Override + public void paramCookieRequiredWithoutDefault400() { + assert400(() -> client.paramCookieRequiredWithoutDefault(null)); + } + + @Test + @Override + public void paramAll200() { + var expected = new ParameterModel( + null, + UUID.randomUUID().toString(), + null, + 123, + UUID.randomUUID(), + LocalDate.now(), + null, + null, + null, + null); + assertEquals(expected, client.paramAll( + expected.string(), + expected.uuid(), + expected.date(), + expected.integer()).body()); + } +} diff --git a/src/it/test-api-records/src/test/java/codegen/server/ValidationControllerTest.java b/src/it/test-api-records/src/test/java/codegen/server/ValidationControllerTest.java new file mode 100644 index 00000000..30bbf83f --- /dev/null +++ b/src/it/test-api-records/src/test/java/codegen/server/ValidationControllerTest.java @@ -0,0 +1,311 @@ +package codegen.server; + +import static codegen.HttpResponseAssertions.assert204; +import static codegen.HttpResponseAssertions.assert400; + +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import codegen.StringModel; +import io.micronaut.test.extensions.junit5.annotation.MicronautTest; +import jakarta.inject.Inject; + +@Disabled("annotation inheritance") +@MicronautTest +public class ValidationControllerTest implements ValidationApiTestSpec { + + private final float diff = 0.0000000000001F; + + @Inject + ValidationApiTestClient client; + + @Test + @Override + public void validationLongMin204() { + assert204(() -> client.validationLongMin(3L)); + assert204(() -> client.validationLongMin(4L)); + assert204(() -> client.validationLongMin(5L)); + } + + @Test + @Override + public void validationLongMin400() { + assert400(() -> client.validationLongMin(2L)); + } + + @Test + @Override + public void validationLongMax204() { + assert204(() -> client.validationLongMax(2L)); + assert204(() -> client.validationLongMax(3L)); + assert204(() -> client.validationLongMax(4L)); + } + + @Test + @Override + public void validationLongMax400() { + assert400(() -> client.validationLongMax(5L)); + } + + @Test + @Override + public void validationLongRange204() { + assert204(() -> client.validationLongRange(3L)); + assert204(() -> client.validationLongRange(4L)); + } + + @Test + @Override + public void validationLongRange400() { + assert400(() -> client.validationLongRange(2L)); + assert400(() -> client.validationLongRange(5L)); + } + + @Test + @Override + public void validationIntegerMin204() { + assert204(() -> client.validationIntegerMin(3)); + assert204(() -> client.validationIntegerMin(4)); + assert204(() -> client.validationIntegerMin(5)); + } + + @Test + @Override + public void validationIntegerMin400() { + assert400(() -> client.validationIntegerMin(2)); + } + + @Test + @Override + public void validationIntegerMax204() { + assert204(() -> client.validationIntegerMax(2)); + assert204(() -> client.validationIntegerMax(3)); + assert204(() -> client.validationIntegerMax(4)); + } + + @Test + @Override + public void validationIntegerMax400() { + assert400(() -> client.validationIntegerMax(5)); + } + + @Test + @Override + public void validationIntegerRange204() { + assert204(() -> client.validationIntegerRange(3)); + assert204(() -> client.validationIntegerRange(4)); + } + + @Test + @Override + public void validationIntegerRange400() { + assert400(() -> client.validationIntegerRange(2)); + assert400(() -> client.validationIntegerRange(5)); + } + + @Test + @Override + public void validationDoubleMin204() { + assert204(() -> client.validationDoubleMin(3D + diff)); + } + + @Test + @Override + public void validationDoubleMin400() { + assert400(() -> client.validationDoubleMin(3D)); + } + + @Test + @Override + public void validationDoubleMax204() { + assert204(() -> client.validationDoubleMax(4D - diff)); + } + + @Test + @Override + public void validationDoubleMax400() { + assert400(() -> client.validationDoubleMax(4D)); + } + + @Test + @Override + public void validationDoubleRange204() { + assert204(() -> client.validationDoubleRange(3D)); + assert204(() -> client.validationDoubleRange(4D)); + } + + @Test + @Override + public void validationDoubleRange400() { + assert400(() -> client.validationDoubleRange(3D - diff)); + assert400(() -> client.validationDoubleRange(4D + diff)); + } + + @Test + @Override + public void validationFloatMin204() { + assert204(() -> client.validationFloatMin(3F + diff)); + } + + @Test + @Override + public void validationFloatMin400() { + assert400(() -> client.validationFloatMin(3F)); + } + + @Test + @Override + public void validationFloatMax204() { + assert204(() -> client.validationFloatMax(4F - diff)); + } + + @Test + @Override + public void validationFloatMax400() { + assert400(() -> client.validationFloatMax(4F)); + } + + @Test + @Override + public void validationFloatRange204() { + assert204(() -> client.validationFloatRange(3F)); + assert204(() -> client.validationFloatRange(4F)); + } + + @Test + @Override + public void validationFloatRange400() { + assert400(() -> client.validationFloatRange(3F - diff)); + assert400(() -> client.validationFloatRange(4F + diff)); + } + + @Test + @Override + public void validationStringPattern204() { + assert204(() -> client.validationStringPattern("abcd")); + } + + @Test + @Override + public void validationStringPattern400() { + assert400(() -> client.validationStringPattern("abcdef")); + assert400(() -> client.validationStringPattern("1234")); + } + + @Test + @Override + public void validationStringMin204() { + assert204(() -> client.validationStringMin("124")); + assert204(() -> client.validationStringMin("1234")); + assert204(() -> client.validationStringMin("12345")); + } + + @Test + @Override + public void validationStringMin400() { + assert400(() -> client.validationStringMin("12")); + } + + @Test + @Override + public void validationStringMax204() { + assert204(() -> client.validationStringMax("12")); + assert204(() -> client.validationStringMax("123")); + assert204(() -> client.validationStringMax("1234")); + } + + @Test + @Override + public void validationStringMax400() { + assert400(() -> client.validationStringMax("12345")); + } + + @Test + @Override + public void validationStringRange204() { + assert204(() -> client.validationStringRange("123")); + assert204(() -> client.validationStringRange("1234")); + } + + @Test + @Override + public void validationStringRange400() { + assert400(() -> client.validationStringRange("12")); + assert400(() -> client.validationStringRange("12345")); + } + + @Test + @Override + public void validationListMin204() { + assert204(() -> client.validationListMin(list(3))); + assert204(() -> client.validationListMin(list(4))); + assert204(() -> client.validationListMin(list(5))); + } + + @Test + @Override + public void validationListMin400() { + assert400(() -> client.validationListMin(list(2))); + } + + @Override + public void validationListMax204() { + assert204(() -> client.validationListMax(list(2))); + assert204(() -> client.validationListMax(list(3))); + assert204(() -> client.validationListMax(list(4))); + } + + @Test + @Override + public void validationListMax400() { + assert400(() -> client.validationListMax(list(5))); + } + + @Test + @Override + public void validationListRange204() { + assert204(() -> client.validationListRange(list(3))); + assert204(() -> client.validationListRange(list(4))); + } + + @Test + @Override + public void validationListRange400() { + assert400(() -> client.validationListRange(list(2))); + assert400(() -> client.validationListRange(list(5))); + } + + @Test + @Override + public void validationListModel204() { + assert204(() -> client + .validationListModel(List.of(new StringModel("foo"), new StringModel("bar")))); + } + + @Test + @Override + public void validationListModel400() { + assert204(() -> client + .validationListModel(List.of(new StringModel("foo"), new StringModel(null)))); + } + + @Test + @Override + public void validationModel204() { + assert204(() -> client.validationModel(new StringModel("meh"))); + } + + @Test + @Override + public void validationModel400() { + assert400(() -> client.validationModel(new StringModel(null))); + } + + private List list(int size) { + return IntStream.rangeClosed(1, size).mapToObj(i -> i).collect(Collectors.toList()); + } +} diff --git a/src/main/java/org/openapitools/codegen/languages/MicronautCodegen.java b/src/main/java/org/openapitools/codegen/languages/MicronautCodegen.java index 6bf51aa7..bd4378b0 100644 --- a/src/main/java/org/openapitools/codegen/languages/MicronautCodegen.java +++ b/src/main/java/org/openapitools/codegen/languages/MicronautCodegen.java @@ -48,6 +48,7 @@ public class MicronautCodegen extends AbstractJavaCodegen public static final String SERDEABLE = "serdeable"; public static final String DATETIME_RELAXED = "dateTimeRelaxed"; public static final String PAGEABLE = "pageable"; + public static final String RECORD = "record"; public static final String GENERATE_AUTHENTICATION = "generateAuthentication"; public static final String GENERATE_EXAMPLES = "generateExamples"; public static final String SEALED = "sealed"; @@ -70,6 +71,7 @@ public class MicronautCodegen extends AbstractJavaCodegen private boolean useOptional = true; private boolean serdeable = true; private boolean dateTimeRelaxed = true; + private boolean record = false; private boolean pageable = false; private boolean sealed = true; @@ -89,6 +91,7 @@ public MicronautCodegen() { cliOptions.add(CliOption.newBoolean(DATETIME_RELAXED, "Relaxed parsing of datetimes.", dateTimeRelaxed)); cliOptions.add(CliOption.newBoolean(PAGEABLE, "Generate provider for pageable (mironaut-data).", pageable)); cliOptions.add(CliOption.newBoolean(SEALED, "Seal interfaces.", sealed)); + cliOptions.add(CliOption.newBoolean(RECORD, "Generate records instead of pojos.", record)); cliOptions.add(CliOption.newBoolean(OPENAPI_NULLABLE, "Enable OpenAPI Jackson Nullable", openApiNullable)); cliOptions.add(CliOption.newBoolean(GENERATE_AUTHENTICATION, "Generate authentication into apis with return code 401.", generateAuthentication)); @@ -118,6 +121,7 @@ public MicronautCodegen() { additionalProperties.put(GENERATE_AUTHENTICATION, generateAuthentication); additionalProperties.put(GENERATE_EXAMPLES, generateExamples); additionalProperties.put(SEALED, sealed); + additionalProperties.put(RECORD, record); // add custom type mappings @@ -217,6 +221,9 @@ public void processOpts() { if (additionalProperties.containsKey(SEALED)) { sealed = convertPropertyToBooleanAndWriteBack(SEALED); } + if (additionalProperties.containsKey(RECORD)) { + record = convertPropertyToBooleanAndWriteBack(RECORD); + } if (additionalProperties.containsKey(SUPPORT_ASYNC)) { supportAsync = convertPropertyToBooleanAndWriteBack(SUPPORT_ASYNC); } @@ -523,6 +530,7 @@ public Map updateAllModels(Map objs) { var extensions = subModel.vendorExtensions; extensions.put("discriminatorPropertyGetter", discriminator.getPropertyGetter()); + extensions.put("discriminatorPropertyName", discriminator.getPropertyName()); extensions.put("discriminatorPropertyType", discriminator.getPropertyType()); extensions.put("discriminatorPropertyValue", switch (discriminator.getPropertyType()) { case "java.lang.String" -> '"' + mappedModel.getMappingName() + '"'; diff --git a/src/main/resources/Micronaut/model.mustache b/src/main/resources/Micronaut/model.mustache index 3aa485b3..4316fe6a 100644 --- a/src/main/resources/Micronaut/model.mustache +++ b/src/main/resources/Micronaut/model.mustache @@ -3,6 +3,6 @@ package {{package}}; {{#description}}/** * {{description}} **/ -{{/description}}{{>generated}}{{#models}}{{#model}}{{#isEnum}}{{>modelEnum}}{{/isEnum}}{{^isEnum}}{{#hasChildren}}{{>modelInterface}}{{/hasChildren}}{{^hasChildren}}{{>modelPojo}}{{/hasChildren}}{{/isEnum}} +{{/description}}{{>generated}}{{#models}}{{#model}}{{#isEnum}}{{>modelEnum}}{{/isEnum}}{{^isEnum}}{{#hasChildren}}{{>modelInterface}}{{/hasChildren}}{{^hasChildren}}{{#record}}{{>modelRecord}}{{/record}}{{^record}}{{>modelPojo}}{{/record}}{{/hasChildren}}{{/isEnum}} {{/model}} {{/models}} diff --git a/src/main/resources/Micronaut/modelInterface.mustache b/src/main/resources/Micronaut/modelInterface.mustache index db465e89..38dffd8b 100644 --- a/src/main/resources/Micronaut/modelInterface.mustache +++ b/src/main/resources/Micronaut/modelInterface.mustache @@ -13,7 +13,7 @@ public{{#sealed}} sealed{{/sealed}} interface {{classname}}{{#interfaces}}{{#-fi java.lang.String JSON_PROPERTY_{{nameInSnakeCase}} = "{{baseName}}";{{/vars}}{{#discriminator}} @com.fasterxml.jackson.annotation.JsonProperty(JSON_DISCRIMINATOR) - {{discriminator.propertyType}} {{discriminator.propertyGetter}}();{{/discriminator}}{{#vendorExtensions.additionalPropertiesMap}} + {{discriminator.propertyType}} {{^record}}{{discriminator.propertyGetter}}{{/record}}{{#record}}{{propertyName}}{{/record}}();{{/discriminator}}{{#vendorExtensions.additionalPropertiesMap}} @com.fasterxml.jackson.annotation.JsonAnyGetter java.util.Map<{{{vendorExtensions.additionalPropertiesMap.keyType}}}, {{{vendorExtensions.additionalPropertiesMap.valueType}}}> getAdditionalProperties(); @@ -22,11 +22,13 @@ public{{#sealed}} sealed{{/sealed}} interface {{classname}}{{#interfaces}}{{#-fi {{/vendorExtensions.additionalPropertiesMap}}{{#hasVars}}{{#vars}} {{#description}} /** {{description}} */ -{{/description}}{{>modelPropertyJackson}} +{{/description}}{{^record}}{{>modelPropertyJackson}} {{>modelPropertyType}} {{getter}}(); @com.fasterxml.jackson.annotation.JsonProperty(JSON_PROPERTY_{{nameInSnakeCase}}) - void {{setter}}({{>modelPropertyType}} new{{nameInCamelCase}});{{/vars}}{{#vars}}{{#isEnum}} + void {{setter}}({{>modelPropertyType}} new{{nameInCamelCase}});{{/record}}{{#record}} +{{>modelPropertyJackson}} + {{>modelPropertyType}} {{name}}();{{/record}}{{/vars}}{{#vars}}{{#isEnum}} {{>modelEnum}}{{/isEnum}}{{/vars}}{{/hasVars}} }{{/vendorExtensions.x-is-one-of-interface}}{{#vendorExtensions.x-is-one-of-interface}}{{^discriminator}}@com.fasterxml.jackson.annotation.JsonTypeInfo(use = com.fasterxml.jackson.annotation.JsonTypeInfo.Id.DEDUCTION, visible = true) @@ -48,5 +50,5 @@ public{{#sealed}} sealed{{/sealed}} interface {{classname}}{{#vendorExtensions.x java.lang.String JSON_DISCRIMINATOR = "{{propertyBaseName}}";{{/discriminator}} @com.fasterxml.jackson.annotation.JsonProperty(JSON_DISCRIMINATOR) - {{discriminator.propertyType}} {{discriminator.propertyGetter}}(); + {{discriminator.propertyType}} {{^record}}{{discriminator.propertyGetter}}{{/record}}{{#record}}{{propertyName}}{{/record}}(); }{{/discriminator}}{{/vendorExtensions.x-is-one-of-interface}} \ No newline at end of file diff --git a/src/main/resources/Micronaut/modelRecord.mustache b/src/main/resources/Micronaut/modelRecord.mustache new file mode 100644 index 00000000..ce52d8a2 --- /dev/null +++ b/src/main/resources/Micronaut/modelRecord.mustache @@ -0,0 +1,17 @@ +{{#serdeable}}@io.micronaut.serde.annotation.Serdeable +{{/serdeable}}public record {{classname}}({{#allVars}} + +{{#description}} /** {{description}} */ +{{/description}}{{#useBeanValidation}}{{>modelPropertyValidation}}{{/useBeanValidation}}{{>modelPropertyJackson}} + {{>modelPropertyType}} {{name}}{{^-last}},{{/-last}}{{/allVars}}){{#interfaceModels}}{{#-first}} implements{{/-first}} {{classname}}{{^-last}}, {{/-last}}{{/interfaceModels}} { +{{#vars}}{{#-first}} +{{/-first}} public static final java.lang.String JSON_PROPERTY_{{nameInSnakeCase}} = "{{baseName}}";{{^-last}} +{{/-last}}{{/vars}}{{#vendorExtensions.discriminatorPropertyValue}} + + @Override + public {{vendorExtensions.discriminatorPropertyType}} {{vendorExtensions.discriminatorPropertyName}}() { + return {{{vendorExtensions.discriminatorPropertyValue}}}; + }{{/vendorExtensions.discriminatorPropertyValue}}{{#allVars}}{{#isEnum}} + +{{>modelEnum}}{{/isEnum}}{{/allVars}} +} \ No newline at end of file diff --git a/src/test/java/org/openapitools/codegen/languages/MicronautCodegenTest.java b/src/test/java/org/openapitools/codegen/languages/MicronautCodegenTest.java index 22ecdcb5..86c9f4c4 100644 --- a/src/test/java/org/openapitools/codegen/languages/MicronautCodegenTest.java +++ b/src/test/java/org/openapitools/codegen/languages/MicronautCodegenTest.java @@ -142,6 +142,14 @@ void modelPojoWithoutSealed() { .addAdditionalProperty(MicronautCodegen.SEALED, false)); } + @DisplayName("model records without JsonNullable") + @Test + void modelRecordsWithoutJsonNullable() { + generate(configurator(SPEC_MODEL, "testmodel.micronaut_record") + .addAdditionalProperty(AbstractJavaCodegen.OPENAPI_NULLABLE, false) + .addAdditionalProperty(MicronautCodegen.RECORD, true)); + } + @DisplayName("model without micronaut annotations") @Test void modelWithoutMicronaut() {