extract projection snapshot logic

implement GameStateRepositoryTest
add lambda to the GameEventHandler.handle{} to set the version

add VersionBuilder
add version to the events
add creation date to the events
rename gameId to aggregateId
add EventHandler interface

src/main/kotlin/eventDemo/app/command/GameCommandRunner.kt

@@ -18,7 +18,7 @@ class GameCommandRunner(
         command: GameCommand,
         outgoingErrorChannelNotification: SendChannel<Notification>,
     ) {
-        val gameState = gameStateRepository.get(command.payload.gameId)
+        val gameState = gameStateRepository.getLast(command.payload.aggregateId)
         val errorNotifier = errorNotifier(command, outgoingErrorChannelNotification)
 
         when (command) {

src/main/kotlin/eventDemo/app/command/command/GameCommand.kt

@@ -11,7 +11,7 @@ sealed interface GameCommand : Command {
 
     @Serializable
     sealed interface Payload {
-        val gameId: GameId
+        val aggregateId: GameId
         val player: Player
     }
 }

src/main/kotlin/eventDemo/app/command/command/ICantPlayCommand.kt

@@ -20,7 +20,7 @@ data class ICantPlayCommand(
 
     @Serializable
     data class Payload(
-        override val gameId: GameId,
+        override val aggregateId: GameId,
         override val player: Player,
     ) : GameCommand.Payload
 
@@ -37,13 +37,14 @@ data class ICantPlayCommand(
         if (playableCards.isEmpty()) {
             val takenCard = state.deck.stack.first()
 
-            eventHandler.handle(
+            eventHandler.handle {
                 PlayerHavePassEvent(
-                    gameId = payload.gameId,
+                    aggregateId = payload.aggregateId,
                     player = payload.player,
                     takenCard = takenCard,
-                ),
-            )
+                    version = it,
+                )
+            }
         } else {
             playerErrorNotifier("You can and must play one card, like ${playableCards.first()::class.simpleName}")
         }

src/main/kotlin/eventDemo/app/command/command/IWantToJoinTheGameCommand.kt

@@ -20,7 +20,7 @@ data class IWantToJoinTheGameCommand(
 
     @Serializable
     data class Payload(
-        override val gameId: GameId,
+        override val aggregateId: GameId,
         override val player: Player,
     ) : GameCommand.Payload
 
@@ -30,12 +30,13 @@ data class IWantToJoinTheGameCommand(
         eventHandler: GameEventHandler,
     ) {
         if (!state.isStarted) {
-            eventHandler.handle(
+            eventHandler.handle {
                 NewPlayerEvent(
-                    payload.gameId,
-                    payload.player,
-                ),
-            )
+                    aggregateId = payload.aggregateId,
+                    player = payload.player,
+                    version = it,
+                )
+            }
         } else {
             playerErrorNotifier("The game is already started")
         }

src/main/kotlin/eventDemo/app/command/command/IWantToPlayCardCommand.kt

@@ -21,7 +21,7 @@ data class IWantToPlayCardCommand(
 
     @Serializable
     data class Payload(
-        override val gameId: GameId,
+        override val aggregateId: GameId,
         override val player: Player,
         val card: Card,
     ) : GameCommand.Payload
@@ -41,13 +41,14 @@ data class IWantToPlayCardCommand(
         }
 
         if (state.canBePlayThisCard(payload.player, payload.card)) {
-            eventHandler.handle(
+            eventHandler.handle {
                 CardIsPlayedEvent(
-                    payload.gameId,
-                    payload.card,
-                    payload.player,
-                ),
-            )
+                    aggregateId = payload.aggregateId,
+                    card = payload.card,
+                    player = payload.player,
+                    version = it,
+                )
+            }
         } else {
             playerErrorNotifier("You cannot play this card")
         }

src/main/kotlin/eventDemo/app/command/command/IamReadyToPlayCommand.kt

@@ -20,7 +20,7 @@ data class IamReadyToPlayCommand(
 
     @Serializable
     data class Payload(
-        override val gameId: GameId,
+        override val aggregateId: GameId,
         override val player: Player,
     ) : GameCommand.Payload
 
@@ -39,12 +39,13 @@ data class IamReadyToPlayCommand(
         } else if (playerIsAlreadyReady) {
             playerErrorNotifier("You are already ready")
         } else {
-            eventHandler.handle(
+            eventHandler.handle {
                 PlayerReadyEvent(
-                    payload.gameId,
-                    payload.player,
-                ),
-            )
+                    aggregateId = payload.aggregateId,
+                    player = payload.player,
+                    version = it,
+                )
+            }
         }
     }
 }

src/main/kotlin/eventDemo/app/event/EventHandler.kt

@@ -0,0 +1,13 @@
+package eventDemo.app.event
+
+import eventDemo.libs.event.AggregateId
+import eventDemo.libs.event.Event
+
+/**
+ * A stream to publish and read the played card event.
+ */
+interface EventHandler<E : Event<ID>, ID : AggregateId> {
+    fun registerProjectionBuilder(builder: (E) -> Unit)
+
+    fun handle(buildEvent: (version: Int) -> E): E
+}

src/main/kotlin/eventDemo/app/event/GameEventHandler.kt

@@ -1,6 +1,8 @@
 package eventDemo.app.event
 
+import eventDemo.app.entity.GameId
 import eventDemo.app.event.event.GameEvent
+import eventDemo.libs.event.VersionBuilder
 
 /**
  * A stream to publish and read the played card event.
@@ -8,20 +10,20 @@ import eventDemo.app.event.event.GameEvent
 class GameEventHandler(
     private val eventBus: GameEventBus,
     private val eventStream: GameEventStream,
-) {
+    private val versionBuilder: VersionBuilder,
+) : EventHandler<GameEvent, GameId> {
     private val projectionsBuilders: MutableList<(GameEvent) -> Unit> = mutableListOf()
 
-    fun registerProjectionBuilder(builder: GameProjectionBuilder) {
+    override fun registerProjectionBuilder(builder: GameProjectionBuilder) {
         projectionsBuilders.add(builder)
     }
 
-    fun handle(vararg events: GameEvent) {
-        events.forEach { event ->
+    override fun handle(buildEvent: (version: Int) -> GameEvent): GameEvent =
+        buildEvent(versionBuilder.buildNextVersion()).also { event ->
             eventStream.publish(event)
             projectionsBuilders.forEach { it(event) }
             eventBus.publish(event)
         }
-    }
 }
 
 typealias GameProjectionBuilder = (GameEvent) -> Unit

src/main/kotlin/eventDemo/app/event/event/CardIsPlayedEvent.kt

@@ -3,15 +3,20 @@ package eventDemo.app.event.event
 import eventDemo.app.entity.Card
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * An [GameEvent] to represent a played card.
  */
 data class CardIsPlayedEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     val card: Card,
     override val player: Player,
-    override val eventId: UUID = UUID.randomUUID(),
+    override val version: Int,
 ) : GameEvent,
-    PlayerActionEvent
+    PlayerActionEvent {
+    override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
+}

src/main/kotlin/eventDemo/app/event/event/GameEvent.kt

@@ -11,5 +11,6 @@ import java.util.UUID
 @Serializable
 sealed interface GameEvent : Event<GameId> {
     override val eventId: UUID
-    override val gameId: GameId
+    override val aggregateId: GameId
+    override val version: Int
 }

src/main/kotlin/eventDemo/app/event/event/GameStartedEvent.kt

@@ -4,26 +4,31 @@ import eventDemo.app.entity.Deck
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
 import eventDemo.app.entity.initHands
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * This [GameEvent] is sent when all players are ready.
  */
 data class GameStartedEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     val firstPlayer: Player,
     val deck: Deck,
+    override val version: Int,
 ) : GameEvent {
     override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
 
     companion object {
         fun new(
             id: GameId,
             players: Set<Player>,
             shuffleIsDisabled: Boolean = isDisabled,
+            version: Int,
         ): GameStartedEvent =
             GameStartedEvent(
-                gameId = id,
+                aggregateId = id,
                 firstPlayer = if (shuffleIsDisabled) players.first() else players.random(),
                 deck =
                     Deck
@@ -31,6 +36,7 @@ data class GameStartedEvent(
                         .let { if (shuffleIsDisabled) it else it.shuffle() }
                         .initHands(players)
                         .placeFirstCardOnDiscard(),
+                version = version,
             )
     }
 }

src/main/kotlin/eventDemo/app/event/event/NewPlayerEvent.kt

@@ -2,14 +2,18 @@ package eventDemo.app.event.event
 
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * An [GameEvent] to represent a new player joining the game.
  */
 data class NewPlayerEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     val player: Player,
+    override val version: Int,
 ) : GameEvent {
     override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
 }

src/main/kotlin/eventDemo/app/event/event/PlayerActionEvent.kt

@@ -2,6 +2,6 @@ package eventDemo.app.event.event
 
 import eventDemo.app.entity.Player
 
-sealed interface PlayerActionEvent {
+sealed interface PlayerActionEvent : GameEvent {
     val player: Player
 }

src/main/kotlin/eventDemo/app/event/event/PlayerChoseColorEvent.kt

@@ -3,16 +3,20 @@ package eventDemo.app.event.event
 import eventDemo.app.entity.Card
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * This [GameEvent] is sent when a player chose a color.
  */
 data class PlayerChoseColorEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     override val player: Player,
     val color: Card.Color,
+    override val version: Int,
 ) : GameEvent,
     PlayerActionEvent {
     override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
 }

src/main/kotlin/eventDemo/app/event/event/PlayerHavePassEvent.kt

@@ -3,16 +3,20 @@ package eventDemo.app.event.event
 import eventDemo.app.entity.Card
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * This [GameEvent] is sent when a player can play.
  */
 data class PlayerHavePassEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     override val player: Player,
     val takenCard: Card,
+    override val version: Int,
 ) : GameEvent,
     PlayerActionEvent {
     override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
 }

src/main/kotlin/eventDemo/app/event/event/PlayerReadyEvent.kt

@@ -2,14 +2,18 @@ package eventDemo.app.event.event
 
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * This [GameEvent] is sent when a player is ready.
  */
 data class PlayerReadyEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     val player: Player,
+    override val version: Int,
 ) : GameEvent {
     override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
 }

src/main/kotlin/eventDemo/app/event/event/PlayerWinEvent.kt

@@ -2,14 +2,18 @@ package eventDemo.app.event.event
 
 import eventDemo.app.entity.GameId
 import eventDemo.app.entity.Player
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
  * This [GameEvent] is sent when a player is ready.
  */
 data class PlayerWinEvent(
-    override val gameId: GameId,
+    override val aggregateId: GameId,
     val player: Player,
+    override val version: Int,
 ) : GameEvent {
     override val eventId: UUID = UUID.randomUUID()
+    override val createdAt: Instant = Clock.System.now()
 }

src/main/kotlin/eventDemo/app/event/projection/GameState.kt

@@ -8,7 +8,8 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 data class GameState(
-    val gameId: GameId,
+    override val aggregateId: GameId,
+    override val lastEventVersion: Int = 0,
     val players: Set<Player> = emptySet(),
     val currentPlayerTurn: Player? = null,
     val cardOnCurrentStack: LastCard? = null,
@@ -18,7 +19,7 @@ data class GameState(
     val deck: Deck = Deck(players),
     val isStarted: Boolean = false,
     val playerWins: Set<Player> = emptySet(),
-) {
+) : Projection<GameId> {
     @Serializable
     data class LastCard(
         val card: Card,

src/main/kotlin/eventDemo/app/event/projection/GameStateBuilder.kt

@@ -23,27 +23,28 @@ fun GameId.buildStateFromEventStream(eventStream: GameEventStream): GameState {
 }
 
 fun Collection<GameEvent>.buildStateFromEvents(): GameState {
-    val gameId = this.firstOrNull()?.gameId ?: error("Cannot build GameState from an empty list")
+    val gameId = this.firstOrNull()?.aggregateId ?: error("Cannot build GameState from an empty list")
     return fold(GameState(gameId)) { state, event ->
         state.apply(event)
     }
 }
 
-fun GameState.apply(event: GameEvent): GameState =
-    let { state ->
+fun GameState?.apply(event: GameEvent): GameState =
+    (this ?: GameState(event.aggregateId)).let { state ->
         val logger = KotlinLogging.logger { }
         if (event is PlayerActionEvent) {
             if (state.currentPlayerTurn != event.player) {
                 logger.atError {
-                    message = "Inconsistent player turn. CurrentPlayerTurn: $currentPlayerTurn | Player: ${event.player}"
+                    message = "Inconsistent player turn. CurrentPlayerTurn: $state.currentPlayerTurn | Player: ${event.player}"
                     payload =
                         mapOf(
-                            "CurrentPlayerTurn" to (currentPlayerTurn ?: "No currentPlayerTurn"),
+                            "CurrentPlayerTurn" to (state.currentPlayerTurn ?: "No currentPlayerTurn"),
                             "Player" to event.player,
                         )
                 }
             }
         }
+
         when (event) {
             is CardIsPlayedEvent -> {
                 val nextDirectionAfterPlay =
@@ -60,9 +61,9 @@ fun GameState.apply(event: GameEvent): GameState =
 
                 val currentPlayerAfterThePlay =
                     if (event.card is Card.AllColorCard) {
-                        currentPlayerTurn
+                        state.currentPlayerTurn
                     } else {
-                        nextPlayer(nextDirectionAfterPlay)
+                        state.nextPlayer(nextDirectionAfterPlay)
                     }
 
                 state.copy(
@@ -98,14 +99,14 @@ fun GameState.apply(event: GameEvent): GameState =
                     logger.error { "taken card is not ot top of the stack: ${event.takenCard}" }
                 }
                 state.copy(
-                    currentPlayerTurn = nextPlayerTurn,
+                    currentPlayerTurn = state.nextPlayerTurn,
                     deck = state.deck.takeOneCardFromStackTo(event.player),
                 )
             }
 
             is PlayerChoseColorEvent -> {
                 state.copy(
-                    currentPlayerTurn = nextPlayerTurn,
+                    currentPlayerTurn = state.nextPlayerTurn,
                     colorOnCurrentStack = event.color,
                 )
             }
@@ -121,9 +122,11 @@ fun GameState.apply(event: GameEvent): GameState =
             }
 
             is PlayerWinEvent -> {
-                copy(
-                    playerWins = playerWins + event.player,
+                state.copy(
+                    playerWins = state.playerWins + event.player,
                 )
             }
-        }
+        }.copy(
+            lastEventVersion = event.version,
+        )
     }

src/main/kotlin/eventDemo/app/event/projection/GameStateRepository.kt

@@ -4,73 +4,32 @@ import eventDemo.app.entity.GameId
 import eventDemo.app.event.GameEventHandler
 import eventDemo.app.event.GameEventStream
 import eventDemo.app.event.event.GameEvent
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.atomic.AtomicInteger
 
 class GameStateRepository(
     private val eventStream: GameEventStream,
     eventHandler: GameEventHandler,
-    private val maxSnapshotCacheSize: Int = 20,
+    maxSnapshotCacheSize: Int = 20,
 ) {
-    private val projections: ConcurrentHashMap<GameId, GameState> = ConcurrentHashMap()
-    private val version: AtomicInteger = AtomicInteger(0)
-    private val projectionsSnapshot: ConcurrentHashMap<GameEvent, GameState> = ConcurrentHashMap()
-    private val sortedSnapshotByVersion: ConcurrentHashMap<GameEvent, Int> = ConcurrentHashMap()
+    private val projectionsSnapshot =
+        ProjectionSnapshotRepositoryInMemory(
+            applyToProjection = GameState?::apply,
+            maxSnapshotCacheSize = maxSnapshotCacheSize,
+        )
 
     init {
         eventHandler.registerProjectionBuilder { event ->
-            val projection = projections[event.gameId]
-            if (projection == null) {
-                event
-                    .buildStateFromEventStreamTo(eventStream)
-                    .update()
-            } else {
-                projection
-                    .apply(event)
-                    .also { projections[it.gameId] = it }
-                    .also { state ->
-                        val newVersion = version.addAndGet(1)
-                        saveSnapshot(event, state, newVersion)
-                        removeOldSnapshot()
-                    }
-            }
+            projectionsSnapshot.applyAndPutToCache(event)
         }
     }
 
-    private fun removeOldSnapshot() {
-        if (projectionsSnapshot.size > maxSnapshotCacheSize) {
-            val numberToRemove = projectionsSnapshot.size - maxSnapshotCacheSize
-            sortedSnapshotByVersion
-                .toList()
-                .sortedBy { it.second }
-                .take(numberToRemove)
-                .toMap()
-                .keys
-                .forEach { event ->
-                    sortedSnapshotByVersion.remove(event)
-                    projectionsSnapshot.remove(event)
-                }
-        }
-    }
-
-    private fun saveSnapshot(
-        event: GameEvent,
-        state: GameState,
-        newVersion: Int,
-    ) {
-        projectionsSnapshot[event] = state
-        sortedSnapshotByVersion[event] = newVersion
-    }
-
     /**
      * Get the last version of the [GameState] from the all eventStream.
      *
      * It fetches it from the local cache if possible, otherwise it builds it.
      */
-    fun get(gameId: GameId): GameState =
-        projections.computeIfAbsent(gameId) {
-            gameId.buildStateFromEventStream(eventStream)
-        }
+    fun getLast(gameId: GameId): GameState =
+        projectionsSnapshot.getLast(gameId)
+            ?: gameId.buildStateFromEventStream(eventStream)
 
     /**
      * Get the [GameState] to the specific [event][GameEvent].
@@ -79,17 +38,7 @@ class GameStateRepository(
      * It fetches it from the local cache if possible, otherwise it builds it.
      */
     fun getUntil(event: GameEvent): GameState =
-        projectionsSnapshot.computeIfAbsent(event) {
-            event.buildStateFromEventStreamTo(eventStream)
-        }
-
-    private fun GameState.update() {
-        projections[gameId] = this
-    }
-
-    /**
-     * Build the state to the specific event
-     */
-    private fun GameEvent.buildStateFromEventStreamTo(eventStream: GameEventStream): GameState =
-        run { eventStream.readAll(gameId).takeWhile { it != this } + this }.buildStateFromEvents()
+        projectionsSnapshot.getUntil(event)
+            ?: (eventStream.readAll(event.aggregateId).takeWhile { it != event } + event)
+                .buildStateFromEvents()
 }

src/main/kotlin/eventDemo/app/event/projection/Projection.kt

@@ -0,0 +1,8 @@
+package eventDemo.app.event.projection
+
+import eventDemo.libs.event.AggregateId
+
+interface Projection<ID : AggregateId> {
+    val aggregateId: ID
+    val lastEventVersion: Int
+}

src/main/kotlin/eventDemo/app/event/projection/ProjectionSnapshotRepositoryInMemory.kt

@@ -0,0 +1,54 @@
+package eventDemo.app.event.projection
+
+import eventDemo.libs.event.AggregateId
+import eventDemo.libs.event.Event
+import java.util.concurrent.ConcurrentHashMap
+
+class ProjectionSnapshotRepositoryInMemory<E : Event<ID>, P : Projection<ID>, ID : AggregateId>(
+    private val maxSnapshotCacheSize: Int = 20,
+    private val applyToProjection: P?.(event: E) -> P,
+) {
+    private val projectionsSnapshot: ConcurrentHashMap<E, P> = ConcurrentHashMap()
+
+    fun applyAndPutToCache(event: E): P {
+        // lock here
+        return projectionsSnapshot
+            .filterKeys { it.aggregateId == event.aggregateId }
+            .toList()
+            .find { (e, _) -> e.version == (event.version - 1) }
+            ?.second
+            .applyToProjection(event)
+            .also { projectionsSnapshot.put(event, it) }
+            .also { removeOldSnapshot() }
+        // Unlock here
+    }
+
+    private fun removeOldSnapshot() {
+        if (projectionsSnapshot.size > maxSnapshotCacheSize) {
+            val numberToRemove = projectionsSnapshot.size - maxSnapshotCacheSize
+
+            projectionsSnapshot
+                .keys
+                .sortedBy { it.version }
+                .take(numberToRemove)
+                .forEach { event ->
+                    projectionsSnapshot.remove(event)
+                }
+        }
+    }
+
+    /**
+     * Get the last version of the [Projection] from the cache.
+     */
+    fun getLast(aggregateId: ID): P? =
+        projectionsSnapshot
+            .filter { it.key.aggregateId == aggregateId }
+            .maxByOrNull { (event, _) -> event.version }
+            ?.value
+
+    /**
+     * Get the [Projection] to the specific [event][Event].
+     * It does not contain the [events][Event] it after this one.
+     */
+    fun getUntil(event: E): P? = projectionsSnapshot.get(event)
+}

src/main/kotlin/eventDemo/app/eventListener/ReactionEventListener.kt

@@ -36,10 +36,13 @@ class ReactionEventListener(
     ) {
         if (state.isReady && !state.isStarted) {
             val reactionEvent =
-                GameStartedEvent.new(
-                    state.gameId,
-                    state.players,
-                )
+                eventHandler.handle {
+                    GameStartedEvent.new(
+                        id = state.aggregateId,
+                        players = state.players,
+                        version = it,
+                    )
+                }
             logger.atInfo {
                 message = "Reaction event was Send $reactionEvent on reaction of: $event"
                 payload =
@@ -48,7 +51,6 @@ class ReactionEventListener(
                         "reactionEvent" to reactionEvent,
                     )
             }
-            eventHandler.handle(reactionEvent)
         } else {
             if (event is PlayerReadyEvent) {
                 logger.info { "All players was not ready ${state.readyPlayers}" }
@@ -63,10 +65,14 @@ class ReactionEventListener(
         val winner = state.playerHasNoCardLeft().firstOrNull()
         if (winner != null) {
             val reactionEvent =
-                PlayerWinEvent(
-                    state.gameId,
-                    winner,
-                )
+                eventHandler.handle {
+                    PlayerWinEvent(
+                        aggregateId = state.aggregateId,
+                        player = winner,
+                        version = it,
+                    )
+                }
+
             logger.atInfo {
                 message = "Reaction event was Send $reactionEvent on reaction of: $event"
                 payload =
@@ -75,7 +81,6 @@ class ReactionEventListener(
                         "reactionEvent" to reactionEvent,
                     )
             }
-            eventHandler.handle(reactionEvent)
         }
     }
 }

src/main/kotlin/eventDemo/app/query/ReadTheGameState.kt

@@ -39,7 +39,7 @@ fun Route.readTheGameState(gameStateRepository: GameStateRepository) {
         // Read the last played card on the game.
         get<Game.Card> { body ->
             gameStateRepository
-                .get(body.game.id)
+                .getLast(body.game.id)
                 .cardOnCurrentStack
                 ?.card
                 ?.let { call.respond(it) }
@@ -48,7 +48,7 @@ fun Route.readTheGameState(gameStateRepository: GameStateRepository) {
 
         // Read the last played card on the game.
         get<Game.State> { body ->
-            val state = gameStateRepository.get(body.game.id)
+            val state = gameStateRepository.getLast(body.game.id)
             call.respond(state)
         }
     }

src/main/kotlin/eventDemo/configuration/ConfigureDI.kt

@@ -11,9 +11,12 @@ import eventDemo.app.eventListener.PlayerNotificationEventListener
 import eventDemo.libs.command.CommandStreamChannelBuilder
 import eventDemo.libs.event.EventBusInMemory
 import eventDemo.libs.event.EventStreamInMemory
+import eventDemo.libs.event.VersionBuilder
+import eventDemo.libs.event.VersionBuilderLocal
 import io.ktor.server.application.Application
 import io.ktor.server.application.install
 import org.koin.core.module.dsl.singleOf
+import org.koin.dsl.bind
 import org.koin.dsl.module
 import org.koin.ktor.plugin.Koin
 import org.koin.logger.slf4jLogger
@@ -40,6 +43,7 @@ val appKoinModule =
             CommandStreamChannelBuilder<GameCommand>()
         }
 
+        singleOf(::VersionBuilderLocal) bind VersionBuilder::class
         singleOf(::GameEventHandler)
         singleOf(::GameCommandRunner)
         singleOf(::GameCommandHandler)

src/main/kotlin/eventDemo/libs/event/Event.kt

@@ -1,5 +1,6 @@
 package eventDemo.libs.event
 
+import kotlinx.datetime.Instant
 import java.util.UUID
 
 /**
@@ -16,5 +17,7 @@ interface AggregateId {
  */
 interface Event<ID : AggregateId> {
     val eventId: UUID
-    val gameId: ID
+    val aggregateId: ID
+    val createdAt: Instant
+    val version: Int
 }

src/main/kotlin/eventDemo/libs/event/EventStreamInMemory.kt

@@ -34,11 +34,11 @@ class EventStreamInMemory<E : Event<ID>, ID : AggregateId> : EventStream<E, ID>
     ): R? =
         events
             .filterIsInstance(eventType.java)
-            .lastOrNull { it.gameId == aggregateId }
+            .lastOrNull { it.aggregateId == aggregateId }
 
     override fun readAll(aggregateId: ID): Set<E> =
         events
-            .filter { it.gameId == aggregateId }
+            .filter { it.aggregateId == aggregateId }
             .toSet()
 }
 

src/main/kotlin/eventDemo/libs/event/VersionBuilder.kt

@@ -0,0 +1,7 @@
+package eventDemo.libs.event
+
+interface VersionBuilder {
+    fun buildNextVersion(): Int
+
+    fun getLastVersion(): Int
+}

src/main/kotlin/eventDemo/libs/event/VersionBuilderLocal.kt

@@ -0,0 +1,11 @@
+package eventDemo.libs.event
+
+import java.util.concurrent.atomic.AtomicInteger
+
+class VersionBuilderLocal : VersionBuilder {
+    private val version: AtomicInteger = AtomicInteger(0)
+
+    override fun buildNextVersion(): Int = version.addAndGet(1)
+
+    override fun getLastVersion(): Int = version.toInt()
+}