Option to remove the source type descriptor from call to the ConversionService for ExternalConversion

[ddnyer]

Hi,

I'm using JMolecules that introduces some wrappers around id values. It comes with standard Spring Converters so the ConversionService of Spring can convert those wrappers from and to the UUID they are holding.

I would like to be able to convert my entities containing those wrappers into DTOs using MapStruct. For that, I use the ExternalConversion annotation like this:

@SpringMapperConfig(
    externalConversions = {
      @ExternalConversion(sourceType = Association.class, targetType = UUID.class),
      @ExternalConversion(sourceType = Identifier.class, targetType = UUID.class)
    })
public interface MapperConfiguration {}

Identifier is an interface defined by JMolecules to identify ID values. It's used like this:

public record StoreId(@NotNull UUID id) implements Identifier {}

MapStruct generates the following ConversionServiceAdapter:

  private static final TypeDescriptor TYPE_DESCRIPTOR_ORG_JMOLECULES_DDD_TYPES_ASSOCIATION = TypeDescriptor.valueOf(Association.class);

  private static final TypeDescriptor TYPE_DESCRIPTOR_JAVA_UTIL_UUID = TypeDescriptor.valueOf(UUID.class);

  private static final TypeDescriptor TYPE_DESCRIPTOR_ORG_JMOLECULES_DDD_TYPES_IDENTIFIER = TypeDescriptor.valueOf(Identifier.class);


  public UUID mapAssociationToUUID(final Association source) {
    return (UUID) conversionService.convert(source, TYPE_DESCRIPTOR_ORG_JMOLECULES_DDD_TYPES_ASSOCIATION, TYPE_DESCRIPTOR_JAVA_UTIL_UUID);
  }

  public UUID mapIdentifierToUUID(final Identifier source) {
    return (UUID) conversionService.convert(source, TYPE_DESCRIPTOR_ORG_JMOLECULES_DDD_TYPES_IDENTIFIER, TYPE_DESCRIPTOR_JAVA_UTIL_UUID);
  }

At first sight, it looks good, but that does not work. The issue is that when calling the ConversionService, the ConversionServiceAdapter specifies the source type using the type descriptor of Identifier. Identifier is just an interface; the actual type I need to convert is StoreId. The Converter registered by JMolecules is not able to determine if it can deal with this conversion or not, the source type Identifier does not hold enough information (not all Identifier can be converted into UUID, it needs to know the actual type StoreId to figure out if it's the case). I also open a ticket on JMolecules to discuss this issue.

If I manually adapt the ConversionServiceAdapter like this, Spring will retrieve the source type at runtime and find out it's a StoreId. The Converter registered by JMolecules will match this time, and the conversion works fine.

public UUID mapIdentifierToUUID(final Identifier source) {
    return (UUID) conversionService.convert(source, TYPE_DESCRIPTOR_JAVA_UTIL_UUID);
  }

Would it be possible to omit the source type descriptor in the ConversionServiceAdapter for ExternalConversion? Either by default or through a parameter in @ExternalConversion.

Thanks

[Chessray]

Granted I don't know much about JMolecules, but is there a particular reason why you can't declare the conversion with type StoreId instead?

[ddeSide]

To give a bit of context, JMolecules provides a few libraries to make explicit some architecture patterns directly into your codebase. Following domain-driven design (DDD) principles, all identifiers should be represented as a dedicated object, making explicit what the ID identifies. So don't use a UUID to identify a Store, but create a StoreId class containing the UUID to make your code more explicit. JMolecules add this Identifier interface to make clear that StoreId is the ID of an entity and not just a random object. It also leverages this interface to add unit tests verifying other DDD principles.

So, in other words, all IDs of all my entities will implement Identifier and will need a mapper to convert them into UUID. Yes, I could tell MapStruct to map a StoreId to a UUID, but I don't want to hardcode that for all IDs of all entities in my application. It's a lot of boilerplate code.

As explained in the linked ticket, my current workaround is to define a Mapper like this. But it feels a bit stupid to reimplement an existing feature.

@Mapper
public class IdentifierMapper { 

  @Setter(onMethod_ = {@Lazy, @Autowired})
  private ConversionService conversionService;

  public UUID convert(@NonNull Identifier source) {
    return conversionService.convert(source, UUID.class);
  }
}

[filiphr]

@ddnyer I am not sure that this belongs to the Spring Extensions. Ideally you would like to register a global mapper that would automatically be available for MapStruct mappers to use without the need to do it through Mapper#uses we have mapstruct/mapstruct#3197 for that.

Or perhaps something like mapstruct/mapstruct#3713, which is talking about value objects, which from what I could read the StoreId is such a value object

[ddeSide]

Indeed, both would work equally well and cover more use cases, so I'm fine with following those issues.