Replace AutoMapper with hand-written entity mappers (#136)

Author: 3keyroman

CLAUDE.md

@@ -10,8 +10,8 @@ Guidance for agents working in this repository.
 | `src/Czertainly.Auth/Controllers` | REST API controllers — `UsersController`, `RolesController`, `PermissionsController`, `ResourcesController`, `ActionsController`. |
 | `src/Czertainly.Auth/Services` | Business logic behind the controllers (`UserService`, `RoleService`, `PermissionService`, `ResourceService`, `ActionService`) and their interfaces. |
 | `src/Czertainly.Auth/Data` | `AuthDbContext`; repository contracts (`Data/Contracts`) and implementations (`Data/Repositiories`, sic); EF Core migrations (`Data/Migrations`). |
-| `src/Czertainly.Auth/Models` | DTOs (`Models/Dto`), EF Core entities and fluent configurations (`Models/Entities`, `Models/Entities/Configurations`), AutoMapper profiles (`Models/Mappings`), options classes (`Models/Config`). |
-| `src/Czertainly.Auth/Common` | Cross-cutting concerns: paging/query-filter abstractions (`Common/Data`), domain exceptions plus the global exception middleware (`Common/Exceptions`), model-validation filters (`Common/Filters`), extension methods (`Common/Extensions`), display-name helpers (`Common/Helpers`), shared DTO/entity base types (`Common/Models`), and the generic `CrudService<TEntity, TResponseDto, TDetailResponseDto>` base (`Common/Services`). |
+| `src/Czertainly.Auth/Models` | DTOs (`Models/Dto`), EF Core entities and fluent configurations (`Models/Entities`, `Models/Entities/Configurations`), hand-written entity/DTO mappers and their `IEntityMapper` adapters (`Models/Mappings`), options classes (`Models/Config`). |
+| `src/Czertainly.Auth/Common` | Cross-cutting concerns: paging/query-filter abstractions (`Common/Data`), domain exceptions plus the global exception middleware (`Common/Exceptions`), model-validation filters (`Common/Filters`), extension methods (`Common/Extensions`), display-name helpers (`Common/Helpers`), shared DTO/entity base types (`Common/Models`), query/paging mappers (`Common/Mappings`), and the generic `CrudService<TEntity, TResponseDto, TDetailResponseDto>` base plus its `IEntityMapper` abstraction (`Common/Services`). |
 | `src/Czertainly.Auth/Properties/launchSettings.json` | Local `dotnet run` launch profiles. |
 | `docker/` | Files copied into the runtime image: `entry.sh` (container entrypoint), `update-cacerts.sh`, `static-functions`. |
 | `hooks/` | Legacy Docker Hub automated-build hook scripts (`build`, `post_push`). |

src/Czertainly.Auth/Common/Mappings/CommonMapper.cs

@@ -0,0 +1,56 @@
+using Czertainly.Auth.Common.Data;
+using Czertainly.Auth.Common.Exceptions;
+using Czertainly.Auth.Common.Models.Dto;
+
+namespace Czertainly.Auth.Common.Mappings
+{
+    public static class CommonMapper
+    {
+        /// <summary>
+        /// Translates the wire level query request into repository query parameters. A leading '-' in SortBy requests
+        /// descending order and the remainder is capitalized, because the sorting is applied through a dynamic
+        /// <c>OrderBy</c> that addresses the entity property by its CLR (PascalCase) name.
+        /// </summary>
+        /// <remarks>
+        /// An absent SortBy - null, empty or whitespace-only - is a legitimate request for no ordering and yields a null
+        /// sort field, which the repository reads as "do not order". A SortBy that is present but cannot name a property,
+        /// which is only a '-' with nothing but whitespace behind it, is malformed rather than absent and is rejected.
+        /// </remarks>
+        /// <exception cref="InvalidFormatException">
+        /// SortBy carries the descending prefix but no property name behind it.
+        /// </exception>
+        public static QueryStringParameters ToQueryStringParameters(this IQueryRequestDto dto)
+        {
+            var sortBy = dto.SortBy ?? string.Empty;
+            var descending = sortBy.StartsWith('-');
+            var sortField = descending ? sortBy[1..] : sortBy;
+
+            // Line endings are stripped because the message reaches the log through the exception middleware.
+            if (descending && string.IsNullOrWhiteSpace(sortField))
+            {
+                throw new InvalidFormatException($"Invalid sortBy value '{sortBy.ReplaceLineEndings(string.Empty)}': the descending prefix '-' must be followed by a property name.");
+            }
+
+            return new QueryStringParameters
+            {
+                Page = dto.Page,
+                PageSize = dto.PageSize,
+                SortBy = string.IsNullOrWhiteSpace(sortField) ? null : char.ToUpper(sortField[0]) + sortField[1..],
+                SortAscending = !descending,
+            };
+        }
+
+        public static PagingMetadata ToPagingMetadata(this IPagedList pagedList)
+        {
+            return new PagingMetadata
+            {
+                CurrentPage = pagedList.CurrentPage,
+                PageSize = pagedList.PageSize,
+                TotalCount = pagedList.TotalCount,
+                TotalPages = pagedList.TotalPages,
+                HasPrevious = pagedList.HasPrevious,
+                HasNext = pagedList.HasNext,
+            };
+        }
+    }
+}

src/Czertainly.Auth/Common/Services/CrudService.cs

@@ -1,6 +1,5 @@
-using AutoMapper;
-using Czertainly.Auth.Common.Data;
-using Czertainly.Auth.Common.Data.Repositories;
+using Czertainly.Auth.Common.Data.Repositories;
+using Czertainly.Auth.Common.Mappings;
 using Czertainly.Auth.Common.Models.Dto;
 using Czertainly.Auth.Common.Models.Entities;
 using Czertainly.Auth.Data.Contracts;
@@ -12,12 +11,12 @@ public abstract class CrudService<TEntity, TResponseDto, TDetailResponseDto> : I
         where TResponseDto : ICrudResponseDto, new()
         where TDetailResponseDto : ICrudResponseDto, new()
     {
-        protected readonly IMapper _mapper;
+        protected readonly IEntityMapper<TEntity, TResponseDto, TDetailResponseDto> _mapper;
         protected readonly ILogger _logger;
         protected readonly IBaseRepository<TEntity> _repository;
         protected readonly IRepositoryManager _repositoryManager;
 
-        public CrudService(IRepositoryManager repositoryManager, IBaseRepository<TEntity> repository, IMapper mapper, ILogger logger)
+        protected CrudService(IRepositoryManager repositoryManager, IBaseRepository<TEntity> repository, IEntityMapper<TEntity, TResponseDto, TDetailResponseDto> mapper, ILogger logger)
         {
             _mapper = mapper;
             _logger = logger;
@@ -26,42 +25,42 @@ public CrudService(IRepositoryManager repositoryManager, IBaseRepository<TEntity
         }
         public virtual async Task<PagedResponse<TResponseDto>> GetAsync(IQueryRequestDto dto)
         {
-            var queryParams = _mapper.Map<QueryStringParameters>(dto);
-            var users = await _repository.GetAllAsync(queryParams);
+            var queryParams = dto.ToQueryStringParameters();
+            var entities = await _repository.GetAllAsync(queryParams);
 
             return new PagedResponse<TResponseDto>
             {
-                Data = _mapper.Map<List<TResponseDto>>(users),
-                Links = _mapper.Map<PagingMetadata>(users),
+                Data = entities.Select(entity => _mapper.ToDto(entity)).ToList(),
+                Links = entities.ToPagingMetadata(),
             };
         }
 
         public virtual async Task<TDetailResponseDto> CreateAsync(ICrudRequestDto dto)
         {
-            var entity = _mapper.Map<TEntity>(dto);
+            var entity = _mapper.ToEntity(dto);
             _repository.Create(entity);
             await _repositoryManager.SaveAsync();
 
             entity = await _repository.GetByKeyAsync(entity.Uuid);
-            return _mapper.Map<TDetailResponseDto>(entity);
+            return _mapper.ToDetailDto(entity);
         }
 
         public virtual async Task<TDetailResponseDto> GetDetailAsync(Guid key)
         {
             var entity = await _repository.GetByKeyAsync(key);
 
-            return _mapper.Map<TDetailResponseDto>(entity);
+            return _mapper.ToDetailDto(entity);
         }
 
         public virtual async Task<TDetailResponseDto> UpdateAsync(Guid key, ICrudRequestDto dto)
         {
             var entity = await _repository.GetByKeyAsync(key);
-            _mapper.Map(dto, entity);
+            _mapper.ApplyUpdate(dto, entity);
 
             //await _repository.UpdateAsync(key, entity);
             await _repositoryManager.SaveAsync();
 
-            return _mapper.Map<TDetailResponseDto>(entity);
+            return _mapper.ToDetailDto(entity);
         }
 
         public virtual async Task DeleteAsync(Guid key)

src/Czertainly.Auth/Common/Services/IEntityMapper.cs

@@ -0,0 +1,38 @@
+using Czertainly.Auth.Common.Models.Dto;
+using Czertainly.Auth.Common.Models.Entities;
+
+namespace Czertainly.Auth.Common.Services
+{
+    /// <summary>
+    /// Entity specific mapping operations needed by <see cref="CrudService{TEntity, TResponseDto, TDetailResponseDto}"/>.
+    /// Implementations are stateless adapters over the hand-written static mappers, so the generic CRUD base does not
+    /// need to know any concrete entity or DTO type.
+    /// </summary>
+    /// <remarks>
+    /// The two response DTOs are covariant because they only ever flow out of this interface. TEntity cannot be, since
+    /// <see cref="ApplyUpdate"/> consumes it while <see cref="ToEntity"/> produces it. Neither response DTO carries a
+    /// <c>new()</c> constraint: nothing here constructs them, so requiring instantiability would only narrow the type
+    /// arguments a covariant conversion can reach.
+    /// </remarks>
+    public interface IEntityMapper<TEntity, out TResponseDto, out TDetailResponseDto>
+        where TEntity : class, IBaseEntity, new()
+        where TResponseDto : ICrudResponseDto
+        where TDetailResponseDto : ICrudResponseDto
+    {
+        /// <summary>
+        /// Builds a new entity from a create request. Throws <see cref="ArgumentException"/> when the runtime type of
+        /// the request is not the one the entity is created from.
+        /// </summary>
+        TEntity ToEntity(ICrudRequestDto dto);
+
+        /// <summary>
+        /// Copies the updatable members of an update request onto an already loaded entity. Throws
+        /// <see cref="ArgumentException"/> when the runtime type of the request is not the one the entity is updated from.
+        /// </summary>
+        void ApplyUpdate(ICrudRequestDto dto, TEntity entity);
+
+        TResponseDto ToDto(TEntity entity);
+
+        TDetailResponseDto ToDetailDto(TEntity entity);
+    }
+}

src/Czertainly.Auth/Czertainly.Auth.csproj

@@ -12,7 +12,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Versioning" Version="5.1.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.10" />

src/Czertainly.Auth/Models/Mappings/ActionMapper.cs

@@ -0,0 +1,64 @@
+using Czertainly.Auth.Common.Models.Dto;
+using Czertainly.Auth.Common.Services;
+using Czertainly.Auth.Models.Dto;
+using ActionEntity = Czertainly.Auth.Models.Entities.Action;
+
+namespace Czertainly.Auth.Models.Mappings
+{
+    public static class ActionMapper
+    {
+        /// <summary>
+        /// An action create request carries exactly the members an update request carries, so the field list lives in
+        /// <see cref="ApplyTo"/> alone.
+        /// </summary>
+        public static ActionEntity ToEntity(this ActionRequestDto dto)
+        {
+            var action = new ActionEntity();
+            dto.ApplyTo(action);
+
+            return action;
+        }
+
+        public static void ApplyTo(this ActionRequestDto dto, ActionEntity action)
+        {
+            action.Name = dto.Name!;
+            action.DisplayName = dto.DisplayName!;
+        }
+
+        public static ActionDto ToDto(this ActionEntity action)
+        {
+            return new ActionDto
+            {
+                Uuid = action.Uuid,
+                Name = action.Name,
+                DisplayName = action.DisplayName,
+            };
+        }
+    }
+
+    /// <summary>
+    /// Actions have no separate detail representation, so the list and the detail response are the same DTO.
+    /// </summary>
+    public sealed class ActionEntityMapper : IEntityMapper<ActionEntity, ActionDto, ActionDto>
+    {
+        public static readonly ActionEntityMapper Instance = new();
+
+        public ActionEntity ToEntity(ICrudRequestDto dto)
+        {
+            if (dto is not ActionRequestDto actionRequestDto) throw new ArgumentException($"Cannot create action from '{dto.GetType().Name}'.", nameof(dto));
+
+            return ActionMapper.ToEntity(actionRequestDto);
+        }
+
+        public void ApplyUpdate(ICrudRequestDto dto, ActionEntity entity)
+        {
+            if (dto is not ActionRequestDto actionRequestDto) throw new ArgumentException($"Cannot update action from '{dto.GetType().Name}'.", nameof(dto));
+
+            ActionMapper.ApplyTo(actionRequestDto, entity);
+        }
+
+        public ActionDto ToDto(ActionEntity entity) => ActionMapper.ToDto(entity);
+
+        public ActionDto ToDetailDto(ActionEntity entity) => ActionMapper.ToDto(entity);
+    }
+}

src/Czertainly.Auth/Models/Mappings/ActionProfile.cs

@@ -0,0 +1,77 @@
+using Czertainly.Auth.Common.Models.Dto;
+using Czertainly.Auth.Common.Services;
+using Czertainly.Auth.Models.Dto;
+using Czertainly.Auth.Models.Entities;
+
+namespace Czertainly.Auth.Models.Mappings
+{
+    public static class ResourceMapper
+    {
+        /// <summary>
+        /// A resource create request carries exactly the members an update request carries, so the field list lives in
+        /// <see cref="ApplyTo"/> alone.
+        /// </summary>
+        public static Resource ToEntity(this ResourceRequestDto dto)
+        {
+            var resource = new Resource();
+            dto.ApplyTo(resource);
+
+            return resource;
+        }
+
+        public static void ApplyTo(this ResourceRequestDto dto, Resource resource)
+        {
+            resource.Name = dto.Name!;
+            resource.DisplayName = dto.DisplayName!;
+            resource.ListObjectsEndpoint = dto.ListObjectsEndpoint;
+        }
+
+        public static ResourceDto ToDto(this Resource resource)
+        {
+            return new ResourceDto
+            {
+                Uuid = resource.Uuid,
+                Name = resource.Name,
+                DisplayName = resource.DisplayName,
+                ListObjectsEndpoint = resource.ListObjectsEndpoint,
+            };
+        }
+
+        public static ResourceDetailDto ToDetailDto(this Resource resource)
+        {
+            return new ResourceDetailDto
+            {
+                Uuid = resource.Uuid,
+                Name = resource.Name,
+                DisplayName = resource.DisplayName,
+                ListObjectsEndpoint = resource.ListObjectsEndpoint,
+                // Actions is loaded through the repository's detail includes or an explicit Include on every path
+                // reaching this mapper - see UserMapper.ToDetailDto for the same reasoning.
+                Actions = resource.Actions?.Select(action => action.ToDto()).ToList() ?? [],
+            };
+        }
+    }
+
+    public sealed class ResourceEntityMapper : IEntityMapper<Resource, ResourceDto, ResourceDetailDto>
+    {
+        public static readonly ResourceEntityMapper Instance = new();
+
+        public Resource ToEntity(ICrudRequestDto dto)
+        {
+            if (dto is not ResourceRequestDto resourceRequestDto) throw new ArgumentException($"Cannot create resource from '{dto.GetType().Name}'.", nameof(dto));
+
+            return ResourceMapper.ToEntity(resourceRequestDto);
+        }
+
+        public void ApplyUpdate(ICrudRequestDto dto, Resource entity)
+        {
+            if (dto is not ResourceRequestDto resourceRequestDto) throw new ArgumentException($"Cannot update resource from '{dto.GetType().Name}'.", nameof(dto));
+
+            ResourceMapper.ApplyTo(resourceRequestDto, entity);
+        }
+
+        public ResourceDto ToDto(Resource entity) => ResourceMapper.ToDto(entity);
+
+        public ResourceDetailDto ToDetailDto(Resource entity) => ResourceMapper.ToDetailDto(entity);
+    }
+}