@ElideTypeConverter for Set, List etc. of some class?

[eedijs]

Hi,

I know that it's possible to add a @ElideTypeConverter for a single field, but is it possible to somehow make this converter to work with a field that is a Set, List etc. of some class? For example:

// Class fields
private ClassOne classOne;
private Set<ClassTwo> setOfClassTwo;

// Converters
    @ElideTypeConverter(type = ClassOne .class, name = "ClassOneSerde")
    public class ClassOneSerde implements Serde<String, ClassOne> {
        // Implementation
    }

    @ElideTypeConverter(type = ClassTwo.class, name = "ClassTwoSerde")
    public class ClassTwoSerde implements Serde<String, Set<ClassTwo>> {
        // Implementation
    }

Are these serdes meant to work like that? I've tried it this way, the ClassTwoSerde doesn't seem to trigger in debug mode.

[aklish]

Try this instead:

// Class fields
private Set<ClassTwo> setOfClassTwo;

// Converters

    @ElideTypeConverter(type = ClassTwo.class, name = "ClassTwoSerde")
    public class ClassTwoSerde implements Serde<String, ClassTwo> {
        // Implementation
    }

[eedijs]

Sorry, seems like the issue is elsewhere for which I'm looking for a solution. Here's another example of my situation:

public class MainClass {
    
    private ClassOne classOne;

    public static class ClassOne {

        private EnumOne enumOne;
        private Set<EnumTwo> enumTwo;
        // etc.
    }
}

My enum class example:

public enum EnumOne {
    ENUM_ONE("some_value");

    private final String value;

    EnumOne(String value) {
        this.value = value;
    }

    public static EnumOne fromString(String value) {
    for (EnumOne enum : EnumOne.values()) {
         if (enum.value.equals(value)) {
            return enum;
        }
    }

     return null;
}

    @Override
    public String toString() {
        return this.value;
    }
}

The problem here is that classOne field gets parsed to a LinkedHashMap when sent in API and then CoerceUtil class does the lookup:

            public Converter lookup(Class<?> sourceType, Class<?> targetType) {
                if (targetType.isEnum() && !CoerceUtil.SERDES.containsKey(targetType)) {
                    return CoerceUtil.TO_ENUM_CONVERTER;
                } else {
                    return (Converter)(Map.class.isAssignableFrom(sourceType) ? CoerceUtil.FROM_MAP_CONVERTER : super.lookup(sourceType, targetType));
                }
            }

But the FromMapConverter creates a new ObjectMapper instance for which I can't configure anything, one feature I would need is READ_ENUMS_USING_TO_STRING so that the enum would be created from it's string value instead.

[aklish]

I would need to see your models to understand better what is going on. For an example of something that sounds like your use case, check out this test:

https://github.com/yahoo/elide/blob/master/elide-integration-tests/src/test/java/com/yahoo/elide/tests/ResourceIT.java#L657-L692

That test produces a response like:

HTTP/1.1 200 OK
Date: Tue, 29 Nov 2022 01:15:14 GMT
Content-Type: application/vnd.api+json
Content-Length: 147
Server: Jetty(10.0.10)

{
    "data": {
        "type": "company",
        "id": "abc",
        "attributes": {
            "address": {
                "street1": "street1",
                "street2": null,
                "properties": {
                    "foo": "bar"
                }
            },
            "description": "ABC"
        }
    }
}

The company model looks like:

@Entity
@Include
@Data
public class Company {

    @Id
    private String id;
    private String description;

    @Embedded
    private Address address;
}

and the Address class looks like:

@Embeddable
@Data
public class Address {

    private String street1;
    private String street2;

    @Column(name = "properties", columnDefinition = "TEXT")
    @Convert(attributeName = "key", converter = MapConverter.class)
    Map<Object, Object> properties;
}

The Convert annotation is an ORM annotation to map properties to the database. It is orthogonal to Elide. Embeddable is similar - it is for the ORM and Elide doesn't look at it. Note that the Address is using lombok (Data annotation) here to generate getters and setters. These are important because if the class is lacking an@Id field (like in a normal Elide model), Elide requires getters and setters to create fields for complex (non-primitive) attribute types.

[eedijs]

Thank you, everything seems to be working fine now.