Backend architecture.
Build the right boundaries first.

ClearLend.slnx
  src/
    ClearLend.Domain/          business concepts and invariants
    ClearLend.Application/     commands, queries and ports
    ClearLend.Infrastructure/  EF Core and external adapters
    ClearLend.Contracts/       public request and response types
    ClearLend.Api/             HTTP, auth and composition root
  tests/
    ClearLend.Domain.Tests/
    ClearLend.Application.Tests/
    ClearLend.Architecture.Tests/
    ClearLend.Api.IntegrationTests/
  docs/decisions/

Application/Applications/CreateDraft/
  CreateDraftCommand.cs
  CreateDraftHandler.cs
  CreateDraftResult.cs
Application/Applications/GetDraft/
  GetDraftQuery.cs
  GetDraftHandler.cs
  DraftDetails.cs
Api/Features/Applications/
  CreateDraftEndpoint.cs
  GetDraftEndpoint.cs

namespace ClearLend.Domain.Examples;

public sealed class DomainRuleException(string code, string message)
    : Exception(message)
{
    public string Code { get; } = code;
}

public readonly record struct BorrowerId(Guid Value);
public readonly record struct LenderId(Guid Value);
public readonly record struct LoanId(Guid Value);

public sealed record Money
{
    public decimal Amount { get; }
    public string Currency { get; }

    private Money(decimal amount, string currency)
        => (Amount, Currency) = (amount, currency);

    public static Money Create(decimal amount, string currency)
    {
        if (amount < 0)
            throw new DomainRuleException("money.negative", "Amount cannot be negative.");
        if (string.IsNullOrWhiteSpace(currency))
            throw new DomainRuleException("money.currency", "Currency is required.");

        var code = currency.Trim().ToUpperInvariant();
        if (code.Length != 3 || code.Any(c => c is < 'A' or > 'Z'))
            throw new DomainRuleException("money.currency", "Use a three-letter currency code.");

        return new Money(amount, code);
    }

    public Money Subtract(Money other)
    {
        ArgumentNullException.ThrowIfNull(other);
        if (Currency != other.Currency)
            throw new DomainRuleException("money.currency_mismatch", "Currencies must match.");
        if (other.Amount > Amount)
            throw new DomainRuleException("money.insufficient", "Amount exceeds the balance.");
        return Create(Amount - other.Amount, Currency);
    }
}

namespace ClearLend.Domain.Examples;

public enum BorrowerStatus { PendingVetting, Vetted, Suspended }

public sealed class Borrower
{
    public BorrowerId Id { get; }
    public string LegalName { get; private set; }
    public BorrowerStatus Status { get; private set; }
    public Money? ApprovedLimit { get; private set; }
    public string? VettingDecisionReference { get; private set; }
    public DateTimeOffset? VettedAt { get; private set; }
    public string? SuspensionReason { get; private set; }
    public DateTimeOffset RegisteredAt { get; }
    public DateTimeOffset LastChangedAt { get; private set; }

    private Borrower(BorrowerId id, string legalName, DateTimeOffset registeredAt)
    {
        Id = id;
        LegalName = legalName;
        Status = BorrowerStatus.PendingVetting;
        RegisteredAt = LastChangedAt = registeredAt;
    }

    public static Borrower Register(
        BorrowerId id, string legalName, DateTimeOffset registeredAt)
    {
        if (id.Value == Guid.Empty)
            throw new DomainRuleException("borrower.id", "Borrower ID is required.");
        if (registeredAt == default)
            throw new DomainRuleException("borrower.time", "Registration time is required.");
        return new Borrower(id, RequireName(legalName), registeredAt);
    }

    public void CorrectLegalName(string legalName, DateTimeOffset changedAt)
    {
        EnsureTime(changedAt);
        if (Status != BorrowerStatus.PendingVetting)
            throw new DomainRuleException("borrower.name_locked", "A vetted name needs a new review.");
        LegalName = RequireName(legalName);
        LastChangedAt = changedAt;
    }

    public void ApproveVetting(
        Money approvedLimit, string decisionReference, DateTimeOffset decidedAt)
    {
        EnsureTime(decidedAt);
        ArgumentNullException.ThrowIfNull(approvedLimit);
        if (Status != BorrowerStatus.PendingVetting || approvedLimit.Amount <= 0)
            throw new DomainRuleException("borrower.vetting", "Pending review and a positive limit are required.");
        if (string.IsNullOrWhiteSpace(decisionReference))
            throw new DomainRuleException("borrower.decision", "A decision reference is required.");

        ApprovedLimit = approvedLimit;
        VettingDecisionReference = decisionReference.Trim();
        VettedAt = LastChangedAt = decidedAt;
        Status = BorrowerStatus.Vetted;
    }

    public void Suspend(string reason, DateTimeOffset changedAt)
    {
        EnsureTime(changedAt);
        if (Status == BorrowerStatus.Suspended || string.IsNullOrWhiteSpace(reason))
            throw new DomainRuleException("borrower.suspension", "A new suspension needs a reason.");
        SuspensionReason = reason.Trim();
        Status = BorrowerStatus.Suspended;
        LastChangedAt = changedAt;
    }

    public void ReopenVetting(DateTimeOffset changedAt)
    {
        EnsureTime(changedAt);
        if (Status != BorrowerStatus.Suspended)
            throw new DomainRuleException("borrower.reopen", "Only a suspended borrower can reopen review.");
        Status = BorrowerStatus.PendingVetting;
        ApprovedLimit = null;
        VettingDecisionReference = null;
        VettedAt = null;
        SuspensionReason = null;
        LastChangedAt = changedAt;
    }

    public bool CanRequest(Money amount)
    {
        ArgumentNullException.ThrowIfNull(amount);
        return Status == BorrowerStatus.Vetted
            && ApprovedLimit is not null
            && amount.Amount > 0
            && amount.Currency == ApprovedLimit.Currency
            && amount.Amount <= ApprovedLimit.Amount;
    }

    private void EnsureTime(DateTimeOffset at)
    {
        if (at < LastChangedAt)
            throw new DomainRuleException("borrower.time", "A change cannot predate the last change.");
    }

    private static string RequireName(string value)
    {
        if (string.IsNullOrWhiteSpace(value))
            throw new DomainRuleException("borrower.name", "Legal name is required.");
        return value.Trim();
    }
}

namespace ClearLend.Domain.Examples;

public enum LenderStatus { PendingVetting, Active, Suspended }

public sealed class Lender
{
    public LenderId Id { get; }
    public string RegisteredName { get; }
    public LenderStatus Status { get; private set; }
    public Money? SingleCommitmentLimit { get; private set; }
    public string? VettingDecisionReference { get; private set; }
    public DateTimeOffset? ApprovedAt { get; private set; }
    public string? SuspensionReason { get; private set; }
    public DateTimeOffset RegisteredAt { get; }
    public DateTimeOffset LastChangedAt { get; private set; }

    private Lender(LenderId id, string registeredName, DateTimeOffset registeredAt)
    {
        Id = id;
        RegisteredName = registeredName;
        Status = LenderStatus.PendingVetting;
        RegisteredAt = LastChangedAt = registeredAt;
    }

    public static Lender Register(
        LenderId id, string registeredName, DateTimeOffset registeredAt)
    {
        if (id.Value == Guid.Empty)
            throw new DomainRuleException("lender.id", "Lender ID is required.");
        if (string.IsNullOrWhiteSpace(registeredName) || registeredAt == default)
            throw new DomainRuleException("lender.registration", "Name and time are required.");
        return new Lender(id, registeredName.Trim(), registeredAt);
    }

    public void ApproveForLending(
        Money singleCommitmentLimit, string decisionReference, DateTimeOffset decidedAt)
    {
        EnsureTime(decidedAt);
        ArgumentNullException.ThrowIfNull(singleCommitmentLimit);
        if (Status != LenderStatus.PendingVetting || singleCommitmentLimit.Amount <= 0)
            throw new DomainRuleException("lender.vetting", "Pending review and a positive limit are required.");
        if (string.IsNullOrWhiteSpace(decisionReference))
            throw new DomainRuleException("lender.decision", "A decision reference is required.");

        SingleCommitmentLimit = singleCommitmentLimit;
        VettingDecisionReference = decisionReference.Trim();
        ApprovedAt = LastChangedAt = decidedAt;
        Status = LenderStatus.Active;
    }

    public void Suspend(string reason, DateTimeOffset changedAt)
    {
        EnsureTime(changedAt);
        if (Status == LenderStatus.Suspended || string.IsNullOrWhiteSpace(reason))
            throw new DomainRuleException("lender.suspension", "A new suspension needs a reason.");
        SuspensionReason = reason.Trim();
        Status = LenderStatus.Suspended;
        LastChangedAt = changedAt;
    }

    public void ReopenVetting(DateTimeOffset changedAt)
    {
        EnsureTime(changedAt);
        if (Status != LenderStatus.Suspended)
            throw new DomainRuleException("lender.reopen", "Only a suspended lender can reopen review.");
        Status = LenderStatus.PendingVetting;
        SingleCommitmentLimit = null;
        VettingDecisionReference = null;
        ApprovedAt = null;
        SuspensionReason = null;
        LastChangedAt = changedAt;
    }

    public bool AllowsSingleCommitment(Money amount)
    {
        ArgumentNullException.ThrowIfNull(amount);
        return Status == LenderStatus.Active
            && SingleCommitmentLimit is not null
            && amount.Amount > 0
            && amount.Currency == SingleCommitmentLimit.Currency
            && amount.Amount <= SingleCommitmentLimit.Amount;
    }

    private void EnsureTime(DateTimeOffset at)
    {
        if (at < LastChangedAt)
            throw new DomainRuleException("lender.time", "A change cannot predate the last change.");
    }
}

namespace ClearLend.Domain.Examples;

public enum LoanStatus { Active, PrincipalCleared }

public sealed class Loan
{
    public LoanId Id { get; }
    public BorrowerId BorrowerId { get; }
    public LenderId LenderId { get; }
    public Guid AcceptedOfferId { get; }
    public Money Principal { get; }
    public decimal FixedNominalAnnualRatePercent { get; }
    public int TermMonths { get; }
    public string FundingConfirmationReference { get; }
    public DateTimeOffset FundedAt { get; }
    public Money OutstandingPrincipal { get; private set; }
    public LoanStatus Status { get; private set; }
    public DateTimeOffset? PrincipalClearedAt { get; private set; }

    private Loan(
        LoanId id, BorrowerId borrowerId, LenderId lenderId,
        Guid acceptedOfferId, Money principal, decimal annualRatePercent,
        int termMonths, string fundingReference, DateTimeOffset fundedAt)
    {
        Id = id;
        BorrowerId = borrowerId;
        LenderId = lenderId;
        AcceptedOfferId = acceptedOfferId;
        Principal = OutstandingPrincipal = principal;
        FixedNominalAnnualRatePercent = annualRatePercent;
        TermMonths = termMonths;
        FundingConfirmationReference = fundingReference;
        FundedAt = fundedAt;
        Status = LoanStatus.Active;
    }

    public static Loan OpenFromConfirmedFunding(
        LoanId id, BorrowerId borrowerId, LenderId lenderId,
        Guid acceptedOfferId, Money principal, decimal annualRatePercent,
        int termMonths, string fundingReference, DateTimeOffset fundedAt)
    {
        ArgumentNullException.ThrowIfNull(principal);
        if (id.Value == Guid.Empty || borrowerId.Value == Guid.Empty
            || lenderId.Value == Guid.Empty || acceptedOfferId == Guid.Empty)
            throw new DomainRuleException("loan.identity", "Loan and party IDs are required.");
        if (principal.Amount <= 0 || annualRatePercent < 0 || termMonths <= 0)
            throw new DomainRuleException("loan.terms", "Positive principal, nonnegative rate and term are required.");
        if (string.IsNullOrWhiteSpace(fundingReference) || fundedAt == default)
            throw new DomainRuleException("loan.funding", "Confirmed funding reference and time are required.");

        return new Loan(id, borrowerId, lenderId, acceptedOfferId, principal,
            annualRatePercent, termMonths, fundingReference.Trim(), fundedAt);
    }

    public void ApplyConfirmedPrincipal(
        Money principalPaid, DateTimeOffset confirmedAt)
    {
        ArgumentNullException.ThrowIfNull(principalPaid);
        if (Status != LoanStatus.Active)
            throw new DomainRuleException("loan.principal_cleared", "A principal-cleared loan cannot receive more principal.");
        if (principalPaid.Amount <= 0 || confirmedAt < FundedAt)
            throw new DomainRuleException("loan.allocation", "Positive principal and a valid time are required.");

        OutstandingPrincipal = OutstandingPrincipal.Subtract(principalPaid);
        if (OutstandingPrincipal.Amount == 0)
        {
            Status = LoanStatus.PrincipalCleared;
            PrincipalClearedAt = confirmedAt;
        }
    }
}

src/ClearLend.Application/
  Abstractions/
    ICurrentActor.cs                 trusted borrower identity
    IBorrowerEligibility.cs          Onboarding decision contract
    ILoanApplicationIds.cs           deterministic ID creation
  Applications/
    Shared/
      AppResult.cs                   typed use-case outcomes
      IDraftWriter.cs                aggregate write port
      IDraftReader.cs                owned read projection port
    CreateDraft/
      CreateDraftCommand.cs
      CreateDraftHandler.cs
      CreatedDraft.cs
    ChangeDraftAmount/
      ChangeDraftAmountCommand.cs
      ChangeDraftAmountHandler.cs
      ChangedDraft.cs
    GetDraft/
      GetDraftQuery.cs
      GetDraftHandler.cs
      DraftDetails.cs
tests/ClearLend.Application.Tests/Applications/
  CreateDraft/  ChangeDraftAmount/  GetDraft/

namespace ClearLend.Domain.Examples;

public readonly record struct LoanApplicationId(Guid Value);
public enum DraftStatus { Draft, Submitted }

// A compact collaborator for this chapter; Step 3 will build the real aggregate.
public sealed class LoanApplication
{
    public LoanApplicationId Id { get; }
    public BorrowerId BorrowerId { get; }
    public Money RequestedAmount { get; private set; }
    public DraftStatus Status { get; private set; }
    public DateTimeOffset UpdatedAt { get; private set; }

    private LoanApplication(LoanApplicationId id, BorrowerId borrowerId,
        Money requestedAmount, DateTimeOffset now)
    {
        Id = id;
        BorrowerId = borrowerId;
        RequestedAmount = requestedAmount;
        Status = DraftStatus.Draft;
        UpdatedAt = now;
    }

    public static LoanApplication CreateDraft(LoanApplicationId id,
        BorrowerId borrowerId, Money requestedAmount, DateTimeOffset now)
    {
        ArgumentNullException.ThrowIfNull(requestedAmount);
        if (id.Value == Guid.Empty || borrowerId.Value == Guid.Empty
            || requestedAmount.Amount <= 0 || now == default)
            throw new DomainRuleException("draft.creation", "A draft needs valid identity, amount and time.");
        return new LoanApplication(id, borrowerId, requestedAmount, now);
    }

    // Repository reconstitution; the real Step 3 aggregate will validate
    // every field required by each persisted status before returning.
    public static LoanApplication Rehydrate(LoanApplicationId id,
        BorrowerId borrowerId, Money requestedAmount,
        DraftStatus status, DateTimeOffset updatedAt)
    {
        if (!Enum.IsDefined(status))
            throw new DomainRuleException("draft.status", "Stored status is unknown.");
        var application = CreateDraft(id, borrowerId, requestedAmount, updatedAt);
        application.Status = status;
        return application;
    }

    public void ChangeRequestedAmount(Money requestedAmount, DateTimeOffset now)
    {
        ArgumentNullException.ThrowIfNull(requestedAmount);
        if (Status != DraftStatus.Draft)
            throw new DomainRuleException("draft.not_editable", "Only a draft can change amount.");
        if (requestedAmount.Amount <= 0 || now < UpdatedAt
            || requestedAmount.Currency != RequestedAmount.Currency)
            throw new DomainRuleException("draft.amount", "Amount and currency must remain valid.");
        RequestedAmount = requestedAmount;
        UpdatedAt = now;
    }
}

using ClearLend.Domain.Examples;

namespace ClearLend.Application.Examples;

public enum FailureKind { Unauthenticated, Invalid, Ineligible, NotFound, Conflict }
public sealed record AppFailure(FailureKind Kind, string Code, string Message);

public sealed class AppResult<T>
{
    public T? Value { get; }
    public AppFailure? Failure { get; }
    public bool Succeeded => Failure is null;

    private AppResult(T? value, AppFailure? failure)
        => (Value, Failure) = (value, failure);

    public static AppResult<T> Ok(T value) => new(value, null);
    public static AppResult<T> Fail(FailureKind kind, string code, string message)
        => new(default, new AppFailure(kind, code, message));
}

// The API constructs this from validated authentication, never from request JSON.
public interface ICurrentActor
{
    BorrowerId? BorrowerId { get; }
}

// An Onboarding module contract; no direct read of its tables.
public interface IBorrowerEligibility
{
    Task<bool> CanStartDraftAsync(BorrowerId borrowerId, Money amount,
        CancellationToken cancellationToken);
}

public interface ILoanApplicationIds
{
    LoanApplicationId NewLoanApplicationId();
}

public sealed record LoadedDraft(LoanApplication Draft, string Version);
public sealed record SavedDraft(bool Saved, string? NewVersion);

// Implemented by Infrastructure. Save uses ID + owner + expected version.
public interface IDraftWriter
{
    Task<string> AddAsync(LoanApplication draft, CancellationToken cancellationToken);
    Task<LoadedDraft?> FindOwnedForChangeAsync(LoanApplicationId id,
        BorrowerId borrowerId, CancellationToken cancellationToken);
    Task<SavedDraft> SaveAsync(LoanApplication draft, string expectedVersion,
        CancellationToken cancellationToken);
}

public sealed record DraftDetails(LoanApplicationId Id, decimal RequestedAmount,
    string Currency, string Status, DateTimeOffset UpdatedAt, string Version);

// A direct owned projection; it need not materialize the aggregate.
public interface IDraftReader
{
    Task<DraftDetails?> ReadOwnedAsync(LoanApplicationId id, BorrowerId borrowerId,
        CancellationToken cancellationToken);
}

public static class RequestedMoney
{
    public static Money? TryCreate(decimal amount, string? currency)
    {
        if (amount <= 0 || string.IsNullOrWhiteSpace(currency)) return null;
        var code = currency.Trim().ToUpperInvariant();
        if (code.Length != 3 || code.Any(c => c is < 'A' or > 'Z')) return null;
        return Money.Create(amount, code); // Domain remains the final guard.
    }
}

using ClearLend.Domain.Examples;

namespace ClearLend.Application.Examples;

public sealed record CreateDraftCommand(decimal RequestedAmount, string Currency);
public sealed record CreatedDraft(LoanApplicationId Id, string Version);

public sealed class CreateDraftHandler(
    ICurrentActor actor,
    IBorrowerEligibility eligibility,
    IDraftWriter writer,
    ILoanApplicationIds ids,
    TimeProvider clock)
{
    public async Task<AppResult<CreatedDraft>> Handle(
        CreateDraftCommand command, CancellationToken cancellationToken)
    {
        var borrowerId = actor.BorrowerId;
        if (borrowerId is null)
            return AppResult<CreatedDraft>.Fail(FailureKind.Unauthenticated,
                "actor.missing", "A borrower sign-in is required.");

        var amount = RequestedMoney.TryCreate(command.RequestedAmount, command.Currency);
        if (amount is null)
            return AppResult<CreatedDraft>.Fail(FailureKind.Invalid,
                "draft.amount", "Enter a positive amount and a three-letter currency.");

        if (!await eligibility.CanStartDraftAsync(borrowerId.Value, amount, cancellationToken))
            return AppResult<CreatedDraft>.Fail(FailureKind.Ineligible,
                "borrower.ineligible", "Borrower is not approved for this request.");

        var draft = LoanApplication.CreateDraft(ids.NewLoanApplicationId(),
            borrowerId.Value, amount, clock.GetUtcNow());
        var version = await writer.AddAsync(draft, cancellationToken);
        return AppResult<CreatedDraft>.Ok(new CreatedDraft(draft.Id, version));
    }
}

using ClearLend.Domain.Examples;

namespace ClearLend.Application.Examples;

public sealed record ChangeDraftAmountCommand(LoanApplicationId Id,
    decimal RequestedAmount, string Currency, string ExpectedVersion);
public sealed record ChangedDraft(LoanApplicationId Id, string Version);

public sealed class ChangeDraftAmountHandler(
    ICurrentActor actor, IDraftWriter writer, TimeProvider clock)
{
    public async Task<AppResult<ChangedDraft>> Handle(
        ChangeDraftAmountCommand command, CancellationToken cancellationToken)
    {
        var borrowerId = actor.BorrowerId;
        if (borrowerId is null)
            return AppResult<ChangedDraft>.Fail(FailureKind.Unauthenticated,
                "actor.missing", "A borrower sign-in is required.");
        if (command.Id.Value == Guid.Empty || string.IsNullOrWhiteSpace(command.ExpectedVersion))
            return AppResult<ChangedDraft>.Fail(FailureKind.Invalid,
                "draft.identity", "Draft ID and expected version are required.");

        var amount = RequestedMoney.TryCreate(command.RequestedAmount, command.Currency);
        if (amount is null)
            return AppResult<ChangedDraft>.Fail(FailureKind.Invalid,
                "draft.amount", "Enter a positive amount and a three-letter currency.");

        var loaded = await writer.FindOwnedForChangeAsync(command.Id,
            borrowerId.Value, cancellationToken);
        if (loaded is null)
            return AppResult<ChangedDraft>.Fail(FailureKind.NotFound,
                "draft.not_found", "Draft was not found.");
        if (!StringComparer.Ordinal.Equals(loaded.Version, command.ExpectedVersion))
            return AppResult<ChangedDraft>.Fail(FailureKind.Conflict,
                "draft.stale", "Reload the draft before saving changes.");

        try
        {
            loaded.Draft.ChangeRequestedAmount(amount, clock.GetUtcNow());
        }
        catch (DomainRuleException error) when (
            error.Code is "draft.not_editable" or "draft.amount")
        {
            return AppResult<ChangedDraft>.Fail(FailureKind.Conflict,
                error.Code, error.Message);
        }

        // The adapter compares the expected version again in SQL. A second
        // writer can win after our read; a failed compare must not overwrite it.
        var saved = await writer.SaveAsync(loaded.Draft,
            command.ExpectedVersion, cancellationToken);
        if (!saved.Saved || saved.NewVersion is null)
            return AppResult<ChangedDraft>.Fail(FailureKind.Conflict,
                "draft.stale", "Reload the draft before saving changes.");

        return AppResult<ChangedDraft>.Ok(new ChangedDraft(command.Id, saved.NewVersion));
    }
}

using ClearLend.Domain.Examples;

namespace ClearLend.Application.Examples;

public sealed record GetDraftQuery(LoanApplicationId Id);

public sealed class GetDraftHandler(ICurrentActor actor, IDraftReader reader)
{
    public async Task<AppResult<DraftDetails>> Handle(
        GetDraftQuery query, CancellationToken cancellationToken)
    {
        var borrowerId = actor.BorrowerId;
        if (borrowerId is null)
            return AppResult<DraftDetails>.Fail(FailureKind.Unauthenticated,
                "actor.missing", "A borrower sign-in is required.");
        if (query.Id.Value == Guid.Empty)
            return AppResult<DraftDetails>.Fail(FailureKind.Invalid,
                "draft.id", "Draft ID is required.");

        // Reader filters by both ID and borrower. Missing and unowned drafts
        // are intentionally indistinguishable to this caller.
        var draft = await reader.ReadOwnedAsync(query.Id,
            borrowerId.Value, cancellationToken);
        return draft is null
            ? AppResult<DraftDetails>.Fail(FailureKind.NotFound,
                "draft.not_found", "Draft was not found.")
            : AppResult<DraftDetails>.Ok(draft);
    }
}

src/ClearLend.Infrastructure/
  DependencyInjection/InfrastructureRegistration.cs
  Persistence/
    ClearLendDbContext.cs
    Applications/
      DraftRow.cs
      DraftRowMap.cs
      DraftMapping.cs
      DraftVersionCodec.cs
      EfDraftWriter.cs
      EfDraftReader.cs
    Migrations/
      20xx..._InitialDrafts.cs
  Integrations/
    Onboarding/            eligibility adapter when its contract is real
    Documents/             storage adapter when evidence is in scope
    Notifications/         sender and outbox worker in a later step
tests/ClearLend.Infrastructure.IntegrationTests/
  DraftPersistenceTests.cs
  DraftConcurrencyTests.cs

using ClearLend.Domain.Examples;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace ClearLend.Infrastructure.Examples;

// Persistence shape stays in Infrastructure; it is never returned by the API.
public sealed class DraftRow
{
    public Guid Id { get; set; }
    public Guid BorrowerId { get; set; }
    public decimal RequestedAmount { get; set; }
    public string Currency { get; set; } = string.Empty;
    public DraftStatus Status { get; set; }
    public DateTimeOffset UpdatedAt { get; set; }
    public byte[] Version { get; set; } = [];
}

public sealed class ClearLendDbContext(DbContextOptions<ClearLendDbContext> options)
    : DbContext(options)
{
    internal DbSet<DraftRow> Drafts => Set<DraftRow>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
        => modelBuilder.ApplyConfiguration(new DraftRowMap());
}

internal sealed class DraftRowMap : IEntityTypeConfiguration<DraftRow>
{
    public void Configure(EntityTypeBuilder<DraftRow> row)
    {
        row.ToTable("LoanApplications", "applications", table =>
        {
            table.HasCheckConstraint("CK_Draft_Amount", "[RequestedAmount] > 0");
            table.HasCheckConstraint("CK_Draft_Status",
                "[Status] IN ('Draft', 'Submitted')");
        });
        row.HasKey(x => x.Id);
        row.Property(x => x.BorrowerId).IsRequired().IsConcurrencyToken();
        row.Property(x => x.RequestedAmount).HasPrecision(28, 10);
        row.Property(x => x.Currency).HasColumnType("char(3)").IsRequired();
        row.Property(x => x.Status).HasConversion<string>()
            .HasMaxLength(24).IsRequired();
        row.Property(x => x.UpdatedAt).IsRequired();
        row.Property(x => x.Version).IsRowVersion();
    }
}

public static class DraftMapping
{
    public static DraftRow ToRow(LoanApplication draft) => new()
    {
        Id = draft.Id.Value,
        BorrowerId = draft.BorrowerId.Value,
        RequestedAmount = draft.RequestedAmount.Amount,
        Currency = draft.RequestedAmount.Currency,
        Status = draft.Status,
        UpdatedAt = draft.UpdatedAt
    };

    public static LoanApplication ToDomain(DraftRow row)
        => LoanApplication.Rehydrate(new LoanApplicationId(row.Id),
            new BorrowerId(row.BorrowerId),
            Money.Create(row.RequestedAmount, row.Currency),
            row.Status, row.UpdatedAt);
}

public static class DraftVersionCodec
{
    public static string Encode(byte[] version) => Convert.ToBase64String(version);

    public static bool TryDecode(string? encoded, out byte[] version)
    {
        version = [];
        if (string.IsNullOrWhiteSpace(encoded)) return false;
        try
        {
            var decoded = Convert.FromBase64String(encoded);
            if (decoded.Length != 8) return false; // SQL Server rowversion is 8 bytes.
            version = decoded;
            return true;
        }
        catch (FormatException) { return false; }
    }
}

using Microsoft.EntityFrameworkCore.Migrations;

namespace ClearLend.Infrastructure.Examples;

// Representative migration; generate and review the real migration in Step 4.
public sealed class InitialDrafts : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.EnsureSchema(name: "applications");
        migrationBuilder.CreateTable(
            name: "LoanApplications",
            schema: "applications",
            columns: table => new
            {
                Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
                BorrowerId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
                RequestedAmount = table.Column<decimal>(type: "decimal(28,10)", nullable: false),
                Currency = table.Column<string>(type: "char(3)", nullable: false),
                Status = table.Column<string>(type: "nvarchar(24)", maxLength: 24, nullable: false),
                UpdatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
                Version = table.Column<byte[]>(type: "rowversion", rowVersion: true, nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_LoanApplications", x => x.Id);
                table.CheckConstraint("CK_Draft_Amount", "[RequestedAmount] > 0");
                table.CheckConstraint("CK_Draft_Status", "[Status] IN ('Draft', 'Submitted')");
            });
    }

    protected override void Down(MigrationBuilder migrationBuilder)
        => migrationBuilder.DropTable(name: "LoanApplications", schema: "applications");
}

using ClearLend.Application.Examples;
using ClearLend.Domain.Examples;
using Microsoft.EntityFrameworkCore;

namespace ClearLend.Infrastructure.Examples;

public sealed class EfDraftWriter(ClearLendDbContext db) : IDraftWriter
{
    public async Task<string> AddAsync(LoanApplication draft,
        CancellationToken cancellationToken)
    {
        var row = DraftMapping.ToRow(draft);
        db.Drafts.Add(row);
        await db.SaveChangesAsync(cancellationToken);
        return DraftVersionCodec.Encode(row.Version); // Returned after commit.
    }

    public async Task<LoadedDraft?> FindOwnedForChangeAsync(
        LoanApplicationId id, BorrowerId borrowerId,
        CancellationToken cancellationToken)
    {
        var row = await db.Drafts.AsNoTracking().SingleOrDefaultAsync(
            x => x.Id == id.Value && x.BorrowerId == borrowerId.Value,
            cancellationToken);
        return row is null ? null : new LoadedDraft(
            DraftMapping.ToDomain(row), DraftVersionCodec.Encode(row.Version));
    }

    public async Task<SavedDraft> SaveAsync(LoanApplication draft,
        string expectedVersion, CancellationToken cancellationToken)
    {
        if (!DraftVersionCodec.TryDecode(expectedVersion, out var originalVersion))
            return new SavedDraft(false, null);

        var row = DraftMapping.ToRow(draft);
        row.Version = originalVersion;
        db.Drafts.Attach(row);
        var entry = db.Entry(row);
        entry.Property(x => x.BorrowerId).OriginalValue = draft.BorrowerId.Value;
        entry.Property(x => x.Version).OriginalValue = originalVersion;
        entry.Property(x => x.RequestedAmount).IsModified = true;
        entry.Property(x => x.Currency).IsModified = true;
        entry.Property(x => x.Status).IsModified = true;
        entry.Property(x => x.UpdatedAt).IsModified = true;

        try
        {
            await db.SaveChangesAsync(cancellationToken);
            return new SavedDraft(true, DraftVersionCodec.Encode(row.Version));
        }
        catch (DbUpdateConcurrencyException)
        {
            entry.State = EntityState.Detached;
            return new SavedDraft(false, null);
        }
    }
}

using ClearLend.Application.Examples;
using ClearLend.Domain.Examples;
using Microsoft.EntityFrameworkCore;

namespace ClearLend.Infrastructure.Examples;

public sealed class EfDraftReader(ClearLendDbContext db) : IDraftReader
{
    public async Task<DraftDetails?> ReadOwnedAsync(LoanApplicationId id,
        BorrowerId borrowerId, CancellationToken cancellationToken)
    {
        var row = await db.Drafts.AsNoTracking()
            .Where(x => x.Id == id.Value && x.BorrowerId == borrowerId.Value)
            .Select(x => new
            {
                x.Id, x.RequestedAmount, x.Currency,
                x.Status, x.UpdatedAt, x.Version
            })
            .SingleOrDefaultAsync(cancellationToken);

        return row is null ? null : new DraftDetails(
            new LoanApplicationId(row.Id), row.RequestedAmount,
            row.Currency, row.Status.ToString(), row.UpdatedAt,
            DraftVersionCodec.Encode(row.Version));
    }
}

using ClearLend.Application.Examples;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace ClearLend.Infrastructure.Examples;

public static class InfrastructureRegistration
{
    public static IServiceCollection AddClearLendInfrastructure(
        this IServiceCollection services, string connectionString)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(connectionString);
        services.AddDbContext<ClearLendDbContext>(options =>
            options.UseSqlServer(connectionString));
        services.AddScoped<IDraftWriter, EfDraftWriter>();
        services.AddScoped<IDraftReader, EfDraftReader>();
        return services;
    }
}