Advanced

// ── Sales Bounded Context ────────────────────────────────────────────────────
// "Customer" here is a prospect being tracked through the sales funnel
package sales;                                                        // => expression
 
record CustomerId(String value) {}                                    // => record CustomerId
// => Shared identity type; only the ID crosses context boundaries
 
class Customer {                                                      // => class Customer
    // => Sales context: Customer has pipeline stage and lead score
    private final CustomerId id;          // => Identity shared with other contexts
    private final String name;            // => Name owned by Sales context only
    private final String pipelineStage;   // => "Prospect/Qualified/Closed" — Sales ubiquitous language
 
    Customer(CustomerId id, String name, String stage) {              // => Customer() called
        this.id = id; this.name = name; this.pipelineStage = stage;   // => this.id assigned
        // => Constructor enforces all fields; no half-constructed Customer
    }
    public CustomerId id() { return id; }                             // => id method
    // => Only ID is exposed outside the context boundary
}
 
// ── Support Bounded Context ──────────────────────────────────────────────────
// Same "Customer" concept, completely different model — ticket count matters here
package support;                                                      // => expression
 
record CustomerId(String value) {}                                    // => record CustomerId
// => Identical structure but separate type — intentional duplication over coupling
 
class Customer {                                                      // => class Customer
    // => Support context: Customer has open tickets, not a pipeline stage
    private final CustomerId id;                                      // => id field
    private final int openTickets;        // => Support ubiquitous language: what matters here
    private final String tier;            // => "Gold/Silver/Bronze" — Support SLA level
 
    Customer(CustomerId id, int openTickets, String tier) {           // => Customer() called
        this.id = id; this.openTickets = openTickets; this.tier = tier; // => this.id assigned
    }
    public int openTickets() { return openTickets; }                  // => openTickets method
    // => Support operations query tickets, not pipeline stages
}

// ── Sales Bounded Context ────────────────────────────────────────────────────
// Kotlin data classes make context-local models concise
object sales {                                                        // => object sales
    @JvmInline value class CustomerId(val value: String)              // => class CustomerId
    // => Inline value class: zero runtime overhead, type-safe identity
 
    data class Customer(                                              // => class Customer
        val id: CustomerId,                                           // => expression
        val name: String,                                             // => expression
        val pipelineStage: String   // => Sales language: "Prospect/Qualified/Closed"
    )
}
 
// ── Support Bounded Context ──────────────────────────────────────────────────
// Entirely separate model; same field name "id" but different type
object support {                                                      // => object support
    @JvmInline value class CustomerId(val value: String)              // => class CustomerId
    // => Separate inline class prevents accidental cross-context ID mixing
 
    data class Customer(                                              // => class Customer
        val id: CustomerId,                                           // => expression
        val openTickets: Int,       // => Support language: ticket count is what matters
        val tier: String            // => "Gold/Silver/Bronze" maps to SLA commitments
    )
}
 
fun main() {                                                          // => main method
    val salesCustomer = sales.Customer(sales.CustomerId("c1"), "Acme", "Qualified") // => salesCustomer initialised
    // => sales.Customer and support.Customer are different types — compiler enforces isolation
    val supportCustomer = support.Customer(support.CustomerId("c1"), 3, "Gold") // => supportCustomer initialised
    println(salesCustomer)   // => Customer(id=CustomerId(value=c1), name=Acme, pipelineStage=Qualified)
    println(supportCustomer) // => Customer(id=CustomerId(value=c1), openTickets=3, tier=Gold)
}

// ── Sales Bounded Context ────────────────────────────────────────────────────
// C# namespaces enforce context boundaries at the module level
namespace Sales {                                                     // => expression
    public record CustomerId(string Value);                           // => record CustomerId
    // => Record type: value equality by default, immutable
 
    public record Customer(CustomerId Id, string Name, string PipelineStage); // => record Customer
    // => PipelineStage is Sales ubiquitous language — not meaningful in other contexts
}
 
// ── Support Bounded Context ──────────────────────────────────────────────────
// Parallel namespace; same names are allowed because they live in separate namespaces
namespace Support {                                                   // => expression
    public record CustomerId(string Value);                           // => record CustomerId
    // => Separate type prevents Sales.CustomerId being passed to Support code
 
    public record Customer(CustomerId Id, int OpenTickets, string Tier); // => record Customer
    // => OpenTickets and Tier are Support language — irrelevant to Sales
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var salesC = new Sales.Customer(new Sales.CustomerId("c1"), "Acme", "Qualified"); // => salesC initialised
        // => Compiler distinguishes Sales.Customer from Support.Customer
        var supportC = new Support.Customer(new Support.CustomerId("c1"), 3, "Gold"); // => supportC initialised
        Console.WriteLine(salesC);    // => Customer { Id = CustomerId { Value = c1 }, Name = Acme, PipelineStage = Qualified }
        Console.WriteLine(supportC);  // => Customer { Id = CustomerId { Value = c1 }, OpenTickets = 3, Tier = Gold }
    }
}

// ── Shared Kernel: sits in its own module/package ────────────────────────────
// Both Billing and Shipping agree on this exact type; any change needs both teams
package sharedkernel;                                                 // => expression
 
record CustomerId(String value) {}                                    // => record CustomerId
// => Shared Kernel type: immutable, no business logic — pure identity
record Money(java.math.BigDecimal amount, String currency) {          // => record Money
    // => Shared Kernel Value Object: both contexts need amount + currency together
    Money add(Money other) {                                          // => expression
        if (!currency.equals(other.currency)) throw new IllegalArgumentException("Currency mismatch"); // => throws if guard fails
        // => Guard: mixing USD and EUR produces nonsense; fail fast
        return new Money(amount.add(other.amount), currency);         // => returns new Money(amount.add(other.amo
        // => Returns new Money — immutable arithmetic, no mutation
    }
}
 
// ── Billing Context uses Shared Kernel ───────────────────────────────────────
package billing;                                                      // => expression
 
class Invoice {                                                       // => class Invoice
    private final sharedkernel.CustomerId customerId; // => Uses Shared Kernel ID type
    private final sharedkernel.Money total;           // => Uses Shared Kernel Money type
    Invoice(sharedkernel.CustomerId id, sharedkernel.Money total) {   // => Invoice() called
        this.customerId = id; this.total = total;                     // => this.customerId assigned
    }
    public sharedkernel.Money total() { return total; }               // => total method
}
 
// ── Shipping Context also uses Shared Kernel ─────────────────────────────────
package shipping;                                                     // => expression
 
class Shipment {                                                      // => class Shipment
    private final sharedkernel.CustomerId customerId; // => Same Shared Kernel type
    private final sharedkernel.Money cost;            // => Same Money type for shipping cost
    Shipment(sharedkernel.CustomerId id, sharedkernel.Money cost) {   // => Shipment() called
        this.customerId = id; this.cost = cost;                       // => this.customerId assigned
    }
}

// ── Shared Kernel ─────────────────────────────────────────────────────────────
object SharedKernel {                                                 // => object SharedKernel
    @JvmInline value class CustomerId(val value: String)              // => class CustomerId
    // => Inline class: no heap allocation, strong typing
 
    data class Money(val amount: java.math.BigDecimal, val currency: String) { // => class Money
        operator fun plus(other: Money): Money {                      // => expression
            require(currency == other.currency) { "Currency mismatch" } // => precondition check
            // => Kotlin operator overload: enables money1 + money2 syntax
            return copy(amount = amount + other.amount)               // => returns copy(amount = amount + other.a
            // => copy() creates new instance — immutability maintained
        }
    }
}
 
// Both contexts import and depend on SharedKernel, nothing else
data class Invoice(val customerId: SharedKernel.CustomerId, val total: SharedKernel.Money) // => class Invoice
// => Billing context — uses Shared Kernel types directly
 
data class Shipment(val customerId: SharedKernel.CustomerId, val cost: SharedKernel.Money) // => class Shipment
// => Shipping context — same Shared Kernel types; change requires bilateral agreement

// ── Shared Kernel ─────────────────────────────────────────────────────────────
namespace SharedKernel {                                              // => expression
    public record CustomerId(string Value);                           // => record CustomerId
    // => Shared type: both Billing and Shipping depend on this
 
    public record Money(decimal Amount, string Currency) {            // => record Money
        public Money Add(Money other) {                               // => Add method
            if (Currency != other.Currency) throw new InvalidOperationException("Currency mismatch"); // => throws if guard fails
            // => Fail fast on currency mismatch; avoids silent data corruption
            return this with { Amount = Amount + other.Amount };      // => returns this with { Amount = Amount + 
            // => With-expression: returns new record with updated Amount — immutable
        }
    }
}
 
namespace Billing {                                                   // => expression
    using SharedKernel;                                               // => namespace/package import
    public record Invoice(CustomerId CustomerId, Money Total);        // => record Invoice
    // => Billing owns Invoice structure; borrows identity + money from Shared Kernel
}
 
namespace Shipping {                                                  // => expression
    using SharedKernel;                                               // => namespace/package import
    public record Shipment(CustomerId CustomerId, Money Cost);        // => record Shipment
    // => Shipping owns Shipment structure; same Shared Kernel dependency
}

// ── Upstream Supplier: Inventory Context ────────────────────────────────────
// Inventory publishes its own DTO; downstream must accept it as-is
package inventory;                                                    // => expression
 
record ProductAvailabilityDto(String productId, int availableQty, String warehouseCode) {} // => record ProductAvailabilityDto
// => DTO published by Supplier; downstream Customer must not modify this class
 
class InventoryService {                                              // => class InventoryService
    public ProductAvailabilityDto checkAvailability(String productId) { // => checkAvailability method
        return new ProductAvailabilityDto(productId, 42, "WH-EU-01"); // => returns new ProductAvailabilityDto(pro
        // => Supplier returns its own model; downstream adapts, not the other way
    }
}
 
// ── Downstream Customer: Order Context ──────────────────────────────────────
// Order context has its own model; it calls Inventory and maps the result
package order;                                                        // => expression
 
record StockLevel(String sku, int qty) {}                             // => record StockLevel
// => Order's internal model: uses "sku" and "qty" — Order ubiquitous language
 
class OrderService {                                                  // => class OrderService
    private final inventory.InventoryService inventoryService;        // => expression
    // => Depends on upstream Supplier; no circular dependency allowed
 
    OrderService(inventory.InventoryService svc) { this.inventoryService = svc; } // => OrderService() called
 
    public StockLevel getStock(String sku) {                          // => getStock method
        var dto = inventoryService.checkAvailability(sku);            // => dto initialised
        // => Customer calls Supplier API; receives Supplier's DTO
        return new StockLevel(dto.productId(), dto.availableQty());   // => returns new StockLevel(dto.productId()
        // => Customer maps Supplier DTO to its own internal model
        // => warehouseCode discarded — not relevant in Order context
    }
}

// ── Upstream Supplier ────────────────────────────────────────────────────────
object Inventory {                                                    // => object Inventory
    data class ProductAvailabilityDto(val productId: String, val qty: Int, val warehouse: String) // => class ProductAvailabilityDto
    // => Supplier owns this DTO shape; downstream must not mutate it
 
    fun checkAvailability(productId: String) = ProductAvailabilityDto(productId, 42, "WH-EU-01") // => checkAvailability method
    // => Supplier API — stable contract that Customer depends on
}
 
// ── Downstream Customer ───────────────────────────────────────────────────────
data class StockLevel(val sku: String, val qty: Int)                  // => class StockLevel
// => Order's own model; mapping happens at the boundary
 
fun getStock(sku: String): StockLevel {                               // => getStock method
    val dto = Inventory.checkAvailability(sku)    // => Calls Supplier
    return StockLevel(sku = dto.productId, qty = dto.qty)             // => returns StockLevel(sku = dto.productId
    // => Maps Supplier DTO → Customer model; warehouse ignored
}
 
fun main() {                                                          // => main method
    println(getStock("SKU-001"))  // => StockLevel(sku=SKU-001, qty=42)
}

// ── Upstream Supplier ────────────────────────────────────────────────────────
namespace Inventory {                                                 // => expression
    public record ProductAvailabilityDto(string ProductId, int Qty, string Warehouse); // => record ProductAvailabilityDto
    // => Supplier DTO: Customer must accept this shape or adapt locally
 
    public class InventoryService {                                   // => InventoryService field
        public ProductAvailabilityDto CheckAvailability(string productId) // => CheckAvailability method
            => new(productId, 42, "WH-EU-01");                        // => expression
        // => Expression-bodied method: concise for simple return
    }
}
 
// ── Downstream Customer ───────────────────────────────────────────────────────
namespace Order {                                                     // => expression
    using Inventory;                                                  // => namespace/package import
    public record StockLevel(string Sku, int Qty);                    // => record StockLevel
    // => Order's internal representation; naming follows Order ubiquitous language
 
    public class OrderService(InventoryService inventory) {           // => class OrderService
        public StockLevel GetStock(string sku) {                      // => GetStock method
            var dto = inventory.CheckAvailability(sku);  // => Calls Supplier
            return new StockLevel(dto.ProductId, dto.Qty);            // => returns new StockLevel(dto.ProductId, 
            // => Translates Supplier model to Order model at the seam
        }
    }
}

// ── Upstream: User Auth Context (e.g. Keycloak) ──────────────────────────────
// External system; we have no influence over its model
package auth;                                                         // => expression
 
record UserPrincipal(String userId, String email, java.util.List<String> roles) {} // => record UserPrincipal
// => Upstream model; in Conformist we use this directly, no mapping
 
// ── Downstream: Notification Context (Conformist) ────────────────────────────
// Deliberately uses auth.UserPrincipal instead of creating its own User class
package notification;                                                 // => expression
 
class NotificationService {                                           // => class NotificationService
    public void sendWelcome(auth.UserPrincipal principal) {           // => sendWelcome method
        // => Conformist: accepts upstream type directly — no adapter, no mapping
        System.out.println("Welcome " + principal.email());           // => output to console
        // => Benefit: zero translation cost
        // => Trade-off: Notification is now coupled to Auth model changes
    }
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var svc = new NotificationService();                          // => svc initialised
        svc.sendWelcome(new auth.UserPrincipal("u1", "alice@example.com", java.util.List.of("USER"))); // => svc.sendWelcome() called
        // => Output: Welcome alice@example.com
    }
}

// ── Upstream model ────────────────────────────────────────────────────────────
data class UserPrincipal(val userId: String, val email: String, val roles: List<String>) // => class UserPrincipal
// => Upstream type; Conformist downstream uses it without wrapping
 
// ── Conformist downstream ────────────────────────────────────────────────────
fun sendWelcome(principal: UserPrincipal) {                           // => sendWelcome method
    // => Conformist: no mapping — directly uses upstream type
    println("Welcome ${principal.email}")                             // => output to console
    // => Simpler code, but downstream is coupled to upstream schema
}
 
fun main() {                                                          // => main method
    sendWelcome(UserPrincipal("u1", "alice@example.com", listOf("USER"))) // => sendWelcome() called
    // => Output: Welcome alice@example.com
}

// ── Upstream model ────────────────────────────────────────────────────────────
public record UserPrincipal(string UserId, string Email, List<string> Roles); // => record UserPrincipal
// => Upstream type — Conformist downstream accepts this directly
 
// ── Conformist downstream ────────────────────────────────────────────────────
public class NotificationService {                                    // => NotificationService field
    public void SendWelcome(UserPrincipal principal) {                // => SendWelcome method
        // => Conformist pattern: no anti-corruption translation layer
        Console.WriteLine($"Welcome {principal.Email}");              // => output to console
        // => Acceptable when upstream model quality is high and we have no influence over it
    }
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        new NotificationService().SendWelcome(new UserPrincipal("u1", "alice@example.com", new() { "USER" })); // => expression
        // => Output: Welcome alice@example.com
    }
}

// ── Legacy upstream model (cannot be modified) ───────────────────────────────
record LegacyClient(String clientNo, String fullName, int statusCode) {} // => record LegacyClient
// => Legacy system: "clientNo" not "customerId", statusCode int not enum
 
// ── Order context's clean model ──────────────────────────────────────────────
enum CustomerStatus { ACTIVE, INACTIVE, SUSPENDED }                   // => enum CustomerStatus
// => Order context uses a proper enum, not magic ints
 
record Customer(String id, String name, CustomerStatus status) {}     // => record Customer
// => Clean Order model — no trace of legacy naming conventions
 
// ── Anti-Corruption Layer ────────────────────────────────────────────────────
// The translator lives at the seam; it knows both models, neither model knows it
class ClientTranslator {                                              // => class ClientTranslator
    public Customer translate(LegacyClient legacy) {                  // => translate method
        return new Customer(                                          // => returns new Customer(
            legacy.clientNo(),          // => Maps "clientNo" → "id" (naming translation)
            legacy.fullName(),           // => Name passes through unchanged
            mapStatus(legacy.statusCode()) // => Translates int → enum (concept translation)
        );                                                            // => expression
    }
    private CustomerStatus mapStatus(int code) {                      // => mapStatus method
        return switch (code) {           // => Switch expression: exhaustive, no default needed
            case 1  -> CustomerStatus.ACTIVE;                         // => expression
            case 2  -> CustomerStatus.INACTIVE;                       // => expression
            default -> CustomerStatus.SUSPENDED;                      // => expression
        };
    }
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var translator = new ClientTranslator();                      // => translator initialised
        var legacy = new LegacyClient("CLT-001", "Alice", 1);         // => legacy initialised
        System.out.println(translator.translate(legacy));             // => output to console
        // => Customer[id=CLT-001, name=Alice, status=ACTIVE]
    }
}

// ── Legacy upstream ───────────────────────────────────────────────────────────
data class LegacyClient(val clientNo: String, val fullName: String, val statusCode: Int) // => class LegacyClient
// => Legacy naming and int status codes we cannot change
 
// ── Clean downstream model ────────────────────────────────────────────────────
enum class CustomerStatus { ACTIVE, INACTIVE, SUSPENDED }             // => enum class
data class Customer(val id: String, val name: String, val status: CustomerStatus) // => class Customer
 
// ── ACL Translator ────────────────────────────────────────────────────────────
object ClientTranslator {                                             // => object ClientTranslator
    fun translate(legacy: LegacyClient) = Customer(                   // => translate method
        id = legacy.clientNo,              // => Name translation at the seam
        name = legacy.fullName,                                       // => name assigned
        status = when (legacy.statusCode) { // => when exhaustively maps ints → enum
            1    -> CustomerStatus.ACTIVE                             // => expression
            2    -> CustomerStatus.INACTIVE                           // => expression
            else -> CustomerStatus.SUSPENDED                          // => expression
        }
    )
}
 
fun main() {                                                          // => main method
    println(ClientTranslator.translate(LegacyClient("CLT-001", "Alice", 1))) // => output to console
    // => Customer(id=CLT-001, name=Alice, status=ACTIVE)
}

// ── Legacy upstream ───────────────────────────────────────────────────────────
public record LegacyClient(string ClientNo, string FullName, int StatusCode); // => record LegacyClient
// => Cannot modify legacy types; ACL absorbs the difference
 
// ── Clean downstream model ────────────────────────────────────────────────────
public enum CustomerStatus { Active, Inactive, Suspended }            // => CustomerStatus field
public record Customer(string Id, string Name, CustomerStatus Status); // => record Customer
 
// ── Anti-Corruption Layer ────────────────────────────────────────────────────
public static class ClientTranslator {                                // => ClientTranslator field
    public static Customer Translate(LegacyClient legacy) => new(     // => Translate method
        Id:     legacy.ClientNo,           // => "ClientNo" → "Id": naming translation
        Name:   legacy.FullName,                                      // => expression
        Status: legacy.StatusCode switch { // => Switch expression: maps int → enum
            1 => CustomerStatus.Active,                               // => expression
            2 => CustomerStatus.Inactive,                             // => expression
            _ => CustomerStatus.Suspended  // => Default handles unknown codes safely
        }
    );                                                                // => expression
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        Console.WriteLine(ClientTranslator.Translate(new LegacyClient("CLT-001", "Alice", 1))); // => output to console
        // => Customer { Id = CLT-001, Name = Alice, Status = Active }
    }
}

import com.fasterxml.jackson.annotation.JsonProperty;
// => Jackson annotation: maps Java field name to JSON key name
 
// ── Published Language DTO ────────────────────────────────────────────────────
// This class IS the contract; changing it is a breaking change for all consumers
record OrderPlacedEvent(
    @JsonProperty("order_id")   String orderId,      // => snake_case JSON key; camelCase Java
    @JsonProperty("customer_id") String customerId,  // => Explicit mapping prevents rename bugs
    @JsonProperty("total_amount") double totalAmount, // => Published field; consumers depend on it
    @JsonProperty("currency")    String currency      // => Currency always accompanies amount
) {}
 
// ── Publisher serialises ─────────────────────────────────────────────────────
// In production, ObjectMapper.writeValueAsString(event) produces:
// {"order_id":"ord-1","customer_id":"cust-1","total_amount":99.50,"currency":"USD"}
// => Contract is the JSON shape, not the Java type

import com.fasterxml.jackson.annotation.JsonProperty                  // => namespace/package import
 
// ── Published Language DTO ────────────────────────────────────────────────────
data class OrderPlacedEvent(                                          // => class OrderPlacedEvent
    @JsonProperty("order_id")    val orderId: String,                 // => expression
    // => @JsonProperty ensures stable JSON key despite Kotlin property name
    @JsonProperty("customer_id") val customerId: String,              // => expression
    @JsonProperty("total_amount") val totalAmount: Double,            // => expression
    @JsonProperty("currency")    val currency: String                 // => expression
)
// => Any consumer reading this JSON shape is a subscriber of this Published Language
// => Version the event type name (e.g. OrderPlacedEventV2) for breaking changes

using System.Text.Json.Serialization;                                 // => namespace/package import
 
// ── Published Language DTO ────────────────────────────────────────────────────
public record OrderPlacedEvent(                                       // => record OrderPlacedEvent
    [property: JsonPropertyName("order_id")]    string OrderId,       // => expression
    // => JsonPropertyName: stable JSON key regardless of C# property name refactoring
    [property: JsonPropertyName("customer_id")] string CustomerId,    // => expression
    [property: JsonPropertyName("total_amount")] decimal TotalAmount, // => expression
    [property: JsonPropertyName("currency")]    string Currency       // => expression
);                                                                    // => expression
// => This record serialises to {"order_id":...,"customer_id":...,...}
// => Consumers in any language can parse the same JSON shape

// ── Open Host Service: Inventory exposes stock via REST ───────────────────────
// Any context or external system can call this endpoint — no custom integration needed
import jakarta.ws.rs.*;                                               // => namespace/package import
import jakarta.ws.rs.core.MediaType;                                  // => namespace/package import
 
@Path("/inventory")                                                   // => expression
@Produces(MediaType.APPLICATION_JSON)                                 // => expression
public class InventoryResource {                                      // => InventoryResource field
 
    @GET                                                              // => expression
    @Path("/products/{sku}/stock")                                    // => expression
    public StockResponse getStock(@PathParam("sku") String sku) {     // => getStock method
        // => OHS: one public API serves all consumers — Sales, Shipping, Reporting
        int qty = lookupStock(sku);    // => Internal lookup; implementation detail hidden
        return new StockResponse(sku, qty, "WH-EU-01");               // => returns new StockResponse(sku, qty, "W
        // => Response is the Published Language; consumers depend on it
    }
 
    private int lookupStock(String sku) { return 42; } // => Simplified for example
}
 
record StockResponse(String sku, int available, String warehouse) {}  // => record StockResponse
// => Published Language DTO returned by the Open Host Service

// ── Open Host Service skeleton (Ktor style) ───────────────────────────────────
import io.ktor.server.routing.*                                       // => namespace/package import
import io.ktor.server.response.*                                      // => namespace/package import
 
data class StockResponse(val sku: String, val available: Int, val warehouse: String) // => class StockResponse
// => Published Language: all consumers receive this shape
 
fun Route.inventoryRoutes() {                                         // => method declaration
    get("/inventory/products/{sku}/stock") {                          // => get() called
        val sku = call.parameters["sku"] ?: return@get                // => sku initialised
        // => Extract path parameter; short-circuit on missing SKU
        call.respond(StockResponse(sku, 42, "WH-EU-01"))              // => call.respond() called
        // => OHS exposes one endpoint; any consumer reads the same JSON
    }
}
// => Benefit: adding a new consumer context requires no code change in Inventory

// ── Open Host Service (minimal API style) ────────────────────────────────────
using Microsoft.AspNetCore.Builder;                                   // => namespace/package import
 
var app = WebApplication.Create();                                    // => app initialised
 
app.MapGet("/inventory/products/{sku}/stock", (string sku) => {       // => app.MapGet() called
    // => OHS: one route serves all downstream consumers
    return Results.Ok(new StockResponse(sku, 42, "WH-EU-01"));        // => returns Results.Ok(new StockResponse(s
    // => Returns Published Language DTO; consumers decode the JSON themselves
});
 
app.Run();                                                            // => app.Run() called
 
public record StockResponse(string Sku, int Available, string Warehouse); // => record StockResponse
// => Published Language record: stable shape across all consumer versions

// ── Subdomain classification as code comments ─────────────────────────────────
// This pattern documents architectural intent; no runtime behaviour
 
// CORE SUBDOMAIN — competitive advantage; build with highest craft
// Pricing engine: proprietary algorithm differentiating the business
interface PricingEngine {
    // => Core: invest in DDD, event sourcing, thorough testing here
    // => Do NOT outsource or use off-the-shelf pricing SaaS
    java.math.BigDecimal calculatePrice(String productId, int quantity, String customerId);
}
 
// SUPPORTING SUBDOMAIN — necessary but not differentiating; build simply
// Notification service: important but every company does the same thing
interface NotificationService {
    // => Supporting: CRUD service with simple domain model is fine here
    // => Can simplify to Transaction Script pattern; no need for full DDD
    void sendEmail(String to, String subject, String body);
}
 
// GENERIC SUBDOMAIN — solved problem; buy or reuse
// Authentication: Identity provider (Keycloak, Auth0) is the right choice
interface AuthenticationService {
    // => Generic: use an off-the-shelf IAM solution
    // => Building custom auth wastes engineering time on a solved problem
    boolean authenticate(String username, String password);
}

// ── Subdomain intent annotations ─────────────────────────────────────────────
// Kotlin annotations make subdomain classification machine-readable
@Target(AnnotationTarget.CLASS)                                       // => expression
annotation class CoreSubdomain(val reason: String)                    // => class CoreSubdomain
// => Use on classes in the core domain; tooling can enforce DDD standards here
 
@Target(AnnotationTarget.CLASS)                                       // => expression
annotation class SupportingSubdomain(val reason: String)              // => class SupportingSubdomain
// => Use on classes in supporting domains; simpler patterns acceptable
 
@Target(AnnotationTarget.CLASS)                                       // => expression
annotation class GenericSubdomain(val reason: String)                 // => class GenericSubdomain
// => Use on classes that should use off-the-shelf solutions
 
@CoreSubdomain(reason = "Proprietary pricing algorithm drives margin") // => expression
interface PricingEngine { fun calculatePrice(productId: String, qty: Int): java.math.BigDecimal } // => interface PricingEngine
 
@SupportingSubdomain(reason = "Necessary but not differentiating")    // => expression
interface NotificationService { fun sendEmail(to: String, subject: String, body: String) } // => interface NotificationService
 
@GenericSubdomain(reason = "Use Auth0 or Keycloak instead of building") // => expression
interface AuthenticationService { fun authenticate(username: String, password: String): Boolean } // => interface AuthenticationService

// ── Subdomain classification via attributes ───────────────────────────────────
[AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class)] // => expression
public class CoreSubdomainAttribute(string Reason) : Attribute { }    // => class CoreSubdomainAttribute
// => Attribute documents investment level; architecture linting can enforce rules
 
[AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class)] // => expression
public class SupportingSubdomainAttribute(string Reason) : Attribute { } // => class SupportingSubdomainAttribute
 
[AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class)] // => expression
public class GenericSubdomainAttribute(string Reason) : Attribute { } // => class GenericSubdomainAttribute
 
[CoreSubdomain("Proprietary pricing algorithm drives margin")]        // => expression
public interface IPricingEngine {                                     // => IPricingEngine field
    decimal CalculatePrice(string productId, int qty, string customerId); // => expression
    // => Core: highest engineering investment, full DDD, event sourcing if warranted
}
 
[SupportingSubdomain("Necessary but not differentiating")]            // => expression
public interface INotificationService {                               // => INotificationService field
    void SendEmail(string to, string subject, string body);           // => expression
    // => Supporting: simple CRUD service; Transaction Script pattern acceptable
}
 
[GenericSubdomain("Use Auth0 instead")]                               // => expression
public interface IAuthService {                                       // => IAuthService field
    bool Authenticate(string username, string password);              // => expression
    // => Generic: outsource to IAM provider; building custom is waste
}

import java.util.*;                                                   // => namespace/package import
 
// ── Small Aggregate: Order with minimal boundary ──────────────────────────────
// Only OrderId and status live here; OrderLines are separate aggregates
record OrderId(String value) {}                                       // => record OrderId
enum OrderStatus { DRAFT, CONFIRMED, SHIPPED }                        // => enum OrderStatus
 
class Order {                                                         // => class Order
    private final OrderId id;                                         // => id field
    private OrderStatus status;                                       // => status field
    // => Small boundary: no collection of lines — less contention, simpler locking
 
    Order(OrderId id) { this.id = id; this.status = OrderStatus.DRAFT; } // => Order() called
 
    public void confirm() {                                           // => confirm method
        if (status != OrderStatus.DRAFT) throw new IllegalStateException("Not DRAFT"); // => throws if guard fails
        // => Guard: invariant is simple because scope is small
        status = OrderStatus.CONFIRMED;                               // => status assigned
        // => State transition; no iteration over potentially large collections
    }
    public OrderStatus status() { return status; }                    // => status method
}
 
// ── Large Aggregate: Order owns OrderLines ────────────────────────────────────
// Can enforce "total must be positive" invariant atomically
class OrderWithLines {                                                // => class OrderWithLines
    private final OrderId id;                                         // => id field
    private final List<String> lines = new ArrayList<>(); // => simplified line type
    private OrderStatus status = OrderStatus.DRAFT;                   // => status declared
    // => Larger boundary: lines included; can check aggregate invariants
 
    OrderWithLines(OrderId id) { this.id = id; }                      // => OrderWithLines() called
 
    public void addLine(String productId) {                           // => addLine method
        if (status != OrderStatus.DRAFT) throw new IllegalStateException("Not DRAFT"); // => throws if guard fails
        lines.add(productId);                                         // => lines.add() called
        // => Invariant enforced atomically: status check + line addition in same lock
    }
    public int lineCount() { return lines.size(); }                   // => lineCount method
    // => Trade-off: concurrent writes block on the same aggregate instance
}

// ── Small aggregate ───────────────────────────────────────────────────────────
data class OrderId(val value: String)                                 // => class OrderId
enum class OrderStatus { DRAFT, CONFIRMED, SHIPPED }                  // => enum class
 
class Order(val id: OrderId) {                                        // => class Order
    var status: OrderStatus = OrderStatus.DRAFT                       // => expression
        private set          // => Private setter: only confirm() can change status
 
    fun confirm() {                                                   // => confirm method
        check(status == OrderStatus.DRAFT) { "Only DRAFT orders can be confirmed" } // => precondition check
        // => check() throws IllegalStateException with the message — idiomatic Kotlin
        status = OrderStatus.CONFIRMED                                // => status assigned
    }
}
// => Small aggregate: low lock contention, fits in single DB row, easy to cache
 
// ── Large aggregate ───────────────────────────────────────────────────────────
class OrderWithLines(val id: OrderId) {                               // => class OrderWithLines
    private val _lines = mutableListOf<String>()                      // => lines declared
    val lines: List<String> get() = _lines  // => Expose as read-only list
    var status = OrderStatus.DRAFT; private set                       // => status initialised
 
    fun addLine(productId: String) {                                  // => addLine method
        check(status == OrderStatus.DRAFT) { "Cannot add to non-DRAFT order" } // => precondition check
        _lines.add(productId)                                         // => _lines.add() called
        // => Atomically: status checked AND line added — no partial state possible
    }
}
// => Trade-off: more contention; larger transaction scope in DB

public enum OrderStatus { Draft, Confirmed, Shipped }                 // => OrderStatus field
public record OrderId(string Value);                                  // => record OrderId
 
// ── Small aggregate ───────────────────────────────────────────────────────────
public class Order(OrderId id) {                                      // => class Order
    public OrderId Id { get; } = id;                                  // => Id field
    public OrderStatus Status { get; private set; } = OrderStatus.Draft; // => Status field
    // => private set: encapsulation — only domain methods mutate status
 
    public void Confirm() {                                           // => Confirm method
        if (Status != OrderStatus.Draft) throw new InvalidOperationException("Not Draft"); // => throws if guard fails
        Status = OrderStatus.Confirmed;                               // => Status assigned
        // => Simple invariant: no loop over collections, low DB contention
    }
}
 
// ── Large aggregate ───────────────────────────────────────────────────────────
public class OrderWithLines(OrderId id) {                             // => class OrderWithLines
    private readonly List<string> _lines = [];                        // => expression
    public IReadOnlyList<string> Lines => _lines;     // => Read-only projection
    public OrderStatus Status { get; private set; } = OrderStatus.Draft; // => Status field
 
    public void AddLine(string productId) {                           // => AddLine method
        if (Status != OrderStatus.Draft) throw new InvalidOperationException("Not Draft"); // => throws if guard fails
        _lines.Add(productId);                                        // => _lines.Add() called
        // => Atomically enforces status + line count constraints in one transaction
    }
}
// => Larger boundary: more invariant coverage; higher contention cost

// ── Domain events ─────────────────────────────────────────────────────────────
record OrderPlacedEvent(String orderId, double amount) {}             // => record OrderPlacedEvent
record PaymentConfirmedEvent(String orderId) {}                       // => record PaymentConfirmedEvent
record PaymentFailedEvent(String orderId, String reason) {}           // => record PaymentFailedEvent
 
// ── Saga state ────────────────────────────────────────────────────────────────
enum SagaStatus { WAITING_PAYMENT, WAITING_SHIPMENT, COMPENSATING, COMPLETED } // => enum SagaStatus
 
// ── Order Fulfillment Saga ────────────────────────────────────────────────────
class OrderFulfillmentSaga {                                          // => class OrderFulfillmentSaga
    private String orderId;                                           // => orderId field
    private SagaStatus status;                                        // => status field
    // => Saga persists its own state so it can resume after restarts
 
    public void on(OrderPlacedEvent event) {                          // => on method
        this.orderId = event.orderId();                               // => this.orderId assigned
        this.status = SagaStatus.WAITING_PAYMENT; // => Transition: start waiting for payment
        System.out.println("SAGA: charge payment for " + orderId);    // => output to console
        // => Issue command to Payment context (via message bus in production)
    }
 
    public void on(PaymentConfirmedEvent event) {                     // => on method
        status = SagaStatus.WAITING_SHIPMENT;     // => Payment done; trigger shipping
        System.out.println("SAGA: reserve stock for " + orderId);     // => output to console
        // => Issue command to Inventory/Shipping context
    }
 
    public void on(PaymentFailedEvent event) {                        // => on method
        status = SagaStatus.COMPENSATING;         // => Compensate: cancel the order
        System.out.println("SAGA: cancel order " + orderId + " reason=" + event.reason()); // => output to console
        // => Compensating transaction: undo prior side effects
    }
 
    public SagaStatus status() { return status; }                     // => status method
}

sealed class SagaEvent                                                // => class SagaEvent
// => Sealed class: when-expressions on SagaEvent are exhaustive; compiler verifies coverage
data class OrderPlaced(val orderId: String, val amount: Double) : SagaEvent() // => class OrderPlaced
// => Triggered when customer places an order; starts the saga
data class PaymentConfirmed(val orderId: String) : SagaEvent()        // => class PaymentConfirmed
// => Triggered when payment service reports success
data class PaymentFailed(val orderId: String, val reason: String) : SagaEvent() // => class PaymentFailed
// => Triggered when payment service reports failure; reason for audit/display
 
enum class SagaStatus { WAITING_PAYMENT, WAITING_SHIPMENT, COMPENSATING, COMPLETED } // => enum class
// => Four states; each state represents what the saga is waiting for next
 
class OrderFulfillmentSaga {                                          // => class OrderFulfillmentSaga
    var status: SagaStatus? = null; private set                       // => expression
    // => Nullable: null means "not started"; private set prevents external mutation
    var orderId: String? = null;    private set                       // => expression
    // => Captured from first event; null until OrderPlaced fires
 
    fun handle(event: SagaEvent) = when (event) {                     // => handle method
        is OrderPlaced      -> { orderId = event.orderId; status = SagaStatus.WAITING_PAYMENT;  println("charge ${event.orderId}") } // => output to console
        // => First event: set orderId and status, then issue charge command
        is PaymentConfirmed -> { status = SagaStatus.WAITING_SHIPMENT;  println("reserve stock for $orderId") } // => output to console
        // => Payment succeeded: advance saga, issue reserve-stock command
        is PaymentFailed    -> { status = SagaStatus.COMPENSATING;      println("cancel $orderId: ${event.reason}") } // => output to console
        // => Payment failed: enter compensation, issue cancel command
        // => when is exhaustive because SagaEvent is sealed — compiler enforces coverage
    }
}
 
fun main() {                                                          // => main method
    val saga = OrderFulfillmentSaga()                                 // => saga initialised
    // => saga.status = null, saga.orderId = null (not started)
    saga.handle(OrderPlaced("ord-1", 99.0))      // => charge ord-1
    // => saga.status = WAITING_PAYMENT; saga.orderId = "ord-1"
    saga.handle(PaymentConfirmed("ord-1"))        // => reserve stock for ord-1
    // => saga.status = WAITING_SHIPMENT
    println(saga.status)                         // => WAITING_SHIPMENT
}

public enum SagaStatus { WaitingPayment, WaitingShipment, Compensating, Completed } // => SagaStatus field
// => Four saga states; each transition triggered by a domain event
 
public record OrderPlacedEvent(string OrderId, decimal Amount);       // => record OrderPlacedEvent
// => Immutable event: order placed, payment not yet confirmed
public record PaymentConfirmedEvent(string OrderId);                  // => record PaymentConfirmedEvent
// => Immutable event: payment succeeded; saga advances to shipping step
public record PaymentFailedEvent(string OrderId, string Reason);      // => record PaymentFailedEvent
// => Immutable event: payment failed; saga enters compensating state
 
public class OrderFulfillmentSaga {                                   // => OrderFulfillmentSaga field
    public string? OrderId   { get; private set; }                    // => expression
    // => Tracked order id; set on first event, used in subsequent steps
    public SagaStatus? Status { get; private set; }                   // => expression
    // => Private setters: only saga handler methods advance state
    // => Null until first event fires; type reflects "not yet started"
 
    public void On(OrderPlacedEvent e) {                              // => On method
        OrderId = e.OrderId; Status = SagaStatus.WaitingPayment;      // => OrderId assigned
        // => Saga initialised: OrderId captured, first state entered
        Console.WriteLine($"charge {OrderId}");     // => Issue payment command
        // => Real saga would publish a ChargeCustomerCommand to the payment service
    }
    public void On(PaymentConfirmedEvent e) {                         // => On method
        Status = SagaStatus.WaitingShipment;                          // => Status assigned
        // => Payment confirmed: advance from WaitingPayment → WaitingShipment
        Console.WriteLine($"reserve stock for {OrderId}");  // => Issue shipping command
        // => Real saga would publish a ReserveStockCommand to the inventory service
    }
    public void On(PaymentFailedEvent e) {                            // => On method
        Status = SagaStatus.Compensating;                             // => Status assigned
        // => Payment failed: enter compensating state to undo prior steps
        Console.WriteLine($"cancel {OrderId}: {e.Reason}"); // => Compensating transaction
        // => Real saga would publish CancelOrderCommand to reverse the order
    }
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var saga = new OrderFulfillmentSaga();                        // => saga initialised
        // => saga.Status = null (not started)
        saga.On(new OrderPlacedEvent("ord-1", 99m));                  // => saga.On() called
        // => saga.Status = WaitingPayment; "charge ord-1" printed
        saga.On(new PaymentConfirmedEvent("ord-1"));                  // => saga.On() called
        // => saga.Status = WaitingShipment; "reserve stock for ord-1" printed
        Console.WriteLine(saga.Status); // => WaitingShipment
    }
}

import java.util.*;                                                   // => namespace/package import
 
sealed interface OrderEvent permits OrderPlaced, ItemAdded, OrderConfirmed {} // => interface OrderEvent
record OrderPlaced(String orderId) implements OrderEvent {}           // => record OrderPlaced
record ItemAdded(String orderId, String sku, int qty) implements OrderEvent {} // => record ItemAdded
record OrderConfirmed(String orderId) implements OrderEvent {}        // => record OrderConfirmed
// => Sealed hierarchy: all possible events are known at compile time
 
class EventSourcedOrder {                                             // => class EventSourcedOrder
    private String id;                                                // => id field
    private final List<String> items = new ArrayList<>(); // => reconstructed items
    private boolean confirmed = false;                                // => confirmed declared
    // => No database state: this object rebuilt by replaying events
 
    public static EventSourcedOrder rehydrate(List<OrderEvent> events) { // => rehydrate method
        var order = new EventSourcedOrder();                          // => order initialised
        for (var event : events) order.apply(event);                  // => iteration over collection
        // => Replay: each event transitions state; final state = current state
        return order;                                                 // => returns order
    // => ends block
    }
 
    private void apply(OrderEvent event) {                            // => apply method
        switch (event) {                                              // => switch() called
            case OrderPlaced e    -> this.id = e.orderId();                   // => Sets ID
            case ItemAdded e      -> items.add(e.sku() + "x" + e.qty());      // => Adds item
            case OrderConfirmed e -> this.confirmed = true;                   // => Marks confirmed
        // => ends block
        }
    }
 
    public String summary() { return "Order " + id + " items=" + items + " confirmed=" + confirmed; } // => summary method
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var events = List.of(new OrderPlaced("ord-1"), new ItemAdded("ord-1","SKU-A",2), new OrderConfirmed("ord-1")); // => events initialised
        System.out.println(EventSourcedOrder.rehydrate(events).summary()); // => output to console
        // => Order ord-1 items=[SKU-Ax2] confirmed=true
    }
}

sealed interface OrderEvent                                           // => interface OrderEvent
data class OrderPlaced(val orderId: String) : OrderEvent              // => class OrderPlaced
data class ItemAdded(val orderId: String, val sku: String, val qty: Int) : OrderEvent // => class ItemAdded
data class OrderConfirmed(val orderId: String) : OrderEvent           // => class OrderConfirmed
 
data class OrderState(val id: String = "", val items: List<String> = emptyList(), val confirmed: Boolean = false) // => class OrderState
// => Pure data class: no methods — state is just data
 
fun applyEvent(state: OrderState, event: OrderEvent): OrderState = when (event) { // => applyEvent method
    is OrderPlaced    -> state.copy(id = event.orderId)               // => state.copy() called
    // => copy() returns new state — pure function, no mutation
    is ItemAdded      -> state.copy(items = state.items + "${event.sku}x${event.qty}") // => state.copy() called
    is OrderConfirmed -> state.copy(confirmed = true)                 // => state.copy() called
}
 
fun rehydrate(events: List<OrderEvent>): OrderState = events.fold(OrderState(), ::applyEvent) // => rehydrate method
// => fold: starts with empty state, applies each event — functional event replay
 
fun main() {                                                          // => main method
    val events = listOf(OrderPlaced("ord-1"), ItemAdded("ord-1","SKU-A",2), OrderConfirmed("ord-1")) // => events initialised
    println(rehydrate(events))                                        // => output to console
    // => OrderState(id=ord-1, items=[SKU-Ax2], confirmed=true)
}

public abstract record OrderEvent;                                    // => OrderEvent field
// => Abstract base: switch expression on OrderEvent requires handling all subtypes
public record OrderPlaced(string OrderId) : OrderEvent;               // => record OrderPlaced
// => First event in the stream; establishes the order id
public record ItemAdded(string OrderId, string Sku, int Qty) : OrderEvent; // => record ItemAdded
// => Each item added emits a separate event; history shows every addition
public record OrderConfirmed(string OrderId) : OrderEvent;            // => record OrderConfirmed
// => Abstract record base: pattern matching works exhaustively with switch expression
 
public record OrderState(string Id = "", List<string>? Items = null, bool Confirmed = false) { // => record OrderState
    public List<string> Items { get; init; } = Items ?? new();        // => List method
    // => init-only property: state is immutable after construction
    // => Null coalescing: Items ?? new() ensures empty list rather than null
}
 
public static class EventSourcedOrder {                               // => EventSourcedOrder field
    public static OrderState Apply(OrderState s, OrderEvent e) => e switch { // => Apply method
        OrderPlaced p    => s with { Id = p.OrderId },                // => expression
        // => with-expression: immutable update — returns new record with Id set
        ItemAdded a      => s with { Items = [..s.Items, $"{a.Sku}x{a.Qty}"] }, // => expression
        // => Spread operator: [..s.Items, newItem] creates new list with item appended
        OrderConfirmed _ => s with { Confirmed = true },              // => expression
        // => Discard pattern _: orderId not needed here, just mark as confirmed
        _                => s                                         // => expression
        // => Default: unknown events are ignored; state unchanged
    };
 
    public static OrderState Rehydrate(IEnumerable<OrderEvent> events) // => Rehydrate method
        => events.Aggregate(new OrderState(), Apply);                 // => events.Aggregate() called
    // => Aggregate: functional fold over event sequence
    // => Starts with empty OrderState; Apply transforms it for each event in sequence
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var events = new OrderEvent[] { new OrderPlaced("ord-1"), new ItemAdded("ord-1","SKU-A",2), new OrderConfirmed("ord-1") }; // => events initialised
        // => Three events: place → add item → confirm
        Console.WriteLine(EventSourcedOrder.Rehydrate(events));       // => output to console
        // => OrderState { Id = ord-1, Items = [SKU-Ax2], Confirmed = True }
    }
}

import java.util.*;                                                   // => namespace/package import
 
record Snapshot(int version, String serialisedState) {}               // => record Snapshot
// => Snapshot: persisted periodically (e.g. every 50 events) to speed up rehydration
 
class SnapshotStore {                                                 // => class SnapshotStore
    private final Map<String, Snapshot> store = new HashMap<>();      // => Map method
    // => In production, this is a DB table alongside the event stream
 
    public void save(String aggregateId, Snapshot snap) { store.put(aggregateId, snap); } // => save method
    public Optional<Snapshot> load(String aggregateId)  { return Optional.ofNullable(store.get(aggregateId)); } // => load method
// => ends block
}
 
class SnapshotAwareOrder {                                            // => class SnapshotAwareOrder
    private String state = "";                                        // => state declared
    private int version = 0;                                          // => version declared
    // => version tracks which events have been applied
 
    public static SnapshotAwareOrder rehydrate(SnapshotStore snapStore, String id, List<String> allEvents) { // => rehydrate method
        var order = new SnapshotAwareOrder();                         // => order initialised
        var snap = snapStore.load(id);                                // => snap initialised
 
        if (snap.isPresent()) {                                       // => precondition check
            order.state   = snap.get().serialisedState(); // => Start from snapshot
            order.version = snap.get().version();          // => Skip events before this version
            System.out.println("Loaded snapshot at v" + order.version); // => output to console
        }
 
        allEvents.stream().skip(order.version).forEach(e -> {         // => allEvents.stream() called
            order.state += "|" + e;   // => Apply only events after snapshot
            order.version++;                                          // => expression
        });
        return order;                                                 // => returns order
    }
 
    public String state()   { return state; }                         // => state method
    public int   version()  { return version; }                       // => version method
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var store = new SnapshotStore();                              // => store initialised
        store.save("ord-1", new Snapshot(2, "PLACED|ITEM_ADDED"));    // => store.save() called
        // => Snapshot saved at version 2; replay needs only events 3+
        var order = SnapshotAwareOrder.rehydrate(store, "ord-1",      // => order initialised
            List.of("PLACED","ITEM_ADDED","CONFIRMED","SHIPPED"));    // => List.of() called
        System.out.println(order.state() + " v=" + order.version());  // => output to console
        // => Loaded snapshot at v2
        // => PLACED|ITEM_ADDED|CONFIRMED|SHIPPED v=4
    }
}

data class Snapshot(val version: Int, val state: String)              // => class Snapshot
 
class SnapshotAwareOrder {                                            // => class SnapshotAwareOrder
    var state = ""; private set                                       // => state initialised
    var version = 0; private set                                      // => version initialised
 
    fun applySnapshot(snap: Snapshot) { state = snap.state; version = snap.version } // => applySnapshot method
    // => Load snapshot state directly — skips replaying early events
 
    fun applyEvent(event: String) { state += "|$event"; version++ }   // => applyEvent method
    // => Apply only events newer than the snapshot version
}
 
fun rehydrate(snapshot: Snapshot?, events: List<String>): SnapshotAwareOrder { // => rehydrate method
    val order = SnapshotAwareOrder()                                  // => order initialised
    snapshot?.let { order.applySnapshot(it) }           // => Load snapshot if available
    events.drop(snapshot?.version ?: 0).forEach(order::applyEvent)    // => events.drop() called
    // => drop: skip events already covered by the snapshot
    return order                                                      // => returns order
}
 
fun main() {                                                          // => main method
    val snap = Snapshot(2, "PLACED|ITEM_ADDED")                       // => snap initialised
    val all  = listOf("PLACED","ITEM_ADDED","CONFIRMED","SHIPPED")    // => all initialised
    val order = rehydrate(snap, all)                                  // => order initialised
    println("${order.state} v=${order.version}")                      // => output to console
    // => PLACED|ITEM_ADDED|CONFIRMED|SHIPPED v=4
}

public record Snapshot(int Version, string State);                    // => record Snapshot
 
public class SnapshotAwareOrder {                                     // => SnapshotAwareOrder field
    public string State   { get; private set; } = "";                 // => State field
    public int    Version { get; private set; } = 0;                  // => Version field
 
    public void ApplySnapshot(Snapshot snap) { State = snap.State; Version = snap.Version; } // => ApplySnapshot method
    // => Fast-forward to snapshot; no need to replay old events
 
    public void ApplyEvent(string ev) { State += $"|{ev}"; Version++; } // => ApplyEvent method
    // => Only apply events newer than snapshot version
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var snap   = new Snapshot(2, "PLACED|ITEM_ADDED");            // => snap initialised
        var events = new[] { "PLACED","ITEM_ADDED","CONFIRMED","SHIPPED" }; // => events initialised
 
        var order = new SnapshotAwareOrder();                         // => order initialised
        order.ApplySnapshot(snap);                        // => Restore from snapshot
        foreach (var e in events.Skip(snap.Version))      // => Skip events 0 and 1
            order.ApplyEvent(e);                                      // => order.ApplyEvent() called
 
        Console.WriteLine($"{order.State} v={order.Version}");        // => output to console
        // => PLACED|ITEM_ADDED|CONFIRMED|SHIPPED v=4
    }
}

import java.time.LocalDate;                                           // => namespace/package import
import java.util.*;                                                   // => namespace/package import
 
record EffectivePrice(LocalDate from, LocalDate to, java.math.BigDecimal amount) {} // => record EffectivePrice
// => Represents price valid within a date range [from, to)
 
class PriceHistory {                                                  // => class PriceHistory
    private final List<EffectivePrice> history = new ArrayList<>();   // => List method
    // => Ordered list of non-overlapping price periods
 
    public void addPeriod(EffectivePrice ep) { history.add(ep); }     // => addPeriod method
    // => In production: validate no overlapping periods before adding
 
    public Optional<java.math.BigDecimal> priceOn(LocalDate date) {   // => Optional method
        return history.stream()                                       // => returns history.stream()
            .filter(p -> !date.isBefore(p.from()) && date.isBefore(p.to())) // => date.isBefore() called
            // => [from, to): inclusive start, exclusive end — standard temporal range
            .map(EffectivePrice::amount)                              // => expression
            .findFirst();                                             // => expression
    }
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var ph = new PriceHistory();                                  // => ph initialised
        ph.addPeriod(new EffectivePrice(LocalDate.of(2024,1,1), LocalDate.of(2024,7,1), new java.math.BigDecimal("9.99"))); // => ph.addPeriod() called
        ph.addPeriod(new EffectivePrice(LocalDate.of(2024,7,1), LocalDate.of(2025,1,1), new java.math.BigDecimal("12.99"))); // => ph.addPeriod() called
        System.out.println(ph.priceOn(LocalDate.of(2024,3,1)));  // => Optional[9.99]
        System.out.println(ph.priceOn(LocalDate.of(2024,9,1)));  // => Optional[12.99]
    }
}

import java.time.LocalDate                                            // => namespace/package import
import java.math.BigDecimal                                           // => namespace/package import
 
data class EffectivePrice(val from: LocalDate, val to: LocalDate, val amount: BigDecimal) // => class EffectivePrice
// => Closed-open interval [from, to); standard temporal modelling convention
 
class PriceHistory {                                                  // => class PriceHistory
    private val periods = mutableListOf<EffectivePrice>()             // => periods declared
 
    fun add(ep: EffectivePrice) { periods.add(ep) }                   // => add method
 
    fun priceOn(date: LocalDate): BigDecimal? =                       // => priceOn method
        periods.firstOrNull { date >= it.from && date < it.to }?.amount // => expression
    // => firstOrNull: returns null if no period covers the date — explicit absence
}
 
fun main() {                                                          // => main method
    val ph = PriceHistory()                                           // => ph initialised
    ph.add(EffectivePrice(LocalDate.of(2024,1,1), LocalDate.of(2024,7,1), BigDecimal("9.99"))) // => ph.add() called
    ph.add(EffectivePrice(LocalDate.of(2024,7,1), LocalDate.of(2025,1,1), BigDecimal("12.99"))) // => ph.add() called
    println(ph.priceOn(LocalDate.of(2024,3,1)))  // => 9.99
    println(ph.priceOn(LocalDate.of(2024,9,1)))  // => 12.99
}

using System;                                                         // => namespace/package import
using System.Collections.Generic;                                     // => namespace/package import
using System.Linq;                                                    // => namespace/package import
 
public record EffectivePrice(DateOnly From, DateOnly To, decimal Amount); // => record EffectivePrice
// => DateOnly: date without time — no timezone confusion for effective dates
 
public class PriceHistory {                                           // => PriceHistory field
    private readonly List<EffectivePrice> _periods = [];              // => expression
 
    public void Add(EffectivePrice ep) => _periods.Add(ep);           // => Add method
 
    public decimal? PriceOn(DateOnly date) =>                         // => method declaration
        _periods.FirstOrDefault(p => date >= p.From && date < p.To)?.Amount; // => _periods.FirstOrDefault() called
    // => FirstOrDefault + ?. : returns null when no covering period exists
// => ends block
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var ph = new PriceHistory();                                  // => ph initialised
        ph.Add(new EffectivePrice(new DateOnly(2024,1,1), new DateOnly(2024,7,1), 9.99m)); // => ph.Add() called
        ph.Add(new EffectivePrice(new DateOnly(2024,7,1), new DateOnly(2025,1,1), 12.99m)); // => ph.Add() called
        Console.WriteLine(ph.PriceOn(new DateOnly(2024,3,1)));  // => 9.99
        Console.WriteLine(ph.PriceOn(new DateOnly(2024,9,1)));  // => 12.99
    }
}

enum OrderStatus { DRAFT, CONFIRMED, SHIPPED, CANCELLED }             // => enum OrderStatus
 
class Order {                                                         // => class Order
    private OrderStatus status = OrderStatus.DRAFT;                   // => status declared
    // => Always starts in DRAFT; state machine entry point
 
    public void confirm() {                                           // => confirm method
        guard(OrderStatus.DRAFT, "confirm");    // => Validate pre-condition
        status = OrderStatus.CONFIRMED;         // => Transition DRAFT → CONFIRMED
    // => ends block
    }
    public void ship() {                                              // => ship method
        guard(OrderStatus.CONFIRMED, "ship");   // => Only CONFIRMED can ship
        status = OrderStatus.SHIPPED;                                 // => status assigned
    // => ends block
    }
    public void cancel() {                                            // => cancel method
        if (status == OrderStatus.SHIPPED) throw new IllegalStateException("Cannot cancel SHIPPED"); // => throws if guard fails
        // => Cancellation allowed from DRAFT or CONFIRMED only
        status = OrderStatus.CANCELLED;                               // => status assigned
    // => ends block
    }
 
    private void guard(OrderStatus required, String action) {         // => guard method
        if (status != required) throw new IllegalStateException(action + " requires " + required + ", was " + status); // => throws if guard fails
        // => Reusable guard; eliminates duplicated if-throw patterns
    // => ends block
    }
    public OrderStatus status() { return status; }                    // => status method
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var o = new Order();                                          // => o initialised
        o.confirm(); System.out.println(o.status()); // => CONFIRMED
        o.ship();    System.out.println(o.status()); // => SHIPPED
    }
}

enum class OrderStatus { DRAFT, CONFIRMED, SHIPPED, CANCELLED }       // => enum class
// => Four states; transition() prevents any invalid state jump
 
class Order {                                                         // => class Order
    var status = OrderStatus.DRAFT; private set                       // => status initialised
    // => Starts as DRAFT; private set: only internal methods may change it
 
    fun confirm() { transition(from = OrderStatus.DRAFT, to = OrderStatus.CONFIRMED) } // => confirm method
    // => Named params clarify intent: from=DRAFT, to=CONFIRMED
    // => If status != DRAFT, transition() throws IllegalStateException
 
    fun ship()    { transition(from = OrderStatus.CONFIRMED, to = OrderStatus.SHIPPED) } // => ship method
    // => Only CONFIRMED orders can be shipped; DRAFT → SHIPPED would throw
 
    fun cancel() {                                                    // => cancel method
        check(status != OrderStatus.SHIPPED) { "Cannot cancel SHIPPED order" } // => precondition check
        // => Guard: SHIPPED is the only non-cancellable state
        status = OrderStatus.CANCELLED                                // => status assigned
        // => All non-SHIPPED states can transition to CANCELLED
    }
 
    private fun transition(from: OrderStatus, to: OrderStatus) {      // => transition method
        check(status == from) { "Expected $from, was $status" }       // => precondition check
        // => Generic transition helper: DRY state machine guard
        // => check() throws IllegalStateException with the message if status != from
        status = to                                                   // => status assigned
        // => Status updated after guard passes; one place to add logging or events
    }
}
 
fun main() {                                                          // => main method
    val o = Order()                                                   // => o initialised
    // => o.status = DRAFT (initial)
    o.confirm(); println(o.status)  // => CONFIRMED
    // => DRAFT → CONFIRMED succeeded; guard passed
    o.ship();    println(o.status)  // => SHIPPED
    // => CONFIRMED → SHIPPED succeeded; guard passed
}

public enum OrderStatus { Draft, Confirmed, Shipped, Cancelled }      // => OrderStatus field
// => Four lifecycle states; Transition() enforces which paths are valid
 
public class Order {                                                  // => Order field
    public OrderStatus Status { get; private set; } = OrderStatus.Draft; // => Status field
    // => Starts as Draft; private set: only Confirm/Ship/Cancel methods may change it
 
    public void Confirm() => Transition(OrderStatus.Draft, OrderStatus.Confirmed); // => Confirm method
    // => Delegates to Transition with expected=Draft, target=Confirmed
    // => If Status != Draft, Transition throws InvalidOperationException
 
    public void Ship()    => Transition(OrderStatus.Confirmed, OrderStatus.Shipped); // => Ship method
    // => Only Confirmed orders can be shipped; Draft → Shipped is an illegal transition
 
    public void Cancel() {                                            // => Cancel method
        if (Status == OrderStatus.Shipped) throw new InvalidOperationException("Cannot cancel Shipped"); // => throws if guard fails
        // => Shipped orders cannot be cancelled; all other states are cancellable
        Status = OrderStatus.Cancelled;                               // => Status assigned
        // => Direct assignment: any non-Shipped status can transition to Cancelled
    }
 
    private void Transition(OrderStatus from, OrderStatus to) {       // => Transition method
        if (Status != from) throw new InvalidOperationException($"Expected {from}, was {Status}"); // => throws if guard fails
        // => Centralised guard: all transitions go through this method
        // => Single point for adding logging, events, or metrics to any state change
        Status = to;                                                  // => Status assigned
        // => Transition applied after guard passes; Status = the target state
    }
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var o = new Order();                                          // => o initialised
        // => o.Status = Draft (initial state)
        o.Confirm(); Console.WriteLine(o.Status); // => Confirmed
        // => Draft → Confirmed succeeded; guard passed
        o.Ship();    Console.WriteLine(o.Status); // => Shipped
        // => Confirmed → Shipped succeeded; guard passed
    }
}

// ── Command ───────────────────────────────────────────────────────────────────
record ConfirmOrderCommand(String orderId) {}                         // => record ConfirmOrderCommand
// => Command object: named intent with data; no business logic here
 
// ── Aggregate (simplified) ────────────────────────────────────────────────────
class Order {                                                         // => class Order
    private final String id;                                          // => id field
    private boolean confirmed = false;                                // => confirmed declared
    Order(String id) { this.id = id; }                                // => Order() called
    public void confirm() { confirmed = true; }                       // => confirm method
    // => Domain logic lives in the aggregate, not the handler
    public boolean confirmed() { return confirmed; }                  // => confirmed method
}
 
// ── Repository ────────────────────────────────────────────────────────────────
interface OrderRepository {                                           // => interface OrderRepository
    Order findById(String id);   // => Load aggregate from persistence
    void  save(Order order);     // => Persist aggregate after mutation
}
 
// ── Command Handler ───────────────────────────────────────────────────────────
class ConfirmOrderHandler {                                           // => class ConfirmOrderHandler
    private final OrderRepository repo;                               // => repo field
    ConfirmOrderHandler(OrderRepository repo) { this.repo = repo; }   // => ConfirmOrderHandler() called
 
    public void handle(ConfirmOrderCommand cmd) {                     // => handle method
        var order = repo.findById(cmd.orderId()); // => 1. Load aggregate
        order.confirm();                           // => 2. Invoke domain logic
        repo.save(order);                          // => 3. Persist result
        // => Handler is thin: orchestrates load→mutate→save, no business logic
    }
}

data class ConfirmOrderCommand(val orderId: String)                   // => class ConfirmOrderCommand
// => Command: plain data, no behaviour
 
class Order(val id: String) {                                         // => class Order
    var confirmed = false; private set                                // => confirmed initialised
    fun confirm() { confirmed = true }                                // => confirm method
    // => Aggregate owns the business rule
// => ends block
}
 
interface OrderRepository {                                           // => interface OrderRepository
    fun findById(id: String): Order                                   // => findById method
    fun save(order: Order)                                            // => save method
}
 
class ConfirmOrderHandler(private val repo: OrderRepository) {        // => class ConfirmOrderHandler
    fun handle(cmd: ConfirmOrderCommand) {                            // => handle method
        val order = repo.findById(cmd.orderId)  // => Load
        order.confirm()                          // => Domain logic
        repo.save(order)                         // => Persist
        // => Handler is a thin orchestrator: no if/else domain logic here
    }
}

public record ConfirmOrderCommand(string OrderId);                    // => record ConfirmOrderCommand
// => Record command: immutable, value-equality, no methods
 
public class Order(string id) {                                       // => class Order
    public string Id { get; } = id;                                   // => Id field
    public bool Confirmed { get; private set; }                       // => Confirmed field
    public void Confirm() => Confirmed = true;                        // => Confirm method
    // => Aggregate method: domain rule lives here, not in handler
// => ends block
}
 
public interface IOrderRepository {                                   // => IOrderRepository field
    Order FindById(string id);                                        // => expression
    void Save(Order order);                                           // => expression
}
 
public class ConfirmOrderHandler(IOrderRepository repo) {             // => class ConfirmOrderHandler
    public void Handle(ConfirmOrderCommand cmd) {                     // => Handle method
        var order = repo.FindById(cmd.OrderId); // => 1. Load aggregate
        order.Confirm();                         // => 2. Execute domain logic
        repo.Save(order);                        // => 3. Persist state
        // => Three-line handler: thin orchestration, no business logic leakage
    }
}

import java.util.*;                                                   // => namespace/package import
 
// ── Domain event ──────────────────────────────────────────────────────────────
record OrderConfirmedEvent(String orderId, java.time.Instant occurredAt) {} // => record OrderConfirmedEvent
 
// ── Outbox entry ──────────────────────────────────────────────────────────────
record OutboxEntry(String id, String eventType, String payload, boolean published) {} // => record OutboxEntry
// => Persisted in same DB transaction as aggregate; relay publishes later
 
// ── Aggregate with pending events ─────────────────────────────────────────────
class Order {                                                         // => class Order
    private final String id;                                          // => id field
    private boolean confirmed = false;                                // => confirmed declared
    private final List<Object> pendingEvents = new ArrayList<>();     // => List method
    // => Events staged here; UnitOfWork flushes them to outbox after save
 
    Order(String id) { this.id = id; }                                // => Order() called
 
    public void confirm() {                                           // => confirm method
        confirmed = true;                                             // => confirmed assigned
        pendingEvents.add(new OrderConfirmedEvent(id, java.time.Instant.now())); // => pendingEvents.add() called
        // => Event recorded in-memory; written to outbox within same DB transaction
    }
 
    public List<Object> drainEvents() {                               // => drainEvents method
        var events = List.copyOf(pendingEvents);                      // => events initialised
        pendingEvents.clear();              // => Drain: caller takes ownership
        return events;                                                // => returns events
    }
}
 
// ── Outbox relay (conceptual — runs as background service) ────────────────────
class OutboxRelay {                                                   // => class OutboxRelay
    public void relay(List<OutboxEntry> unpublished) {                // => relay method
        for (var entry : unpublished) {                               // => iteration over collection
            publishToBroker(entry.payload());        // => Push to Kafka/RabbitMQ
            markPublished(entry.id());               // => Mark sent; idempotent check on broker side
        }
    }
    private void publishToBroker(String payload) { System.out.println("publish: " + payload); } // => output to console
    private void markPublished(String id)        { System.out.println("mark sent: " + id); } // => output to console
}

import java.time.Instant                                              // => namespace/package import
 
data class OrderConfirmedEvent(val orderId: String, val occurredAt: Instant) // => class OrderConfirmedEvent
data class OutboxEntry(val id: String, val eventType: String, val payload: String, val published: Boolean) // => class OutboxEntry
 
class Order(val id: String) {                                         // => class Order
    var confirmed = false; private set                                // => confirmed initialised
    private val _pendingEvents = mutableListOf<Any>()                 // => pendingEvents declared
    val pendingEvents: List<Any> get() = _pendingEvents  // => Read-only view
 
    fun confirm() {                                                   // => confirm method
        confirmed = true                                              // => confirmed assigned
        _pendingEvents += OrderConfirmedEvent(id, Instant.now())      // => _pendingEvents assigned
        // => += appends; event queued for outbox flush in same transaction
    // => ends block
    }
 
    fun drainEvents(): List<Any> {                                    // => drainEvents method
        val drained = _pendingEvents.toList()  // => Snapshot
        _pendingEvents.clear()                 // => Clear after drain
        return drained                                                // => returns drained
    }
}
// => Outbox relay polls DB for unpublished entries, pushes to broker, marks sent

using System;                                                         // => namespace/package import
using System.Collections.Generic;                                     // => namespace/package import
 
public record OrderConfirmedEvent(string OrderId, DateTime OccurredAt); // => record OrderConfirmedEvent
// => Immutable event record; captures order id and the exact confirmation time
public record OutboxEntry(string Id, string EventType, string Payload, bool Published); // => record OutboxEntry
// => DB row in the outbox table; Published=false until relay processes it
 
public class Order(string id) {                                       // => class Order
    public string Id { get; } = id;                                   // => Id field
    // => Identity: set from constructor argument; get-only
    public bool Confirmed { get; private set; }                       // => Confirmed field
    // => Starts false; Confirm() is the only method that sets this to true
    private readonly List<object> _pending = [];                      // => expression
    // => Staging area for events; flushed to outbox in same DB transaction as aggregate save
 
    public void Confirm() {                                           // => Confirm method
        Confirmed = true;                                             // => Confirmed assigned
        // => State change happens before event is staged
        _pending.Add(new OrderConfirmedEvent(id, DateTime.UtcNow));   // => _pending.Add() called
        // => Event staged in memory; repository flushes to outbox within same EF transaction
        // => DateTime.UtcNow captures the confirmation timestamp
    }
 
    public IReadOnlyList<object> DrainEvents() {                      // => DrainEvents method
        var copy = _pending.ToArray();   // => Snapshot before clearing
        _pending.Clear();                                             // => _pending.Clear() called
        // => Clear after snapshot; prevents double-flush on subsequent calls
        return copy;                                                  // => returns copy
        // => Caller (repository/unit-of-work) writes these to the outbox table
        // => Returned as IReadOnlyList; caller cannot mutate the original list
    }
}

import java.util.*;                                                   // => namespace/package import
 
record IntegrationEvent(String eventId, String type, String payload) {} // => record IntegrationEvent
// => eventId: unique per event; used to detect duplicates
 
class IdempotentEventConsumer {                                       // => class IdempotentEventConsumer
    private final Set<String> processedIds = new HashSet<>();         // => Set method
    // => In production, backed by a DB table with unique constraint on eventId
 
    public boolean process(IntegrationEvent event) {                  // => process method
        if (processedIds.contains(event.eventId())) {                 // => precondition check
            System.out.println("SKIP duplicate: " + event.eventId()); // => output to console
            return false;                  // => Already processed; skip safely
        // => ends block
        }
        doProcess(event);                  // => First time seeing this event
        processedIds.add(event.eventId()); // => Mark as processed AFTER successful handling
        return true;                                                  // => returns true
    // => ends block
    }
 
    private void doProcess(IntegrationEvent event) {                  // => doProcess method
        System.out.println("PROCESS: " + event.type() + " id=" + event.eventId()); // => output to console
    // => ends block
    }
// => ends block
}
 
class Demo {                                                          // => class Demo
    public static void main(String[] args) {                          // => main method
        var consumer = new IdempotentEventConsumer();                 // => consumer initialised
        var event = new IntegrationEvent("evt-001", "OrderConfirmed", "{}"); // => event initialised
        consumer.process(event);  // => PROCESS: OrderConfirmed id=evt-001
        consumer.process(event);  // => SKIP duplicate: evt-001
    }
}

data class IntegrationEvent(val eventId: String, val type: String, val payload: String) // => class IntegrationEvent
 
class IdempotentConsumer {                                            // => class IdempotentConsumer
    private val processed = mutableSetOf<String>()                    // => processed declared
    // => HashSet: O(1) lookup; in production use DB unique index
 
    fun process(event: IntegrationEvent): Boolean {                   // => process method
        if (event.eventId in processed) {                             // => precondition check
            println("SKIP ${event.eventId}")                          // => output to console
            return false  // => Duplicate: safe no-op
        // => ends block
        }
        println("PROCESS ${event.type} id=${event.eventId}")  // => Handle event
        processed += event.eventId                             // => Mark as done
        return true                                                   // => returns true
    // => ends block
    }
// => ends block
}
 
fun main() {                                                          // => main method
    val c = IdempotentConsumer()                                      // => c initialised
    val e = IntegrationEvent("evt-001", "OrderConfirmed", "{}")       // => e initialised
    c.process(e)   // => PROCESS OrderConfirmed id=evt-001
    c.process(e)   // => SKIP evt-001
}

using System;                                                         // => namespace/package import
using System.Collections.Generic;                                     // => namespace/package import
 
public record IntegrationEvent(string EventId, string Type, string Payload); // => record IntegrationEvent
// => Immutable event record; EventId is the idempotency key
 
public class IdempotentConsumer {                                     // => IdempotentConsumer field
    private readonly HashSet<string> _processed = [];                 // => expression
    // => In production: DB table with UNIQUE constraint on event_id column
    // => HashSet gives O(1) Contains() checks; no linear scan
 
    public bool Process(IntegrationEvent ev) {                        // => Process method
        if (_processed.Contains(ev.EventId)) {                        // => precondition check
            // => Already processed this event id; safe to skip
            Console.WriteLine($"SKIP {ev.EventId}");                  // => output to console
            return false;                   // => Duplicate: idempotent no-op
            // => Returning false signals to caller that event was skipped (not an error)
        }
        Console.WriteLine($"PROCESS {ev.Type} id={ev.EventId}");      // => output to console
        // => First-time processing: domain logic would execute here in production
        _processed.Add(ev.EventId);         // => Record after successful processing
        // => Mark AFTER handling; if handling throws, id is not recorded, so retry is safe
        return true;                                                  // => returns true
        // => true = event was freshly processed
    }
}
 
class Program {                                                       // => class Program
    static void Main() {                                              // => Main method
        var c = new IdempotentConsumer();                             // => c initialised
        // => Fresh consumer; no events processed yet
        var e = new IntegrationEvent("evt-001", "OrderConfirmed", "{}"); // => e initialised
        // => One event with id "evt-001"; same instance will be sent twice (simulating retry)
        c.Process(e);  // => PROCESS OrderConfirmed id=evt-001
        // => First call: processes and records evt-001; returns true
        c.Process(e);  // => SKIP evt-001
        // => Second call (retry): evt-001 already in _processed; skipped; returns false
    }
}