Building a Feature Slice — End to End

A vertical slice for CreatePrescription includes:
  1. Endpoint:   receives HTTP POST, sends Command to MediatR
  2. Command:    immutable record with all input data
  3. Validator:  FluentValidation rules for the command
  4. Handler:    business logic + persistence
  5. Response:   what the endpoint returns to the client

All five files live in Features/Prescriptions/CreatePrescription/
No other folder needs to change.

// Features/Prescriptions/CreatePrescription/CreatePrescriptionCommand.cs
public sealed record CreatePrescriptionCommand(
    Guid    PatientId,
    string  MedicationName,
    decimal DoseAmount,
    string  DoseUnit,
    Guid    PrescriberId,
    string? Instructions) : IRequest<Result<CreatePrescriptionResponse>>;

// Features/Prescriptions/CreatePrescription/CreatePrescriptionResponse.cs
public sealed record CreatePrescriptionResponse(
    Guid     PrescriptionId,
    string   MedicationName,
    decimal  DoseAmount,
    string   DoseUnit,
    DateTime PrescribedAt);

// Features/Prescriptions/CreatePrescription/CreatePrescriptionValidator.cs
public sealed class CreatePrescriptionValidator
    : AbstractValidator<CreatePrescriptionCommand>
{
    public CreatePrescriptionValidator()
    {
        RuleFor(c => c.PatientId)
            .NotEmpty()
            .WithMessage("PatientId is required.");

        RuleFor(c => c.MedicationName)
            .NotEmpty()
            .MaximumLength(200)
            .WithMessage("Medication name must be between 1 and 200 characters.");

        RuleFor(c => c.DoseAmount)
            .GreaterThan(0)
            .LessThanOrEqualTo(10000)
            .WithMessage("Dose amount must be between 0 and 10000.");

        RuleFor(c => c.DoseUnit)
            .NotEmpty()
            .Must(u => new[] { "mg", "mcg", "g", "units/kg", "IU" }.Contains(u))
            .WithMessage("Dose unit must be a recognized unit.");

        RuleFor(c => c.PrescriberId)
            .NotEmpty()
            .WithMessage("PrescriberId is required.");
    }
}

// Features/Prescriptions/CreatePrescription/CreatePrescriptionHandler.cs
public sealed class CreatePrescriptionHandler
    : IRequestHandler<CreatePrescriptionCommand, Result<CreatePrescriptionResponse>>
{
    private readonly ApplicationDbContext _db;
    private readonly IUnitOfWork          _uow;
    private readonly IMediator            _mediator;

    public CreatePrescriptionHandler(
        ApplicationDbContext db,
        IUnitOfWork          uow,
        IMediator            mediator)
    {
        _db       = db;
        _uow      = uow;
        _mediator = mediator;
    }

    public async Task<Result<CreatePrescriptionResponse>> Handle(
        CreatePrescriptionCommand command, CancellationToken ct)
    {
        // 1. Load patient — fail fast if not found
        var patient = await _db.Patients
            .FirstOrDefaultAsync(p => p.Id == new PatientId(command.PatientId), ct);

        if (patient is null)
            return Result.Failure<CreatePrescriptionResponse>(DomainErrors.Patient.NotFound);

        // 2. Load prescriber — fail fast if not found
        var prescriber = await _db.Clinicians
            .FirstOrDefaultAsync(c => c.Id == new ClinicianId(command.PrescriberId), ct);

        if (prescriber is null)
            return Result.Failure<CreatePrescriptionResponse>(DomainErrors.Clinician.NotFound);

        // 3. Domain: create prescription
        var prescriptionResult = Prescription.Create(
            patient.Id,
            command.MedicationName,
            new DosageValue(command.DoseAmount, command.DoseUnit),
            prescriber.Id,
            command.Instructions);

        if (prescriptionResult.IsFailure)
            return Result.Failure<CreatePrescriptionResponse>(prescriptionResult.Error);

        var prescription = prescriptionResult.Value;

        // 4. Deactivate previous active prescriptions for same medication
        await _db.Prescriptions
            .Where(p => p.PatientId == patient.Id &&
                        p.MedicationName == command.MedicationName &&
                        p.IsActive)
            .ExecuteUpdateAsync(
                s => s.SetProperty(p => p.IsActive, false), ct);

        // 5. Persist
        await _db.Prescriptions.AddAsync(prescription, ct);
        await _uow.SaveChangesAsync(ct);

        // 6. Publish domain event (fire-and-forget side effects)
        await _mediator.Publish(new PrescriptionCreatedNotification(
            prescription.Id.Value, patient.Id.Value, command.MedicationName), ct);

        return Result.Success(new CreatePrescriptionResponse(
            prescription.Id.Value,
            prescription.MedicationName,
            prescription.Dose.Amount,
            prescription.Dose.Unit,
            prescription.PrescribedAt));
    }
}

// Features/Prescriptions/CreatePrescription/CreatePrescriptionEndpoint.cs
public sealed class CreatePrescriptionEndpoint : IEndpoint
{
    public void MapEndpoint(IEndpointRouteBuilder app)
    {
        app.MapPost("api/prescriptions",
            async (CreatePrescriptionRequest request, ISender sender, CancellationToken ct) =>
            {
                var command = new CreatePrescriptionCommand(
                    request.PatientId,
                    request.MedicationName,
                    request.DoseAmount,
                    request.DoseUnit,
                    request.PrescriberId,
                    request.Instructions);

                var result = await sender.Send(command, ct);

                return result.IsSuccess
                    ? Results.CreatedAtRoute("GetPrescription",
                        new { prescriptionId = result.Value.PrescriptionId },
                        result.Value)
                    : result.Error == DomainErrors.Patient.NotFound
                        ? Results.NotFound(new { error = result.Error.Description })
                        : Results.UnprocessableEntity(new { error = result.Error.Description });
            })
            .WithName("CreatePrescription")
            .WithSummary("Create a new prescription for a patient")
            .Produces<CreatePrescriptionResponse>(StatusCodes.Status201Created)
            .Produces(StatusCodes.Status404NotFound)
            .Produces(StatusCodes.Status422UnprocessableEntity)
            .RequireAuthorization("CanPrescribe");
    }
}

// Separate request DTO (decoupled from the command)
public sealed record CreatePrescriptionRequest(
    Guid    PatientId,
    string  MedicationName,
    decimal DoseAmount,
    string  DoseUnit,
    Guid    PrescriberId,
    string? Instructions);

HTTP POST /api/prescriptions
  → Endpoint receives request, maps to Command
  → ISender.Send(command)
    → LoggingBehavior: logs "Handling CreatePrescriptionCommand"
    → ValidationBehavior: runs CreatePrescriptionValidator
      → If invalid: throws ValidationException → 400
    → CreatePrescriptionHandler.Handle()
      → Load patient, prescriber
      → Create domain entity
      → Deactivate old prescriptions
      → SaveChanges
      → Publish PrescriptionCreatedNotification
    → LoggingBehavior: logs "Handled CreatePrescriptionCommand in 45ms"
  → Endpoint maps Result to 201 Created or error response