Add support to add type information to JSON objects only

[mvlcek]

Goal
I want to have type information to be added only to JSON objects as properties to retain the general structure of the generated JSON, i.e.:

• never add type information for a collection/array type, as a construct list: ["com.example.MyType", [...]] can not be handled by standard REST clients, for which the information is irrelevant anyways
• don't add the type information to objects that are not serialized as objects, e.g. dates serialized to ISO strings, as again ["java.util.date", "2023-01-01T00:00:00+00:00"] is not a valid JSON date

Justification
The goal is to have a valid JSON/javascript representation (arrays only for collections/array, but no array wrappers to include type information), just with additional type information for java clients wherever possible.

Proposed Solution
Add a configuration option to the ObjectMapper (new value to DefaultTyping) to only add type information properties to objects that are serialized as JSON objects.

Remarks
It is clear that not everything can be deserialized correctly, when using this approach, if there is not enough contextual information (e.g. deserializing a list of dates as a List), but it is better than having no type information at all, while still being able to also have non-Java clients.

Current Workaround
It seems that the only way to do this currently is to override ObjectMapper.DefaultTypeResolverBuilder similar to here, additionally exclude Date (serialized to ISO string), classes with custom de/serialization to something other than objects, etc. But it still fails for some generics (where type argument is Date, e.g. a custom Period<Date> class, where the date fields from and to are still generated as ["java.util.date", "2023-..."]), etc.

[cowtowncoder]

I think I understand the intent here and it makes sense. But I am not sure this is possible to implement reliably, for general case. The problem is that serializers are free to use whichever Shape (Object, Array, Scalar) they want for values and there is no 1-to-1 metadata to indicate which Java types would be serialized using which Shape.
This mapping is configuration-dependent as well.
But DefaultTyping can ONLY determine its applicability on JavaType, and without access to serializer that would be used.

So basically I don't think there's a way to reliably implement this for all types.

Having said that, I suppose it might be possible to implement new default DefaultTyping set using heuristics that could work for most common cases.
I don't think I have time to work on this myself, but if anyone wants to have a go I'd be happy to help.

[mvlcek]

So it might not be possible using just DefaultTypeResolverBuilder. But from the exceptions I got when trying to configure this, I suppose that the addition of the type property is done, after the serializer has serialized the object?
If that is the case the type adding mechanism can also check the type of JSON generated by the serializer?
Can you point me to the class/method where the adding of the type property happens?

[cowtowncoder]

Well, interaction between JsonSerializer (contents) and TypeSerializer (prefix and/or suffix around value) works roughly such that JsonSerializer.serializeWithType(...) is called when polymorphic handling is enabled for the type.
Parent serializer (or for root value ObjectMapper/ObjectWriter initialization code) calls this method, passing TypeSerializer. For POJOs ("beans") code is roughly like so:

    public void serializeWithType(Object bean,
            JsonGenerator gen, SerializerProvider ctxt, TypeSerializer typeSer)
    {
        // ...
        WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_OBJECT);
        typeSer.writeTypePrefix(gen, ctxt, typeIdDef);
        // ...
       _serializeProperties(bean, gen, ctxt);
        typeSer.writeTypeSuffix(gen, ctxt, typeIdDef);
    }

And that JsonToken.START_OBJECT is what informs TypeSerializer what is the context (which Shape is to be used).

But basically once there is TypeSerializer (polymorphic typing enabled), it MUST typically write something.
What is needed for suppression is either:

1. Make sure no TypeSerializer is constructed (disable polymorphic typing for value type) or
2. Create TypeSerializer that knows how to write START_OBJECT/ARRAY, END_OBJECT/ARRAY pairs but nothing else (or I guess rather only add Type Id when START_OBJECT/END_OBJECT pair is needed).

I'd guess that (1) is by far simpler to make work, although then again.