Issue with mapper reuse and after/before map

[PaulVrugt]

We are running into an issue with mapperly, and I'l like to discuss with you if this is a bug or not. Suppose I have the following classes I want to map:

//source classes:
public class MyClass
{
    public int MyProperty { get; set; }
    public required OtherClass OtherClassProperty { get; set; }
}

public class OtherClass
{
    public int OtherProperty { get; set; }
}

//target classes:
public class MyTargetClass
{
    public int MyProperty { get; set; }
    public required OtherTargetClass OtherClassProperty { get; set; }
}

public class OtherTargetClass
{
    public int OtherProperty { get; set; }
}

And I want to have a custom before/after map for the mapping from OtherClass to OtherTargetClass, so my mapping configuration looks like:

//main class mapping
public static partial MyTargetClass Map(MyClass input);

//auto mapping of sub class
[MapperIgnoreTarget(nameof(OtherTargetClass.OtherProperty))]
[MapperRequiredMapping(RequiredMappingStrategy.Target)]
private static partial OtherTargetClass MapAuto(OtherClass input);

//custom mapping for sub class (as described in https://mapperly.riok.app/docs/configuration/before-after-map/)
public static OtherTargetClass Map(OtherClass input)
{
    var test = MapAuto(input);
    test.OtherProperty = 15;
    return test;
}

The problem here, is that the mapping generator now generates the following for the mapping for the MyTargetClass mapping:

public static partial global::Example.MyTargetClass Map(global::Example.MyClass input)
{
    var target = new global::Example.MyTargetClass()
    {
        OtherClassProperty = MapAuto(input.OtherClassProperty),
    };
    target.MyProperty = input.MyProperty;
    return target;
}

As you can see, the mapper ignores my Map method which has custom mapping logic. I think the mapper should prioritize public mapping methods over private mapping methods, because now I end up with a partially mapped TargetClass without any mention of issues.

This particularly becomes a problem when the sub class in my example is completely auto mapped at first, and gets a custom mapping method later on. There is no warning whatsoever that other mappings will break because of this

What are your thoughts on this?

[latonz]

Mapperly always uses the first matching mapping when mapping one type to another. Mappings in the same class are preferred over mappings from other classes included with UseMapper/UseStaticMapper. If you switch the order of the members in your class (put the Map method before the MapAuto) it should work.
The documentation for this definitely needs to be improved: #579
We should probably introduce a PrimaryMappingAttribute or similar to make this more explicit in the future, maybe even require it to be set if there are multiple user defined / user implemented mappings given for a specific type.

[PaulVrugt]

Thanks for the quick reply!

Good to see that there is a workaround, but this of course is very error prone. I indeed would really like to see a PrimaryMappingAttribute attribute, and it being required to solve this. This would would prevent mappers from breaking accidentally. Shall I enter an issue for this?