Application Layer — Use Cases, Interfaces, and Orchestration

Application layer is responsible for:
  ✓ Command handlers (create patient, approve drug order)
  ✓ Query handlers (get patient by ID, list active prescriptions)
  ✓ Input validation (FluentValidation validators)
  ✓ Interfaces for external services (IEmailService, IPharmacyNotificationService)
  ✓ Repository interfaces (IPatientRepository)
  ✓ Response DTOs (PatientResponse, PrescriptionSummary)
  ✓ Result types (Result, Error)

Application layer does NOT:
  ✗ Implement repositories (that is Infrastructure's job)
  ✗ Contain EF Core, SQL, or Redis
  ✗ Contain HTTP routing or serialization
  ✗ Contain complex domain rules (those belong in entities)

<!-- src/SystemForge.Application/SystemForge.Application.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="FluentValidation" Version="11.*" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Domain\SystemForge.Domain.csproj" />
  </ItemGroup>
</Project>

// Application/Patients/Commands/CreatePatient/CreatePatientCommand.cs
namespace SystemForge.Application.Patients.Commands.CreatePatient;

public sealed record CreatePatientCommand(
    string Name,
    DateOnly DateOfBirth,
    string MRN);

// Application/Patients/Queries/GetPatient/GetPatientQuery.cs
public sealed record GetPatientQuery(PatientId PatientId);

// Application/DrugOrders/Commands/ApproveOrder/ApproveOrderCommand.cs
public sealed record ApproveOrderCommand(
    DrugOrderId OrderId,
    string ApprovedBy);

// Application/Patients/Commands/CreatePatient/CreatePatientCommandHandler.cs
namespace SystemForge.Application.Patients.Commands.CreatePatient;

public sealed class CreatePatientCommandHandler
{
    private readonly IPatientRepository _patients;
    private readonly IUnitOfWork _unitOfWork;

    public CreatePatientCommandHandler(
        IPatientRepository patients,
        IUnitOfWork unitOfWork)
    {
        _patients    = patients;
        _unitOfWork  = unitOfWork;
    }

    public async Task<Result<PatientId>> Handle(
        CreatePatientCommand command,
        CancellationToken ct)
    {
        // Check business precondition
        if (await _patients.ExistsByMRNAsync(command.MRN, ct))
            return Result.Failure<PatientId>(PatientErrors.MRNAlreadyExists);

        // Delegate creation to the domain entity
        var patientResult = Patient.Create(command.Name, command.DateOfBirth, command.MRN);
        if (patientResult.IsFailure)
            return Result.Failure<PatientId>(patientResult.Error);

        var patient = patientResult.Value;
        await _patients.AddAsync(patient, ct);
        await _unitOfWork.SaveChangesAsync(ct);   // dispatches domain events inside

        return Result.Success(patient.Id);
    }
}

// Application/Patients/Queries/GetPatient/GetPatientQueryHandler.cs
public sealed class GetPatientQueryHandler
{
    private readonly IPatientRepository _patients;

    public GetPatientQueryHandler(IPatientRepository patients)
        => _patients = patients;

    public async Task<Result<PatientResponse>> Handle(
        GetPatientQuery query,
        CancellationToken ct)
    {
        var patient = await _patients.GetByIdAsync(query.PatientId, ct);

        if (patient is null)
            return Result.Failure<PatientResponse>(PatientErrors.NotFound);

        var response = new PatientResponse(
            patient.Id.Value,
            patient.Name,
            patient.DateOfBirth,
            patient.MRN,
            patient.IsActive,
            patient.Prescriptions.Select(p => new PrescriptionSummary(
                p.Id.Value,
                p.MedicationCode.Value,
                p.Dosage.ToString(),
                p.IsActive)).ToList());

        return Result.Success(response);
    }
}

// Application/Patients/Queries/GetPatient/PatientResponse.cs
public sealed record PatientResponse(
    Guid Id,
    string Name,
    DateOnly DateOfBirth,
    string MRN,
    bool IsActive,
    IReadOnlyList<PrescriptionSummary> Prescriptions);

public sealed record PrescriptionSummary(
    Guid Id,
    string MedicationCode,
    string Dosage,
    bool IsActive);

// Application/Abstractions/IPatientRepository.cs
namespace SystemForge.Application.Abstractions;

public interface IPatientRepository
{
    Task<Patient?> GetByIdAsync(PatientId id, CancellationToken ct);
    Task<Patient?> GetByMRNAsync(string mrn, CancellationToken ct);
    Task<bool> ExistsByMRNAsync(string mrn, CancellationToken ct);
    Task AddAsync(Patient patient, CancellationToken ct);
    Task<IReadOnlyList<Patient>> GetActiveAsync(CancellationToken ct);
}

// Application/Abstractions/IDrugOrderRepository.cs
public interface IDrugOrderRepository
{
    Task<DrugOrder?> GetByIdAsync(DrugOrderId id, CancellationToken ct);
    Task AddAsync(DrugOrder order, CancellationToken ct);
    Task<IReadOnlyList<DrugOrder>> GetPendingOrdersAsync(CancellationToken ct);
}

// Application/Abstractions/IUnitOfWork.cs
public interface IUnitOfWork
{
    Task<int> SaveChangesAsync(CancellationToken ct);
}

// Application/Abstractions/IEmailService.cs
public interface IEmailService
{
    Task SendAsync(string to, string subject, string body, CancellationToken ct);
}

// Application/Abstractions/IPharmacyNotificationService.cs
public interface IPharmacyNotificationService
{
    Task NotifyOrderReadyForDispensingAsync(DrugOrderId orderId, CancellationToken ct);
}

// Application/Abstractions/IAuditLog.cs
public interface IAuditLog
{
    Task LogAsync(string message, CancellationToken ct);
    Task LogUserActionAsync(string userId, string action, string entityType, string entityId, CancellationToken ct);
}

// Application/Abstractions/ICurrentUser.cs
public interface ICurrentUser
{
    string? UserId { get; }
    string? Email { get; }
    bool IsAuthenticated { get; }
}

// Application/DependencyInjection.cs
using Microsoft.Extensions.DependencyInjection;

namespace SystemForge.Application;

public static class DependencyInjection
{
    public static IServiceCollection AddApplication(this IServiceCollection services)
    {
        var assembly = typeof(AssemblyReference).Assembly;

        // Register all command handlers
        services.Scan(scan => scan
            .FromAssemblies(assembly)
            .AddClasses(classes => classes.Where(t =>
                t.Name.EndsWith("CommandHandler") || t.Name.EndsWith("QueryHandler")))
            .AsSelf()
            .WithScopedLifetime());

        // Register all FluentValidation validators
        services.AddValidatorsFromAssembly(assembly);

        return services;
    }
}

Application/
├── AssemblyReference.cs
├── DependencyInjection.cs
├── Abstractions/
│   ├── IPatientRepository.cs
│   ├── IDrugOrderRepository.cs
│   ├── IUnitOfWork.cs
│   ├── IEmailService.cs
│   ├── IPharmacyNotificationService.cs
│   └── ICurrentUser.cs
├── Common/
│   ├── Result.cs
│   └── Error.cs
├── Patients/
│   ├── Commands/
│   │   └── CreatePatient/
│   │       ├── CreatePatientCommand.cs
│   │       ├── CreatePatientCommandHandler.cs
│   │       └── CreatePatientCommandValidator.cs
│   ├── Queries/
│   │   └── GetPatient/
│   │       ├── GetPatientQuery.cs
│   │       ├── GetPatientQueryHandler.cs
│   │       └── PatientResponse.cs
│   └── Events/
│       └── PatientRegisteredDomainEventHandler.cs
└── DrugOrders/
    ├── Commands/
    │   └── ApproveOrder/
    │       ├── ApproveOrderCommand.cs
    │       ├── ApproveOrderCommandHandler.cs
    │       └── ApproveOrderCommandValidator.cs
    └── Events/
        └── DrugOrderApprovedDomainEventHandler.cs