Support for merging two instances of a class

[tim-mit]

Thank you very much for Mapperly! Being familiar with Mapstruct in Java land it's really nice to have a C# library that has the same approach and the performance/debugging benefits mark it really appealing.

I wanted to check if Mapperly already supports the ability to merge two instances of the same class, returning the target instance value for a property if the matching property in the source instance is null?

I'm wanting to do something like the following:

public class Car {
    public int NumberOfSeats { get; set; }
    public int NumberOfDoors { get; set; }
}

[Mapper]
public partial class CarMapper
{
    public partial void MergeCars(Car car, Car targetCar);
}

var mapper = new CarMapper();
var finalCar = new Car { NumberOfSeats = 4, NumberOfDoors = 4 };
var partiallyPopulatedCarInstance = new Car { NumberOfDoors = 2 };

mapper.MergeCars(partiallyPopulatedCarInstance, finalCar);

finalCar.NumberOfSeats.Should().Be(4); // currently breaks as the null value from the source instance overwrites the value set initially in the target instance
finalCar.NumberOfDoors.Should().Be(2); // ok as the source instance supplies a value for this property which is used

Currently this doesn't quite work because the mapping method created ends up looking like the following which happily sets null values from the source against the target - overwriting the values I'd like to keep.

public partial void MergeCars(Car car, Car targetCar)
{
    targetCar.NumberOfSeats = car.NumberOfSeats;
    targetCar.NumberOfDoors = car.NumberOfDoors;
}

I'm hoping to be able to get a generated method that looks something like the following which will only copy the value from the source to the target if its not null:

public partial void MergeCars(Car car, Car targetCar)
{
    if (car.NumberOfSeats != null) {
        targetCar.NumberOfSeats = car.NumberOfSeats;
    }
    if (car.NumberOfDoors != null) {
        targetCar.NumberOfDoors = car.NumberOfDoors;
    }
}

Is this possible today using some attributes / mapping magic? If not is it an attribute or similar to support ignoring null values during source to target mapping something you'd be willing to add or have contributed to Mapperly?

[latonz]

Thank you for your request. This is not yet implemented in Mapperly, but I think this would be a great feature. In MapStruct would you address this by using NullValuePropertyMappingStrategy.IGNORE?

[tim-mit]

Yes, in MapStruct the equivalent behavior would be achieved using the NullValuePropertyMappingStrategy.IGNORE option in the attributes that configure the mapping.

My request here is effectively the same as the MapStruct ticket mapstruct/mapstruct#649 I think. My need comes from the same use case too, handling partial updates in a PATCH endpoint on a REST API.

Happy to have a go at contributing a PR if that's something you'd like?

[latonz]

There are a few open questions on how we should implement the API for this. We already have Riok.Mapperly.Abstractions.MapperAttribute.ThrowOnPropertyMappingNullMismatch. I think it would be a good idea to deprecate this property and introduce a new NullPropertyMappingStrategy property on the MapperAttribute. What strategies should be available? Should it also be configurable on a mapper method and/or property level? What are your thoughts on this?

On a first thought the following strategies come to my mind:

• SET_OR_IGNORE (same as ThrowOnPropertyMappingNullMismatch=false, sets the value if the target is nullable or the source is not null, ignores the mapping if the source is null and the target is not nullable)
• SET_OR_THROW (same as ThrowOnPropertyMappingNullMismatch=true, sets the value if the target is nullable or the source is not null, throws if the source is null and the target is not nullable)
• SET_OR_DEFAULT (sets the value if the target is nullable or the source is not null, sets a default value otherwise (default for value types, empty string for strings, new() for classes; throw if no parameterless ctor exists)
• IGNORE (ignores the property if the source is null)
• DEFAULT (sets the value if the source is not null, sets a default value otherwise) (similar to SET_OR_DEFAULT but does never set null values).

The SET_OR_IGNORE, SET_OR_THROW and IGNORE strategies would be required from the beginning (to deprecate the ThrowOnPropertyMappingNullMismatch and to make use of the new feature). The DEFAULT strategy could be added later. Also configuration options at the method and/or property level could be added later.
I'm not really sure about the naming of the strategies (especially DEFAULT), maybe the above names with a _IF_NULL suffix would be better...

Would be very happy to accept a PR, but the API and exact expected behaviour should be clarified first.

[tim-mit]

I think being able to define a NullPropertyMappingStrategy initially on the MapperAttribute, but in the longer term at both the method and property level would be good. Method level so that all properties in a particular method can have the strategy set, and property level so that very fine grained control is possible.

IIUC Mapperly doesn't have method level mapping configuration functionality currently, so having separate classes with different MapperAttribute configuration set for the NullPropertyMappingStrategy coupled with property level configuration would still provide the flexibility to define things as required.

The strategies you've listed look comprehensive to me. Regarding naming, I like you suggestion of using _IF_NULL as a suffix. For someone less familiar with Mapperly seeing something like the below hints at what is going to be produced:

[Mapper(
    NullPropertyMappingStrategy = NullPropertyMappingStrategy.IGNORE_IF_NULL
)]
public partial class CarMapper
{
  ...
}

Depending on how explicit you like to be in naming it might be even clearer to use the term NullPropertyInSourceMappingStrategy?

[latonz]

I created #98. Would be happy to accept a PR, let me know if I can provide you any starting points or other support. Also please let me know if you start working on this feature, so that we can assign the issue to you.