Best practice for enums that implement interfaces?

[antch]

In my codebase I have a bunch of enums that follow the pattern:

public enum MyEnum implements Descriptive {

  VAL1("Value 1 Description"), VAL2("Value 2 Description");
  
  private String description;

  private MyEnum(String description) {
    this.description = description;
  }

  @Override
  public String getDescription() {
    return this.description;
  }

  public String getCustomField() {
    //specific to this enum, not part of an interface
  }
  
}

In this case there is value to having a TypeScript enum for just the enum values (current behavior), but in some cases we need to deal with the MyEnum fields and super-interfaces so having the ability to generate those as well would be really useful. Right now we have to manually create additional types for each enum.

Is there any way to get the generator to create the enum with just the values, as it does now, as well as to create them as classes with proper inheritance?

I do see ClassEnumExtension but I don't think that supports generating multiple types?

Thanks!

[vojtechhabarta]

I am not sure how exactly you want to use generated types. Let's say you have following Java class:

class MyEnumUsage {
    MyEnum myEnum;
}

so generated TypeScript interface would be:

interface MyEnumUsage {
    myEnum: MyEnum;  // what is MyEnum here?
}

What type should these properties have? Should this type reference generated interface or enum?

In any case I think this has no easy solution. You can try two ways:

1. have Java class and use ClassEnumExtension to create TsEnumModel in addition to TsBeanModel (and retain both)
2. have Java enum and create TsBeanModel in some new extension in addition to TsEnumModel

Actually I cannot recommend point 2.
In both cases you would need to solve name conflict by appending some suffix to one of these types.

If you will try to modify ClassEnumExtension you will need to remove withoutBeans(classEnums) call here:

typescript-generator/typescript-generator-core/src/main/java/cz/habarta/typescript/generator/ext/ClassEnumExtension.java

Line 68 in 71eff38

return model.withEnums(stringEnums).withoutBeans(classEnums);

to retain both types and you will need to generate unique name for new TsEnumModel using symbolTable.getSymbol(cls, suffix) method.

[antch]

I realized that some of the confusion may be because I accidentally used class instead of enum in my snippet -- I just corrected it.

So, the main use case that I have is services that return metadata about the enums themselves, for example, a service that currently returns JSON like:

{
  "com.mypackage.MyEnum": {
    "VAL1": { //this object is what needs a generated interface
      "name: "VAL1",
      "description": "Value 1 Description",
      "customField": 42
    }
  },
  "com.myotherpackage.MyOtherEnum": {
    //snip
  }
}

You are correct in that I'd want to generate both a TypeScript class (that models the enum as a bean), and an enum as is currently supported. You are also correct in that there would be some sort of suffix that would need to be added to one of them to avoid conflicts -- I'm leaning towards appending "EnumClass" or "Class" to the bean and leaving the enum name as-is.

The other important thing is that if the Java enum implements any interfaces those would need types as well to support inheritance just like with the other generated classes.

[vojtechhabarta]

And how do you make Jackson to return enum constant as object instead of just single value?

[antch]

The enum gets converted to a Map via reflection in the endpoint.

[vojtechhabarta]

I don't see any reasonable way how to generate both TypeScript enum and interface from one Java enum. In general it is always a problem to generate types for JSON data produced using reflections or using custom serializers.

But maybe I misunderstood your case. Maybe it is sufficient just to generate one TypeScript enum type for one Java enum and TypeScript interfaces for Java interfaces as usual. You could have for example following Java types:

interface BasicEnum {
    String getConstantName();
}
interface Descriptive extends BasicEnum {
    String getDescription();
}
interface MyEnumDescription extends Descriptive {
}
enum MyEnum implements MyEnumDescription {
    // ...
}
class SomeClass {
    MyEnum getSelectedMyEnum() {
        return MyEnum.VAL1;
    }
    List<MyEnumDescription> getMyEnumDescriptions() {
        // ...
    }
}

When you generate TypeScript declarations for SomeClass you will also get declarations for all needed enums and interfaces. You can also remove MyEnumDescription interface if you don't need it end derive enum directly from Descriptive.

[antch]

I don't really understand the example, I will have to spend some time to digest it. All I need is to be able to generate a TS class from the enum treated like a class, as well as the enum itself...

[vojtechhabarta]

Generating these two declarations from single Java enum is currently really problematic.

So what I tried to suggest was (in Java) for each enum MyEnumX also create interface IMyEnumX with the same set of getter methods. And then let typescript-generator to generate declarations for those interfaces as well as original enums. In this case generated TypeScript interface IMyEnumX will have the same structure as MyEnumX constans represented as objects.

[antch]

Ok, thanks for letting me know. Unfortunately there are hundreds of enums so I will do my best with a generic Enum interface and some manual type extensions in TS when needed.

[richturner]

I know this issue is closed but I've come up against this situation also, in my situation the enum is used to define a well known set of interface implementations that can be used within the JVM; here's an abstract example:

public interface Coloured {
   String getColour();
}

public enum Fruit implements Coloured {
   BANANA("yellow"),
   ORANGE("orange");

   public String getColour();
}

public interface ColouredUsage {
   Coloured getColouredThing();
}

In typescript it would be nice if I could reference these well known implementations of Coloured just like I do in java, one way I have thought of doing this is to output the following (based on above abstract example):

const Fruit = {
    BANANA: {colour: "yellow"},
    ORANGE: {colour: "orange"}
};

interface Coloured {
   colour: string;
}

interface ColouredUsage {
   colouredThing: Coloured;
}

const colouredUsage: ColouredUsage = {
   colouredThing: Fruit.BANANA
}

Would be good to have an extension to cover this use case, any tips on implementing this @vojtechhabarta ?

[vojtechhabarta]

I don't know what is nice solution for this case. If you really want to generate this you can look into existing extensions here: https://github.com/vojtechhabarta/typescript-generator/tree/master/typescript-generator-core/src/main/java/cz/habarta/typescript/generator/ext.

You could also try to write or generate union types like type ColouredUnion = Fruit | Flower and use it instead of type Coloured. Similar approach is used for tagged unions feature (#81).

But I would first try to simplify this domain model for TypeScript.

[richturner]

I have created an extension that outputs enums that implement interfaces as classes with static fields that represent each enum member; this allows these enums to be referenced by a property with a type that matches one of the enums interfaces, providing java enum functionality in typescript. It wasn't a simple task and it works well on a fairly large code base I am working with (included a basic topological sort to figure out ordering of the generated enum classes).

The extension only makes sense when output type is implementation as const initializers are not allowed in declaration files.

In some ways it would be nice to see this more tightly integrated and cleaned up but it is starting to move this generator towards more of a full blown transpiler.

@vojtechhabarta I'd agree that a simplified domain model is always something to aim for to allow cross platform usage. In my scenario I am working with a very dynamic object model and having well known implementations of interfaces is important, given the flexibility of java enums we chose to use them for this purpose, but could also just as feasibly be done as static final fields in a java class; either way it is nice to have these available in typescript also.

Can be found here, I've also added a test for this functionality.

[vojtechhabarta]

I am not sure if the goal should be to handle whole Java language 😏

But if you think your extension could be useful for others you can create PR (ideally with example) and I will merge it.