Custom Jackson Bean(De)seralizerModifier is not considered when inferring Schema

[haisi]

Is your feature request related to a problem? Please describe.

I use a custom Jackson BeanSerializerModifier.
However, springdoc does not consider this customisation when inferring the Schema.

In this specific case, the SingleValueWrappingTypeSerializerModifier unwraps value-objects (annotated or interface-marked with jMolecules DDD types) containing a single "base-type".

record Email(String value) implements ValueObject {}
// vs. otherwise
record Email(@JsonValue String value) implements ValueObject {}

Meaning, instead of generating a schema like this:

The schema contains a nested structure for the value object --- despite Jackson serialising the object flat

Describe the solution you'd like

• The automatically generated schema matches "somehow" what Jackson produces --- despite custom seralizer modifiers.

Describe alternatives you've considered

• For my use-case, simply adding an @Schema with either an example or explicitly defining the type works
• Skip the custom serializer all together and always, explicitly use @JsonValue

Additional context

• I have reproduced the issue here.
• Initially discussed here: Springdoc/Swagger integration for Single-Value Value-Objects xmolecules/jmolecules-integrations#310 (comment)

[bnasslahsen]

@haisi,

I don't believe you could achieve it with your own Jackson custom Serializer.

The straight forward option, is to provide your own converter.
Below an example, that you can adapt to your context.

@Component
public class JMoleculesIdentifierConverter implements ModelConverter {

	private final ObjectMapperProvider objectMapperProvider;

	public JMoleculesIdentifierConverter(ObjectMapperProvider objectMapperProvider) {
		this.objectMapperProvider = objectMapperProvider;
	}

	@Override
	public Schema resolve(AnnotatedType type, ModelConverterContext context, Iterator<ModelConverter> chain) {
		JavaType javaType = objectMapperProvider.jsonMapper().constructType(type.getType());
		Class<?> rawClass = javaType.getRawClass();
		if (Identifier.class.isAssignableFrom(rawClass)) {
			Class<?> singleFieldType = getSingleFieldType(rawClass);
			if (singleFieldType != null) {
				type = new AnnotatedType(singleFieldType);
			}
		}
		return (chain.hasNext()) ? chain.next().resolve(type, context, chain) : null;
	}

	private Class<?> getSingleFieldType(Class<?> rawClass) {
		if (rawClass.isRecord()) {
			RecordComponent[] components = rawClass.getRecordComponents();
			return (components.length == 1) ? components[0].getType() : null;
		} else {
			Field[] fields = rawClass.getDeclaredFields();
			return (fields.length == 1) ? fields[0].getType() : null;
		}
	}
}