chore: replace Automapper with Mapperly

backend/src/MethodConf.Cms/Controllers/ConferenceIssueController.cs

@@ -1,8 +1,8 @@
 using Asp.Versioning;
-using AutoMapper;
 using MethodConf.Cms.Domain;
 using MethodConf.Cms.Domain.Errors;
 using MethodConf.Cms.Dtos;
+using MethodConf.Cms.Mapping;
 using MethodConf.Cms.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
@@ -11,19 +11,19 @@ namespace MethodConf.Cms.Controllers;
 [ApiController]
 [ApiVersion("1.0")]
 [Route(RouteTemplates.ConferenceIssue)]
-public class ConferenceIssueController(IConferenceIssueService conferenceIssueService, IMapper mapper) : Controller
+public class ConferenceIssueController(IConferenceIssueService conferenceIssueService, IssueMapper mapper) : Controller
 {
     [HttpPost]
     public async Task<ActionResult<CreateIssueResponseDto>> CreateIssue(Guid conferenceId, CreateIssueRequestDto request)
     {
-        var createIssue = mapper.Map<CreateIssue>(request);
+        var createIssue = mapper.ToCreateIssue(request);
 
         var result = await conferenceIssueService.CreateIssue(conferenceId, createIssue);
 
         return result switch
         {
             { IsFailed: true } when result.Errors.Any(e => e is InvalidEntityIdError) => NotFound(result.Errors),
-            { IsSuccess: true } => Ok(mapper.Map<CreateIssueResponseDto>(result.Value)),
+            { IsSuccess: true } => Ok(mapper.ToCreateIssueResponseDto(result.Value)),
             _ => StatusCode(500)
         };
     }

backend/src/MethodConf.Cms/Controllers/ConferenceScheduleController.cs

@@ -1,7 +1,7 @@
 using Asp.Versioning;
-using AutoMapper;
 using MethodConf.Cms.Domain.Errors;
 using MethodConf.Cms.Dtos;
+using MethodConf.Cms.Mapping;
 using MethodConf.Cms.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
@@ -10,7 +10,7 @@ namespace MethodConf.Cms.Controllers;
 [ApiController]
 [ApiVersion("1.0")]
 [Route(RouteTemplates.ConferenceSchedule)]
-public class ConferenceScheduleController(IConferenceScheduleService conferenceScheduleService, IMapper mapper) : Controller
+public class ConferenceScheduleController(IConferenceScheduleService conferenceScheduleService, ScheduleMapper mapper) : Controller
 {
     [HttpGet]
     public ActionResult<ConferenceScheduleResponseDto> GetSchedule(Guid conferenceId)
@@ -20,7 +20,7 @@ public ActionResult<ConferenceScheduleResponseDto> GetSchedule(Guid conferenceId
         return result switch
         {
             { IsFailed: true } when result.Errors.Any(e => e is InvalidEntityIdError) => NotFound(result.Errors),
-            { IsSuccess: true } => Ok(mapper.Map<ConferenceScheduleResponseDto>(result.Value)),
+            { IsSuccess: true } => Ok(mapper.ToDto(result.Value)),
             _ => StatusCode(500)
         };
     }

backend/src/MethodConf.Cms/Controllers/SessionFeedbackController.cs

@@ -1,27 +1,27 @@
-using AutoMapper;
 using MethodConf.Cms.Domain;
 using MethodConf.Cms.Domain.Errors;
 using MethodConf.Cms.Dtos;
+using MethodConf.Cms.Mapping;
 using MethodConf.Cms.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
 namespace MethodConf.Cms.Controllers;
 
 [ApiController]
 [Route(RouteTemplates.SessionFeedback)]
-public class SessionFeedbackController(ISessionFeedbackService sessionFeedbackService, IMapper mapper) : Controller
+public class SessionFeedbackController(ISessionFeedbackService sessionFeedbackService, SessionFeedbackMapper mapper) : Controller
 {
     [HttpPost]
     public async Task<ActionResult<SessionFeedbackResponseDto>> Create(Guid sessionId, CreateSessionFeedbackRequestDto request)
     {
-        var createSessionFeedback = mapper.Map<CreateSessionFeedback>(request);
+        var createSessionFeedback = mapper.ToCreateSessionFeedback(request);
 
         var result = await sessionFeedbackService.Create(sessionId, createSessionFeedback);
 
         return result switch
         {
             { IsFailed: true } when result.Errors.Any(e => e is InvalidEntityIdError) => BadRequest(result.Errors),
-            { IsSuccess: true } => Ok(mapper.Map<SessionFeedbackResponseDto>(result.Value)),
+            { IsSuccess: true } => Ok(mapper.ToDto(result.Value)),
             _ => StatusCode(500)
         };
     }

backend/src/MethodConf.Cms/Mapping/IssueMapper.cs

@@ -0,0 +1,38 @@
+using MethodConf.Cms.Domain;
+using MethodConf.Cms.Dtos;
+using Riok.Mapperly.Abstractions;
+
+namespace MethodConf.Cms.Mapping;
+
+[Mapper]
+public partial class IssueMapper
+{
+    [MapProperty(nameof(CreateIssueRequestDto.Phone), nameof(CreateIssue.PhoneNumber))]
+    public partial CreateIssue ToCreateIssue(CreateIssueRequestDto src);
+
+    [MapperIgnoreTarget(nameof(Issue.Id))]
+    [MapperIgnoreTarget(nameof(Issue.CreatedAt))]
+    public partial Issue ToIssue(CreateIssue src, Guid conferenceId);
+
+    [MapperIgnoreSource(nameof(IssueWithResponse.Id))]
+    [MapperIgnoreSource(nameof(IssueWithResponse.ConferenceId))]
+    [MapProperty(nameof(IssueWithResponse.PhoneNumber), nameof(CreateIssueResponseDto.Phone))]
+    public partial CreateIssueResponseDto ToCreateIssueResponseDto(IssueWithResponse src);
+
+    [MapperIgnoreSource(nameof(Issue.Id))]
+    [MapperIgnoreSource(nameof(Issue.ConferenceId))]
+    [MapperIgnoreSource(nameof(Issue.CreatedAt))]
+    [MapperIgnoreTarget(nameof(NewIssueEmailViewModel.Title))]
+    [MapProperty(nameof(Issue.PhoneNumber), nameof(NewIssueEmailViewModel.Phone))]
+    public partial NewIssueEmailViewModel ToNewIssueEmailViewModel(Issue src);
+
+    [MapperIgnoreSource(nameof(Issue.Id))]
+    [MapperIgnoreSource(nameof(Issue.ConferenceId))]
+    [MapperIgnoreSource(nameof(Issue.CreatedAt))]
+    [MapProperty(nameof(Issue.PhoneNumber), nameof(NewIssueAppResponseViewModel.Phone))]
+    public partial NewIssueAppResponseViewModel ToNewIssueAppResponseViewModel(Issue src);
+
+    [MapperIgnoreSource(nameof(Issue.CreatedAt))]
+    [MapValue(nameof(IssueWithResponse.ResponseMarkup), "")]
+    public partial IssueWithResponse ToIssueWithResponse(Issue src);
+}

backend/src/MethodConf.Cms/Mapping/ScheduleMapper.cs

@@ -0,0 +1,29 @@
+using MethodConf.Cms.Domain;
+using MethodConf.Cms.Dtos;
+using Riok.Mapperly.Abstractions;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.PublishedModels;
+
+namespace MethodConf.Cms.Mapping;
+
+[Mapper(RequiredMappingStrategy = RequiredMappingStrategy.Target)]
+public partial class ScheduleMapper(IDocumentUrlService documentUrlService)
+{
+    [MapperRequiredMapping(RequiredMappingStrategy.Both)]
+    public partial ConferenceScheduleResponseDto ToDto(ConferenceSchedule src);
+
+    [MapProperty(nameof(Session.Key), nameof(SessionItem.Key), Use = nameof(ResolveSessionKey))]
+    public partial SessionItem ToSessionItem(Session src);
+
+    [MapPropertyFromSource(nameof(TrackItem.Sessions), Use = nameof(MapTrackSessions))]
+    public partial TrackItem ToTrackItem(Track src);
+
+    private SessionItem[] MapTrackSessions(Track src)
+    {
+        var sessions = src.Children<Session>() ?? [];
+        return sessions.Select(ToSessionItem).ToArray();
+    }
+
+    private string ResolveSessionKey(Guid key) =>
+        documentUrlService.GetUrlSegment(key, "", false) ?? key.ToString();
+}

backend/src/MethodConf.Cms/Mapping/SessionFeedbackMapper.cs

@@ -0,0 +1,21 @@
+using MethodConf.Cms.Domain;
+using MethodConf.Cms.Dtos;
+using Riok.Mapperly.Abstractions;
+
+namespace MethodConf.Cms.Mapping;
+
+[Mapper]
+public partial class SessionFeedbackMapper
+{
+    public partial CreateSessionFeedback ToCreateSessionFeedback(CreateSessionFeedbackRequestDto src);
+
+    [MapperIgnoreSource(nameof(SessionFeedback.SessionId))]
+    [MapperIgnoreSource(nameof(SessionFeedback.CreatedAt))]
+    public partial SessionFeedbackResponseDto ToDto(SessionFeedback src);
+
+    [MapValue(nameof(SessionFeedback.Id), Use = nameof(EmptyGuid))]
+    [MapperIgnoreTarget(nameof(SessionFeedback.CreatedAt))]
+    public partial SessionFeedback ToSessionFeedback(CreateSessionFeedback src, Guid sessionId);
+
+    private static Guid EmptyGuid() => Guid.Empty;
+}

backend/src/MethodConf.Cms/MethodConf.Cms.csproj

@@ -10,14 +10,14 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="AutoMapper" Version="16.1.1" />
         <PackageReference Include="FluentResults" Version="4.0.0" />
         <PackageReference Include="MimeKit" Version="4.17.0" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.8">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
         <PackageReference Include="Razor.Templating.Core" Version="3.1.0" />
+        <PackageReference Include="Riok.Mapperly" Version="4.3.1" />
         <PackageReference Include="Umbraco.Cms" Version="18.0.2" />
         <PackageReference Include="uSync" Version="18.0.1" />
     </ItemGroup>

backend/src/MethodConf.Cms/Services/ConferenceIssueService.cs

@@ -1,9 +1,9 @@
-using AutoMapper;
 using FluentResults;
 using MethodConf.Cms.Domain;
 using MethodConf.Cms.Domain.Errors;
 using MethodConf.Cms.Dtos;
 using MethodConf.Cms.Infrastructure;
+using MethodConf.Cms.Mapping;
 using MethodConf.Cms.Services.Interfaces;
 using Microsoft.Extensions.Options;
 using Razor.Templating.Core;
@@ -21,7 +21,7 @@ public class ConferenceIssueService(
     IEmailSender emailSender,
     IRazorTemplateEngine razorEngine,
     IOptions<GlobalSettings> globalSettings,
-    IMapper mapper) : IConferenceIssueService
+    IssueMapper mapper) : IConferenceIssueService
 {
     private const string OrganizerEmailSubject = "New Issue Reported for Method Conf";
     private const string ReporterEmailSubject = "Your Issue Has Been Recieved";
@@ -33,8 +33,7 @@ public async Task<Result<IssueWithResponse>> CreateIssue(Guid conferenceId, Crea
             return Result.Fail(new InvalidEntityIdError(conferenceId.ToString()));
         }
 
-        var newIssue = mapper.Map<Issue>(createIssue);
-        newIssue.ConferenceId = conference.Key;
+        var newIssue = mapper.ToIssue(createIssue, conference.Key);
         newIssue.CreatedAt = DateTime.UtcNow;
 
         dbContext.Add(newIssue);
@@ -56,15 +55,15 @@ public async Task<Result<IssueWithResponse>> CreateIssue(Guid conferenceId, Crea
             await SendOrganizerEmail(newIssue);
         }
 
-        var issueWithResponse = mapper.Map<IssueWithResponse>(newIssue);
+        var issueWithResponse = mapper.ToIssueWithResponse(newIssue);
         issueWithResponse.ResponseMarkup = await GetResponseMessage(newIssue) ?? "";
 
         return issueWithResponse;
     }
 
     private async Task SendOrganizerEmail(Issue issue)
     {
-        var vm = mapper.Map<NewIssueEmailViewModel>(issue);
+        var vm = mapper.ToNewIssueEmailViewModel(issue);
         vm.Title = OrganizerEmailSubject;
 
         var content = await razorEngine.RenderAsync("~/Views/Templates/NewIssueOrganizerEmail.cshtml", vm);
@@ -82,7 +81,7 @@ private async Task SendOrganizerEmail(Issue issue)
 
     private async Task SendReporterEmail(string reporterEmail, Issue issue)
     {
-        var vm = mapper.Map<NewIssueEmailViewModel>(issue);
+        var vm = mapper.ToNewIssueEmailViewModel(issue);
         vm.Title = ReporterEmailSubject;
         var content = await razorEngine.RenderAsync("~/Views/Templates/NewIssueReporterEmail.cshtml", vm);
 
@@ -102,7 +101,7 @@ private async Task SendReporterEmail(string reporterEmail, Issue issue)
 
     public async Task<string?> GetResponseMessage(Issue issue)
     {
-        var vm = mapper.Map<NewIssueAppResponseViewModel>(issue);
+        var vm = mapper.ToNewIssueAppResponseViewModel(issue);
         return await razorEngine.RenderAsync("~/Views/Templates/NewIssueAppResponse.cshtml", vm);
     }
 }

backend/src/MethodConf.Cms/Services/ConferenceScheduleService.cs

@@ -1,15 +1,15 @@
-using AutoMapper;
 using FluentResults;
 using MethodConf.Cms.Domain;
 using MethodConf.Cms.Domain.Errors;
+using MethodConf.Cms.Mapping;
 using MethodConf.Cms.Services.Interfaces;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Web;
 using Umbraco.Cms.Web.Common.PublishedModels;
 
 namespace MethodConf.Cms.Services;
 
-public class ConferenceScheduleService(IPublishedContentQuery publishedContentQuery, IScheduleGridGenerator scheduleGridGenerator, IMapper mapper) : IConferenceScheduleService
+public class ConferenceScheduleService(IPublishedContentQuery publishedContentQuery, IScheduleGridGenerator scheduleGridGenerator, ScheduleMapper mapper) : IConferenceScheduleService
 {
     public Result<ConferenceSchedule> GetSchedule(Guid conferenceId)
     {
@@ -27,10 +27,10 @@ public Result<ConferenceSchedule> GetSchedule(Guid conferenceId)
             switch (sessionOrTrack)
             {
                 case Session session:
-                    scheduleItems.Add(mapper.Map<SessionItem>(session));
+                    scheduleItems.Add(mapper.ToSessionItem(session));
                     continue;
                 case Track track:
-                    scheduleItems.Add(mapper.Map<TrackItem>(track));
+                    scheduleItems.Add(mapper.ToTrackItem(track));
                     continue;
             }
         }

backend/src/MethodConf.Cms/Services/DependencyInjection.cs

@@ -11,7 +11,9 @@ public static IHostApplicationBuilder AddApplicationServices(this IHostApplicati
         builder.Services.AddScoped<IConferenceScheduleService, ConferenceScheduleService>();
         builder.Services.AddScoped<ISessionFeedbackService, SessionFeedbackService>();
         builder.Services.AddScoped<IConferenceIssueService, ConferenceIssueService>();
-        builder.Services.AddAutoMapper(_ => { }, typeof(DefaultProfile).Assembly);
+        builder.Services.AddScoped<ScheduleMapper>();
+        builder.Services.AddScoped<SessionFeedbackMapper>();
+        builder.Services.AddScoped<IssueMapper>();
         builder.Services.AddRazorTemplating();
 
         return builder;

backend/src/MethodConf.Cms/Services/SessionFeedbackService.cs

@@ -1,15 +1,15 @@
-using AutoMapper;
 using FluentResults;
 using MethodConf.Cms.Domain;
 using MethodConf.Cms.Domain.Errors;
 using MethodConf.Cms.Infrastructure;
+using MethodConf.Cms.Mapping;
 using MethodConf.Cms.Services.Interfaces;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Web.Common.PublishedModels;
 
 namespace MethodConf.Cms.Services;
 
-public class SessionFeedbackService(IPublishedContentQuery publishedContentQuery, AppDbContext dbContext, IMapper mapper) : ISessionFeedbackService
+public class SessionFeedbackService(IPublishedContentQuery publishedContentQuery, AppDbContext dbContext, SessionFeedbackMapper mapper) : ISessionFeedbackService
 {
 
     public async Task<Result<SessionFeedback>> Create(Guid sessionId, CreateSessionFeedback createSessionFeedback)
@@ -24,8 +24,7 @@ public async Task<Result<SessionFeedback>> Create(Guid sessionId, CreateSessionF
             return new IneligibleForFeedback(session);
         }
 
-        var sessionFeedback = mapper.Map<SessionFeedback>(createSessionFeedback);
-        sessionFeedback.SessionId = session.Key;
+        var sessionFeedback = mapper.ToSessionFeedback(createSessionFeedback, session.Key);
         sessionFeedback.CreatedAt = DateTime.UtcNow;