refactor: apply dependency injection pattern across command and query handlers

Author: al3xjohnson

CLAUDE.md

@@ -75,6 +75,45 @@ Remember: PRDs help ensure features are built to meet user needs and business ob
    - Remove any un-needed whitespace
    - Simplify collection initializations where possible
 
+## Dependency Injection Pattern
+
+**IMPORTANT**: All services, handlers, and classes using dependency injection MUST follow this pattern:
+
+1. **Use primary constructors** for dependency injection
+2. **Create private readonly fields** for ALL injected dependencies
+3. **Prefix fields with underscore** (e.g., `_userRepository`, `_logger`)
+4. **Initialize fields from constructor parameters**
+
+Example:
+```csharp
+public class SomeService(
+    IUserRepository userRepository,
+    IUnitOfWork unitOfWork,
+    IMapper mapper,
+    ILogger<SomeService> logger) : ISomeService
+{
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<SomeService> _logger = logger;
+
+    public async Task DoSomething()
+    {
+        // Use _userRepository, _unitOfWork, etc. (NOT userRepository)
+        User? user = await _userRepository.GetByIdAsync(id);
+        _logger.LogInformation("Did something");
+    }
+}
+```
+
+This pattern applies to:
+- All service implementations (IUserService, ITeslaApiService, etc.)
+- All MediatR command and query handlers
+- All authentication handlers
+- Any class using constructor dependency injection
+
+**Never** use constructor parameters directly in methods - always use the private readonly fields.
+
 4. **Modern C# patterns**:
    - **Use expression-bodied members** for methods/properties that can be expressed as a single expression
    - **Formatting**: Place `=>` on the same line as the method signature

src/services/TeslaStarter.Application/Users/Commands/CreateUser/CreateUserCommandHandler.cs

@@ -8,10 +8,15 @@ public sealed class CreateUserCommandHandler(
     IMapper mapper,
     ILogger<CreateUserCommandHandler> logger) : IRequestHandler<CreateUserCommand, UserDto>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<CreateUserCommandHandler> _logger = logger;
+
     public async Task<UserDto> Handle(CreateUserCommand request, CancellationToken cancellationToken)
     {
         // Check if user already exists with external ID
-        User? existingUserByExternalId = await userRepository.GetByExternalIdAsync(
+        User? existingUserByExternalId = await _userRepository.GetByExternalIdAsync(
             ExternalId.Create(request.ExternalId),
             cancellationToken);
 
@@ -25,7 +30,7 @@ public async Task<UserDto> Handle(CreateUserCommand request, CancellationToken c
         }
 
         // Check if user already exists with email
-        User? existingUserByEmail = await userRepository.GetByEmailAsync(
+        User? existingUserByEmail = await _userRepository.GetByEmailAsync(
             Email.Create(request.Email),
             cancellationToken);
 
@@ -44,13 +49,13 @@ public async Task<UserDto> Handle(CreateUserCommand request, CancellationToken c
             request.Email,
             request.DisplayName);
 
-        userRepository.Add(user);
+        _userRepository.Add(user);
 
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Created user {UserId} with external ID {ExternalId}",
+        _logger.LogInformation("Created user {UserId} with external ID {ExternalId}",
             user.Id.Value, user.ExternalId.Value);
 
-        return mapper.Map<UserDto>(user);
+        return _mapper.Map<UserDto>(user);
     }
 }

src/services/TeslaStarter.Application/Users/Commands/LinkTeslaAccount/LinkTeslaAccountCommandHandler.cs

@@ -9,9 +9,13 @@ public sealed class LinkTeslaAccountCommandHandler(
     IMapper mapper,
     ILogger<LinkTeslaAccountCommandHandler> logger) : IRequestHandler<LinkTeslaAccountCommand, UserDto>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<LinkTeslaAccountCommandHandler> _logger = logger;
     public async Task<UserDto> Handle(LinkTeslaAccountCommand request, CancellationToken cancellationToken)
     {
-        User? user = await userRepository.GetByIdAsync(
+        User? user = await _userRepository.GetByIdAsync(
             new UserId(request.UserId),
             cancellationToken) ?? throw new NotFoundException(nameof(User), request.UserId);
 
@@ -28,12 +32,12 @@ public async Task<UserDto> Handle(LinkTeslaAccountCommand request, CancellationT
             ]);
         }
 
-        userRepository.Update(user);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        _userRepository.Update(user);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Linked Tesla account {TeslaAccountId} to user {UserId}",
+        _logger.LogInformation("Linked Tesla account {TeslaAccountId} to user {UserId}",
             request.TeslaAccountId, user.Id.Value);
 
-        return mapper.Map<UserDto>(user);
+        return _mapper.Map<UserDto>(user);
     }
 }

src/services/TeslaStarter.Application/Users/Commands/RecordLogin/RecordLoginCommandHandler.cs

@@ -9,19 +9,23 @@ public sealed class RecordLoginCommandHandler(
     IMapper mapper,
     ILogger<RecordLoginCommandHandler> logger) : IRequestHandler<RecordLoginCommand, UserDto>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<RecordLoginCommandHandler> _logger = logger;
     public async Task<UserDto> Handle(RecordLoginCommand request, CancellationToken cancellationToken)
     {
-        User? user = await userRepository.GetByIdAsync(
+        User? user = await _userRepository.GetByIdAsync(
             new UserId(request.UserId),
             cancellationToken) ?? throw new NotFoundException(nameof(User), request.UserId);
 
         user.RecordLogin();
 
-        userRepository.Update(user);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        _userRepository.Update(user);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Recorded login for user {UserId}", user.Id.Value);
+        _logger.LogInformation("Recorded login for user {UserId}", user.Id.Value);
 
-        return mapper.Map<UserDto>(user);
+        return _mapper.Map<UserDto>(user);
     }
 }

src/services/TeslaStarter.Application/Users/Commands/UnlinkTeslaAccount/UnlinkTeslaAccountCommandHandler.cs

@@ -9,9 +9,13 @@ public sealed class UnlinkTeslaAccountCommandHandler(
     IMapper mapper,
     ILogger<UnlinkTeslaAccountCommandHandler> logger) : IRequestHandler<UnlinkTeslaAccountCommand, UserDto>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<UnlinkTeslaAccountCommandHandler> _logger = logger;
     public async Task<UserDto> Handle(UnlinkTeslaAccountCommand request, CancellationToken cancellationToken)
     {
-        User user = await userRepository.GetByIdAsync(
+        User user = await _userRepository.GetByIdAsync(
             new UserId(request.UserId),
             cancellationToken) ?? throw new NotFoundException(nameof(User), request.UserId);
 
@@ -28,11 +32,11 @@ public async Task<UserDto> Handle(UnlinkTeslaAccountCommand request, Cancellatio
             ]);
         }
 
-        userRepository.Update(user);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        _userRepository.Update(user);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Unlinked Tesla account from user {UserId}", user.Id.Value);
+        _logger.LogInformation("Unlinked Tesla account from user {UserId}", user.Id.Value);
 
-        return mapper.Map<UserDto>(user);
+        return _mapper.Map<UserDto>(user);
     }
 }

src/services/TeslaStarter.Application/Users/Commands/UpdateProfile/UpdateProfileCommandHandler.cs

@@ -9,14 +9,18 @@ public sealed class UpdateProfileCommandHandler(
     IMapper mapper,
     ILogger<UpdateProfileCommandHandler> logger) : IRequestHandler<UpdateProfileCommand, UserDto>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<UpdateProfileCommandHandler> _logger = logger;
     public async Task<UserDto> Handle(UpdateProfileCommand request, CancellationToken cancellationToken)
     {
-        User user = await userRepository.GetByIdAsync(
+        User user = await _userRepository.GetByIdAsync(
             new UserId(request.UserId),
             cancellationToken) ?? throw new NotFoundException(nameof(User), request.UserId);
 
         // Check if another user already has this email
-        User? existingUserWithEmail = await userRepository.GetByEmailAsync(
+        User? existingUserWithEmail = await _userRepository.GetByEmailAsync(
             Email.Create(request.Email),
             cancellationToken);
 
@@ -31,11 +35,11 @@ public async Task<UserDto> Handle(UpdateProfileCommand request, CancellationToke
 
         user.UpdateProfile(request.Email, request.DisplayName);
 
-        userRepository.Update(user);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        _userRepository.Update(user);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Updated profile for user {UserId}", user.Id.Value);
+        _logger.LogInformation("Updated profile for user {UserId}", user.Id.Value);
 
-        return mapper.Map<UserDto>(user);
+        return _mapper.Map<UserDto>(user);
     }
 }

src/services/TeslaStarter.Application/Users/Queries/GetUser/GetUserQueryHandler.cs

@@ -7,12 +7,14 @@ public sealed class GetUserQueryHandler(
     IUserRepository userRepository,
     IMapper mapper) : IRequestHandler<GetUserQuery, UserDto>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IMapper _mapper = mapper;
     public async Task<UserDto> Handle(GetUserQuery request, CancellationToken cancellationToken)
     {
-        User user = await userRepository.GetByIdAsync(
+        User user = await _userRepository.GetByIdAsync(
             new UserId(request.UserId),
             cancellationToken) ?? throw new NotFoundException(nameof(User), request.UserId);
 
-        return mapper.Map<UserDto>(user);
+        return _mapper.Map<UserDto>(user);
     }
 }

src/services/TeslaStarter.Application/Users/Queries/GetUserByExternalId/GetUserByExternalIdQueryHandler.cs

@@ -6,12 +6,14 @@ public sealed class GetUserByExternalIdQueryHandler(
     IUserRepository userRepository,
     IMapper mapper) : IRequestHandler<GetUserByExternalIdQuery, UserDto?>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IMapper _mapper = mapper;
     public async Task<UserDto?> Handle(GetUserByExternalIdQuery request, CancellationToken cancellationToken)
     {
-        User? user = await userRepository.GetByExternalIdAsync(
+        User? user = await _userRepository.GetByExternalIdAsync(
             ExternalId.Create(request.ExternalId),
             cancellationToken);
 
-        return user != null ? mapper.Map<UserDto>(user) : null;
+        return user != null ? _mapper.Map<UserDto>(user) : null;
     }
 }

src/services/TeslaStarter.Application/Vehicles/Commands/LinkVehicle/LinkVehicleCommandHandler.cs

@@ -8,11 +8,15 @@ public sealed class LinkVehicleCommandHandler(
     IMapper mapper,
     ILogger<LinkVehicleCommandHandler> logger) : IRequestHandler<LinkVehicleCommand, VehicleDto>
 {
+    private readonly IVehicleRepository _vehicleRepository = vehicleRepository;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly IMapper _mapper = mapper;
+    private readonly ILogger<LinkVehicleCommandHandler> _logger = logger;
     public async Task<VehicleDto> Handle(LinkVehicleCommand request, CancellationToken cancellationToken)
     {
 
         // Check if vehicle already exists with this identifier
-        Vehicle? existingVehicle = await vehicleRepository.GetByVehicleIdentifierAsync(
+        Vehicle? existingVehicle = await _vehicleRepository.GetByVehicleIdentifierAsync(
             request.VehicleIdentifier,
             cancellationToken);
 
@@ -31,12 +35,12 @@ public async Task<VehicleDto> Handle(LinkVehicleCommand request, CancellationTok
             request.VehicleIdentifier,
             request.DisplayName);
 
-        vehicleRepository.Add(vehicle);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        _vehicleRepository.Add(vehicle);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
-        logger.LogInformation("Linked vehicle {VehicleIdentifier} to Tesla account {TeslaAccountId}",
+        _logger.LogInformation("Linked vehicle {VehicleIdentifier} to Tesla account {TeslaAccountId}",
             vehicle.VehicleIdentifier, vehicle.TeslaAccountId.Value);
 
-        return mapper.Map<VehicleDto>(vehicle);
+        return _mapper.Map<VehicleDto>(vehicle);
     }
 }

src/services/TeslaStarter.Application/Vehicles/Commands/SyncUserVehicles/SyncUserVehiclesCommandHandler.cs

@@ -10,9 +10,15 @@ public sealed class SyncUserVehiclesCommandHandler(
     IUnitOfWork unitOfWork,
     ILogger<SyncUserVehiclesCommandHandler> logger) : IRequestHandler<SyncUserVehiclesCommand, int>
 {
+    private readonly IUserRepository _userRepository = userRepository;
+    private readonly IVehicleRepository _vehicleRepository = vehicleRepository;
+    private readonly ITeslaApiService _teslaApiService = teslaApiService;
+    private readonly IUnitOfWork _unitOfWork = unitOfWork;
+    private readonly ILogger<SyncUserVehiclesCommandHandler> _logger = logger;
+
     public async Task<int> Handle(SyncUserVehiclesCommand request, CancellationToken cancellationToken)
     {
-        User? user = await userRepository.GetByExternalIdAsync(
+        User? user = await _userRepository.GetByExternalIdAsync(
             ExternalId.Create(request.ExternalId),
             cancellationToken) ?? throw new NotFoundException(nameof(User), request.ExternalId);
 
@@ -23,7 +29,7 @@ public async Task<int> Handle(SyncUserVehiclesCommand request, CancellationToken
         }
 
         // Fetch vehicles from Tesla API
-        IReadOnlyList<TeslaVehicleDto> teslaVehicles = await teslaApiService.GetVehiclesAsync(user.TeslaAccount.AccessToken!);
+        IReadOnlyList<TeslaVehicleDto> teslaVehicles = await _teslaApiService.GetVehiclesAsync(user.TeslaAccount.AccessToken!);
 
         _logger.LogInformation("Found {Count} vehicles for user {UserId}", teslaVehicles.Count, user.Id.Value);
 
@@ -32,7 +38,7 @@ public async Task<int> Handle(SyncUserVehiclesCommand request, CancellationToken
         foreach (TeslaVehicleDto teslaVehicle in teslaVehicles)
         {
             // Check if vehicle already exists
-            Vehicle? existingVehicle = await vehicleRepository.GetByVehicleIdentifierAsync(
+            Vehicle? existingVehicle = await _vehicleRepository.GetByVehicleIdentifierAsync(
                 teslaVehicle.Vin,
                 cancellationToken);
 
@@ -44,7 +50,7 @@ public async Task<int> Handle(SyncUserVehiclesCommand request, CancellationToken
                     teslaVehicle.Vin,
                     string.IsNullOrEmpty(teslaVehicle.DisplayName) ? null : teslaVehicle.DisplayName);
 
-                vehicleRepository.Add(vehicle);
+                _vehicleRepository.Add(vehicle);
                 syncedCount++;
 
                 _logger.LogInformation("Added new vehicle {VIN} for user {UserId}",
@@ -56,18 +62,16 @@ public async Task<int> Handle(SyncUserVehiclesCommand request, CancellationToken
                 existingVehicle.UpdateDisplayName(teslaVehicle.DisplayName);
                 existingVehicle.RecordSync();
 
-                vehicleRepository.Update(existingVehicle);
+                _vehicleRepository.Update(existingVehicle);
                 syncedCount++;
 
                 _logger.LogInformation("Updated vehicle {VIN} for user {UserId}",
                     teslaVehicle.Vin, user.Id.Value);
             }
         }
 
-        await unitOfWork.SaveChangesAsync(cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
 
         return syncedCount;
     }
-
-    private readonly ILogger<SyncUserVehiclesCommandHandler> _logger = logger;
 }