[kotlin-spring] seal allOf discriminator parent interfaces by default (#23953)

A model with a discriminator is rendered as an interface. Because the
generator knows every subtype at generation time, that interface can be
sealed, which lets callers use exhaustive `when` matching and stops
external code from adding implementors that the discriminator mapping
does not know about.

Adds `useSealedDiscriminatorInterfaces` (default true). Set it to false
to restore the plain `interface` rendering, which is needed when the
generated interface is implemented from outside the generated package.

Also declares SchemaSupportFeature.allOf, which the generator supports
but did not advertise.


Claude-Session: https://claude.ai/code/session_01VBn7VWUxZL6mTUbg21xNjm

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: rvlasveld

docs/generators/kotlin-spring.md

@@ -74,6 +74,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |useFlowForArrayReturnType|Whether to use Flow for array/collection return types when reactive is enabled. If false, will use List instead.| |true|
 |useJackson3|Use Jackson 3 dependencies (tools.jackson package). Only available with `useSpringBoot4`. Defaults to true when `useSpringBoot4` is enabled.| |false|
 |useResponseEntity|Whether (when false) to return actual type (e.g. List<Fruit>) and handle non-happy path responses via exceptions flow or (when true) return entire ResponseEntity (e.g. ResponseEntity<List<Fruit>>). If disabled, method are annotated using a @ResponseStatus annotation, which has the status of the first response declared in the Api definition| |true|
+|useSealedDiscriminatorInterfaces|Generate sealed interfaces instead of plain interfaces for allOf discriminator parent models. When true (default), discriminator parents rendered as `sealed interface`, enabling exhaustive `when` matching and preventing external implementors (which cannot know all subtypes). Set to false to restore the legacy plain `interface` behavior, e.g. when you implement the generated interface from a module outside the generated package.| |true|
 |useSealedResponseInterfaces|Generate sealed interfaces for endpoint responses that all possible response types implement. Allows controllers to return any valid response type in a type-safe manner (e.g., sealed interface CreateUserResponse implemented by User, ConflictResponse, ErrorResponse)| |false|
 |useSpringBoot3|Generate code and provide dependencies for use with Spring Boot ≥ 3 (use jakarta instead of javax in imports). Enabling this option will also enable `useJakartaEe`.| |false|
 |useSpringBoot4|Generate code and provide dependencies for use with Spring Boot 4.x. Enabling this option will also enable `useJakartaEe`.| |false|
@@ -325,7 +326,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |Composite|✓|OAS2,OAS3
 |Polymorphism|✓|OAS2,OAS3
 |Union|✗|OAS3
-|allOf|✗|OAS2,OAS3
+|allOf|✓|OAS2,OAS3
 |anyOf|✗|OAS3
 |oneOf|✓|OAS3
 |not|✗|OAS3

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java

@@ -115,6 +115,7 @@ public class KotlinSpringServerCodegen extends AbstractKotlinCodegen
     public static final String GENERATE_PAGEABLE_CONSTRAINT_VALIDATION = "generatePageableConstraintValidation";
     public static final String SUBSTITUTE_GENERIC_PAGED_MODEL = "substituteGenericPagedModel";
     public static final String USE_SEALED_RESPONSE_INTERFACES = "useSealedResponseInterfaces";
+    public static final String USE_SEALED_DISCRIMINATOR_INTERFACES = "useSealedDiscriminatorInterfaces";
     public static final String COMPANION_OBJECT = "companionObject";
     public static final String SUSPEND_FUNCTIONS = "suspendFunctions";
 
@@ -201,6 +202,7 @@ public void setAutoXSpringPaginated(boolean autoXSpringPaginated) {
     @Setter private boolean generatePageableConstraintValidation = false;
     @Setter private boolean substituteGenericPagedModel = false;
     @Setter private boolean useSealedResponseInterfaces = false;
+    @Setter private boolean useSealedDiscriminatorInterfaces = true;
     @Setter private boolean companionObject = false;
     @Setter private boolean useEnumValueInterface = false;
     private String valuedEnumClassName = "ValuedEnum";
@@ -262,7 +264,8 @@ public KotlinSpringServerCodegen() {
                 )
                 .includeSchemaSupportFeatures(
                         SchemaSupportFeature.Polymorphism,
-                        SchemaSupportFeature.oneOf
+                        SchemaSupportFeature.oneOf,
+                        SchemaSupportFeature.allOf
                 )
                 .includeParameterFeatures(
                         ParameterFeature.Cookie
@@ -329,6 +332,13 @@ public KotlinSpringServerCodegen() {
         addSwitch(USE_SEALED_RESPONSE_INTERFACES,
                 "Generate sealed interfaces for endpoint responses that all possible response types implement. Allows controllers to return any valid response type in a type-safe manner (e.g., sealed interface CreateUserResponse implemented by User, ConflictResponse, ErrorResponse)",
                 useSealedResponseInterfaces);
+        addSwitch(USE_SEALED_DISCRIMINATOR_INTERFACES,
+                "Generate sealed interfaces instead of plain interfaces for allOf discriminator parent models. " +
+                "When true (default), discriminator parents rendered as `sealed interface`, enabling exhaustive " +
+                "`when` matching and preventing external implementors (which cannot know all subtypes). " +
+                "Set to false to restore the legacy plain `interface` behavior, e.g. when you implement " +
+                "the generated interface from a module outside the generated package.",
+                useSealedDiscriminatorInterfaces);
         addOption(X_KOTLIN_IMPLEMENTS_SKIP, "A list of fully qualified interfaces that should NOT be implemented despite their presence in vendor extension `x-kotlin-implements`. Example: yaml `xKotlinImplementsSkip: [com.some.pack.WithPhotoUrls]` skips implementing the interface in any schema", "empty list");
         addOption(X_KOTLIN_IMPLEMENTS_FIELDS_SKIP, "A list of fields per schema name that should NOT be created with `override` keyword despite their presence in vendor extension `x-kotlin-implements-fields` for the schema. Example: yaml `xKotlinImplementsFieldsSkip: Pet: [photoUrls]` skips `override` for `photoUrls` in schema `Pet`", "empty map");
         addOption(SCHEMA_IMPLEMENTS, "A map of single interface or a list of interfaces per schema name that should be implemented (serves similar purpose as `x-kotlin-implements`, but is fully decoupled from the api spec). Example: yaml `schemaImplements: {Pet: com.some.pack.WithId, Category: [com.some.pack.CategoryInterface], Dog: [com.some.pack.Canine, com.some.pack.OtherInterface]}` implements interfaces in schemas `Pet` (interface `com.some.pack.WithId`), `Category` (interface `com.some.pack.CategoryInterface`), `Dog`(interfaces `com.some.pack.Canine`, `com.some.pack.OtherInterface`)", "empty map");
@@ -652,6 +662,12 @@ public void processOpts() {
         }
         writePropertyBack(USE_SEALED_RESPONSE_INTERFACES, useSealedResponseInterfaces);
 
+        if (additionalProperties.containsKey(USE_SEALED_DISCRIMINATOR_INTERFACES)) {
+            this.setUseSealedDiscriminatorInterfaces(
+                    Boolean.parseBoolean(additionalProperties.get(USE_SEALED_DISCRIMINATOR_INTERFACES).toString()));
+        }
+        writePropertyBack(USE_SEALED_DISCRIMINATOR_INTERFACES, useSealedDiscriminatorInterfaces);
+
         if (additionalProperties.containsKey(COMPANION_OBJECT)) {
             this.setCompanionObject(convertPropertyToBooleanAndWriteBack(COMPANION_OBJECT));
         } else {

modules/openapi-generator/src/main/resources/kotlin-spring/dataClass.mustache

@@ -14,7 +14,7 @@
 {{#vendorExtensions.x-class-extra-annotation}}
 {{{.}}}
 {{/vendorExtensions.x-class-extra-annotation}}
-{{#discriminator}}interface {{classname}}{{/discriminator}}{{^discriminator}}{{#vendorExtensions.x-is-open-class}}open {{/vendorExtensions.x-is-open-class}}{{^vendorExtensions.x-is-open-class}}{{#hasVars}}data {{/hasVars}}{{/vendorExtensions.x-is-open-class}}class {{classname}}(
+{{#discriminator}}{{#useSealedDiscriminatorInterfaces}}sealed {{/useSealedDiscriminatorInterfaces}}interface {{classname}}{{/discriminator}}{{^discriminator}}{{#vendorExtensions.x-is-open-class}}open {{/vendorExtensions.x-is-open-class}}{{^vendorExtensions.x-is-open-class}}{{#hasVars}}data {{/hasVars}}{{/vendorExtensions.x-is-open-class}}class {{classname}}(
 {{#requiredVars}}
 {{>dataClassReqVar}}{{^-last}},
 {{/-last}}{{/requiredVars}}{{#hasRequired}}{{#hasOptional}},

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/spring/KotlinSpringServerCodegenTest.java

@@ -8105,4 +8105,92 @@ public void testMultiLevelAllOfWithEscapedPropertyNames() throws IOException {
         assertFileContains(mid, "\"2ndField=\" + `2ndField`");
         assertFileNotContains(mid, "$`2ndField`");
     }
+
+    // ==================== allOf sealed interface tests ====================
+
+    @Test(description = "allOf discriminator parent generates sealed interface by default")
+    public void testAllOfDiscriminatorParentIsSealedInterfaceByDefault() throws IOException {
+        File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
+        output.deleteOnExit();
+
+        new DefaultGenerator().opts(new ClientOptInput()
+                        .openAPI(new OpenAPIParser().readLocation("src/test/resources/3_1/polymorphism-allof-and-discriminator.yaml", null, new ParseOptions()).getOpenAPI())
+                        .config(new KotlinSpringServerCodegen() {{
+                            setOutputDir(output.getAbsolutePath());
+                        }}))
+                .generate();
+
+        String outputPath = output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/model";
+
+        // Pet should be a sealed interface with Jackson annotations
+        assertFileContains(Paths.get(outputPath + "/Pet.kt"),
+                "sealed interface Pet",
+                "@JsonTypeInfo", "property = \"petType\"", "visible = true",
+                "@JsonSubTypes"
+        );
+        // Children must remain data classes — sealing only applies to the discriminator parent
+        assertFileContains(Paths.get(outputPath + "/Dog.kt"), "data class Dog");
+        assertFileContains(Paths.get(outputPath + "/Cat.kt"), "data class Cat");
+        assertFileNotContains(Paths.get(outputPath + "/Dog.kt"), "sealed");
+        assertFileNotContains(Paths.get(outputPath + "/Cat.kt"), "sealed");
+    }
+
+    @Test(description = "allOf discriminator parent generates plain interface when useSealedDiscriminatorInterfaces=false")
+    public void testAllOfDiscriminatorOptOutPlainInterface() throws IOException {
+        File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
+        output.deleteOnExit();
+
+        new DefaultGenerator().opts(new ClientOptInput()
+                        .openAPI(new OpenAPIParser().readLocation("src/test/resources/3_1/polymorphism-allof-and-discriminator.yaml", null, new ParseOptions()).getOpenAPI())
+                        .config(new KotlinSpringServerCodegen() {{
+                            setOutputDir(output.getAbsolutePath());
+                            additionalProperties().put(USE_SEALED_DISCRIMINATOR_INTERFACES, "false");
+                        }}))
+                .generate();
+
+        String outputPath = output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/model";
+
+        // Opt-out: plain interface, not sealed
+        assertFileContains(Paths.get(outputPath + "/Pet.kt"), "interface Pet");
+        assertFileNotContains(Paths.get(outputPath + "/Pet.kt"), "sealed interface Pet");
+    }
+
+    @Test(description = "allOf sealed interface correctly composes external x-kotlin-implements supertypes")
+    public void testSealedInterfaceWithExternalSupertypes() throws IOException {
+        File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
+        output.deleteOnExit();
+
+        new DefaultGenerator().opts(new ClientOptInput()
+                        .openAPI(new OpenAPIParser().readLocation("src/test/resources/3_0/kotlin/petstore-with-x-kotlin-implements.yaml", null, new ParseOptions()).getOpenAPI())
+                        .config(new KotlinSpringServerCodegen() {{
+                            setOutputDir(output.getAbsolutePath());
+                        }}))
+                .generate();
+
+        String outputPath = output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/model";
+
+        // Pet has x-kotlin-implements external supertypes; sealed should come before those
+        assertFileContains(Paths.get(outputPath + "/Pet.kt"),
+                "sealed interface Pet : com.some.pack.Named"
+        );
+    }
+
+    @Test(description = "oneOf sealed interface stays sealed when useSealedDiscriminatorInterfaces=false (different template path)")
+    public void testOneOfInterfaceStillSealedWhenAllOfFlagOff() throws IOException {
+        File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
+        output.deleteOnExit();
+
+        new DefaultGenerator().opts(new ClientOptInput()
+                        .openAPI(new OpenAPIParser().readLocation("src/test/resources/3_0/kotlin/polymorphism-oneof-discriminator.yaml", null, new ParseOptions()).getOpenAPI())
+                        .config(new KotlinSpringServerCodegen() {{
+                            setOutputDir(output.getAbsolutePath());
+                            additionalProperties().put(USE_SEALED_DISCRIMINATOR_INTERFACES, "false");
+                        }}))
+                .generate();
+
+        String outputPath = output.getAbsolutePath() + "/src/main/kotlin/org/openapitools/model";
+
+        // oneOf parent uses oneof_interface.mustache, not dataClass.mustache — flag has no effect on it
+        assertFileContains(Paths.get(outputPath + "/Animal.kt"), "sealed interface Animal");
+    }
 }

samples/server/others/kotlin-springboot/allOf-multilevel/src/main/kotlin/org/openapitools/model/Animal.kt

@@ -31,7 +31,7 @@ import jakarta.validation.Valid
       JsonSubTypes.Type(value = Dog::class, name = "Dog")
 )
 
-interface Animal {
+sealed interface Animal {
 
         val className: kotlin.String
 

samples/server/petstore/kotlin-springboot-include-http-request-context-delegate/src/main/kotlin/org/openapitools/model/Pet.kt

@@ -44,7 +44,7 @@ import io.swagger.annotations.ApiModelProperty
       JsonSubTypes.Type(value = Dog::class, name = "Dog")
 )
 
-interface Pet : com.some.pack.Named, com.some.pack.WithCategory, com.some.pack.WithDefaultMethods, com.some.pack.WithPhotoUrls, java.io.Serializable {
+sealed interface Pet : com.some.pack.Named, com.some.pack.WithCategory, com.some.pack.WithDefaultMethods, com.some.pack.WithPhotoUrls, java.io.Serializable {
 
         @get:ApiModelProperty(required = true, value = "")
         override val name: kotlin.String

samples/server/petstore/kotlin-springboot-request-cookie/src/main/kotlin/org/openapitools/model/Animal.kt

@@ -34,7 +34,7 @@ import io.swagger.v3.oas.annotations.media.Schema
       JsonSubTypes.Type(value = Dog::class, name = "DOG")
 )
 
-interface Animal {
+sealed interface Animal {
                 @get:Schema(requiredMode = Schema.RequiredMode.REQUIRED, description = "")
         val className: kotlin.String
 

samples/server/petstore/kotlin-springboot-x-kotlin-implements/src/main/kotlin/org/openapitools/model/Pet.kt

@@ -44,7 +44,7 @@ import io.swagger.annotations.ApiModelProperty
       JsonSubTypes.Type(value = Dog::class, name = "Dog")
 )
 
-interface Pet : com.some.pack.Named, com.some.pack.WithCategory, com.some.pack.WithDefaultMethods, com.some.pack.WithId, java.io.Serializable {
+sealed interface Pet : com.some.pack.Named, com.some.pack.WithCategory, com.some.pack.WithDefaultMethods, com.some.pack.WithId, java.io.Serializable {
 
         @get:ApiModelProperty(required = true, value = "")
         override val name: kotlin.String