Page History

@Aggregate
class OrderAggregate() {

    @AggregateIdentifier
    lateinit var orderId: String

    constructor(cmd: CreateOrderCommand) : this() {
        AggregateLifecycle.apply(OrderCreatedEvent(cmd.orderId, cmd.product))
    }

    @EventSourcingHandler
    fun on(event: OrderCreatedEvent) {
        this.orderId = event.orderId
        println("Order created: ${event.product}")
    }
}

data class CreateOrderCommand(val orderId: String, val product: String)
data class OrderCreatedEvent(val orderId: String, val product: String)

sealed interface Command
data class CreateOrder(val orderId: String, val product: String) : Command

sealed interface Event
data class OrderCreated(val orderId: String, val product: String) : Event

data class OrderState(val orderId: String? = null, val product: String? = null) {
    fun apply(event: OrderCreated) = this.copy(orderId = event.orderId, product = event.product)
}

class OrderAggregate private constructor(
    private val context: akka.actor.typed.javadsl.ActorContext<Command>
) : EventSourcedBehavior<Command, Event, OrderState>(
    PersistenceId.ofUniqueId("order-${context.self.path().name}"),
    OrderState()
) {
    companion object {
        fun create(): Behavior<Command> = Behaviors.setup { ctx -> OrderAggregate(ctx) }
    }

    override fun commandHandler(): CommandHandler<Command, Event, OrderState> =
        newCommandHandlerBuilder()
            .forAnyState()
            .onCommand(CreateOrder::class.java) { state, cmd ->
                Effect().persist(OrderCreated(cmd.orderId, cmd.product))
            }.build()

    override fun eventHandler(): EventHandler<OrderState, Event> =
        newEventHandlerBuilder()
            .forAnyState()
            .onEvent(OrderCreated::class.java) { state, event ->
                state.apply(event)
            }.build()
}