feature: Support for sealed classes containing tagged unions

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.

Sealed types are supported in kotlin 1.6+ and Java 17+, however, we don't really need the sealed functionality, as we are an offline, one-shot generator, this may work to generate the correct type mappings, but fail to parse on the runtime object mapper side unless the user is using the supported kotlin and java versions.

Author: Nthalk

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;
+            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,60 @@ public void testIntermediateUnions() {
         Assertions.assertEquals(expected.trim(), output.trim());
     }
 
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
+    public 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 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);
+    }
 }