Type error with union types (fromDataUnion)

[ychailler]

I sometimes get a type error in the fromDataUnion(data) method in the switch expression :

static fromDataUnion(data: RoleUnion): RoleUnion {
        if (!data) {
            return data;
        }
        switch (data.role) {
            case "ROLE_A":
                return RoleA.fromData(data);
            case "ROLE_B":
                return RoleB.fromData(data);
            case "ROLE_C":
                return RoleC.fromData(data); // here
...

I had to add a cast to make it work :
RoleC.fromData(<RoleC> data);

Maybe we could add automatically this cast in every switch case to avoid type errors ?

[vojtechhabarta]

I would like to first know what exactly is wrong.
Could you please extract some example? Something like you just provided plus RoleUnion and RoleC?

[ychailler]

i tried to extract the piece of generated code that does not compile from my result file :

/* tslint:disable */
/* eslint-disable */
// Generated using typescript-generator version 2.15.527 on 2019-06-22 08:47:14.

export class Role {
    role: LVRole;

    static fromData(data: Role, target?: Role): Role {
        if (!data) {
            return data;
        }
        const instance = target || new Role();
        instance.role = data.role;
        return instance;
    }

    static fromDataUnion(data: RoleUnion): RoleUnion {
        if (!data) {
            return data;
        }
        switch (data.role) {
            case "CLIENT":
                return ClientRole.fromData(data);
            case "CONTACT":
                return ContactRole.fromData(data);
        }
    }
}

export class ClientRole extends Role {
    type: string;

    static fromData(data: ClientRole, target?: ClientRole): ClientRole {
        if (!data) {
            return data;
        }
        const instance = target || new ClientRole();
        super.fromData(data, instance);
        instance.type = data.type;
        return instance;
    }
}

export class ContactRole extends Role {
    static fromData(data: ContactRole, target?: ContactRole): ContactRole {
        if (!data) {
            return data;
        }
        const instance = target || new ContactRole();
        super.fromData(data, instance);
        return instance;
    }
}

export type RoleUnion = ClientRole | ContactRole
export enum LVRole {
    CLIENT = "CLIENT",
    CONTACT = "CONTACT"
}

The error I get is

> tsc --module umd --moduleResolution node --target es5 --lib es6 --declaration --sourceMap index.ts

index.ts:23:44 - error TS2345: Argument of type 'RoleUnion' is not assignable to parameter of type 'ClientRole'.
  Type 'ContactRole' is not assignable to type 'ClientRole'.
    Property 'type' is missing in type 'ContactRole'.

23                 return ClientRole.fromData(data);
                                              ~~~~

[ychailler]

Here i add the Java class for Role with its jackson annotations

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "role", include = JsonTypeInfo.As.PROPERTY, visible = false)
@JsonSubTypes({
    @JsonSubTypes.Type(value = ClientRole.class, name = "CLIENT"),
    @JsonSubTypes.Type(value = ContactRole.class, name = "CONTACT")
})
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY, getterVisibility = JsonAutoDetect.Visibility.NONE, setterVisibility = JsonAutoDetect.Visibility.NONE)
public abstract class Role {
 private LVRole role;
...
}

[vojtechhabarta]

Thanks for your example.
I realized that the root cause is more complex and deeper.
In your example Role class hierarchy is not handled by typescript-generator correctly as tagged union. Ideally following TypeScript code should be generated but there are missing discriminant properties (marked in comments):

export class Role {
    role: "CLIENT" | "CONTACT";  // is LVRole
}
export class ClientRole extends Role {
    role: "CLIENT";  // is missing
    type: string;
}
export class ContactRole extends Role {
    role: "CONTACT";  // is missing
}
export type RoleUnion = ClientRole | ContactRole;

When I removed LVRole role field this code was generated correctly.
And with this code fromDataUnion method is valid.

So ideally I would fix these discriminant properties but it is not clear how because there is a problem in Jackson library itself. When you try to serialize following data:

ClientRole clientRole = new ClientRole();
clientRole.role = LVRole.CONTACT;
clientRole.type = "aaa";
System.out.println(new ObjectMapper().writeValueAsString(clientRole));

Jackson produces invalid JSON:

{
    "role": "CLIENT",
    "role": "CONTACT",
    "type": "aaa"
}

I think current solution for you is to remove LVRole role field because it is not working correctly in Jackson. I think that (as it is designed in Jackson now) you should leave handling of role property to Jackson and in Java just use instanceof operator (instead of this property).

[vojtechhabarta]

You can also change include = JsonTypeInfo.As.PROPERTY to include = JsonTypeInfo.As.EXISTING_PROPERTY which should solve problem with duplicated property in JSON but this is not recognized as tagged union by typescript-generator.

[ychailler]

Hello,

Thanks for your answer, but unfortunately I don't have access to the java library that contain the classes and cannot change the Jackson annotations.

[vojtechhabarta]

In v2.16.538 I changed how issue with duplicate property is handled (#392). So now typescript-generator should produce valid TypeScript code because it will not generate tagged union in this case. Please let me know if there is still some invalid code.

But I think you should still request author of the class to change it to avoid this Jackson issue.