Intermediate

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
// ── Value Objects (self-contained; same shapes as beginner section) ─────────
record PurchaseOrderId(String value) {           // => record PurchaseOrderId
    PurchaseOrderId {                            // => compact constructor (Java 16+)
        if (value == null || !value.startsWith("po_"))  // => format rule: po_<uuid>
            throw new IllegalArgumentException("PurchaseOrderId must start with po_"); // => "po_" prefix guards the identity
    }
}
record SupplierId(String value) {               // => record SupplierId
    SupplierId {
        if (value == null || !value.startsWith("sup_")) // => format rule: sup_<uuid>
            throw new IllegalArgumentException("SupplierId must start with sup_"); // => "sup_" prefix guards supplier identity
    }
}
record Money(BigDecimal amount, String currency) {  // => record Money
    Money {
        if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) // => non-negative
            throw new IllegalArgumentException("Money amount must be >= 0"); // => negative amounts are domain violations
    }
}
enum UnitOfMeasure { EACH, BOX, KG, LITRE, HOUR }  // => closed enum from spec
record Quantity(int value, UnitOfMeasure unit) {    // => record Quantity
    Quantity { if (value <= 0) throw new IllegalArgumentException("Quantity.value > 0"); } // => zero/negative quantity is not a quantity
 
// ── Line item — owned by PurchaseOrder, NOT an aggregate root itself ─────────
record PurchaseOrderLine(                       // => record PurchaseOrderLine
    String lineId,                             // => simple surrogate within aggregate boundary
    String skuCode,                            // => matches SkuCode format; kept as String for brevity
    Quantity quantity,                         // => carries unit of measure
    Money unitPrice                            // => price per unit at time of PO creation
) {}
 
// ── Aggregate root ────────────────────────────────────────────────────────────
enum PurchaseOrderStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
// => Five states used in intermediate examples; full machine extended later
 
class PurchaseOrder {                          // => class PurchaseOrder (aggregate root)
    private final PurchaseOrderId id;          // => identity; final — never changes
    private final SupplierId supplierId;       // => reference to supplier aggregate by id only
    // => Aggregate roots reference other roots by id, never by object reference
    private final List<PurchaseOrderLine> lines; // => mutable internally; exposed as unmodifiable
    private PurchaseOrderStatus status;        // => mutable — changes on each valid transition
 
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId) { // => constructor
        this.id         = id;
        this.supplierId = supplierId;
        this.lines      = new ArrayList<>();   // => starts with empty line list
        this.status     = PurchaseOrderStatus.DRAFT; // => all POs begin in Draft
    }
 
    public PurchaseOrderId getId()       { return id; }          // => read-only
    public SupplierId getSupplierId()    { return supplierId; }  // => read-only
    public PurchaseOrderStatus getStatus(){ return status; }     // => read-only
    public List<PurchaseOrderLine> getLines() {
        return Collections.unmodifiableList(lines); // => defensive copy prevents external mutation
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = new PurchaseOrder(                    // => po created
    new PurchaseOrderId("po_550e8400-0000"),   // => valid id; starts with po_
    new SupplierId("sup_660f9511-0001")        // => supplier referenced by id only
);
System.out.println(po.getStatus());            // => Output: DRAFT
System.out.println(po.getLines().size());      // => Output: 0

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
// ── Minimal supporting types (self-contained) ─────────────────────────────────
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
record Money(BigDecimal amount, String currency) {}
enum UnitOfMeasure { EACH, BOX, KG, LITRE, HOUR }
record Quantity(int value, UnitOfMeasure unit) {
    Quantity { if (value <= 0) throw new IllegalArgumentException("Quantity > 0"); }
}
record PurchaseOrderLine(String lineId, String skuCode, Quantity quantity, Money unitPrice) {}
enum PurchaseOrderStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
 
class PurchaseOrder {
    private final PurchaseOrderId id;
    private final SupplierId supplierId;
    private final List<PurchaseOrderLine> lines = new ArrayList<>();
    private PurchaseOrderStatus status = PurchaseOrderStatus.DRAFT;
 
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId) {
        this.id = id; this.supplierId = supplierId;
    }
 
    // ── Invariant-enforcing mutator ───────────────────────────────────────────
    public void addLine(PurchaseOrderLine line) {    // => addLine called
        if (status != PurchaseOrderStatus.DRAFT) {  // => invariant: lines only added in Draft
            throw new IllegalStateException(
                "Lines can only be added to a DRAFT PurchaseOrder, current: " + status);
        }
        // => Once Issued, lines are immutable per domain spec
        if (line == null)                           // => null guard; fail fast
            throw new IllegalArgumentException("line must not be null");
        boolean duplicate = lines.stream()
            .anyMatch(l -> l.lineId().equals(line.lineId())); // => duplicate line id check
        if (duplicate)                              // => domain rule: unique lineId within PO
            throw new IllegalArgumentException("Duplicate lineId: " + line.lineId());
        lines.add(line);                            // => mutation allowed only through this method
    }
 
    public Money computeTotal() {                   // => computeTotal derived from lines
        BigDecimal sum = lines.stream()
            .map(l -> l.unitPrice().amount()
                       .multiply(BigDecimal.valueOf(l.quantity().value()))) // => line total
            .reduce(BigDecimal.ZERO, BigDecimal::add); // => sum all lines
        String currency = lines.isEmpty() ? "USD" : lines.get(0).unitPrice().currency();
        return new Money(sum, currency);            // => returns new Money; no field stored
    }
 
    public List<PurchaseOrderLine> getLines() { return Collections.unmodifiableList(lines); }
    public PurchaseOrderStatus getStatus()    { return status; }
    public PurchaseOrderId getId()            { return id; }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = new PurchaseOrder(
    new PurchaseOrderId("po_550e8400-0001"),
    new SupplierId("sup_660f9511-0001")
);
po.addLine(new PurchaseOrderLine(               // => line added successfully
    "L1", "OFF-001234",
    new Quantity(5, UnitOfMeasure.BOX),
    new Money(new BigDecimal("20.00"), "USD")
));
po.addLine(new PurchaseOrderLine(               // => second line added
    "L2", "TLS-9999",
    new Quantity(2, UnitOfMeasure.EACH),
    new Money(new BigDecimal("150.00"), "USD")
));
System.out.println(po.getLines().size());       // => Output: 2
System.out.println(po.computeTotal().amount()); // => Output: 400.00 (5*20 + 2*150)
 
try {
    po.getLines().add(null);                    // => UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Cannot mutate lines externally"); // => Output: Cannot mutate lines externally
}

import java.math.BigDecimal;
 
// ── Supporting types ──────────────────────────────────────────────────────────
record Money(BigDecimal amount, String currency) {}
 
// ── Domain enum with derivation logic ────────────────────────────────────────
enum ApprovalLevel {                        // => enum ApprovalLevel
    L1,   // => ≤ $1,000 — first-line manager
    L2,   // => ≤ $10,000 — department head
    L3;   // => > $10,000 — CFO or board
 
    // Factory method on the enum: derivation rule expressed in one place
    public static ApprovalLevel from(Money total) {  // => static factory; Money → ApprovalLevel
        if (total == null)                           // => guard: Money must be provided
            throw new IllegalArgumentException("total is required");
        BigDecimal amount = total.amount();
        // => Thresholds from domain spec: L1 ≤ 1k, L2 ≤ 10k, L3 above
        if (amount.compareTo(new BigDecimal("1000.00")) <= 0)  return L1; // => ≤ 1,000
        if (amount.compareTo(new BigDecimal("10000.00")) <= 0) return L2; // => ≤ 10,000
        return L3;                                   // => > 10,000 — highest approval needed
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
Money smallPO    = new Money(new BigDecimal("500.00"),   "USD"); // => 500 USD
Money mediumPO   = new Money(new BigDecimal("5000.00"),  "USD"); // => 5,000 USD
Money largePO    = new Money(new BigDecimal("25000.00"), "USD"); // => 25,000 USD
 
System.out.println(ApprovalLevel.from(smallPO));  // => Output: L1
System.out.println(ApprovalLevel.from(mediumPO)); // => Output: L2
System.out.println(ApprovalLevel.from(largePO));  // => Output: L3
 
// Derived value used in aggregate submission logic:
ApprovalLevel level = ApprovalLevel.from(largePO); // => level = L3
System.out.println(level == ApprovalLevel.L3);     // => Output: true
// => L3 POs must route to CFO for approval per domain spec

// ── Supporting types ──────────────────────────────────────────────────────────
@JvmInline value class SupplierId(val value: String) {  // => inline value class; zero allocation
    init { require(value.startsWith("sup_")) { "SupplierId must start with sup_" } }
    // => Kotlin's require throws IllegalArgumentException on false
}
 
data class Email(val address: String) {           // => Email value object
    init { require(address.contains("@")) { "Email must contain @" } }
    // => Minimal RFC-5322 guard; production would use a proper library
}
 
// ── Supplier lifecycle states ─────────────────────────────────────────────────
enum class SupplierStatus {
    PENDING,      // => newly registered; cannot receive POs
    APPROVED,     // => vetted; eligible for new POs
    SUSPENDED,    // => temporarily ineligible; existing POs continue
    BLACKLISTED   // => excluded from all activity; existing POs forced to Disputed
}
 
// ── Aggregate root ────────────────────────────────────────────────────────────
class Supplier(val id: SupplierId, val email: Email) { // => primary constructor
    var status: SupplierStatus = SupplierStatus.PENDING // => starts in PENDING
        private set                                     // => only transitions via methods
 
    fun approve() {                                     // => approve() — valid from PENDING only
        check(status == SupplierStatus.PENDING) {       // => Kotlin check() → IllegalStateException
            "Can only approve a PENDING supplier, current: $status"
        }
        status = SupplierStatus.APPROVED                // => transition: PENDING → APPROVED
    }
 
    fun suspend() {                                     // => suspend() — valid from APPROVED only
        check(status == SupplierStatus.APPROVED) {
            "Can only suspend an APPROVED supplier, current: $status"
        }
        status = SupplierStatus.SUSPENDED               // => transition: APPROVED → SUSPENDED
    }
 
    fun blacklist() {                                   // => blacklist() — from APPROVED or SUSPENDED
        check(status == SupplierStatus.APPROVED || status == SupplierStatus.SUSPENDED) {
            "Cannot blacklist from $status"
        }
        status = SupplierStatus.BLACKLISTED             // => transition to terminal state
        // => Caller responsible for triggering Disputed state on existing POs
    }
 
    fun isEligibleForNewPurchaseOrders(): Boolean =     // => eligibility derived from status
        status == SupplierStatus.APPROVED               // => only APPROVED suppliers receive new POs
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val supplier = Supplier(SupplierId("sup_660f9511-0001"), Email("vendor@acme.com"))
println(supplier.status)                         // => Output: PENDING
supplier.approve()
println(supplier.status)                         // => Output: APPROVED
println(supplier.isEligibleForNewPurchaseOrders()) // => Output: true
supplier.suspend()
println(supplier.isEligibleForNewPurchaseOrders()) // => Output: false
 
try {
    supplier.approve()                            // => IllegalStateException: SUSPENDED is not PENDING
} catch (e: IllegalStateException) {
    println(e.message)                            // => Output: Can only approve a PENDING supplier...
}

// ── Sealed class hierarchy: each state is its own type ───────────────────────
// => Sealed permits exactly five subtypes; no other class may extend PurchaseOrderStatus
sealed interface PurchaseOrderStatus
    permits PurchaseOrderStatus.Draft,
            PurchaseOrderStatus.AwaitingApproval,
            PurchaseOrderStatus.Approved,
            PurchaseOrderStatus.Issued,
            PurchaseOrderStatus.Cancelled {
 
    record Draft() implements PurchaseOrderStatus {}         // => Draft: no extra data
    record AwaitingApproval() implements PurchaseOrderStatus {} // => AwaitingApproval state
    record Approved() implements PurchaseOrderStatus {}      // => Approved state
    record Issued() implements PurchaseOrderStatus {}        // => Issued state
    record Cancelled(String reason) implements PurchaseOrderStatus {} // => Cancelled carries reason
    // => Cancelled is the only terminal state that carries context; reason aids audit trail
}
 
// ── Pattern-match with exhaustive switch (Java 21 preview, enabled by default in 21+) ─
static String describe(PurchaseOrderStatus s) {    // => static helper for demo
    return switch (s) {                            // => sealed switch: compiler checks all arms
        case PurchaseOrderStatus.Draft d           -> "Draft: awaiting line items";
        case PurchaseOrderStatus.AwaitingApproval a-> "Awaiting approval from manager";
        case PurchaseOrderStatus.Approved ap       -> "Approved: ready to issue to supplier";
        case PurchaseOrderStatus.Issued i          -> "Issued: supplier has been notified";
        case PurchaseOrderStatus.Cancelled c       -> "Cancelled: " + c.reason();
        // => No default needed: sealed types guarantee exhaustiveness at compile time
    };
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
PurchaseOrderStatus draft  = new PurchaseOrderStatus.Draft();         // => draft state
PurchaseOrderStatus issued = new PurchaseOrderStatus.Issued();        // => issued state
PurchaseOrderStatus cancelled = new PurchaseOrderStatus.Cancelled("Vendor out of stock");
 
System.out.println(describe(draft));     // => Output: Draft: awaiting line items
System.out.println(describe(issued));    // => Output: Issued: supplier has been notified
System.out.println(describe(cancelled)); // => Output: Cancelled: Vendor out of stock

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
 
// ── Minimal supporting types ───────────────────────────────────────────────────
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
record Money(BigDecimal amount, String currency) {}
enum UnitOfMeasure { EACH, BOX }
record Quantity(int value, UnitOfMeasure unit) {}
record PurchaseOrderLine(String lineId, String skuCode, Quantity qty, Money unitPrice) {}
 
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
 
// ── Aggregate with state machine ───────────────────────────────────────────────
class PurchaseOrder {
    private final PurchaseOrderId id;
    private final SupplierId supplierId;
    private final List<PurchaseOrderLine> lines = new ArrayList<>();
    private POStatus status = POStatus.DRAFT;    // => always starts in DRAFT
 
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId) {
        this.id = id; this.supplierId = supplierId;
    }
 
    public void addLine(PurchaseOrderLine line) {           // => addLine: DRAFT only
        require(status == POStatus.DRAFT, "addLine requires DRAFT, got " + status);
        lines.add(line);
    }
 
    public void submit() {                                  // => DRAFT → AWAITING_APPROVAL
        require(status == POStatus.DRAFT, "submit requires DRAFT");
        require(!lines.isEmpty(), "Cannot submit PO with no line items"); // => domain invariant
        status = POStatus.AWAITING_APPROVAL;                // => transition committed
    }
 
    public void approve() {                                 // => AWAITING_APPROVAL → APPROVED
        require(status == POStatus.AWAITING_APPROVAL, "approve requires AWAITING_APPROVAL");
        status = POStatus.APPROVED;
    }
 
    public void issue() {                                   // => APPROVED → ISSUED
        require(status == POStatus.APPROVED, "issue requires APPROVED");
        status = POStatus.ISSUED;
        // => Once ISSUED, lines become immutable — enforced in addLine guard
    }
 
    public void cancel(String reason) {                     // => any pre-ISSUED → CANCELLED
        require(status != POStatus.ISSUED && status != POStatus.CANCELLED,
            "Cannot cancel from " + status);
        status = POStatus.CANCELLED;
    }
 
    private void require(boolean cond, String msg) {        // => guard helper
        if (!cond) throw new IllegalStateException(msg);
    }
 
    public POStatus getStatus() { return status; }
    public PurchaseOrderId getId() { return id; }
    public List<PurchaseOrderLine> getLines() { return List.copyOf(lines); }
}
 
// ── Usage: happy path ─────────────────────────────────────────────────────────
var po = new PurchaseOrder(new PurchaseOrderId("po_550e8400-0031"),
                           new SupplierId("sup_660f9511-0001"));
po.addLine(new PurchaseOrderLine("L1", "OFF-001234",
    new Quantity(3, UnitOfMeasure.BOX),
    new Money(new BigDecimal("40.00"), "USD")));    // => line added in DRAFT
po.submit();                                        // => DRAFT → AWAITING_APPROVAL
System.out.println(po.getStatus());                 // => Output: AWAITING_APPROVAL
po.approve();                                       // => AWAITING_APPROVAL → APPROVED
po.issue();                                         // => APPROVED → ISSUED
System.out.println(po.getStatus());                 // => Output: ISSUED
 
// ── Invalid transition ────────────────────────────────────────────────────────
try {
    po.addLine(new PurchaseOrderLine("L2", "TLS-9999",
        new Quantity(1, UnitOfMeasure.EACH),
        new Money(new BigDecimal("100.00"), "USD"))); // => IllegalStateException
} catch (IllegalStateException e) {
    System.out.println(e.getMessage());             // => Output: addLine requires DRAFT, got ISSUED
}

// ── Domain exception hierarchy ────────────────────────────────────────────────
// => Base class for all domain rule violations; distinct from infrastructure errors
class DomainException extends RuntimeException {
    DomainException(String message) { super(message); }
}
 
// => Specific subtype for state machine violations; callers can catch selectively
class InvalidTransitionException extends DomainException {
    private final String from;   // => current state name
    private final String to;     // => attempted target state name
    InvalidTransitionException(String from, String to) {
        super("Invalid transition from " + from + " to " + to);
        this.from = from; this.to = to;
    }
    public String getFrom() { return from; } // => allows callers to log structured diagnostics
    public String getTo()   { return to; }
}
 
// => Raised when a PO with no lines is submitted — separate concern from state
class EmptyPurchaseOrderException extends DomainException {
    EmptyPurchaseOrderException() { super("A PurchaseOrder must have at least one line before submission"); }
}
 
// ── Aggregate using typed exceptions ─────────────────────────────────────────
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
 
class PurchaseOrderSM {                               // => simplified for this example
    private POStatus status = POStatus.DRAFT;
    private int lineCount = 0;
 
    public void addLine() { lineCount++; }            // => simplified line addition
 
    public void submit() {                            // => DRAFT → AWAITING_APPROVAL
        if (status != POStatus.DRAFT)
            throw new InvalidTransitionException(status.name(), "AWAITING_APPROVAL");
            // => Structured: caller knows from-state and to-state
        if (lineCount == 0)
            throw new EmptyPurchaseOrderException();  // => separate domain rule
        status = POStatus.AWAITING_APPROVAL;
    }
 
    public void approve() {
        if (status != POStatus.AWAITING_APPROVAL)
            throw new InvalidTransitionException(status.name(), "APPROVED");
        status = POStatus.APPROVED;
    }
 
    public POStatus getStatus() { return status; }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = new PurchaseOrderSM();
 
try {
    po.submit();                                      // => EmptyPurchaseOrderException; no lines
} catch (EmptyPurchaseOrderException e) {
    System.out.println(e.getMessage());
    // => Output: A PurchaseOrder must have at least one line before submission
}
 
po.addLine();
po.submit();                                          // => DRAFT → AWAITING_APPROVAL
 
try {
    po.submit();                                      // => InvalidTransitionException; already AWAITING
} catch (InvalidTransitionException e) {
    System.out.println("From: " + e.getFrom());      // => Output: From: AWAITING_APPROVAL
    System.out.println("To: " + e.getTo());          // => Output: To: AWAITING_APPROVAL
    System.out.println(e.getMessage());
    // => Output: Invalid transition from AWAITING_APPROVAL to AWAITING_APPROVAL
}

using System;
using System.Collections.Generic;
 
// ── Status enum ────────────────────────────────────────────────────────────────
public enum POStatus
{
    Draft, AwaitingApproval, Approved, Issued, Cancelled
    // => Intermediate subset; full machine adds more states in advanced section
}
 
// ── Aggregate with cancellation off-ramp ──────────────────────────────────────
public class PurchaseOrder
{
    public string Id { get; }           // => init-only: set once in constructor
    public POStatus Status { get; private set; } = POStatus.Draft; // => starts in Draft
 
    private static readonly HashSet<POStatus> CancellableStates = new()
    {
        POStatus.Draft,
        POStatus.AwaitingApproval,
        POStatus.Approved
        // => Issued is the last state before PAID where cancellation remains valid
        // => Per spec: (any pre-Paid) --cancel--> Cancelled
    };
    // => Static set computed once; O(1) lookup per cancel() call
 
    public PurchaseOrder(string id)
    {
        if (string.IsNullOrEmpty(id) || !id.StartsWith("po_")) // => format guard
            throw new ArgumentException("Id must start with po_");
        Id = id;
    }
 
    public void Submit()
    {
        if (Status != POStatus.Draft)                          // => state guard
            throw new InvalidOperationException($"Cannot submit from {Status}");
        Status = POStatus.AwaitingApproval;
    }
 
    public void Approve()
    {
        if (Status != POStatus.AwaitingApproval)
            throw new InvalidOperationException($"Cannot approve from {Status}");
        Status = POStatus.Approved;
    }
 
    public void Cancel(string reason)
    {
        if (!CancellableStates.Contains(Status))               // => O(1) HashSet lookup
            throw new InvalidOperationException(
                $"Cannot cancel from {Status}. Cancellable: Draft, AwaitingApproval, Approved");
        // => reason is logged/used by application layer; aggregate just transitions
        Status = POStatus.Cancelled;
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = new PurchaseOrder("po_550e8400-0033");
po.Submit();
po.Approve();
po.Cancel("Supplier no longer available");          // => Approved → Cancelled
Console.WriteLine(po.Status);                       // => Output: Cancelled
 
var po2 = new PurchaseOrder("po_550e8400-0034");
try {
    po2.Cancel("Test");                             // => valid: Draft is cancellable
    Console.WriteLine(po2.Status);                  // => Output: Cancelled
} catch (Exception e) {
    Console.WriteLine(e.Message);
}

import java.math.BigDecimal;
import java.math.RoundingMode;
 
// ── Value objects ─────────────────────────────────────────────────────────────
enum UnitOfMeasure { EACH, BOX, KG, LITRE, HOUR }
 
record Quantity(int value, UnitOfMeasure unit) { // => record Quantity
    Quantity {
        if (value <= 0)                          // => domain invariant: must be positive
            throw new IllegalArgumentException("Quantity.value must be > 0, got " + value);
    }
    public boolean isSameUnit(Quantity other) {  // => unit-compatibility check
        return this.unit == other.unit;          // => enum equality: fast, exact
    }
}
 
record Tolerance(BigDecimal percentage) {        // => record Tolerance
    Tolerance {
        if (percentage == null
            || percentage.compareTo(BigDecimal.ZERO) < 0    // => 0% minimum
            || percentage.compareTo(new BigDecimal("0.10")) > 0) // => 10% maximum per spec
            throw new IllegalArgumentException("Tolerance must be 0 ≤ pct ≤ 0.10");
    }
 
    // Returns true if actual is within tolerance of expected
    public boolean isWithin(BigDecimal expected, BigDecimal actual) {
        if (expected.compareTo(BigDecimal.ZERO) == 0) // => zero expected: exact match required
            return actual.compareTo(BigDecimal.ZERO) == 0;
        BigDecimal deviation = actual.subtract(expected).abs()
            .divide(expected, 6, RoundingMode.HALF_UP); // => |actual - expected| / expected
        return deviation.compareTo(percentage) <= 0;    // => within tolerance?
    }
}
 
// ── Three-way match helper ─────────────────────────────────────────────────────
static boolean threeWayMatch(
    BigDecimal poUnitPrice,   // => price per unit from PurchaseOrder
    Quantity grnQty,          // => quantity from GoodsReceiptNote
    BigDecimal invoiceAmount, // => total on Invoice
    Tolerance tolerance) {    // => acceptable deviation (default 2%)
 
    BigDecimal expected = poUnitPrice
        .multiply(BigDecimal.valueOf(grnQty.value())); // => expected = price × received qty
    return tolerance.isWithin(expected, invoiceAmount); // => is invoice within tolerance?
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var tolerance = new Tolerance(new BigDecimal("0.02")); // => 2% default tolerance from spec
 
// Perfect match
boolean exact = threeWayMatch(
    new BigDecimal("20.00"),
    new Quantity(5, UnitOfMeasure.BOX),
    new BigDecimal("100.00"),  // => 5 × 20 = 100.00 exact
    tolerance
);
System.out.println("Exact match: " + exact);         // => Output: Exact match: true
 
// Within tolerance (1.5% deviation)
boolean within = threeWayMatch(
    new BigDecimal("20.00"),
    new Quantity(5, UnitOfMeasure.BOX),
    new BigDecimal("101.50"),  // => 1.5% above expected 100.00
    tolerance
);
System.out.println("Within tolerance: " + within);   // => Output: Within tolerance: true
 
// Outside tolerance (3% deviation)
boolean outside = threeWayMatch(
    new BigDecimal("20.00"),
    new Quantity(5, UnitOfMeasure.BOX),
    new BigDecimal("103.00"),  // => 3% above expected; exceeds 2% tolerance
    tolerance
);
System.out.println("Outside tolerance: " + outside); // => Output: Outside tolerance: false

import java.time.Instant;
 
// ── Minimal ID types ──────────────────────────────────────────────────────────
record PurchaseOrderId(String value) {}
record RequisitionId(String value) {}
record SupplierId(String value) {}
 
// ── Domain events: past-tense names, immutable records ───────────────────────
// => Each event carries only the data consumers need — no full aggregate snapshot
record PurchaseOrderIssued(              // => purchasing context event
    PurchaseOrderId purchaseOrderId,     // => which PO was issued
    SupplierId supplierId,               // => which supplier receives the notification
    Instant issuedAt                     // => when the transition occurred
) {}
// => Consumers: supplier-notifier (EDI/email), receiving (opens GRN expectation)
 
record RequisitionApproved(             // => purchasing context event
    RequisitionId requisitionId,        // => which requisition was approved
    String approverId,                  // => who approved (user id from identity context)
    Instant approvedAt                  // => timestamp of approval
) {}
// => Consumer: purchasing auto-converts this to a PO Draft
 
record SupplierApproved(                // => supplier context event
    SupplierId supplierId,              // => which supplier is now eligible
    Instant approvedAt
) {}
// => Consumer: purchasing eligible-for-PO list
 
// ── Records are immutable by default — no setters ────────────────────────────
PurchaseOrderIssued evt = new PurchaseOrderIssued(
    new PurchaseOrderId("po_550e8400-0035"),  // => po id
    new SupplierId("sup_660f9511-0001"),      // => supplier id
    Instant.now()                             // => current UTC timestamp
);
System.out.println(evt.purchaseOrderId().value()); // => Output: po_550e8400-0035
System.out.println(evt.supplierId().value());      // => Output: sup_660f9511-0001
 
// Structural equality — same data means equal events (useful in tests)
PurchaseOrderIssued same = new PurchaseOrderIssued(
    evt.purchaseOrderId(), evt.supplierId(), evt.issuedAt()
);
System.out.println(evt.equals(same));  // => Output: true
// => Record equals compares all fields; no custom equals() needed

import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
// ── Types ─────────────────────────────────────────────────────────────────────
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
record Money(BigDecimal amount, String currency) {}
enum UnitOfMeasure { EACH, BOX }
record Quantity(int value, UnitOfMeasure unit) {}
record PurchaseOrderLine(String lineId, String skuCode, Quantity qty, Money unitPrice) {}
 
// ── Domain event ──────────────────────────────────────────────────────────────
record PurchaseOrderIssued(PurchaseOrderId purchaseOrderId, SupplierId supplierId, Instant issuedAt) {}
 
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
 
// ── Aggregate collecting events ───────────────────────────────────────────────
class PurchaseOrder {
    private final PurchaseOrderId id;
    private final SupplierId supplierId;
    private final List<PurchaseOrderLine> lines = new ArrayList<>();
    private POStatus status = POStatus.DRAFT;
 
    // => Domain events collected here; drained by application layer after save
    private final List<Object> domainEvents = new ArrayList<>();
 
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId) {
        this.id = id; this.supplierId = supplierId;
    }
 
    public void addLine(PurchaseOrderLine line) {
        if (status != POStatus.DRAFT)
            throw new IllegalStateException("addLine requires DRAFT");
        lines.add(line);
    }
 
    public void submit() {
        if (status != POStatus.DRAFT) throw new IllegalStateException("submit requires DRAFT");
        if (lines.isEmpty()) throw new IllegalStateException("Cannot submit empty PO");
        status = POStatus.AWAITING_APPROVAL;  // => DRAFT → AWAITING_APPROVAL
        // => No event on submit: approval routing is triggered by RequisitionApproved, not here
    }
 
    public void approve() {
        if (status != POStatus.AWAITING_APPROVAL) throw new IllegalStateException("approve requires AWAITING_APPROVAL");
        status = POStatus.APPROVED;           // => AWAITING_APPROVAL → APPROVED
    }
 
    public void issue() {
        if (status != POStatus.APPROVED) throw new IllegalStateException("issue requires APPROVED");
        status = POStatus.ISSUED;             // => APPROVED → ISSUED
        domainEvents.add(new PurchaseOrderIssued(id, supplierId, Instant.now()));
        // => Event registered but NOT dispatched — persisted first, then dispatched
    }
 
    // ── Application layer API ─────────────────────────────────────────────────
    public List<Object> drainDomainEvents() {          // => called by app layer after save
        var snapshot = List.copyOf(domainEvents);      // => copy before clearing
        domainEvents.clear();                          // => drain: events not dispatched twice
        return snapshot;                               // => caller dispatches these events
    }
 
    public POStatus getStatus()          { return status; }
    public PurchaseOrderId getId()       { return id; }
    public List<PurchaseOrderLine> getLines() { return Collections.unmodifiableList(lines); }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = new PurchaseOrder(new PurchaseOrderId("po_550e8400-0036"),
                           new SupplierId("sup_660f9511-0001"));
po.addLine(new PurchaseOrderLine("L1", "OFF-001234",
    new Quantity(2, UnitOfMeasure.BOX),
    new Money(new BigDecimal("50.00"), "USD")));
po.submit();
po.approve();
po.issue();                                     // => ISSUED; PurchaseOrderIssued event queued
 
List<Object> events = po.drainDomainEvents();   // => application layer drains after save
System.out.println(events.size());              // => Output: 1
System.out.println(events.get(0).getClass().getSimpleName()); // => Output: PurchaseOrderIssued
 
List<Object> empty = po.drainDomainEvents();    // => already drained; no double dispatch
System.out.println(empty.size());               // => Output: 0

import java.math.BigDecimal;
import java.time.Instant;
import java.util.UUID;
 
// ── Types ─────────────────────────────────────────────────────────────────────
record RequisitionId(String value) {}
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
record Money(BigDecimal amount, String currency) {}
enum UnitOfMeasure { EACH, BOX }
record Quantity(int value, UnitOfMeasure unit) {}
 
// ── Incoming event ────────────────────────────────────────────────────────────
record RequisitionApproved(    // => emitted by PurchaseRequisition aggregate after approval
    RequisitionId requisitionId,
    SupplierId preferredSupplierId, // => operator selected supplier during approval
    String skuCode,
    Quantity quantity,
    Money estimatedCost,
    Instant approvedAt
) {}
 
// ── Resulting aggregate (created by handler) ───────────────────────────────────
record PurchaseOrderLine(String lineId, String skuCode, Quantity qty, Money unitPrice) {}
 
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED }
 
class PurchaseOrder {
    final PurchaseOrderId id;
    final SupplierId supplierId;
    final java.util.List<PurchaseOrderLine> lines = new java.util.ArrayList<>();
    POStatus status = POStatus.DRAFT;      // => created in DRAFT; ready for further enrichment
 
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId) {
        this.id = id; this.supplierId = supplierId;
    }
    void addLine(PurchaseOrderLine l) { lines.add(l); }
}
 
// ── Domain event handler ───────────────────────────────────────────────────────
// => Stateless: takes event, applies domain logic, returns new aggregate
// => No Spring annotations: pure domain; infrastructure wires this up
static PurchaseOrder onRequisitionApproved(RequisitionApproved event) {
    // => Generate a new PurchaseOrderId from the requisition id for traceability
    var poId = new PurchaseOrderId(
        "po_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16));
    // => The approved supplier becomes the PO's supplier
    var po = new PurchaseOrder(poId, event.preferredSupplierId());
    // => Seed PO with one line derived from the requisition
    po.addLine(new PurchaseOrderLine(
        "L1",
        event.skuCode(),
        event.quantity(),
        event.estimatedCost()     // => estimated cost becomes unit price on initial PO
    ));
    // => PO is DRAFT; procurement officer can adjust before submission
    return po;
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var event = new RequisitionApproved(
    new RequisitionId("req_550e8400-aaaa"),
    new SupplierId("sup_660f9511-0001"),
    "OFF-001234",
    new Quantity(5, UnitOfMeasure.BOX),
    new Money(new BigDecimal("200.00"), "USD"),
    Instant.now()
);
PurchaseOrder po = onRequisitionApproved(event); // => new PO created from event
System.out.println(po.status);                  // => Output: DRAFT
System.out.println(po.lines.size());            // => Output: 1
System.out.println(po.supplierId.value());      // => Output: sup_660f9511-0001

import java.time.Instant
 
// ── Types ─────────────────────────────────────────────────────────────────────
@JvmInline value class SupplierId(val value: String) {
    init { require(value.startsWith("sup_")) { "SupplierId must start with sup_" } }
}
 
// ── Event emitted by supplier context ─────────────────────────────────────────
data class SupplierApproved(           // => supplier context event
    val supplierId: SupplierId,        // => who was approved
    val approvedAt: Instant            // => when
)
// => Consumer: purchasing context's eligible-supplier list
 
// ── Recipient: purchasing context policy ───────────────────────────────────────
class EligibleSupplierPolicy {         // => pure domain policy; no Spring annotations
    private val eligibleIds = mutableSetOf<SupplierId>() // => in-memory set of eligible suppliers
    // => Production: persisted in purchasing aggregate's read model
 
    fun handle(event: SupplierApproved) { // => event handler method
        eligibleIds.add(event.supplierId) // => add to eligible set on approval
        // => Purchasing can now create POs referencing this supplier
    }
 
    fun isEligible(supplierId: SupplierId): Boolean = // => query used before PO creation
        supplierId in eligibleIds         // => Kotlin in-operator delegates to contains()
 
    fun eligibleCount(): Int = eligibleIds.size // => observable size for tests
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val policy = EligibleSupplierPolicy()
val sup1 = SupplierId("sup_660f9511-0001")
val sup2 = SupplierId("sup_660f9511-0002")
 
println(policy.isEligible(sup1))   // => Output: false — not yet approved
 
policy.handle(SupplierApproved(sup1, Instant.now())) // => sup1 approved
println(policy.isEligible(sup1))   // => Output: true
println(policy.isEligible(sup2))   // => Output: false — sup2 never approved
println(policy.eligibleCount())    // => Output: 1
 
policy.handle(SupplierApproved(sup2, Instant.now())) // => sup2 approved
println(policy.eligibleCount())    // => Output: 2

import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
 
// ── Value objects ─────────────────────────────────────────────────────────────
record PurchaseOrderId(String value) {
    PurchaseOrderId { require(value != null && value.startsWith("po_"), "id must start with po_"); }
    private static void require(boolean c, String m) { if (!c) throw new IllegalArgumentException(m); }
}
record SupplierId(String value) {
    SupplierId { if (value == null || !value.startsWith("sup_")) throw new IllegalArgumentException("SupplierId invalid"); }
}
record Money(BigDecimal amount, String currency) {
    Money { if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) throw new IllegalArgumentException("Money amount >= 0"); }
}
enum UnitOfMeasure { EACH, BOX, KG }
record Quantity(int value, UnitOfMeasure unit) {
    Quantity { if (value <= 0) throw new IllegalArgumentException("Quantity > 0"); }
}
record PurchaseOrderLine(String lineId, String skuCode, Quantity qty, Money unitPrice) {}
 
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
record PurchaseOrderIssued(PurchaseOrderId id, SupplierId sid, Instant issuedAt) {}
 
// ── Aggregate with factory method ─────────────────────────────────────────────
class PurchaseOrder {
    private final PurchaseOrderId id;
    private final SupplierId supplierId;
    private final Instant createdAt;          // => captured at creation for audit
    private final List<PurchaseOrderLine> lines = new ArrayList<>();
    private POStatus status = POStatus.DRAFT;
    private final List<Object> domainEvents  = new ArrayList<>();
 
    private PurchaseOrder(PurchaseOrderId id, SupplierId supplierId, Instant createdAt) {
        this.id = id; this.supplierId = supplierId; this.createdAt = createdAt;
        // => private constructor: only factory method can call this
    }
 
    // ── Static factory ────────────────────────────────────────────────────────
    public static PurchaseOrder create(SupplierId supplierId) { // => factory hides ID generation
        if (supplierId == null) throw new IllegalArgumentException("supplierId required");
        var id = new PurchaseOrderId("po_" + UUID.randomUUID().toString().replace("-", "")); // => new unique id
        // => UUID v4 with "po_" prefix; matches spec format
        return new PurchaseOrder(id, supplierId, Instant.now()); // => creation timestamp from clock
    }
 
    // ── Reconstitution factory (used by repository, NOT for new POs) ─────────
    public static PurchaseOrder reconstitute(PurchaseOrderId id, SupplierId supplierId,
                                             Instant createdAt, POStatus status) {
        var po = new PurchaseOrder(id, supplierId, createdAt); // => id and timestamp restored from DB
        po.status = status;                                    // => status restored; no invariant check
        // => Reconstitution skips domain validation: DB rows are assumed already-valid past facts
        return po;
    }
 
    public void addLine(PurchaseOrderLine l) {
        if (status != POStatus.DRAFT) throw new IllegalStateException("addLine: DRAFT only");
        lines.add(l);
    }
 
    public void issue() {
        if (status != POStatus.APPROVED) throw new IllegalStateException("issue: APPROVED only");
        status = POStatus.ISSUED;
        domainEvents.add(new PurchaseOrderIssued(id, supplierId, Instant.now()));
    }
 
    public List<Object> drainDomainEvents() {
        var snap = List.copyOf(domainEvents); domainEvents.clear(); return snap;
    }
 
    public PurchaseOrderId getId()    { return id; }
    public SupplierId getSupplierId() { return supplierId; }
    public POStatus getStatus()       { return status; }
    public Instant getCreatedAt()     { return createdAt; }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = PurchaseOrder.create(new SupplierId("sup_660f9511-0001")); // => factory; id auto-generated
System.out.println(po.getId().value().startsWith("po_")); // => Output: true
System.out.println(po.getStatus());                       // => Output: DRAFT
System.out.println(po.getCreatedAt() != null);            // => Output: true
 
// Reconstitution from persisted row
var reconstituted = PurchaseOrder.reconstitute(
    new PurchaseOrderId("po_550e8400-existing"),
    new SupplierId("sup_660f9511-0001"),
    Instant.parse("2026-01-15T08:00:00Z"),
    POStatus.APPROVED                          // => restored without triggering approval logic
);
System.out.println(reconstituted.getStatus()); // => Output: APPROVED

import java.util.List;
import java.util.Optional;
 
// ── Minimal types ─────────────────────────────────────────────────────────────
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
 
// ── Aggregate placeholder ─────────────────────────────────────────────────────
class PurchaseOrder {                          // => full aggregate; simplified for interface demo
    private final PurchaseOrderId id;
    private final SupplierId supplierId;
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId) {
        this.id = id; this.supplierId = supplierId;
    }
    public PurchaseOrderId getId()    { return id; }
    public SupplierId getSupplierId() { return supplierId; }
}
 
// ── Repository interface — domain layer ────────────────────────────────────────
// => Interface lives in the domain package; implementation lives in infrastructure
// => Hexagonal architecture: domain defines the port, infra provides the adapter
interface PurchaseOrderRepository {
    void save(PurchaseOrder order);             // => persist new or update existing aggregate
    // => Upsert semantics: infrastructure decides INSERT vs UPDATE based on id existence
 
    Optional<PurchaseOrder> findById(PurchaseOrderId id);
    // => Optional: caller must handle the not-found case explicitly
    // => Never returns null — nulls cause NPE bugs in calling code
 
    List<PurchaseOrder> findBySupplier(SupplierId supplierId);
    // => Bounded query: returns all POs for a given supplier
    // => Used by supplier suspension logic to locate affected orders
 
    default boolean exists(PurchaseOrderId id) { // => default implementation using findById
        return findById(id).isPresent();         // => avoids repeated boilerplate in callers
    }
}
 
// ── In-memory test implementation (no JPA, no SQL) ────────────────────────────
class InMemoryPurchaseOrderRepository implements PurchaseOrderRepository {
    private final java.util.Map<PurchaseOrderId, PurchaseOrder> store = new java.util.HashMap<>();
    // => HashMap: O(1) put/get; fine for tests; production uses JDBC/JPA adapter
 
    @Override
    public void save(PurchaseOrder order) {
        store.put(order.getId(), order);         // => upsert: put overwrites on duplicate key
    }
 
    @Override
    public Optional<PurchaseOrder> findById(PurchaseOrderId id) {
        return Optional.ofNullable(store.get(id)); // => Optional.ofNullable: wraps null safely
    }
 
    @Override
    public List<PurchaseOrder> findBySupplier(SupplierId supplierId) {
        return store.values().stream()
            .filter(po -> po.getSupplierId().equals(supplierId)) // => linear scan; fine for tests
            .toList();
    }
}
 
// ── Usage (as domain/application layer code would use it) ─────────────────────
PurchaseOrderRepository repo = new InMemoryPurchaseOrderRepository();
 
var po1 = new PurchaseOrder(new PurchaseOrderId("po_550e8400-0040"),
                             new SupplierId("sup_660f9511-0001"));
var po2 = new PurchaseOrder(new PurchaseOrderId("po_550e8400-0041"),
                             new SupplierId("sup_660f9511-0001"));
repo.save(po1);                                  // => stored
repo.save(po2);                                  // => stored
 
Optional<PurchaseOrder> found = repo.findById(new PurchaseOrderId("po_550e8400-0040"));
System.out.println(found.isPresent());           // => Output: true
 
List<PurchaseOrder> bySupplier = repo.findBySupplier(new SupplierId("sup_660f9511-0001"));
System.out.println(bySupplier.size());           // => Output: 2
 
boolean missing = repo.exists(new PurchaseOrderId("po_nonexistent-9999"));
System.out.println(missing);                     // => Output: false

import java.math.BigDecimal;
import java.util.List;
 
// ── Supporting types ──────────────────────────────────────────────────────────
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
record Money(BigDecimal amount, String currency) {}
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
 
class PurchaseOrder {
    private final PurchaseOrderId id;
    private final SupplierId supplierId;
    private final Money total;
    private final POStatus status;
    PurchaseOrder(PurchaseOrderId id, SupplierId supplierId, Money total, POStatus status) {
        this.id = id; this.supplierId = supplierId; this.total = total; this.status = status;
    }
    public PurchaseOrderId getId()    { return id; }
    public SupplierId getSupplierId() { return supplierId; }
    public Money getTotal()           { return total; }
    public POStatus getStatus()       { return status; }
}
 
// ── Specification interface ───────────────────────────────────────────────────
interface POSpecification {                        // => domain-typed; not generic for clarity
    boolean isSatisfiedBy(PurchaseOrder po);
    default POSpecification and(POSpecification other) { // => composable
        return po -> this.isSatisfiedBy(po) && other.isSatisfiedBy(po);
        // => Logical AND composition; chains multiple rules
    }
}
 
// ── Concrete specifications ───────────────────────────────────────────────────
class AwaitingApprovalSpec implements POSpecification {
    @Override
    public boolean isSatisfiedBy(PurchaseOrder po) {
        return po.getStatus() == POStatus.AWAITING_APPROVAL; // => status predicate
    }
}
 
class RequiresL3ApprovalSpec implements POSpecification {
    private static final BigDecimal L3_THRESHOLD = new BigDecimal("10000.00");
    @Override
    public boolean isSatisfiedBy(PurchaseOrder po) {
        return po.getTotal().amount().compareTo(L3_THRESHOLD) > 0; // => financial threshold
    }
}
 
// ── Repository method accepting specification ─────────────────────────────────
class InMemoryPORepo {
    private final List<PurchaseOrder> store;
    InMemoryPORepo(List<PurchaseOrder> pos) { this.store = pos; }
 
    public List<PurchaseOrder> findBy(POSpecification spec) {
        return store.stream()
            .filter(spec::isSatisfiedBy)  // => specification applied as stream predicate
            .toList();
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var pos = List.of(
    new PurchaseOrder(new PurchaseOrderId("po_0001"), new SupplierId("sup_0001"),
        new Money(new BigDecimal("500.00"), "USD"), POStatus.AWAITING_APPROVAL),
    new PurchaseOrder(new PurchaseOrderId("po_0002"), new SupplierId("sup_0001"),
        new Money(new BigDecimal("15000.00"), "USD"), POStatus.AWAITING_APPROVAL),
    new PurchaseOrder(new PurchaseOrderId("po_0003"), new SupplierId("sup_0002"),
        new Money(new BigDecimal("200.00"), "USD"), POStatus.DRAFT)
);
var repo = new InMemoryPORepo(pos);
 
var awaitingSpec  = new AwaitingApprovalSpec();
var l3Spec        = new RequiresL3ApprovalSpec();
var l3Awaiting    = awaitingSpec.and(l3Spec); // => composed: awaiting AND > $10k
 
List<PurchaseOrder> l3Results = repo.findBy(l3Awaiting);
System.out.println(l3Results.size()); // => Output: 1 — only po_0002 matches both
 
List<PurchaseOrder> awaiting = repo.findBy(awaitingSpec);
System.out.println(awaiting.size());  // => Output: 2 — po_0001 and po_0002

import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
 
// ── Cross-context IDs (value objects only; no PO object reference) ─────────────
record PurchaseOrderId(String value) {}  // => reference to purchasing context by id only
enum UnitOfMeasure { EACH, BOX, KG, LITRE }
record Quantity(int value, UnitOfMeasure unit) {
    Quantity { if (value <= 0) throw new IllegalArgumentException("Quantity > 0"); }
}
 
// ── GRN line with QC flag ─────────────────────────────────────────────────────
record GRNLine(
    String lineId,          // => surrogate within aggregate
    String skuCode,         // => matches PO line sku for three-way match
    Quantity received,      // => actual quantity received
    Quantity expected,      // => copied from PO line at GRN creation for comparison
    boolean qualityFlagged  // => true = QC team flagged discrepancy
) {
    public boolean hasDiscrepancy() {     // => derived: qty or QC issue
        return qualityFlagged
            || received.value() != expected.value(); // => quantity mismatch counts as discrepancy
    }
}
 
// ── GRN aggregate root ────────────────────────────────────────────────────────
enum GRNStatus { OPEN, COMPLETE, DISPUTED }
 
class GoodsReceiptNote {
    private final String id;                     // => grn_<uuid>
    private final PurchaseOrderId purchaseOrderId; // => reference by id; no PO object
    private final Instant receivedAt;
    private final List<GRNLine> lines = new ArrayList<>();
    private GRNStatus status = GRNStatus.OPEN;   // => OPEN until all lines recorded
 
    GoodsReceiptNote(String id, PurchaseOrderId poId) {
        if (id == null || !id.startsWith("grn_"))
            throw new IllegalArgumentException("GRN id must start with grn_");
        this.id = id;
        this.purchaseOrderId = poId;
        this.receivedAt = Instant.now();
    }
 
    public void addLine(GRNLine line) {           // => add received line
        if (status != GRNStatus.OPEN)             // => can only add lines while OPEN
            throw new IllegalStateException("Cannot add lines to " + status + " GRN");
        lines.add(line);
    }
 
    public void close() {                         // => finalize receipt
        if (status != GRNStatus.OPEN) throw new IllegalStateException("GRN not OPEN");
        boolean anyDiscrepancy = lines.stream().anyMatch(GRNLine::hasDiscrepancy);
        status = anyDiscrepancy ? GRNStatus.DISPUTED : GRNStatus.COMPLETE;
        // => DISPUTED triggers GoodsReceiptDiscrepancyDetected event (not shown for brevity)
    }
 
    public GRNStatus getStatus()         { return status; }
    public PurchaseOrderId getPoId()     { return purchaseOrderId; }
    public List<GRNLine> getLines()      { return List.copyOf(lines); }
    public long discrepancyCount()       { return lines.stream().filter(GRNLine::hasDiscrepancy).count(); }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var grn = new GoodsReceiptNote("grn_770a1234-0042",
                               new PurchaseOrderId("po_550e8400-0036")); // => references PO by id
grn.addLine(new GRNLine("L1", "OFF-001234",
    new Quantity(5, UnitOfMeasure.BOX),   // => received exactly 5
    new Quantity(5, UnitOfMeasure.BOX),   // => expected 5
    false));                              // => no QC flag — perfect receipt
grn.addLine(new GRNLine("L2", "TLS-9999",
    new Quantity(1, UnitOfMeasure.EACH),  // => received 1
    new Quantity(2, UnitOfMeasure.EACH),  // => expected 2 — quantity discrepancy
    false));
grn.close();
System.out.println(grn.getStatus());       // => Output: DISPUTED
System.out.println(grn.discrepancyCount()); // => Output: 1

import java.math.BigDecimal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
 
// ── Value objects ──────────────────────────────────────────────────────────────
record PurchaseOrderId(String value) {}
record SupplierId(String value) {}
record Money(BigDecimal amount, String currency) {}
enum UnitOfMeasure { EACH, BOX }
record Quantity(int value, UnitOfMeasure unit) {}
 
// ── Event types ───────────────────────────────────────────────────────────────
sealed interface POEvent permits POEvent.Created, POEvent.LineAdded,
                                 POEvent.Submitted, POEvent.Approved, POEvent.Issued {
    record Created(PurchaseOrderId id, SupplierId supplierId, Instant at) implements POEvent {}
    record LineAdded(String lineId, String skuCode, Quantity qty, Money unitPrice) implements POEvent {}
    record Submitted(Instant at) implements POEvent {}
    record Approved(String approverId, Instant at) implements POEvent {}
    record Issued(Instant at) implements POEvent {}
}
 
// ── Aggregate with event-fold reconstitution ──────────────────────────────────
enum POStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED }
 
class PurchaseOrderES {                        // => ES = event-sourced variant
    private PurchaseOrderId id;
    private SupplierId supplierId;
    private final List<String> lineIds = new ArrayList<>();
    private POStatus status;
    private final List<POEvent> uncommittedEvents = new ArrayList<>();
 
    // ── Static reconstitution from event stream ───────────────────────────────
    public static PurchaseOrderES reconstitute(List<POEvent> history) {
        var po = new PurchaseOrderES();       // => empty aggregate; no state yet
        for (POEvent event : history) {       // => replay each event in sequence
            po.apply(event);                  // => fold event into state; no guards here
        }
        return po;                            // => aggregate state reflects full history
    }
 
    // ── apply: pure state fold, no guards, no event collection ───────────────
    private void apply(POEvent event) {
        switch (event) {                      // => exhaustive sealed switch
            case POEvent.Created c -> {
                this.id = c.id();             // => restore id from event
                this.supplierId = c.supplierId(); // => restore supplier from event
                this.status = POStatus.DRAFT; // => initial state from Created event
            }
            case POEvent.LineAdded la -> lineIds.add(la.lineId()); // => restore line tracking
            case POEvent.Submitted s  -> status = POStatus.AWAITING_APPROVAL;
            case POEvent.Approved a   -> status = POStatus.APPROVED;
            case POEvent.Issued i     -> status = POStatus.ISSUED;
        }
    }
 
    // ── Command: raise event then apply ───────────────────────────────────────
    public void approve(String approverId) {
        if (status != POStatus.AWAITING_APPROVAL)
            throw new IllegalStateException("approve requires AWAITING_APPROVAL");
        var event = new POEvent.Approved(approverId, Instant.now()); // => create event
        apply(event);                         // => apply immediately to update in-memory state
        uncommittedEvents.add(event);         // => queue for persistence to event store
    }
 
    public List<POEvent> drainUncommittedEvents() {
        var snap = List.copyOf(uncommittedEvents); uncommittedEvents.clear(); return snap;
    }
 
    public POStatus getStatus()      { return status; }
    public PurchaseOrderId getId()   { return id; }
    public int lineCount()           { return lineIds.size(); }
}
 
// ── Usage: reconstitute from stored events ────────────────────────────────────
List<POEvent> storedHistory = List.of(
    new POEvent.Created(new PurchaseOrderId("po_550e8400-0043"),
                        new SupplierId("sup_660f9511-0001"),
                        Instant.parse("2026-01-10T08:00:00Z")),
    new POEvent.LineAdded("L1", "OFF-001234",
                          new Quantity(3, UnitOfMeasure.BOX),
                          new Money(new BigDecimal("30.00"), "USD")),
    new POEvent.Submitted(Instant.parse("2026-01-10T09:00:00Z"))
);
var po = PurchaseOrderES.reconstitute(storedHistory); // => state rebuilt from history
System.out.println(po.getStatus());                   // => Output: AWAITING_APPROVAL
System.out.println(po.lineCount());                   // => Output: 1
 
po.approve("user_cfo_001");                           // => valid transition; event queued
System.out.println(po.getStatus());                   // => Output: APPROVED
 
List<POEvent> newEvents = po.drainUncommittedEvents();
System.out.println(newEvents.size());                 // => Output: 1
System.out.println(newEvents.get(0).getClass().getSimpleName()); // => Output: Approved

using System;
using System.Text.RegularExpressions;
 
// ── BankAccount value object ───────────────────────────────────────────────────
public sealed record BankAccount      // => sealed record: immutable value object
{
    public string Iban { get; }       // => init-only after construction
    public string Bic  { get; }       // => init-only after construction
 
    private static readonly Regex IbanPattern =
        new(@"^[A-Z]{2}\d{2}[A-Z0-9]{1,30}$", RegexOptions.Compiled);
    // => Regex compiled once; reused across all BankAccount constructions
    // => Pattern covers common IBAN shapes; production would use a dedicated library
 
    public BankAccount(string iban, string bic)
    {
        if (string.IsNullOrWhiteSpace(iban))          // => null/empty guard
            throw new ArgumentException("IBAN is required");
        if (!IbanPattern.IsMatch(iban))               // => format guard
            throw new ArgumentException($"Invalid IBAN format: {iban}");
        if (string.IsNullOrWhiteSpace(bic))           // => BIC null guard
            throw new ArgumentException("BIC is required");
        if (bic.Length != 8 && bic.Length != 11)      // => BIC is 8 or 11 chars per spec
            throw new ArgumentException($"BIC must be 8 or 11 characters, got: {bic.Length}");
        Iban = iban.ToUpperInvariant();               // => normalise to uppercase
        Bic  = bic.ToUpperInvariant();                // => normalise to uppercase
    }
 
    // C# records provide structural equality automatically
    // => Two BankAccounts with same IBAN and BIC are equal — value semantics
}
 
// ── Supplier aggregate referencing BankAccount ─────────────────────────────────
public enum SupplierStatus { Pending, Approved, Suspended }
 
public class Supplier
{
    public string Id       { get; }           // => sup_<uuid>; identity
    public SupplierStatus Status { get; private set; } = SupplierStatus.Pending;
    public BankAccount? PaymentAccount { get; private set; } // => nullable until supplier sets up payment
    // => ? nullable: supplier may be approved before bank details are registered
 
    public Supplier(string id)
    {
        if (!id.StartsWith("sup_")) throw new ArgumentException("Id must start with sup_");
        Id = id;
    }
 
    public void RegisterBankAccount(BankAccount account)
    {
        if (account is null) throw new ArgumentNullException(nameof(account));
        PaymentAccount = account;              // => bank details can be updated; not immutable on supplier
    }
 
    public void Approve()
    {
        if (Status != SupplierStatus.Pending)
            throw new InvalidOperationException($"Cannot approve from {Status}");
        Status = SupplierStatus.Approved;
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var supplier = new Supplier("sup_660f9511-0044");
supplier.Approve();
 
var bank = new BankAccount("GB29NWBK60161331926819", "NWBKGB2L"); // => valid IBAN, 8-char BIC
supplier.RegisterBankAccount(bank);
Console.WriteLine(supplier.PaymentAccount?.Iban);  // => Output: GB29NWBK60161331926819
Console.WriteLine(supplier.PaymentAccount?.Bic);   // => Output: NWBKGB2L
 
// Structural equality: same data = same value
var same = new BankAccount("GB29NWBK60161331926819", "NWBKGB2L");
Console.WriteLine(bank == same);                   // => Output: True (record equality)
 
try {
    var badBic = new BankAccount("GB29NWBK60161331926819", "TOOLONG12345"); // => 12 chars; invalid
} catch (ArgumentException e) {
    Console.WriteLine(e.Message);                  // => Output: BIC must be 8 or 11 characters, got: 12
}

import java.util.Optional;
 
// ── Legacy ERP DTO (simulates external system shape) ─────────────────────────
// => This is NOT a domain class; it mirrors the legacy system's JSON/XML payload
record LegacySupplierDto(
    String vendorCode,    // => legacy id field; may or may not have "sup_" prefix
    String vendorEmail,   // => always lowercase in legacy system
    String statusFlag,    // => "A" = active, "S" = suspended, "B" = blacklisted, other = pending
    String ibanRaw,       // => may have spaces; legacy doesn't normalise
    String bicRaw         // => may be empty string if not set
) {}
 
// ── Domain types ──────────────────────────────────────────────────────────────
record SupplierId(String value) {
    SupplierId { if (value == null || !value.startsWith("sup_")) throw new IllegalArgumentException("Invalid SupplierId"); }
}
record Email(String address) {
    Email { if (address == null || !address.contains("@")) throw new IllegalArgumentException("Invalid Email"); }
}
enum SupplierStatus { PENDING, APPROVED, SUSPENDED, BLACKLISTED }
 
// ── Anti-Corruption Layer ─────────────────────────────────────────────────────
// => Pure translation function: legacy type in, domain type out
// => No domain logic here — only mapping; domain model stays clean
class SupplierAcl {
 
    public record TranslationResult(       // => structured result: domain object + warnings
        SupplierId id,
        Email email,
        SupplierStatus status,
        java.util.List<String> warnings    // => non-fatal mapping issues logged for ops team
    ) {}
 
    public static TranslationResult translate(LegacySupplierDto dto) {
        var warnings = new java.util.ArrayList<String>();
 
        // ── ID translation ────────────────────────────────────────────────────
        String rawId = dto.vendorCode();
        String domainId = rawId.startsWith("sup_") ? rawId : "sup_" + rawId;
        // => Legacy system may omit the prefix; ACL normalises it
 
        // ── Email translation ─────────────────────────────────────────────────
        var email = new Email(dto.vendorEmail().toLowerCase()); // => already lowercase; safe
 
        // ── Status translation ────────────────────────────────────────────────
        SupplierStatus status = switch (dto.statusFlag()) {
            case "A" -> SupplierStatus.APPROVED;
            case "S" -> SupplierStatus.SUSPENDED;
            case "B" -> SupplierStatus.BLACKLISTED;
            default  -> {
                warnings.add("Unknown statusFlag '" + dto.statusFlag() + "', defaulting to PENDING");
                yield SupplierStatus.PENDING; // => safe default; ops team alerted via warning
            }
        };
 
        return new TranslationResult(new SupplierId(domainId), email, status, warnings);
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var legacyDto = new LegacySupplierDto(
    "V-10023",                           // => no sup_ prefix in legacy system
    "vendor@acme.com",
    "A",                                 // => "A" maps to APPROVED
    "GB29 NWBK 6016 1331 9268 19",       // => spaces in IBAN — legacy doesn't strip
    "NWBKGB2L"
);
 
var result = SupplierAcl.translate(legacyDto);
System.out.println(result.id().value()); // => Output: sup_V-10023
System.out.println(result.status());     // => Output: APPROVED
System.out.println(result.warnings().isEmpty()); // => Output: true
 
var unknownDto = new LegacySupplierDto("V-99999", "x@y.com", "X", "", "");
var unknownResult = SupplierAcl.translate(unknownDto);
System.out.println(unknownResult.status()); // => Output: PENDING
System.out.println(unknownResult.warnings().get(0));
// => Output: Unknown statusFlag 'X', defaulting to PENDING

// ── purchasing package (package purchasing;) ──────────────────────────────────
// => All classes below belong to: package purchasing;
 
record PurchaseOrderId(String value) {             // => strong ID in purchasing context
    PurchaseOrderId {
        if (value == null || !value.startsWith("po_"))
            throw new IllegalArgumentException("PurchaseOrderId must start with po_");
        // => enforces po_<uuid> format at context boundary
    }
}
 
// Integration event — the ONLY thing that crosses to other contexts
record PurchaseOrderIssuedIntegrationEvent(
    String purchaseOrderId,   // => serialised as String — no typed IDs cross context boundary
    String supplierId,        // => same: String, not SupplierId record
    java.util.List<String> skuCodes // => simplified line summary
) {}
// => Integration events are plain data; domain types stay inside the context
 
// ── receiving package (package receiving;) ────────────────────────────────────
// => Receiving imports the integration event — NOT PurchaseOrderId or Money
// => receiving never imports: import purchasing.PurchaseOrderId;  ← FORBIDDEN
 
record ExpectedDeliveryId(String value) {}         // => receiving's own ID type
record ExpectedDelivery(
    ExpectedDeliveryId id,
    String purchaseOrderRef,   // => stores po id as String — no coupling to purchasing type
    java.util.List<String> skuCodes
) {}
 
class ExpectedDeliveryFactory {
    // => Creates receiving aggregate from purchasing integration event
    public static ExpectedDelivery fromIntegrationEvent(PurchaseOrderIssuedIntegrationEvent event) {
        var id = new ExpectedDeliveryId("ed_" + java.util.UUID.randomUUID());
        // => ExpectedDeliveryId is receiving's own concept; not reusing purchasing's ID
        return new ExpectedDelivery(id, event.purchaseOrderId(), event.skuCodes());
        // => purchaseOrderRef stored as String — reference only, no object coupling
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var event = new PurchaseOrderIssuedIntegrationEvent(
    "po_abc123",                          // => purchasing emits this over message bus
    "sup_xyz789",
    java.util.List.of("OFF-001", "OFF-002")
);
var delivery = ExpectedDeliveryFactory.fromIntegrationEvent(event);
System.out.println(delivery.purchaseOrderRef()); // => Output: po_abc123
System.out.println(delivery.skuCodes());         // => Output: [OFF-001, OFF-002]
// => receiving knows the PO reference but has no dependency on purchasing package

import java.math.BigDecimal;
import java.util.List;
import java.util.function.Predicate;
 
// ── Domain types ──────────────────────────────────────────────────────────────
record Money(BigDecimal amount, String currency) {}
enum PurchaseOrderStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
record PurchaseOrderId(String value) {}
record PurchaseOrderSummary(              // => lightweight summary for queries
    PurchaseOrderId id,
    PurchaseOrderStatus status,
    Money totalValue                      // => total line value in currency
) {}
 
// ── Specification interface ───────────────────────────────────────────────────
@FunctionalInterface
interface Specification<T> {
    boolean isSatisfiedBy(T candidate);  // => returns true if candidate meets the predicate
    // => composable: and(), or(), not() default methods below
 
    default Specification<T> and(Specification<T> other) {
        return candidate -> this.isSatisfiedBy(candidate) && other.isSatisfiedBy(candidate);
        // => logical AND; short-circuits on first false
    }
    default Specification<T> or(Specification<T> other) {
        return candidate -> this.isSatisfiedBy(candidate) || other.isSatisfiedBy(candidate);
        // => logical OR; short-circuits on first true
    }
    default Specification<T> not() {
        return candidate -> !this.isSatisfiedBy(candidate);
        // => logical NOT; useful for exclusion queries
    }
}
 
// ── Named specifications — domain language predicates ─────────────────────────
class AwaitingApprovalSpec implements Specification<PurchaseOrderSummary> {
    public boolean isSatisfiedBy(PurchaseOrderSummary po) {
        return po.status() == PurchaseOrderStatus.AWAITING_APPROVAL;
        // => true only for POs sitting in the approval queue
    }
}
 
class HighValueSpec implements Specification<PurchaseOrderSummary> {
    private final BigDecimal threshold;
    HighValueSpec(BigDecimal threshold) { this.threshold = threshold; }
    // => threshold is injected — reusable with different L2 / L3 limits
 
    public boolean isSatisfiedBy(PurchaseOrderSummary po) {
        return po.totalValue().amount().compareTo(threshold) > 0;
        // => true when PO total exceeds threshold; triggers senior-manager routing
    }
}
 
// ── In-memory repository stub (illustrates specification usage) ───────────────
class InMemoryPurchaseOrderQueryService {
    private final List<PurchaseOrderSummary> store;
    InMemoryPurchaseOrderQueryService(List<PurchaseOrderSummary> store) {
        this.store = List.copyOf(store);  // => defensive copy; query service is read-only
    }
    public List<PurchaseOrderSummary> findAll(Specification<PurchaseOrderSummary> spec) {
        return store.stream()
            .filter(spec::isSatisfiedBy)  // => applies predicate; no SQL here
            .toList();                    // => returns matching summaries
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var pos = List.of(
    new PurchaseOrderSummary(new PurchaseOrderId("po_001"), PurchaseOrderStatus.AWAITING_APPROVAL, new Money(new BigDecimal("15000"), "USD")),
    new PurchaseOrderSummary(new PurchaseOrderId("po_002"), PurchaseOrderStatus.AWAITING_APPROVAL, new Money(new BigDecimal("500"),   "USD")),
    new PurchaseOrderSummary(new PurchaseOrderId("po_003"), PurchaseOrderStatus.APPROVED,          new Money(new BigDecimal("20000"), "USD"))
);
var service = new InMemoryPurchaseOrderQueryService(pos);
 
var awaitingApproval = new AwaitingApprovalSpec();
var highValue        = new HighValueSpec(new BigDecimal("10000"));
var combined         = awaitingApproval.and(highValue);  // => composite predicate
 
var results = service.findAll(combined);
System.out.println(results.size());                     // => Output: 1
System.out.println(results.get(0).id().value());        // => Output: po_001
// => po_002 excluded: awaiting but low-value; po_003 excluded: high-value but not awaiting

import java.math.BigDecimal;
import java.time.LocalDate;
 
// ── Write side: aggregate for commands ───────────────────────────────────────
// (same PurchaseOrder aggregate from earlier examples — abbreviated here)
enum PurchaseOrderStatus { DRAFT, AWAITING_APPROVAL, APPROVED, ISSUED, CANCELLED }
record PurchaseOrderId(String value) {}
record Money(BigDecimal amount, String currency) {}
 
class PurchaseOrder {                          // => aggregate root on the write side
    private final PurchaseOrderId id;
    private PurchaseOrderStatus status;
    private Money totalValue;
    private String requestorName;
    private LocalDate requestedDate;
 
    PurchaseOrder(PurchaseOrderId id, String requestorName, Money totalValue) {
        this.id            = id;
        this.status        = PurchaseOrderStatus.DRAFT;       // => initial state
        this.totalValue    = totalValue;
        this.requestorName = requestorName;
        this.requestedDate = LocalDate.now();
    }
 
    void submitForApproval() {
        if (status != PurchaseOrderStatus.DRAFT)
            throw new IllegalStateException("Only DRAFT POs can be submitted");
        // => enforce domain invariant: submission only from DRAFT
        status = PurchaseOrderStatus.AWAITING_APPROVAL;       // => state transition
    }
 
    PurchaseOrderId getId()       { return id; }
    PurchaseOrderStatus getStatus(){ return status; }
    Money getTotalValue()         { return totalValue; }
    String getRequestorName()     { return requestorName; }
    LocalDate getRequestedDate()  { return requestedDate; }
}
 
// ── Read side: flat read model shaped for the approval dashboard ──────────────
// => NOT the aggregate; no invariants here — just data the dashboard needs
record ApprovalDashboardRow(          // => read model: one row per PO awaiting approval
    String poId,                      // => String, not PurchaseOrderId — no domain type on read side
    String requestor,
    String totalDisplay,              // => pre-formatted "USD 15,000.00" — view-ready
    String requestedDate,             // => pre-formatted "2026-05-15" — view-ready
    String statusLabel                // => human label: "Awaiting Approval"
) {}
 
// ── Read model projector — updates read model from domain events ──────────────
// => In real CQRS this is an event handler; here simplified as a direct updater
class ApprovalDashboardProjector {
    private final java.util.List<ApprovalDashboardRow> rows = new java.util.ArrayList<>();
 
    public void project(PurchaseOrder po) {
        // => Only project POs that belong on the dashboard
        if (po.getStatus() != PurchaseOrderStatus.AWAITING_APPROVAL) return;
 
        var row = new ApprovalDashboardRow(
            po.getId().value(),
            po.getRequestorName(),
            po.getTotalValue().currency() + " " + po.getTotalValue().amount().toPlainString(),
            // => formatted at projection time — not at query time
            po.getRequestedDate().toString(),
            "Awaiting Approval"
        );
        rows.add(row);                        // => append to read model store
    }
 
    public java.util.List<ApprovalDashboardRow> getRows() {
        return java.util.Collections.unmodifiableList(rows); // => read-only view
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var po = new PurchaseOrder(new PurchaseOrderId("po_001"), "Alice", new Money(new BigDecimal("15000"), "USD"));
po.submitForApproval();                       // => DRAFT → AWAITING_APPROVAL
 
var projector = new ApprovalDashboardProjector();
projector.project(po);                        // => read model updated
 
var dashboard = projector.getRows();
System.out.println(dashboard.size());         // => Output: 1
System.out.println(dashboard.get(0).totalDisplay()); // => Output: USD 15000
System.out.println(dashboard.get(0).statusLabel());  // => Output: Awaiting Approval
// => Read model is flat, denormalised, pre-formatted — no joins at query time