Circular dependencies with custom mapping & PreserveReferenceHandler

[joaooo]

Hello, i have implemented mapperly with UseReferenceHandling = true but some of my methods have custom implementations and are used directly to map my objects, therefore im kinda unsure what i should do, since i wanted mapperly to create a PreserveReferenceHandler instance.

Example:

[Mapper(UseReferenceHandling = true)]
public partial class CarMapper
{
        public partial CarDto CarToCarDto(Car car);
	
	public WheelDTO Map(Wheel wheel, [ReferenceHandler] IReferenceHandler myRefHandler) 
	{
	      // custom implementation and this method is called in Wheel Repository directly
	}
}

Car has wheels and wheel has a car

In this case, my wheels map method is called directly, should i be extending IReferenceHandler and implement my own class like PreserveReferenceHandler? I guess i expected mapperly to do that load for me. Also, tried removing the attribute from the argument but i get stackoverflow, i assume it's because that custom implementation is not taking care of circular dependencies.
Can someone point me in the right direction please?

Thanks in advance :)

EDIT: added a few more information and also some clarifications
EDIT 2: Also, when i added [Mapper(UseReferenceHandling = true)] to my class (which is a lot more complex than the example i provided), i started having errors regarding some specific properties not being mapped properly (when they are already ignored) and whenever i placed certain maps in different lines of the file, sometimes it fixed the "errors", sometimes it just caused more. Is this normal or is it a bug?

[latonz]

This use case is currently not supported by Mapperly. However, couldn't you move the method in another class (not annotated with MapperAttribute) and call it from your wheel repository and from CarMapper.Map?
Regarding Edit 2: Sounds like a strange behaviour, is it consistently reproducible? Can you provide the steps to reproduce it?

[latonz]

Sorry I don't fully understand, can you outline an object hierarchy and the implementation of the manually implemented mapping method that shows your problem?
If reference handling is enabled, for each public mapping method without a reference handler parameter Mapperly creates a private method with a reference handler and calls it with new PreserveReferenceHandler(). Subsequent calls pass then the reference handler instance through the entire call stack.
Supporting this use-case is not planned in the short term, but feel free to contribute yourself 😉

I cannot reproduce this. IDE's sometimes show errors when generating the code, while a user is still editing it and it is not (yet) valid. Probably this is the case here. What wonders me is that the errors disappear once UseReferenceHandling is removed. What kind of errors ware emitted?

[joaooo]

Something similar (i removed one nested object) would be this:

public class Product 
{
	public string Name { get; set; }
	public IEnumerable<InnerProduct> InnerProduct { get; set; }
}

public class InnerProduct 
{
	public string Name { get; set; }
	public Product Product { get; set; }
	public IEnumerable<Offer> Offers { get; set; }
}

public class Offer 
{
	public string Name { get; set; }
	public Product Product { get; set; }
}

public InnerProductDTO Map(InnerProduct source)
{
	if (source is null)
	{
		return null;
	}

	var target = new InnerProductDTO();
	// extra props and methods
	
	target.Product = Map(source.Product)
	//more code

}

I know this is probably not much, but my scenario is quite complex and not that easy to explain/exemplify without exposing the entire models
So, the reference handler is the same through the entire scope of the mapping process right? (which makes completely sense) therefore creating my own implementation won't really help my use case, unless i implement it on every method.

Regarding the other issue, i waited several seconds before and after saving IDE, tried with Rider and VS 2022, both had the same issues, on saving the file and even on building the solution. The errors emitted were all "Error RMG007 : Could not map member" between a class and an Enum, like in the example i provided above (with the Product.Model and ProductDTO.Model)

[latonz]

What do you mean for every method? You would simply need one class that implements the IReferenceHandler. You create one instance if you call a Mapperly method from outside of a mapper which then gets passed around by Mapperly.

[latonz]

I cannot reproduce the second issue. Please provide clear steps and code for each step on how to reproduce or even better create a minimal repro (in a gist / git repo).

[joaooo]

I misspelled it when i said "unless i implement it on every method", what i meant to say was that i had to pass the IReferenceHandler instance to every single method, which is what i did and managed to get it to work. Not sure if this would be possible, but in the future it would also be nice having our mapper class accessing the referenceHandler implementation through DI and the auto generated code make a use of it. This way, we didn't need to change method signatures, which in my case, were still quite a lot.

Regarding the second issue, i will try to reproduce it using different models and create a repo with it