Can mapperly do generic type conversions of properties or wrap all generated property maps with a custom static mapper?

[bbarry]

I'm looking to convert from automapper but I can't figure out what to look for for the equivilant of this:

public class ContributionMapperProfile : Profile
{
    public ContributionMapperProfile()
    {
        CreateMap(typeof(Optional<>), typeof(object))
            .ConvertUsing(typeof(OptionalTypeConverter<>));

        CreateMap<UpdateContributionInput, ContributionEntity>(MemberList.None)
            .ForMember(dest => dest.Id, opt => opt.Ignore());
    }
}

public class OptionalTypeConverter<T> : ITypeConverter<Optional<T>, object>
{
    public object Convert(Optional<T> source, object destination, ResolutionContext context)
    {
        return source.HasValue ? source.Value! : destination;
    }
}

UpdateContributionInput has a bunch of fields with the same names as ContributionEntity but the types on the input side are Optional<> generics of the types on the entity side. If the types were the same we would have a mapperly version:

[Mapper]
public class ContributionMapper
{
    // I need to get all relevant properties to be mapped via this method
    public static T MapOptionalMember<T>(Optional<T> source, T target) => source.HasValue ? source.Value : target;

    [MapperIgnoreTarget(nameof(CashTransactionEntity.Id))]
    public static partial void MapToCashTransactionEntityInternal(UpdateContributionInput source, CashTransactionEntity target);
}

but because (almost) all the properties on source are Optional (for example Optional<string?> Comment on source vs string? Comment on target), the properties are not being mapped properly since an implicit cast exists from Optional<string?> to string? (removed some namespaces and unnecessary code):

[global::System.CodeDom.Compiler.GeneratedCode("Riok.Mapperly", "4.3.0.0")]
public static partial void MapToContributionEntityInternal(UpdateContributionInput source, ContributionEntity target)
{
    // ...
    target.Comment = (string)source.Comment;
}

For reference the Optional type:

public readonly struct Optional<T>
    : IEquatable<Optional<T>>
    , IOptional
{
    public Optional(T? value)
    {
        Value = value;
        HasValue = true;
    }

    private Optional(T? value, bool hasValue)
    {
        Value = value;
        HasValue = hasValue;
    }

    public T? Value { get; }

    object? IOptional.Value => Value;

    [MemberNotNullWhen(true, nameof(Value))]
    public bool HasValue { get; }

    public bool IsEmpty => !HasValue;

    public override string ToString()
    {
        return HasValue ? Value?.ToString() ?? "null" : "unspecified";
    }

    public bool Equals(Optional<T> other)
    {
        if (!HasValue && !other.HasValue)
        {
            return true;
        }

        if (HasValue != other.HasValue)
        {
            return false;
        }

        return Equals(Value, other.Value);
    }

    public override bool Equals(object? obj)
    {
        if (obj is null)
        {
            return IsEmpty;
        }
        return obj is Optional<T> n && Equals(n);
    }

    public override int GetHashCode()
    {
        return (HasValue ? Value?.GetHashCode() ?? 0 : 0);
    }

    public static bool operator ==(Optional<T> left, Optional<T> right)
    {
        return left.Equals(right);
    }

    public static bool operator !=(Optional<T> left, Optional<T> right)
    {
        return !left.Equals(right);
    }

    public static implicit operator Optional<T>(T value)
        => new(value);

    [return: MaybeNull]
    public static implicit operator T(Optional<T> optional)
        => optional.Value;

    public static Optional<T> Empty(T? defaultValue = default)
        => new(defaultValue, false);

    public static Optional<T> From(IOptional optional)
    {
        if (optional.HasValue || optional.Value != null)
        {
            return new Optional<T>((T?)optional.Value, optional.HasValue);
        }

        return new Optional<T>();
    }
}

Note: [UserMapping] doesn't work because I need to consider the existing target value, I'm looking for something roughly like this:

    [UserMapping(Default = true)]
    public static T MapOptionalToValue<T>(Optional<T> source, T target) => source.HasValue ? source.Value : target;
    
    // generates
    target.Comment = MapOptionalToValue(source.Comment, target.Comment);

or

    // generates
    if (source.HasValue) { target.Comment = (string)source.Comment; }

[latonz]

Duplicate of #1285