Struggles while supporting a "One Of" data type

[Jonathan-Zollinger]

Overview

this server I'm consuming has one field which can be one of 5 types and I feel like I'm over complicating how to support this.

Data Examples

The data I'm consuming is the field in Zendesk's ticketing api for custom fields - it's pretty basic so I'm kinda frustrated I'm struggling with this. the json has two properties, an ID of type long and a nullable property called "value" whose value can either be a a number with no decimals, a number with two decimal points, boolean, String or lastly an array of strings.

{id: 123456, "spam and eggs" }, {"id": 654321, false }, {"id": 99, "value": ["alpha", "beta"]}'

What I've tried

since micronaut uses jackson, I read up on jackson's implementation of polymorphic deserialization and came up with the below (along with each of the classes with similar annotations), but I couldn't work through errors stating that no default constructor could be found in my tests.

Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
@Data
@JsonPropertyOrder({
        TicketCustomFieldsInner.JSON_PROPERTY_ID,
        TicketCustomFieldsInner.JSON_PROPERTY_VALUE,
})
@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.PROPERTY,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = TicketCustomFieldStringArray.class, name = "string[]"),
        @JsonSubTypes.Type(value = TicketCustomFieldLong.class, name = "long"),
        @JsonSubTypes.Type(value = TicketCustomFieldFloat.class, name = "float"),
        @JsonSubTypes.Type(value = TicketCustomFieldString.class, name = "string"),
        @JsonSubTypes.Type(value = TicketCustomFieldBoolean.class, name = "boolean")
})
@Serdeable
public class TicketCustomFieldsInner {

    public static final String JSON_PROPERTY_ID = "id";
    public static final String JSON_PROPERTY_VALUE = "value";

    /**
     * The id of the custom field
     */
    @Nullable
    @JsonProperty(JSON_PROPERTY_ID)
    @JsonInclude(JsonInclude.Include.USE_DEFAULTS)
    private Long id;

    /**
     * The value of the custom field
     */
    @Nullable
    @JsonProperty(JSON_PROPERTY_VALUE)
    @JsonInclude(JsonInclude.Include.USE_DEFAULTS)
    private Object value;

}

example implementing class

@EqualsAndHashCode(callSuper = true)
@Data
@Serdeable
@JsonTypeName("string[]")
public class TicketCustomFieldStringArray extends TicketCustomFieldsInner {
    private String[] value;
}

Like I said, I couldn't get this to work - in my tests I kept getting errors stating that jackson couldn't find constructors to use. similarly I tried implementing jackson's deduction based serialization but couldn't get anywhere that way either

My Overcomplicated take

what I've currently written that is working but makes me think I've gone about this wrong because of how complicated it is.

DTO

@Data
@Accessors(chain = true)
@EqualsAndHashCode
public class TicketCustomField<T> {
    Long id;
    T value;
}

Serde implementation

@Override
public TicketCustomField<?> deserialize(Decoder decoder, DecoderContext context, Argument<? super TicketCustomField<?>> instance) throws IOException {
    Long id = null;
    Object value = null;
    Argument<?> valueTypeArgument = instance.getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT);
    var objectDecoder = decoder.decodeObject();
    String currentKey;
    while ((currentKey = objectDecoder.decodeKey()) != null) {
        switch (currentKey) {
            case "id" -> id = decoder.decodeLong();
            case "value" -> {
                switch (valueTypeArgument.getType()) {
                    case Class<?> c when c == String.class -> value = decoder.decodeString();
                    case Class<?> c when c == List.class -> value = decodeStringList(decoder);
                    case Class<?> c when c == Long.class -> value = decoder.decodeNumber().longValue();
                    case Class<?> c when c == Float.class -> value = decoder.decodeNumber().floatValue();
                    case Class<?> c when c == Boolean.class -> value = decoder.decodeBoolean();
                    case Class<?> c when c == Object.class || c == Void.class -> value = decoder.decodeNull();
                    default -> throw new IllegalArgumentException(VALIDATION_ERR);
                }
            }
            default -> decoder.skipValue();
        }
    }

    return new TicketCustomField<>().setId(id).setValue(value);
}

Test:

@Unroll
def "should deserialize polymorphic custom field type: #expectedClass.simpleName"() {
    given: "A raw JSON snippet representing a customized field payload"
    def json = """{"id": 42, "value": ${jsonValue}}"""

    when: "We explicitly request parsing using a concrete type Argument"
    def targetArgument = Argument.of(TicketCustomField, valueClass)
    TicketCustomField<?> result = objectMapper.readValue(json, targetArgument)

    then: "The structural fields are correctly extracted"
    result.id == 42
    expectedClass.isInstance(result.value)

    and: "The data value matches our expected value perfectly"
    result.value == expectedValue

    where:
    jsonValue             | valueClass | expectedClass | expectedValue
    '"flibberty giblets"' | String     | String        | "flibberty giblets"
    'true'                | Boolean    | Boolean       | true
    '10023'               | Long       | Long          | 10023L
    '45.29'               | Float      | Float         | 45.29f
}

Wrap Up

ultimately I can't help but think I'm overcomplicating this. technically my tests are passing, but I haven't even gotten to testing the encoding portion of the serde class, which I'm sure isn't working in its current state.

Can anyone point out how this is meant to be done with micronaut's serialization? I appreciate any help, thanks!