feature: Support for sealed classes containing tagged unions

Java language level 17 and above supports isSealed on member types.

This uses the proposal of FasterXML/jackson-module-kotlin#239 and the general solution of FasterXML/jackson-module-kotlin#240 to import subtypes of a sealed object or interface that are annotated with `@JsonTypeName` and assignable to the container class or interface to create a much less verbose method of generating tagged unions.

Author: Nthalk

typescript-generator-core/pom.xml

@@ -331,6 +331,14 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>17</source>
+                    <target>17</target>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/parser/Jackson2Parser.java

@@ -9,6 +9,7 @@
 import com.fasterxml.jackson.annotation.JsonPropertyDescription;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.JsonTypeName;
 import com.fasterxml.jackson.annotation.JsonUnwrapped;
 import com.fasterxml.jackson.annotation.JsonView;
 import com.fasterxml.jackson.annotation.ObjectIdGenerators;
@@ -108,11 +109,11 @@ public Jackson2Parser create(Settings settings, TypeProcessor commonTypeProcesso
     }
 
     public static class JaxbParserFactory extends Jackson2ParserFactory {
-        
+
         public JaxbParserFactory() {
             super(true);
         }
-        
+
     }
 
     private final ObjectMapper objectMapper = new ObjectMapper();
@@ -336,16 +337,23 @@ private BeanModel parseBean(SourceType<Class<?>> sourceClass, List<String> class
             }
         }
 
-        final List<Class<?>> taggedUnionClasses;
+        final List<Class<?>> taggedUnionClasses = new ArrayList();
         final JsonSubTypes jsonSubTypes = sourceClass.type.getAnnotation(JsonSubTypes.class);
         if (jsonSubTypes != null) {
-            taggedUnionClasses = new ArrayList<>();
             for (JsonSubTypes.Type type : jsonSubTypes.value()) {
                 addBeanToQueue(new SourceType<>(type.value(), sourceClass.type, "<subClass>"));
                 taggedUnionClasses.add(type.value());
             }
-        } else {
-            taggedUnionClasses = null;
+        } else if(sourceClass.type.isSealed()){
+            for (Class<?> cls: sourceClass.type.getDeclaredClasses()){
+                if(sourceClass.type.isAssignableFrom(cls)){
+                    JsonTypeName jsonTypeName = cls.getAnnotation(JsonTypeName.class);
+                    if(jsonTypeName != null){
+                        addBeanToQueue(new SourceType<>(cls, sourceClass.type, "<subClass>"));
+                        taggedUnionClasses.add(cls);
+                    }
+                }
+            }
         }
         final Type superclass = sourceClass.type.getGenericSuperclass() == Object.class ? null : sourceClass.type.getGenericSuperclass();
         if (superclass != null) {

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/Jackson2ParserTest.java

@@ -93,9 +93,9 @@ public void testTaggedUnion() {
         final BeanModel bean4 = model.getBean(SubTypeDiscriminatedByName4.class);
         final BeanModel bean5 = model.getBean(SubTypeDiscriminatedByName5.class);
         Assertions.assertEquals(4, bean0.getTaggedUnionClasses().size());
-        Assertions.assertNull(bean1.getTaggedUnionClasses());
-        Assertions.assertNull(bean2.getTaggedUnionClasses());
-        Assertions.assertNull(bean3.getTaggedUnionClasses());
+        Assertions.assertTrue(bean1.getTaggedUnionClasses().isEmpty());
+        Assertions.assertTrue(bean2.getTaggedUnionClasses().isEmpty());
+        Assertions.assertTrue(bean3.getTaggedUnionClasses().isEmpty());
         Assertions.assertEquals("kind", bean0.getDiscriminantProperty());
         Assertions.assertEquals("explicit-name1", bean1.getDiscriminantLiteral());
         Assertions.assertEquals("SubType2", bean2.getDiscriminantLiteral());
@@ -492,7 +492,7 @@ private ClassWithJsonCreatorConstructor(@JsonProperty("a") String a, @MyOptional
         public String toString() {
             return "{" + "a=" + a + ", b=" + b + '}';
         }
-        
+
     }
     @Test
     public void testFactoryMethod() throws JsonProcessingException {
@@ -526,7 +526,7 @@ public static ClassWithJsonCreatorFactoryMethod create(@JsonProperty("a") String
         public String toString() {
             return "{" + "a=" + a + ", b=" + b + '}';
         }
-        
+
     }
 
     @Retention(RetentionPolicy.RUNTIME)

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/TaggedUnionsTest.java

@@ -82,21 +82,21 @@ private static class CCircle2 implements IShape2 {
     })
     interface IShape3 {
     }
-    
+
     interface IQuadrilateral3 extends IShape3 {
     }
-    
+
     interface INamedShape3 extends IShape3 {
         String getName();
     }
-    
+
     interface INamedQuadrilateral3 extends INamedShape3, IQuadrilateral3 {
     }
-    
+
     @JsonTypeName("rectangle")
     interface IRectangle3 extends INamedQuadrilateral3 {
     }
-    
+
     @JsonTypeName("circle")
     interface ICircle3 extends INamedShape3 {
     }
@@ -689,4 +689,62 @@ public void testIntermediateUnions() {
         Assertions.assertEquals(expected.trim(), output.trim());
     }
 
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
+    public sealed interface SealedInterface {
+        @JsonTypeName("a")
+        final class SealedInterfaceA implements SealedInterface {
+        }
+        @JsonTypeName
+        final class SealedInterfaceB implements SealedInterface {
+        }
+        final class SealedInterfaceC_ShouldBeMissing{}
+    }
+    @Test
+    public void testSealedInterfaceDetection() {
+        final String output = new TypeScriptGenerator(TestUtils.settings()).generateTypeScript(Input.from(SealedInterface.class));
+        Assertions.assertEquals("\n" +
+                "interface SealedInterface {\n" +
+                "    \"@type\": \"TaggedUnionsTest$SealedInterface$SealedInterfaceB\" | \"a\";\n" +
+                "}\n" +
+                "\n" +
+                "interface SealedInterfaceB extends SealedInterface {\n" +
+                "    \"@type\": \"TaggedUnionsTest$SealedInterface$SealedInterfaceB\";\n" +
+                "}\n" +
+                "\n" +
+                "interface SealedInterfaceA extends SealedInterface {\n" +
+                "    \"@type\": \"a\";\n" +
+                "}\n" +
+                "\n" +
+                "type SealedInterfaceUnion = SealedInterfaceB | SealedInterfaceA;\n", output);
+    }
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
+    public sealed class SealedClass {
+        @JsonTypeName("a")
+        final class SealedClassA extends SealedClass {
+        }
+        @JsonTypeName
+        final class SealedClassB extends SealedClass {
+        }
+        final class SealedClassC_ShouldBeMissing{}
+    }
+    @Test
+    public void testSealedClassDetection() {
+        final String output = new TypeScriptGenerator(TestUtils.settings()).generateTypeScript(Input.from(SealedClass.class));
+        Assertions.assertEquals("\n" +
+                "interface SealedClass {\n" +
+                "    \"@type\": \"TaggedUnionsTest$SealedClass\" | \"TaggedUnionsTest$SealedClass$SealedClassB\" | \"a\";\n" +
+                "}\n" +
+                "\n" +
+                "interface SealedClassB extends SealedClass {\n" +
+                "    \"@type\": \"TaggedUnionsTest$SealedClass$SealedClassB\";\n" +
+                "}\n" +
+                "\n" +
+                "interface SealedClassA extends SealedClass {\n" +
+                "    \"@type\": \"a\";\n" +
+                "}\n" +
+                "\n" +
+                "type SealedClassUnion = SealedClassB | SealedClassA;\n", output);
+    }
+
 }