Support mapping derived types

[onionhammer]

[KnownType] and [JsonDerivedType] attributes are used on a base type to inform callers/serializers etc what its known derived types are, Mapperly could use this to automatically generate bindings for known types

[latonz]

As stated by the MS docs

Specifies types that should be recognized by the DataContractSerializer when serializing or deserializing a given type.
this is used by DataContractSerializer. Mapperly should not be coupled to the DataContractSerializer.

Could you provide an example of a mapper declaration including relevant classes and what you expect the generated code to look like?

[onionhammer]

@latonz KnownType is also used by Swagger to find derived types.

.NET's new [JsonDerivedType] attribute could also be used as an attribute to detect derived types.

Usage could look like this

[KnownType(typeof(Dog))]
[KnownType(typeof(Cat))]
public abstract class AnimalBase
{
    public required string Name { get; set; }
}

public class Dog : AnimalBase
{
    public required string DogName { get; set; }
}

public class Cat : AnimalBase
{
    public int CatAge { get; set; }
}

public abstract class AnimalBaseDTO
{
    public string? Name { get; set; }
}

public class DogDTO : AnimalBaseDTO
{
    public string? DogName { get; set; }
}

public class CatDTO : AnimalBaseDTO
{
    public int CatAge { get; set; }
}

public static partial class Mapper
{
    public static partial List<AnimalBaseDTO>? MapAnimal(List<AnimalBase>? input);
}

Mapperly's automatic implementation could look like this

public static partial class ModelMapper
{
    public static partial List<AnimalBaseDTO>? MapAnimal(List<AnimalBase>? input)
    {
        if (input == null)
            return null;

        return new List<AnimalBaseDTO>(
            input.Select(p => p switch
            {
                Dog dog => MapDog(dog),
                Cat cat => MapCat(cat),
                _ => throw new NotSupportedException(),
            })
        );
    }

    public static MapDog(Dog input)
    {
        return new CatDto
        {
            Name = input.Name,
            DogName = input.DogName,
        };
    }

    public static MapCat(Cat input)
    {
        return new DogDto
        {
            Name = input.Name,
            CatAge = input.CatAge,
        };
    }
}

[latonz]

Ah now I understand what you are looking for. This would be a great addition to Mapperly!
However, a separate attribute will probably be necessary to match type pairs (source type and associated target type, Dog => DogDto in your sample). This could look like this:

[Mapper]
public static partial class ModelMapper
{
    public static partial List<AnimalBaseDTO> MapAnimals(List<AnimalBase> input);

    [MapDerivedType(typeof(Dog), typeof(DogDto))]
    [MapDerivedType(typeof(Cat), typeof(CatDto))]
    private static partial AnimalBaseDTO MapAnimal(AnimalBase input);
}

[jnyrup]

A perhaps simpler case is if using Mapperly to generate a deep cloner.
Wouldn't TSource then trivially be equal to TDest?

(You might want to hide the comments regarding generic attributes to keep the thread manageable)

[latonz]

@jnyrup that's true. I don't think it is worth to introduce a separate attribute for this, as Mapperly's primary use case is object-to-object mapping and the verbosity in this case isn't much higher to configure Mapperly to just clone objects.

[github-actions]

🎉 This issue has been resolved in version 3.0.0 🎉

The release is available on:

• GitHub release
• v3.0.0

Your semantic-release bot 📦🚀