feat: remove snapshot on ProjectionRepository

src/main/kotlin/eventDemo/adapter/infrastructureLayer/event/projection/GameListRepositoryInMemory.kt

@@ -2,28 +2,20 @@ package eventDemo.adapter.infrastructureLayer.event.projection
 
 import eventDemo.business.entity.GameId
 import eventDemo.business.event.GameEventBus
-import eventDemo.business.event.GameEventStore
 import eventDemo.business.event.projection.GameList
 import eventDemo.business.event.projection.GameListRepository
 import eventDemo.business.event.projection.GameProjectionBus
 import eventDemo.business.event.projection.GameState
 import eventDemo.business.event.projection.apply
-import eventDemo.libs.event.projection.ProjectionSnapshotRepositoryInMemory
-import eventDemo.libs.event.projection.SnapshotConfig
+import eventDemo.libs.event.projection.ProjectionRepositoryInMemory
 import io.github.oshai.kotlinlogging.withLoggingContext
 
 /**
  * Manages [projections][GameList], their building and publication in the [bus][GameProjectionBus].
  */
-class GameListRepositoryInMemory(
-  eventStore: GameEventStore,
-  snapshotConfig: SnapshotConfig = SnapshotConfig(),
-) : GameListRepository {
-  private val projectionsSnapshot =
-    ProjectionSnapshotRepositoryInMemory(
-      name = GameListRepositoryInMemory::class,
-      eventStore = eventStore,
-      snapshotCacheConfig = snapshotConfig,
+class GameListRepositoryInMemory : GameListRepository {
+  private val projectionsRepository =
+    ProjectionRepositoryInMemory(
       applyToProjection = GameList::apply,
       initialStateBuilder = { aggregateId: GameId -> GameList(aggregateId) },
     )
@@ -32,11 +24,11 @@ class GameListRepositoryInMemory(
     projectionBus: GameProjectionBus,
     eventBus: GameEventBus,
   ) {
-    // On new event was received, build snapshot and publish it to the projection bus
+    // On new event was received, build projection and publish it to the projection bus
     eventBus.subscribe { event ->
       withLoggingContext("event" to event.toString()) {
-        projectionsSnapshot
-          .applyAndPutToCache(event)
+        projectionsRepository
+          .applyAndSave(event)
           .also { projectionBus.publish(it) }
       }
     }
@@ -48,5 +40,5 @@ class GameListRepositoryInMemory(
    * It fetches it from the local cache if possible, otherwise it builds it.
    */
   override fun getList(): List<GameList> =
-    projectionsSnapshot.getList()
+    projectionsRepository.getList()
 }

src/main/kotlin/eventDemo/adapter/infrastructureLayer/event/projection/GameListRepositoryInRedis.kt

@@ -2,14 +2,12 @@ package eventDemo.adapter.infrastructureLayer.event.projection
 
 import eventDemo.business.entity.GameId
 import eventDemo.business.event.GameEventBus
-import eventDemo.business.event.GameEventStore
 import eventDemo.business.event.projection.GameList
 import eventDemo.business.event.projection.GameListRepository
 import eventDemo.business.event.projection.GameProjectionBus
 import eventDemo.business.event.projection.GameState
 import eventDemo.business.event.projection.apply
-import eventDemo.libs.event.projection.ProjectionSnapshotRepositoryInRedis
-import eventDemo.libs.event.projection.SnapshotConfig
+import eventDemo.libs.event.projection.ProjectionRepositoryInRedis
 import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.serialization.json.Json
 import redis.clients.jedis.UnifiedJedis
@@ -18,14 +16,10 @@ import redis.clients.jedis.UnifiedJedis
  * Manages [projections][GameList], their building and publication in the [bus][GameProjectionBus].
  */
 class GameListRepositoryInRedis(
-  eventStore: GameEventStore,
   jedis: UnifiedJedis,
-  snapshotConfig: SnapshotConfig = SnapshotConfig(),
 ) : GameListRepository {
-  private val projectionsSnapshot =
-    ProjectionSnapshotRepositoryInRedis(
-      eventStore = eventStore,
-      snapshotCacheConfig = snapshotConfig,
+  private val projectionsRepository =
+    ProjectionRepositoryInRedis(
       initialStateBuilder = { aggregateId: GameId -> GameList(aggregateId) },
       projectionClass = GameList::class,
       projectionToJson = { Json.encodeToString(GameList.serializer(), it) },
@@ -40,8 +34,8 @@ class GameListRepositoryInRedis(
   ) {
     eventBus.subscribe { event ->
       withLoggingContext("event" to event.toString()) {
-        projectionsSnapshot
-          .applyAndPutToCache(event)
+        projectionsRepository
+          .applyAndSave(event)
           .also { projectionBus.publish(it) }
       }
     }
@@ -53,5 +47,5 @@ class GameListRepositoryInRedis(
    * It fetches it from the local cache if possible, otherwise it builds it.
    */
   override fun getList(): List<GameList> =
-    projectionsSnapshot.getList()
+    projectionsRepository.getList()
 }

src/main/kotlin/eventDemo/adapter/infrastructureLayer/event/projection/GameStateRepositoryInMemory.kt

@@ -2,28 +2,19 @@ package eventDemo.adapter.infrastructureLayer.event.projection
 
 import eventDemo.business.entity.GameId
 import eventDemo.business.event.GameEventBus
-import eventDemo.business.event.GameEventStore
-import eventDemo.business.event.event.GameEvent
 import eventDemo.business.event.projection.GameProjectionBus
 import eventDemo.business.event.projection.GameState
 import eventDemo.business.event.projection.GameStateRepository
 import eventDemo.business.event.projection.apply
-import eventDemo.libs.event.projection.ProjectionSnapshotRepositoryInMemory
-import eventDemo.libs.event.projection.SnapshotConfig
+import eventDemo.libs.event.projection.ProjectionRepositoryInMemory
 import io.github.oshai.kotlinlogging.withLoggingContext
 
 /**
  * Manages [projections][GameState], their building and publication in the [bus][GameProjectionBus].
  */
-class GameStateRepositoryInMemory(
-  eventStore: GameEventStore,
-  snapshotConfig: SnapshotConfig = SnapshotConfig(),
-) : GameStateRepository {
-  private val projectionsSnapshot =
-    ProjectionSnapshotRepositoryInMemory(
-      name = GameStateRepositoryInMemory::class,
-      eventStore = eventStore,
-      snapshotCacheConfig = snapshotConfig,
+class GameStateRepositoryInMemory : GameStateRepository {
+  private val projectionsRepository =
+    ProjectionRepositoryInMemory(
       applyToProjection = GameState::apply,
       initialStateBuilder = { aggregateId: GameId -> GameState(aggregateId) },
     )
@@ -32,33 +23,19 @@ class GameStateRepositoryInMemory(
     projectionBus: GameProjectionBus,
     eventBus: GameEventBus,
   ) {
-    // On new event was received, build snapshot and publish it to the projection bus
+    // On new event was received, build projection and publish it to the projection bus
     eventBus.subscribe { event ->
       withLoggingContext("event" to event.toString()) {
-        projectionsSnapshot
-          .applyAndPutToCache(event)
+        projectionsRepository
+          .applyAndSave(event)
           .also { projectionBus.publish(it) }
       }
     }
   }
 
   /**
-   * Get the last version of the [GameState] from the all eventStream.
-   *
-   * It fetches it from the local cache if possible, otherwise it builds it.
+   * Get the [GameState].
    */
-  override fun getLast(gameId: GameId): GameState =
-    projectionsSnapshot.getLast(gameId)
-
-  /**
-   * Get the [GameState] to the specific [event][GameEvent].
-   * It does not contain the [events][GameEvent] it after this one.
-   *
-   * It fetches it from the local cache if possible, otherwise it builds it.
-   */
-  override fun getUntil(event: GameEvent): GameState =
-    projectionsSnapshot.getUntil(event)
-
-  override fun count(gameId: GameId): Int =
-    projectionsSnapshot.count(gameId)
+  override fun get(gameId: GameId): GameState =
+    projectionsRepository.get(gameId)
 }

src/main/kotlin/eventDemo/adapter/infrastructureLayer/event/projection/GameStateRepositoryInRedis.kt

@@ -2,14 +2,11 @@ package eventDemo.adapter.infrastructureLayer.event.projection
 
 import eventDemo.business.entity.GameId
 import eventDemo.business.event.GameEventBus
-import eventDemo.business.event.GameEventStore
-import eventDemo.business.event.event.GameEvent
 import eventDemo.business.event.projection.GameProjectionBus
 import eventDemo.business.event.projection.GameState
 import eventDemo.business.event.projection.GameStateRepository
 import eventDemo.business.event.projection.apply
-import eventDemo.libs.event.projection.ProjectionSnapshotRepositoryInRedis
-import eventDemo.libs.event.projection.SnapshotConfig
+import eventDemo.libs.event.projection.ProjectionRepositoryInRedis
 import io.github.oshai.kotlinlogging.withLoggingContext
 import kotlinx.serialization.json.Json
 import redis.clients.jedis.UnifiedJedis
@@ -18,14 +15,10 @@ import redis.clients.jedis.UnifiedJedis
  * Manages [projections][GameState], their building and publication in the [bus][GameProjectionBus].
  */
 class GameStateRepositoryInRedis(
-  eventStore: GameEventStore,
   jedis: UnifiedJedis,
-  snapshotConfig: SnapshotConfig = SnapshotConfig(),
 ) : GameStateRepository {
-  private val projectionsSnapshot =
-    ProjectionSnapshotRepositoryInRedis(
-      eventStore = eventStore,
-      snapshotCacheConfig = snapshotConfig,
+  private val projectionsRepository =
+    ProjectionRepositoryInRedis(
       initialStateBuilder = { aggregateId: GameId -> GameState(aggregateId) },
       projectionClass = GameState::class,
       projectionToJson = { Json.encodeToString(GameState.serializer(), it) },
@@ -38,33 +31,19 @@ class GameStateRepositoryInRedis(
     projectionBus: GameProjectionBus,
     eventBus: GameEventBus,
   ) {
-    // On new event was received, build snapshot and publish it to the projection bus
+    // On new event was received, build projection and publish it to the projection bus
     eventBus.subscribe { event ->
       withLoggingContext("event" to event.toString()) {
-        projectionsSnapshot
-          .applyAndPutToCache(event)
+        projectionsRepository
+          .applyAndSave(event)
           .also { projectionBus.publish(it) }
       }
     }
   }
 
   /**
-   * Get the last version of the [GameState] from the all eventStream.
-   *
-   * It fetches it from the local cache if possible, otherwise it builds it.
+   * Get the [GameState].
    */
-  override fun getLast(gameId: GameId): GameState =
-    projectionsSnapshot.getLast(gameId)
-
-  /**
-   * Get the [GameState] to the specific [event][GameEvent].
-   * It does not contain the [events][GameEvent] it after this one.
-   *
-   * It fetches it from the local cache if possible, otherwise it builds it.
-   */
-  override fun getUntil(event: GameEvent): GameState =
-    projectionsSnapshot.getUntil(event)
-
-  override fun count(gameId: GameId): Int =
-    projectionsSnapshot.count(gameId)
+  override fun get(gameId: GameId): GameState =
+    projectionsRepository.get(gameId)
 }

src/main/kotlin/eventDemo/adapter/interfaceLayer/query/ReadTheGameState.kt

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

src/main/kotlin/eventDemo/business/command/GameCommandHandler.kt

@@ -86,12 +86,12 @@ class GameCommandHandler(
    * If the command fail, send an [error notification][CommandErrorNotification],
    * if success, send a [success notification][CommandSuccessNotification]
    */
-  suspend fun handle(
+  fun handle(
     player: Player,
     gameId: GameId,
     command: GameCommand,
-    sendSuccess: suspend () -> Unit,
-    sendError: suspend (message: String) -> Unit,
+    sendSuccess: () -> Unit,
+    sendError: (message: String) -> Unit,
   ) {
     if (command.payload.aggregateId.id != gameId.id) {
       logger.warn { "Handle command Refuse, the gameId of the command is not the same" }
@@ -114,26 +114,26 @@ class GameCommandHandler(
   }
 }
 
-private fun SendChannel<Notification>.sendSuccess(command: GameCommand): suspend () -> Unit =
+private fun SendChannel<Notification>.sendSuccess(command: GameCommand): () -> Unit =
   {
     val logger = KotlinLogging.logger { }
     CommandSuccessNotification(commandId = command.id)
       .also { notification ->
         withLoggingContext("notification" to notification.toString(), "commandId" to command.id.toString()) {
           logger.debug { "Notification SUCCESS sent" }
-          send(notification)
+          trySend(notification)
         }
       }
   }
 
-private fun SendChannel<Notification>.sendError(command: GameCommand): suspend (message: String) -> Unit =
+private fun SendChannel<Notification>.sendError(command: GameCommand): (message: String) -> Unit =
   {
     val logger = KotlinLogging.logger { }
     CommandErrorNotification(message = it, command = command)
       .also { notification ->
         withLoggingContext("notification" to notification.toString(), "command" to command.toString()) {
           logger.warn { "Notification ERROR sent: ${notification.message}" }
-          send(notification)
+          trySend(notification)
         }
       }
   }

src/main/kotlin/eventDemo/business/command/action/ICantPlay.kt

@@ -12,7 +12,7 @@ data class ICantPlay(
   private val gameStateRepository: GameStateRepository,
 ) : CommandAction<ICantPlayCommand, PlayerHavePassEvent> {
   override fun run(command: ICantPlayCommand): (version: Int) -> PlayerHavePassEvent {
-    val state = gameStateRepository.getLast(command.payload.aggregateId)
+    val state = gameStateRepository.get(command.payload.aggregateId)
 
     if (state.currentPlayerTurn != command.payload.player) {
       throw CommandException("Its not your turn!")

src/main/kotlin/eventDemo/business/command/action/IWantToJoinTheGame.kt

@@ -12,7 +12,7 @@ data class IWantToJoinTheGame(
   private val gameStateRepository: GameStateRepository,
 ) : CommandAction<IWantToJoinTheGameCommand, NewPlayerEvent> {
   override fun run(command: IWantToJoinTheGameCommand): (version: Int) -> NewPlayerEvent {
-    val state = gameStateRepository.getLast(command.payload.aggregateId)
+    val state = gameStateRepository.get(command.payload.aggregateId)
     if (!state.isStarted) {
       return {
         NewPlayerEvent(

src/main/kotlin/eventDemo/business/command/action/IWantToPlayCard.kt

@@ -12,7 +12,7 @@ data class IWantToPlayCard(
   private val gameStateRepository: GameStateRepository,
 ) : CommandAction<IWantToPlayCardCommand, CardIsPlayedEvent> {
   override fun run(command: IWantToPlayCardCommand): (version: Int) -> CardIsPlayedEvent {
-    val state = gameStateRepository.getLast(command.payload.aggregateId)
+    val state = gameStateRepository.get(command.payload.aggregateId)
 
     if (!state.isStarted) {
       throw CommandException("The game is Not started")

src/main/kotlin/eventDemo/business/command/action/IamReadyToPlay.kt

@@ -13,7 +13,7 @@ class IamReadyToPlay(
 ) : CommandAction<IamReadyToPlayCommand, PlayerReadyEvent> {
   @Throws(CommandException::class)
   override fun run(command: IamReadyToPlayCommand): (version: Int) -> PlayerReadyEvent {
-    val state = gameStateRepository.getLast(command.payload.aggregateId)
+    val state = gameStateRepository.get(command.payload.aggregateId)
     val playerExist: Boolean = state.players.contains(command.payload.player)
     val playerIsAlreadyReady: Boolean = state.readyPlayers.contains(command.payload.player)
 

src/main/kotlin/eventDemo/business/event/projection/gameState/GameStateRepository.kt

@@ -1,12 +1,7 @@
 package eventDemo.business.event.projection
 
 import eventDemo.business.entity.GameId
-import eventDemo.business.event.event.GameEvent
 
 interface GameStateRepository {
-  fun getLast(gameId: GameId): GameState
-
-  fun getUntil(event: GameEvent): GameState
-
-  fun count(gameId: GameId): Int
+  fun get(gameId: GameId): GameState
 }

src/main/kotlin/eventDemo/business/event/projection/projectionListener/ReactionListener.kt

@@ -37,7 +37,7 @@ class ReactionListener(
     }
   }
 
-  private suspend fun sendStartGameEvent(state: GameState) {
+  private fun sendStartGameEvent(state: GameState) {
     if (state.isReady && !state.isStarted) {
       val reactionEvent =
         eventHandler.handle(state.aggregateId) {
@@ -54,7 +54,7 @@ class ReactionListener(
     }
   }
 
-  private suspend fun sendWinnerEvent(state: GameState) {
+  private fun sendWinnerEvent(state: GameState) {
     val winner = state.playerHasNoCardLeft().firstOrNull()
     if (winner != null) {
       val reactionEvent =

src/main/kotlin/eventDemo/configuration/injection/ConfigureDIInfrastructure.kt

@@ -13,7 +13,6 @@ import eventDemo.business.event.GameEventStore
 import eventDemo.business.event.projection.GameListRepository
 import eventDemo.business.event.projection.GameProjectionBus
 import eventDemo.business.event.projection.GameStateRepository
-import eventDemo.libs.event.projection.SnapshotConfig
 import org.koin.core.module.Module
 import org.koin.core.module.dsl.singleOf
 import org.koin.core.scope.Scope
@@ -65,10 +64,10 @@ fun Module.configureDIInfrastructure(config: Configuration) {
   singleOf(::GameProjectionBusInRabbitMQ) bind GameProjectionBus::class
 
   single {
-    GameStateRepositoryInRedis(get(), get(), snapshotConfig = SnapshotConfig())
+    GameStateRepositoryInRedis(get())
   } bind GameStateRepository::class
 
   single {
-    GameListRepositoryInRedis(get(), get(), snapshotConfig = SnapshotConfig())
+    GameListRepositoryInRedis(get())
   } bind GameListRepository::class
 }

src/main/kotlin/eventDemo/libs/bus/Bus.kt

@@ -1,13 +1,22 @@
 package eventDemo.libs.bus
 
 interface Bus<T> {
-  suspend fun publish(item: T)
+  /**
+   * Publish a new [message][item] to the bus.
+   */
+  fun publish(item: T)
 
   /**
-   * @param priority The higher the priority, the more it will be called first
+   * Subscribe a [lambda][block] to the bus.
+   *
+   * When a message is sent to the bus, the [block] is executed.
    */
-  fun subscribe(block: suspend (T) -> Unit): Subscription
+  fun subscribe(block: (T) -> Unit): Subscription
 
+  /**
+   * The returns of the [subscribe] method.
+   * It can be called to [cancel][close] the subscription.
+   */
   interface Subscription : AutoCloseable {
     override fun close()
   }

src/main/kotlin/eventDemo/libs/bus/BusInMemory.kt

@@ -2,28 +2,25 @@ package eventDemo.libs.bus
 
 import io.github.oshai.kotlinlogging.KotlinLogging
 import io.github.oshai.kotlinlogging.withLoggingContext
-import kotlinx.coroutines.coroutineScope
 import kotlin.reflect.KClass
 
 class BusInMemory<E>(
   val name: KClass<*> = BusInMemory::class,
 ) : Bus<E> {
   private val logger = KotlinLogging.logger(name.qualifiedName.toString())
-  private val subscribers: MutableList<suspend (E) -> Unit> = mutableListOf()
+  private val subscribers: MutableList<(E) -> Unit> = mutableListOf()
 
-  override suspend fun publish(item: E) {
+  override fun publish(item: E) {
     withLoggingContext("busItem" to item.toString()) {
       logger.info { "Item sent to the bus" }
       subscribers
         .forEach {
-          coroutineScope {
-            it(item)
-          }
+          it(item)
         }
     }
   }
 
-  override fun subscribe(block: suspend (E) -> Unit): Bus.Subscription {
+  override fun subscribe(block: (E) -> Unit): Bus.Subscription {
     subscribers.add(block)
     return object : Bus.Subscription {
       override fun close() {

src/main/kotlin/eventDemo/libs/bus/BusInRabbitMQ.kt

@@ -42,21 +42,19 @@ class BusInRabbitMQ<E>(
       }
   }
 
-  override suspend fun publish(item: E) {
+  override fun publish(item: E) {
     connection
       .createChannel()
-      .use {
-        it.basicPublish(
-          exchangeName,
-          routingKey,
-          AMQP.BasicProperties(),
-          objectToString(item).toByteArray(),
-        )
-      }
+      .basicPublish(
+        exchangeName,
+        routingKey,
+        AMQP.BasicProperties(),
+        objectToString(item).toByteArray(),
+      )
     logger.info { "Item sent to the bus" }
   }
 
-  override fun subscribe(block: suspend (E) -> Unit): Bus.Subscription {
+  override fun subscribe(block: (E) -> Unit): Bus.Subscription {
     connection
       .createChannel()
       .also { channel ->

src/main/kotlin/eventDemo/libs/command/CommandHandler.kt

@@ -44,7 +44,7 @@ class CommandHandler<B : Bus<E>, E : Event<ID>, ID : AggregateId, C : Command>(
    *
    * It restricts to run only once the [command].
    */
-  suspend fun handle(
+  fun handle(
     aggregateId: ID,
     command: C,
     callback: CommandCallback<C>,
@@ -99,10 +99,10 @@ private class EventCommandMap<C : Command, E : Event<*>>(
     val event: E,
     val date: Instant,
   ) {
-    suspend operator fun invoke(error: CommandException? = null) {
+    operator fun invoke(error: CommandException? = null) {
       callback(command, error)
     }
   }
 }
 
-typealias CommandCallback<C> = suspend (command: C, error: CommandException?) -> Unit
+typealias CommandCallback<C> = (command: C, error: CommandException?) -> Unit

src/main/kotlin/eventDemo/libs/command/CommandRunnerController.kt

@@ -14,7 +14,7 @@ class CommandRunnerController<C : Command>(
 ) {
   private val executedCommand: ConcurrentHashMap<CommandId, Pair<Boolean, Instant>> = ConcurrentHashMap()
 
-  suspend fun runOnlyOnce(
+  fun runOnlyOnce(
     command: C,
     action: CommandBlock<C>,
   ) {

src/main/kotlin/eventDemo/libs/command/CommandStreamChannel.kt

@@ -34,7 +34,7 @@ class CommandStreamChannel<C : Command>(
     }
   }
 
-  private suspend fun runAndLogStatus(
+  private fun runAndLogStatus(
     command: C,
     action: CommandBlock<C>,
   ) {
@@ -47,4 +47,4 @@ class CommandStreamChannel<C : Command>(
   }
 }
 
-typealias CommandBlock<C> = suspend (C) -> Unit
+typealias CommandBlock<C> = (C) -> Unit

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

@@ -4,7 +4,7 @@ package eventDemo.libs.event
  * A stream to publish and read the played card event.
  */
 interface EventHandler<E : Event<ID>, ID : AggregateId> {
-  suspend fun handle(
+  fun handle(
     aggregateId: ID,
     buildEvent: (version: Int) -> E,
   ): E

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

@@ -19,7 +19,7 @@ class EventHandlerImpl<E : Event<ID>, ID : AggregateId>(
   /**
    * Build Event then send it to the event store and bus.
    */
-  override suspend fun handle(
+  override fun handle(
     aggregateId: ID,
     buildEvent: (version: Int) -> E,
   ): E =
@@ -34,13 +34,9 @@ class EventHandlerImpl<E : Event<ID>, ID : AggregateId>(
             .also {
               withLoggingContext("event" to it.toString()) {
                 eventStore.publish(it)
+                eventBus.publish(it)
               }
             }
-        }.also { event ->
-          withLoggingContext("event" to event.toString()) {
-            // Publish to the bus
-            eventBus.publish(event)
-          }
         }
     }
 }

src/main/kotlin/eventDemo/libs/event/projection/ProjectionRepository.kt

@@ -0,0 +1,34 @@
+package eventDemo.libs.event.projection
+
+import eventDemo.libs.event.AggregateId
+import eventDemo.libs.event.Event
+
+interface ProjectionRepository<E : Event<ID>, P : Projection<ID>, ID : AggregateId> {
+  /**
+   * Update projection with the event.
+   */
+  fun apply(event: E): P
+
+  /**
+   * Update projection with the event, and save it.
+   */
+  fun applyAndSave(event: E): P
+
+  /**
+   * Save the projection.
+   */
+  fun save(projection: P)
+
+  /**
+   * Build the list of all [Projections][Projection]
+   */
+  fun getList(
+    limit: Int = 100,
+    offset: Int = 0,
+  ): List<P>
+
+  /**
+   * Build the last version of the [Projection] from the cache.
+   */
+  fun get(aggregateId: ID): P
+}

src/main/kotlin/eventDemo/libs/event/projection/ProjectionRepositoryAbs.kt

@@ -0,0 +1,63 @@
+package eventDemo.libs.event.projection
+
+import eventDemo.libs.event.AggregateId
+import eventDemo.libs.event.Event
+import io.github.oshai.kotlinlogging.KotlinLogging
+import io.github.oshai.kotlinlogging.withLoggingContext
+
+/**
+ * Repository abstraction to declare common process
+ */
+abstract class ProjectionRepositoryAbs<E : Event<ID>, P : Projection<ID>, ID : AggregateId>(
+  private val applyToProjection: P.(event: E) -> P,
+) : ProjectionRepository<E, P, ID> {
+  private val logger = KotlinLogging.logger {}
+
+  /**
+   * Update projection with the event.
+   *
+   * 1. get the last projection
+   * 2. apply the new event to the projection
+   */
+  override fun apply(event: E): P =
+    get(event.aggregateId).applyToProjectionSecure(event)
+
+  /**
+   * Update projection with the event, and save it.
+   *
+   * 1. get the last projection
+   * 2. apply the new event to projection
+   * 3. save it
+   */
+  override fun applyAndSave(event: E): P =
+    apply(event)
+      .also {
+        withLoggingContext("projection" to it.toString(), "event" to event.toString()) {
+          save(it)
+        }
+      }
+
+  /**
+   * Wrap the [applyToProjection] lambda to avoid duplicate apply of the same event.
+   */
+  protected val applyToProjectionSecure: P.(event: E) -> P = { event ->
+    withLoggingContext("event" to event.toString(), "projection" to this.toString()) {
+      if (canBeApply(event)) {
+        applyToProjection(event)
+      } else if (event.version <= lastEventVersion) {
+        "Event is already in the Projection, skip apply.".let {
+          logger.warn { it }
+          error(it)
+        }
+      } else {
+        "The version of the event must follow directly after the version of the projection.".let {
+          logger.error { it }
+          error(it)
+        }
+      }
+    }
+  }
+
+  private fun P.canBeApply(event: E): Boolean =
+    event.version == lastEventVersion + 1
+}

src/main/kotlin/eventDemo/libs/event/projection/ProjectionRepositoryInMemory.kt

@@ -0,0 +1,46 @@
+package eventDemo.libs.event.projection
+
+import eventDemo.libs.event.AggregateId
+import eventDemo.libs.event.Event
+import java.util.concurrent.ConcurrentHashMap
+
+class ProjectionRepositoryInMemory<E : Event<ID>, P : Projection<ID>, ID : AggregateId>(
+  private val initialStateBuilder: (aggregateId: ID) -> P,
+  applyToProjection: P.(event: E) -> P,
+) : ProjectionRepositoryAbs<E, P, ID>(applyToProjection),
+  ProjectionRepository<E, P, ID> {
+  private val projections: ConcurrentHashMap<ID, P> = ConcurrentHashMap()
+
+  /**
+   * Build the list of all [Projections][Projection]
+   */
+  override fun getList(
+    limit: Int,
+    offset: Int,
+  ): List<P> =
+    projections
+      .values
+      .drop(offset)
+      .take(limit)
+
+  /**
+   * Get the [Projection].
+   */
+  override fun get(aggregateId: ID): P =
+    projections[aggregateId]
+      ?: initialStateBuilder(aggregateId)
+
+  /**
+   * Save the projection.
+   */
+  override fun save(projection: P) {
+    projections.compute(projection.aggregateId) { id: ID, proj: P? ->
+      val currentProjection = proj ?: initialStateBuilder(projection.aggregateId)
+      if (currentProjection.lastEventVersion < projection.lastEventVersion) {
+        projection
+      } else {
+        currentProjection
+      }
+    }
+  }
+}

src/main/kotlin/eventDemo/libs/event/projection/ProjectionRepositoryInRedis.kt

@@ -0,0 +1,80 @@
+package eventDemo.libs.event.projection
+
+import eventDemo.libs.event.AggregateId
+import eventDemo.libs.event.Event
+import io.github.oshai.kotlinlogging.KotlinLogging
+import redis.clients.jedis.UnifiedJedis
+import redis.clients.jedis.params.ScanParams
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+import kotlin.reflect.KClass
+
+class ProjectionRepositoryInRedis<E : Event<ID>, P : Projection<ID>, ID : AggregateId>(
+  private val jedis: UnifiedJedis,
+  private val initialStateBuilder: (aggregateId: ID) -> P,
+  private val projectionClass: KClass<P>,
+  private val projectionToJson: (P) -> String,
+  private val jsonToProjection: (String) -> P,
+  applyToProjection: P.(event: E) -> P,
+) : ProjectionRepositoryAbs<E, P, ID>(applyToProjection),
+  ProjectionRepository<E, P, ID> {
+  val logger = KotlinLogging.logger { }
+  private val lock = ReentrantLock()
+
+  /**
+   * Get the list of all [Projections][Projection]
+   */
+  override fun getList(
+    limit: Int,
+    offset: Int,
+  ): List<P> =
+    jedis
+      .hscan(
+        projectionClass.redisHKey,
+        offset.toString(),
+        ScanParams()
+          .match("*")
+          .count(limit),
+      ).result
+      .mapNotNull {
+        jsonToProjection(it.value)
+      }
+
+  /**
+   * Get the [Projection].
+   */
+  override fun get(aggregateId: ID): P =
+    jedis
+      .hget(
+        projectionClass.redisHKey,
+        aggregateId.id.toString(),
+      ).let {
+        if (it == null || it == "nil") {
+          initialStateBuilder(aggregateId)
+        } else {
+          jsonToProjection(it)
+        }
+      }
+
+  override fun save(projection: P) {
+    lock.withLock {
+      if (get(projection.aggregateId).lastEventVersion < projection.lastEventVersion) {
+        jedis.hset(
+          projection.redisHKey,
+          projection.aggregateId.id.toString(),
+          projectionToJson(projection),
+        )
+        logger.info { "Projection saved" }
+      } else {
+        logger.error { "Projection save SKIP (an early version exists)" }
+        error("Projection save SKIP (an early version exists)")
+      }
+    }
+  }
+}
+
+private val <P : Projection<*>> KClass<P>.redisHKey: String get() =
+  "projection:$simpleName"
+
+private val <P : Projection<*>> P.redisHKey: String get() =
+  this::class.redisHKey

src/main/kotlin/eventDemo/libs/event/projection/ProjectionSnapshotRepository.kt

@@ -1,35 +0,0 @@
-package eventDemo.libs.event.projection
-
-import eventDemo.libs.event.AggregateId
-import eventDemo.libs.event.Event
-
-interface ProjectionSnapshotRepository<E : Event<ID>, P : Projection<ID>, ID : AggregateId> {
-  /**
-   * Create a snapshot for the event
-   */
-  suspend fun applyAndPutToCache(event: E): P
-
-  fun count(aggregateId: ID): Int
-
-  fun countAll(): Int
-
-  /**
-   * Build the list of all [Projections][Projection]
-   */
-  fun getList(
-    limit: Int = 100,
-    offset: Int = 0,
-  ): List<P>
-
-  /**
-   * Build the last version of the [Projection] from the cache.
-   */
-  fun getLast(aggregateId: ID): P
-
-  /**
-   * Build the [Projection] to the specific [event][Event].
-   *
-   * It does not contain the [events][Event] it after this one.
-   */
-  fun getUntil(event: E): P
-}

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

@@ -1,226 +0,0 @@
-package eventDemo.libs.event.projection
-
-import eventDemo.libs.event.AggregateId
-import eventDemo.libs.event.Event
-import eventDemo.libs.event.EventStore
-import eventDemo.libs.event.EventStream
-import io.github.oshai.kotlinlogging.KotlinLogging
-import io.github.oshai.kotlinlogging.withLoggingContext
-import kotlinx.datetime.Clock
-import kotlinx.datetime.Instant
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.ConcurrentLinkedQueue
-import kotlin.reflect.KClass
-
-class ProjectionSnapshotRepositoryInMemory<E : Event<ID>, P : Projection<ID>, ID : AggregateId>(
-  val name: KClass<*> = ProjectionSnapshotRepositoryInMemory::class,
-  private val eventStore: EventStore<E, ID>,
-  private val initialStateBuilder: (aggregateId: ID) -> P,
-  private val snapshotCacheConfig: SnapshotConfig = SnapshotConfig(),
-  private val applyToProjection: P.(event: E) -> P,
-) : ProjectionSnapshotRepository<E, P, ID> {
-  private val projectionsSnapshot: ConcurrentHashMap<ID, ConcurrentLinkedQueue<Pair<P, Instant>>> = ConcurrentHashMap()
-  private val logger = KotlinLogging.logger(name.qualifiedName.toString())
-
-  /**
-   * Create a snapshot for the event
-   *
-   * 1. get the last snapshot with a version lower than that of the event
-   * 2. get the events with a greater version of the snapshot
-   * 3. apply the event to the snapshot
-   * 4. apply the new event to the projection
-   * 5. save it
-   * 6. remove old one
-   */
-  override suspend fun applyAndPutToCache(event: E): P =
-    getUntil(event)
-      .also {
-        withLoggingContext("projection" to it.toString()) {
-          save(it)
-          removeOldSnapshot(it.aggregateId)
-        }
-      }
-
-  override fun count(aggregateId: ID): Int =
-    projectionsSnapshot[aggregateId]?.count() ?: 0
-
-  override fun countAll(): Int =
-    projectionsSnapshot.mappingCount().toInt()
-
-  /**
-   * Build the list of all [Projections][Projection]
-   */
-  override fun getList(
-    limit: Int,
-    offset: Int,
-  ): List<P> =
-    projectionsSnapshot
-      .map { (id, b) ->
-        getLast(id)
-      }.drop(offset)
-      .take(limit)
-
-  /**
-   * Build the last version of the [Projection] from the cache.
-   *
-   * 1. get the last snapshot
-   * 2. get the missing event to the snapshot
-   * 3. apply the missing events to the snapshot
-   */
-  override fun getLast(aggregateId: ID): P {
-    val lastSnapshot = getLastSnapshot(aggregateId)?.first
-    val missingEventOfSnapshot = getEventAfterTheSnapshot(aggregateId, lastSnapshot)
-    return lastSnapshot.applyEvents(aggregateId, missingEventOfSnapshot)
-  }
-
-  /**
-   * Build the [Projection] to the specific [event][Event].
-   *
-   * It does not contain the [events][Event] it after this one.
-   *
-   * 1. get the last snapshot before the event
-   * 2. get the events with a greater version of the snapshot but lower of passed event
-   * 3. apply the events to the snapshot
-   */
-  override fun getUntil(event: E): P {
-    val lastSnapshot = getLastSnapshotBeforeOrEqualEvent(event)?.first
-    if (lastSnapshot?.lastEventVersion == event.version) {
-      return lastSnapshot
-    }
-
-    val missingEventOfSnapshot =
-      eventStore
-        .getStream(event.aggregateId)
-        // take the last snapshot version +1 to event version
-        .readVersionBetween(lastSnapshot, event)
-
-    return if (lastSnapshot?.lastEventVersion == event.version) {
-      lastSnapshot
-    } else {
-      lastSnapshot.applyEvents(event.aggregateId, missingEventOfSnapshot)
-    }
-  }
-
-  /**
-   * Remove the oldest [snapshot][P] of the [queue][projectionsSnapshot].
-   *
-   * The rules are pass in the controller.
-   */
-  private fun removeOldSnapshot(aggregateId: ID) {
-    projectionsSnapshot[aggregateId]?.let { queue ->
-      if (snapshotCacheConfig.enabled) {
-        queue
-          .excludeFirstAndLast()
-          .excludeTheHeadBySize()
-          .excludeNewerByDate()
-          .excludeByModulo()
-          .forEach { queue.remove(it) }
-      }
-    }
-  }
-
-  /**
-   * Return a new list without the first and last snapshot.
-   *
-   * Exclude from deletion the first and the last.
-   */
-  private fun FilteredList<P>.excludeFirstAndLast(): FilteredList<P> =
-    sortedBy { it.first.lastEventVersion }
-      .drop(1)
-      .dropLast(1)
-
-  /**
-   * Return a new list of event filtered by the version modulo.
-   *
-   * Exclude from deletion 1 element out of 10 (if modulo 10 in [config][snapshotCacheConfig]).
-   */
-  private fun FilteredList<P>.excludeByModulo(): FilteredList<P> =
-    filter { (it.first.lastEventVersion % snapshotCacheConfig.modulo) != 1 }
-
-  /**
-   * Return a new list of event filtered by the maximum size.
-   *
-   * Exclude from removal all [snapshot][projectionsSnapshot] that in the head of the queue.
-   */
-  private fun FilteredList<P>.excludeTheHeadBySize(): FilteredList<P> {
-    // filter if size exceeds the limit
-    return sortedBy { it.first.lastEventVersion }
-      .dropLast(snapshotCacheConfig.maxSnapshotCacheSize)
-  }
-
-  /**
-   * Return a new list of event filtered by the maximum date.
-   *
-   * Exclude from removal all [snapshot][projectionsSnapshot] that newer of the date (in [config][SnapshotConfig]).
-   */
-  private fun FilteredList<P>.excludeNewerByDate(): FilteredList<P> {
-    val now = Clock.System.now()
-    val deadLine = now - snapshotCacheConfig.maxSnapshotCacheTtl
-    return filter { deadLine < it.second }
-  }
-
-  /**
-   * Save the snapshot.
-   */
-  private fun save(projection: P) {
-    projectionsSnapshot
-      .computeIfAbsent(projection.aggregateId) { ConcurrentLinkedQueue() }
-      .add(Pair(projection, Clock.System.now()))
-      .also { logger.info { "Projection saved" } }
-  }
-
-  /**
-   * Get the last snapshot when the version is lower of then event version
-   */
-  private fun getLastSnapshotBeforeOrEqualEvent(event: E) =
-    projectionsSnapshot[event.aggregateId]
-      ?.sortedByDescending { it.first.lastEventVersion }
-      ?.find { it.first.lastEventVersion <= event.version }
-
-  /**
-   * Get the last snapshot (with the higher version).
-   */
-  private fun getLastSnapshot(aggregateId: ID) =
-    projectionsSnapshot[aggregateId]
-      ?.maxByOrNull { it.first.lastEventVersion }
-
-  /**
-   * Get the events from the [event stream][EventStream] when the version is higher of the snapshot.
-   *
-   * If the snapshot is null, it takes all events from the event [event stream][EventStream]
-   */
-  private fun getEventAfterTheSnapshot(
-    aggregateId: ID,
-    snapshot: P?,
-  ) =
-    eventStore
-      .getStream(aggregateId)
-      .readGreaterOfVersion(snapshot?.lastEventVersion ?: 0)
-
-  /**
-   * Apply events to the projection.
-   */
-  private fun P?.applyEvents(
-    aggregateId: ID,
-    eventsToApply: Set<E>,
-  ): P =
-    eventsToApply.fold(this ?: initialStateBuilder(aggregateId), applyToProjectionSecure)
-
-  /**
-   * Wrap the [applyToProjection] lambda to avoid duplicate apply of the same event.
-   */
-  private val applyToProjectionSecure: P.(event: E) -> P = { event ->
-    withLoggingContext("event" to event.toString(), "projection" to this.toString()) {
-      if (event.version == lastEventVersion + 1) {
-        applyToProjection(event)
-      } else if (event.version <= lastEventVersion) {
-        KotlinLogging.logger { }.warn { "Event is already in the Projection, skip apply." }
-        this
-      } else {
-        error("The version of the event must follow directly after the version of the projection.")
-      }
-    }
-  }
-}
-
-private typealias FilteredList<P> = Collection<Pair<P, Instant>>

src/main/kotlin/eventDemo/libs/event/projection/ProjectionSnapshotRepositoryInRedis.kt

@@ -1,240 +0,0 @@
-package eventDemo.libs.event.projection
-
-import eventDemo.libs.event.AggregateId
-import eventDemo.libs.event.Event
-import eventDemo.libs.event.EventStore
-import eventDemo.libs.toRanges
-import io.github.oshai.kotlinlogging.KotlinLogging
-import io.github.oshai.kotlinlogging.withLoggingContext
-import redis.clients.jedis.UnifiedJedis
-import redis.clients.jedis.params.ScanParams
-import redis.clients.jedis.params.SortingParams
-import kotlin.reflect.KClass
-
-class ProjectionSnapshotRepositoryInRedis<E : Event<ID>, P : Projection<ID>, ID : AggregateId>(
-  private val eventStore: EventStore<E, ID>,
-  private val jedis: UnifiedJedis,
-  private val initialStateBuilder: (aggregateId: ID) -> P,
-  private val snapshotCacheConfig: SnapshotConfig = SnapshotConfig(),
-  private val projectionClass: KClass<P>,
-  private val projectionToJson: (P) -> String,
-  private val jsonToProjection: (String) -> P,
-  private val applyToProjection: P.(event: E) -> P,
-) : ProjectionSnapshotRepository<E, P, ID> {
-  val logger = KotlinLogging.logger { }
-
-  /**
-   * Create a snapshot for the event
-   *
-   * 1. get the last snapshot with a version lower than that of the event
-   * 2. get the events with a greater version of the snapshot
-   * 3. apply the event to the snapshot
-   * 4. apply the new event to the projection
-   * 5. save it
-   * 6. remove old one
-   */
-  override suspend fun applyAndPutToCache(event: E): P =
-    getUntil(event)
-      .also {
-        withLoggingContext(mapOf("projection" to it.toString(), "event" to event.toString())) {
-          save(it)
-          removeOldSnapshot(it.aggregateId, event.version)
-        }
-      }
-
-  override fun count(aggregateId: ID): Int =
-    jedis.zcount(projectionClass.redisKey(aggregateId), Double.MIN_VALUE, Double.MAX_VALUE).toInt()
-
-  override fun countAll(): Int =
-    jedis.zcount(projectionClass.redisKey, Double.MIN_VALUE, Double.MAX_VALUE).toInt()
-
-  /**
-   * Get the list of all [Projections][Projection]
-   */
-  override fun getList(
-    limit: Int,
-    offset: Int,
-  ): List<P> =
-    jedis
-      .scan(
-        offset.toString(),
-        ScanParams()
-          .match(projectionClass.redisKeySearchList)
-          .count(limit),
-      ).result
-      .mapNotNull { key ->
-        getLastByKey(key)
-          ?.let(jsonToProjection)
-      }
-
-  /**
-   * Get the last version of the [Projection] from the cache.
-   *
-   * 1. get the last snapshot
-   * 2. get the missing event to the snapshot
-   * 3. apply the missing events to the snapshot
-   */
-  override fun getLast(aggregateId: ID): P =
-    getLastByKey(projectionClass.redisKey(aggregateId))
-      ?.let(jsonToProjection)
-      ?: initialStateBuilder(aggregateId)
-
-  private fun getLastByKey(key: String): String? =
-    jedis
-      .sort(
-        key,
-        SortingParams()
-          .desc()
-          .by("score")
-          .limit(0, 1),
-      ).firstOrNull()
-
-  /**
-   * Build the [Projection] to the specific [event][Event].
-   *
-   * It does not contain the [events][Event] it after this one.
-   *
-   * 1. get the last snapshot before the event
-   * 2. get the events with a greater version of the snapshot but lower of passed event
-   * 3. apply the events to the snapshot
-   */
-  override fun getUntil(event: E): P {
-    val lastSnapshot =
-      jedis
-        .zrangeByScore(
-          projectionClass.redisKey(event.aggregateId),
-          1.0,
-          event.version.toDouble(),
-          0,
-          1,
-        ).firstOrNull()
-        ?.let(jsonToProjection)
-    if (lastSnapshot?.lastEventVersion == event.version) {
-      return lastSnapshot
-    }
-    if (lastSnapshot != null && lastSnapshot.lastEventVersion > event.version) {
-      logger.error { "Cannot be apply event on more recent snapshot" }
-      error("Cannot be apply event on more recent snapshot")
-    }
-
-    val missingEventOfSnapshot =
-      eventStore
-        .getStream(event.aggregateId)
-        // take the last snapshot version +1 to event version
-        .readVersionBetween(lastSnapshot, event)
-
-    return if (lastSnapshot?.lastEventVersion == event.version) {
-      lastSnapshot
-    } else {
-      lastSnapshot.applyEvents(event.aggregateId, missingEventOfSnapshot)
-    }
-  }
-
-  private fun save(projection: P) {
-    val added = jedis.zadd(projection.redisKey, projection.lastEventVersion.toDouble(), projectionToJson(projection))
-    if (added < 1) {
-      logger.error { "Projection NOT saved (already exists)" }
-    } else {
-      logger.info { "Projection saved" }
-      if (snapshotCacheConfig.maxSnapshotCacheTtl.isFinite()) {
-        jedis.expire(projection.redisKey, snapshotCacheConfig.maxSnapshotCacheTtl.inWholeSeconds)
-      }
-    }
-  }
-
-  /**
-   * Apply events to the projection.
-   */
-  private fun P?.applyEvents(
-    aggregateId: ID,
-    eventsToApply: Set<E>,
-  ): P =
-    eventsToApply.fold(this ?: initialStateBuilder(aggregateId), applyToProjectionSecure)
-
-  /**
-   * Wrap the [applyToProjection] lambda to avoid duplicate apply of the same event.
-   */
-  private val applyToProjectionSecure: P.(event: E) -> P = { event ->
-    withLoggingContext("event" to event.toString(), "projection" to this.toString()) {
-      if (event.version == lastEventVersion + 1) {
-        applyToProjection(event)
-      } else if (event.version <= lastEventVersion) {
-        KotlinLogging.logger { }.warn { "Event is already in the Projection, skip apply." }
-        this
-      } else {
-        error("The version of the event must follow directly after the version of the projection.")
-      }
-    }
-  }
-
-  fun removeOldSnapshot(
-    aggregateId: AggregateId,
-    lastVersion: Int,
-  ) {
-    if (snapshotCacheConfig.enabled) {
-      removeByModulo(aggregateId, lastVersion)
-      removeTheHeadBySize(aggregateId, lastVersion)
-    }
-  }
-
-  private fun removeByModulo(
-    aggregateId: AggregateId,
-    lastVersion: Int,
-  ) {
-    (lastVersion - (snapshotCacheConfig.maxSnapshotCacheSize * snapshotCacheConfig.modulo))
-      .let { if (it < 2) 2 else it }
-      .let { IntRange(it, lastVersion - 1) }
-      .filter { (it % snapshotCacheConfig.modulo) != 1 }
-      .toRanges()
-      .map {
-        jedis
-          .zremrangeByScore(
-            projectionClass.redisKey(aggregateId),
-            it.first.toDouble(),
-            it.last.toDouble(),
-          ).also { removedCount ->
-            if (removedCount > 0) {
-              logger.debug {
-                "$removedCount snapshot removed Modulo(${snapshotCacheConfig.modulo}) (${it.first} to ${it.last}) [lastVersion=$lastVersion]"
-              }
-            }
-          }
-      }
-  }
-
-  private fun removeTheHeadBySize(
-    aggregateId: AggregateId,
-    lastVersion: Int,
-  ) {
-    (lastVersion - (snapshotCacheConfig.maxSnapshotCacheSize * snapshotCacheConfig.modulo))
-      .toDouble()
-      .let {
-        jedis
-          .zremrangeByScore(
-            projectionClass.redisKey(aggregateId),
-            2.0,
-            it,
-          ).also { removedCount ->
-            if (removedCount > 0) {
-              logger.info {
-                "$removedCount snapshot removed Size(${snapshotCacheConfig.maxSnapshotCacheSize}) (1.0 to $it) [lastVersion=$lastVersion]"
-              }
-            }
-          }
-      }
-  }
-}
-
-val <P : Projection<*>> KClass<P>.redisKeySearchList: String get() {
-  return "projection:$simpleName:*"
-}
-
-val <P : Projection<*>> P.redisKey: String get() {
-  return "projection:${this::class.simpleName}:${aggregateId.id}"
-}
-
-fun <P : Projection<*>, A : AggregateId> KClass<P>.redisKey(aggregateId: A): String =
-  "projection:$simpleName:${aggregateId.id}"
-
-val <P : Projection<*>> KClass<P>.redisKey: String get() =
-  "projection:$simpleName"

src/main/kotlin/eventDemo/libs/event/projection/SnapshotConfig.kt

@@ -1,26 +0,0 @@
-package eventDemo.libs.event.projection
-
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.minutes
-
-data class SnapshotConfig(
-  /**
-   * Keep snapshot when is on the head of the queue cache
-   */
-  val maxSnapshotCacheSize: Int = 20,
-  /**
-   * Keep snapshot when is newer of
-   *
-   *     snapshot.date > now + maxSnapshotCacheTtl
-   */
-  val maxSnapshotCacheTtl: Duration = 10.minutes,
-  /**
-   * Keep snapshot when version is this modulo
-   *
-   *     snapshot.lastVersion % modulo == 1
-   */
-  val modulo: Int = 10,
-  val enabled: Boolean = true,
-)
-
-val DISABLED_CONFIG = SnapshotConfig(Int.MAX_VALUE, Duration.INFINITE, Int.MAX_VALUE, enabled = false)