What am I doing wrong?

[baynezy]

I have the following:

public readonly record struct Email
{
    public string Address { get; init; }
}

[StronglyTypedId(
    StronglyTypedIdBackingType.Guid,
    converters: StronglyTypedIdConverter.SystemTextJson)]
public partial struct ProfileId
{
}

public class Profile
{
    public ProfileId Id { get; init; }
    public Email Email { get; init; }
}

public class UpdateProfileRequest
{
    public Guid ProfileId { get; set; }
    public string Email { get; set; } = string.Empty;
}

Mapperly does not seem to like the next level of nesting with Address

E.g.

public static partial class Mapper
{
    [MapProperty(nameof(UpdateProfileRequest.ProfileId), nameof(Profile.Id))]
    [MapProperty(nameof(UpdateProfileRequest.Email), nameof(Profile.Email.Address))]
    internal static partial Profile UpdateProfileRequestToProfile(UpdateProfileRequest req);

This outputs

[RMG007] Could not map member UpdateProfileRequest.Email of type string to Domain.Profile.Email of type Email
[RMG005] Specified member Address on mapping target type Profile was not found

[TimothyMakkison]

nameof(Profile.Email.Address) evaluates to "Address", Mapperly tries and fails to map UpdateProfileRequest.Email to Profile.Address, this fails because the member Address does not exist on Profile.

The second error is due to Mapperly attempting to automatically resolve the mapping of UpdateProfileRequest.Email to Profile. Because Profile has a member called email, Mapperly attempts to map to it, because it cannot resolve the conversion of string -> Email it fails.

Use the following instead:

[MapProperty(nameof(UpdateProfileRequest.Email), "Email.Address")]

[baynezy]

@TimothyMakkison - thanks for your prompt response. That has certainly moved the needle.

I now get [RMG016] Cannot map to init only member path Domain.Email.Email.Address

That is because it is a readonly struct and requires the values to be passed in when initialised.

Is that possible?

[TimothyMakkison]

Mapperly supports init/required mapping but MapProperty can't map to nested init/required only members. For nested members MapProperty adds an additional statement after initalization to modify the property, prventing it from being used for init/required properties, this might change in the future. 🤞

// slightly broken example
var target = new global::Riok.Mapperly.Sample.Profile()
{
    Id = req.ProfileId
};
target.Email.Address = req.Email;
return target;

Normally changing from init to set would solve this but you wouldn't be able to use a readonly struct 😐
Mapperly might be able to use the constructor

public readonly record struct Email
{
    public Email(string address)
    {
        Address = address;
    }
    public string Address { get; init; }
}
// or primary constructor
public readonly record struct Email(string Address);

[baynezy]

Nice idea, but it still is unhappy even if I use the primary constructor.

I guess I will do this one manually.

Is this worth adding as an issue?

Thanks for your help.

[TimothyMakkison]

Is this worth adding as an issue?

Please do, I have a couple ideas of how to resolve this in the future. It would be handy to have something to point to. I also found a bug trying to help you 😄

Nice idea, but it still is unhappy even if I use the primary constructor.
I guess I will do this one manually.

Just thought of something. Try the following:

[MapProperty(nameof(UpdateProfileRequest.ProfileId), nameof(Profile.Id))]
internal static partial Profile UpdateProfileRequestToProfile(UpdateProfileRequest req);

private static Email Map(string value)
{
    return new Email() { Address = value};
}

Mapperly will see a matching Email member on the source and attempt to map string -> Email, resolving this with the provided mapping.

[baynezy]

That works a treat thanks.

So just so I understand if there is a private Map method that has the correct signature then it will utilise that?

[TimothyMakkison]

Yeah, when mapping between two objects, Mapperly will check for a similar mapping and use it.
It can use either a user implemented mapping or another partial mapping.

Documentation here

[baynezy]

I see so the name of the function is immaterial it is just the types in the signature that matter. Thanks so much.