Adding an alias to the @JsonTypeInfo property lookup

[MaxwellBo]

Hi!

My org has two JSON encoding schemes active in the system, one with minified keys and values and another one with unminified keys and values. These encodings are serialized and deserialized by independent class definitions. I am unifiying these classes, by adapting existing unminified-deserializing classes to decode both encoding schemes simultaneously, and deleting minified-deserializing classes.

I have been well served by the @JsonAliass annotation, by adding @JsonAlias("<MINIFIED KEY>") to fields. However, I have run into issues when trying to adapt classes that use @JsonTypeInfo.

I would like to add A? as an alias to @JsonTypeInfo's discriminator property lookup such that the following JSON strings are deserialised by the Shape abstract class:

{ "type": "square", "width": 1.0 } AND { "A?": "A", "A": 1.0 }

Codifying this into a test:

package example;

import static org.assertj.core.api.Assertions.assertThat;

import com.fasterxml.jackson.annotation.JsonAlias;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeInfo.Id;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;

public class DiscriminatorAliasTest {

  @JsonTypeInfo(use = Id.NAME, include = As.PROPERTY, property = "type", propertyAlias = "A?")
  @JsonSubTypes({
      @JsonSubTypes.Type(value = Square.class, names = { "square", "A" }),
      @JsonSubTypes.Type(value = Circle.class, names = { "circle", "B" })
  })
  static abstract class Shape {
    abstract public String name();
  }

  static class Square extends Shape {
    @JsonProperty("width")
    @JsonAlias("A")
    public float width;

    @Override
    public String name() { return "square"; }
  }

  static class Circle extends Shape {
    @JsonProperty("diameter")
    @JsonAlias("B")
    public float diameter;

    @Override
    public String name() { return "circle"; }
  }

  @Test
  public void testDiscriminator() throws Exception {
    ObjectMapper mapper = new ObjectMapper();

    // Passes
    String squareJsonUnminified = "{\"type\":\"square\", \"width\": 1.0 }";
    Shape square = mapper.readerFor(Shape.class).readValue(squareJsonUnminified);
    assertThat(square.name()).isEqualTo("square");

    // This fails (as expected)
    String squareJsonMinified = "{\"A?\":\"A\", \"A\": 1.0 }";
    Shape squareAgain = mapper.readerFor(Shape.class).readValue(squareJsonMinified);
    assertThat(squareAgain.name()).isEqualTo("square");
  }
}

I've used the non-existent propertyAlias parameter in this example above, so obviously this does not pass at the moment.

I'm wondering if there's a simple enough work around here using a semi-custom @JsonTypeInfo configuration and some subtle modifications to Square and Circle. I've managed to get the above test case passing with a custom @JsonDeserialize(using = ShapeDeserializer.class) but it's not a pretty or scalable solution. As you can imagine, I'm trying to make this change to many classes, so the smaller the diff the better.

Thank-you in advance to all contributors and maintainers of this library.

[cowtowncoder]

Ok, I can see how this could be useful, but knowing how the implementation works, I must say that it is unlikely that alias support will be added for Type discriminator property.

I suspect various work-arounds may exist; for example, reading of content first as JsonNode, replacing "A?" with "type".
But nothing obvious, nice and clean comes to mind unfortunately.

[MaxwellBo]

Ah thank-you for the swift response @cowtowncoder.

Your answer is somewhat a relief: I came to a similar conclusion and implemented the JsonNode workaround in my custom @JsonDeserialize(using = ShapeDeserializer.class).

Thank-you again!

[hajdamak]

@MaxwellBo @cowtowncoder Can you please share more details how exactly this custom deserializer that replaces fields would look like?

[JooHyukKim]

You mean how to implement custom deserializer? If so, there is bunch of example on Google or SO

[hajdamak]

No. I mean how to implement deserializer that handles this particular case. For example as @cowtowncoder suggested by replacing A? property with type or any other way.

[MaxwellBo]

@hajdamak

Ideally @JsonTypeInfo would accept a properties param instead of a single property, akin to the names param of @JsonSubTypes.Type such that

@JsonTypeInfo(use = Id.NAME, include = As.PROPERTY, properties = { "type", "A?" })

would define "A?" as a type discriminator field alias.

We ended up developing a workaround (at odds with the suggestion of @cowtowncoder) with a custom
@JsonTypeInfoPropertyAlias annotation, with usage:

@JsonTypeResolver(AliasedPropertyTypeResolver.class)
@JsonTypeInfoPropertyAlias("A?")
@JsonTypeInfo(use = Id.NAME, include = As.PROPERTY, property = "type")
@JsonSubTypes({
  @JsonSubTypes.Type(value = CaseA.class, names = { "CASE_A", "A" }),
  @JsonSubTypes.Type(value = CaseB.class, names = { "CASE_B", "B" }),
})
public abstract static class Base {
  ...
}

public static class CaseA extends Base {
  ...
}}

and implementation:

public class AliasedPropertyTypeResolver extends StdTypeResolverBuilder {

  /**
   * A variant of {@link AsPropertyTypeDeserializer} that accepts an additional property to
   * inspect for a type identifier.
   * <p>
   * A {@link AsPropertyTypeDeserializer} is the {@link TypeDeserializer} that a
   * {@link StdTypeResolverBuilder} will synthesize when a
   * {@link com.fasterxml.jackson.annotation.JsonTypeInfo} is configured like so:
   * {@code @JsonTypeInfo(use = Id.NAME, include = As.PROPERTY, property = "type")
   *
   */
  private static class AliasedPropertyTypeInfoDeserializer extends AsPropertyTypeDeserializer {
    private final String typePropertyAlias;

    public AliasedPropertyTypeInfoDeserializer(AsPropertyTypeDeserializer src, BeanProperty property, String typePropertyAlias) {
      super(src, property);
      this.typePropertyAlias = typePropertyAlias;
    }

    @Override
    public TypeDeserializer forProperty(BeanProperty prop) {
      return (_property == prop) ? this : new AliasedPropertyTypeInfoDeserializer(this, prop, typePropertyAlias);
    }

    /**
     * This method implementation was copy-pasted from
     * {@link AsPropertyTypeDeserializer#deserializeTypedFromObject(JsonParser, DeserializationContext)}
     * except the change to the line
     * {@code if (name.equals(this._typePropertyName) || ignoreCase && name.equalsIgnoreCase(this._typePropertyName)) {}
     * to support the aliasing functionality.
     */
    @Override
    public Object deserializeTypedFromObject(JsonParser p, DeserializationContext ctxt) throws
        IOException {

      JsonToken t = p.currentToken();
      if (t == JsonToken.START_OBJECT) {
        t = p.nextToken();
      } else if (t != JsonToken.FIELD_NAME) {
        return _deserializeTypedUsingDefaultImpl(p, ctxt, null, _msgForMissingId);
      }

      TokenBuffer tb = null;
      for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) {
        final String name = p.currentName();
        p.nextToken();
        // This line below was changed from the parent implementation
        if (name.equals(_typePropertyName) || name.equals(typePropertyAlias)) {
          String typeId = p.getValueAsString();
          if (typeId != null) {
            return _deserializeTypedForId(p, ctxt, tb, typeId);
          }
        }
        if (tb == null) {
          tb = ctxt.bufferForInputBuffering(p);
        }
        tb.writeFieldName(name);
        tb.copyCurrentStructure(p);
      }
      return _deserializeTypedUsingDefaultImpl(p, ctxt, tb, _msgForMissingId);
    }
  }

  @Target({ ElementType.TYPE })
  @Retention(RetentionPolicy.RUNTIME)
  public @interface JsonTypeInfoPropertyAlias {
    String value();
  }

  @Override
  public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType,
      Collection<NamedType> subtypes) {
    BeanDescription bean = config.introspectClassAnnotations(baseType.getRawClass());
    AnnotatedClass ac = bean.getClassInfo();
    var annotation = ac.getAnnotation(JsonTypeInfoPropertyAlias.class);
    var secondary = annotation.value();
    var deserializer = super.buildTypeDeserializer(config, baseType, subtypes);
    if (deserializer instanceof AsPropertyTypeDeserializer propertyDeserializer) {
      return new AliasedPropertyTypeInfoDeserializer(propertyDeserializer, null, secondary);
    }

    throw new AssertionError("AliasedPropertyTypeResolver should only be used with property type infos.");
  }
}