시도된 프롬프트 내용은 이러한 정보 Style이 이용되었으며, 나머지는 AI응답에 의해 생성된 컨텐츠입니다.

장바구니 기능을 만들고 싶은 단순하게 장바기느를 구매만 이용하는게 아닌

장바구니의 이벤트를 활용(담기/빼기..), 이벤트를 추적해 구매자의 최종 구매 심리적 요인과

구매예측을 만들고 싶음 기본 이벤트를 설계해.... 

class Order(private val id: UUID, private val items: List<OrderItem>) { fun addItem(item: OrderItem) { /* 비즈니스 규칙 검증 후 추가 */ } }

Given(주문이 생성되어 있고) When(상품을 추가하면) Then(상품이 주문에 포함되어야 한다)

given(OrderCreatedEvent) when(AddItemCommand) then(shouldEmit(ItemAddedEvent))

이 도메인 모델을 참고해~ 이벤트를 처리하는 녀석들을 액터모델로 만들고
이벤트들을 퍼시던트를 이용해 저장시켜죠 

-도메인 모델이 이미지로 첨부되었습니다.

1. RegisterCustomerCommand
   → CustomerRegisteredEvent
   → CustomerState 업데이트

// 명령
sealed interface CustomerCommand
data class RegisterCustomer(val name: String, val replyTo: ActorRef<CustomerResponse>) : CustomerCommand

// 이벤트
sealed interface CustomerEvent
data class CustomerRegistered(val customerId: String, val name: String) : CustomerEvent

// 상태
data class CustomerState(val customers: Map<String, String> = emptyMap()) {
    fun applyEvent(event: CustomerRegistered): CustomerState {
        return copy(customers = customers + (event.customerId to event.name))
    }
}

// 응답
sealed interface CustomerResponse
data class RegisterSuccess(val customerId: String) : CustomerResponse

class CustomerPersistentActor private constructor(
    context: ActorContext<CustomerCommand>,
    persistenceId: PersistenceId,
) : EventSourcedBehavior<CustomerCommand, CustomerEvent, CustomerState>(
    persistenceId,
    emptyState = CustomerState(),
    commandHandler = commandHandler(),
    eventHandler = eventHandler()
) {

    companion object {
        fun create(entityId: String): Behavior<CustomerCommand> {
            return Behaviors.setup { context ->
                CustomerPersistentActor(
                    context,
                    PersistenceId.ofUniqueId("Customer-$entityId")
                )
            }
        }

        private fun commandHandler(): CommandHandler<CustomerCommand, CustomerEvent, CustomerState> {
            return newCommandHandlerBuilder()
                .forAnyState()
                .onCommand(RegisterCustomer::class.java) { state, cmd ->
                    val event = CustomerRegistered(UUID.randomUUID().toString(), cmd.name)
                    Effect().persist(event)
                        .thenReply(cmd.replyTo) { newState -> RegisterSuccess(event.customerId) }
                }
                .build()
        }

        private fun eventHandler(): EventHandler<CustomerState, CustomerEvent> {
            return newEventHandlerBuilder()
                .forAnyState()
                .onEvent(CustomerRegistered::class.java) { state, event ->
                    state.applyEvent(event)
                }
                .build()
        }
    }
}

val customerRouter = Routers.pool(5,
    Behaviors.supervise(CustomerPersistentActor.create("routered"))
        .onFailure(SupervisorStrategy.restart())
).withRoundRobinRouting()

pekko.persistence.journal.plugin = "pekko.persistence.journal.inmem"
pekko.persistence.snapshot-store.plugin = "pekko.persistence.snapshot-store.local"

최종 장바구니에 등록된 아이템을 단순하게 구매만 하기위한 기능도 필요함 
DurableStateBehavior  를 이용해 장단점도 설명

sealed interface CartCommand
data class AddItem(val itemId: String, val replyTo: ActorRef<CartResponse>) : CartCommand
data class Checkout(val replyTo: ActorRef<CartResponse>) : CartCommand

sealed interface CartResponse
data class CartUpdated(val items: List<String>) : CartResponse
data class CheckoutSuccess(val purchased: List<String>) : CartResponse

data class CartState(val items: List<String> = emptyList()) {
    fun add(itemId: String) = copy(items = items + itemId)
    fun clear() = copy(items = emptyList())
}

class CartActor private constructor(
    context: ActorContext<CartCommand>,
    persistenceId: PersistenceId
) : DurableStateBehavior<CartCommand, CartState>(persistenceId) {

    override fun emptyState(): CartState = CartState()

    companion object {
        fun create(userId: String): Behavior<CartCommand> {
            return Behaviors.setup { context ->
                CartActor(context, PersistenceId.ofUniqueId("cart-$userId"))
            }
        }
    }

    override fun commandHandler(): CommandHandler<CartCommand, CartState> {
        return newCommandHandlerBuilder()
            .forAnyState()
            .onCommand(AddItem::class.java) { state, cmd ->
                val updated = state.add(cmd.itemId)
                Effect().setState(updated)
                    .thenReply(cmd.replyTo) { CartUpdated(updated.items) }
            }
            .onCommand(Checkout::class.java) { state, cmd ->
                val purchased = state.items
                Effect().setState(state.clear())
                    .thenReply(cmd.replyTo) { CheckoutSuccess(purchased) }
            }
            .build()
    }
}

.onCommand(Checkout::class.java) { state, cmd ->
    val purchased = state.items
    // publishToKafka(purchased) 등의 외부 IO 필요 시 외부 알림 처리 포함
    Effect().setState(state.clear())
        .thenReply(cmd.replyTo) { CheckoutSuccess(purchased) }
}