SHRIKE-54: expose notion of persistent snapshot in backward-compatible way (#321)

Done as backward-compatible alternative to
#318

The PR should be merged after
#319 to avoid
breaking changes & major version bump.

---------

Co-authored-by: Denys Fakhritdinov <dfakhritdinov@evolution.com>

Author: dfakhritdinov

persistence/src/main/scala/com/evolutiongaming/akkaeffect/persistence/EventSourcedActorOf.scala

@@ -116,7 +116,8 @@ object EventSourcedActorOf {
 
           _          <- log.debug(s"recovery completed with seqNr $seqNr")
           journaller <- eventStore.asJournaller(actorCtx, seqNr).toResource
-          receive    <- recovering.completed(seqNr, journaller, snapshotStore.asSnapshotter)
+          context     = Recovering.RecoveryContext(seqNr, journaller, snapshotStore.asSnapshotter)
+          receive    <- recovering.completed(context)
         } yield receive
 
         receive.onError {
@@ -125,7 +126,7 @@ object EventSourcedActorOf {
       }
   }
 
-  implicit final private class SnapshotOps[S](val snapshot: SnapshotStore.Offer[S]) extends AnyVal {
+  implicit final private[evolutiongaming] class SnapshotOps[S](val snapshot: SnapshotStore.Offer[S]) extends AnyVal {
 
     def asOffer: SnapshotOffer[S] =
       SnapshotOffer(
@@ -135,7 +136,8 @@ object EventSourcedActorOf {
 
   }
 
-  implicit final private class SnapshotStoreOps[F[_], A](val store: SnapshotStore[F, A]) extends AnyVal {
+  implicit final private[evolutiongaming] class SnapshotStoreOps[F[_], A](val store: SnapshotStore[F, A])
+      extends AnyVal {
 
     def asSnapshotter: Snapshotter[F, A] = new Snapshotter[F, A] {
 
@@ -154,7 +156,7 @@ object EventSourcedActorOf {
     }
   }
 
-  implicit final private class EventStoreOps[F[_], E](val store: EventStore[F, E]) extends AnyVal {
+  implicit final private[evolutiongaming] class EventStoreOps[F[_], E](val store: EventStore[F, E]) extends AnyVal {
 
     def asJournaller(actorCtx: ActorCtx[F], seqNr: SeqNr)(implicit F: Concurrent[F], log: Log[F]): F[Journaller[F, E]] =
       for {

persistence/src/main/scala/com/evolutiongaming/akkaeffect/persistence/Persistence.scala

@@ -58,7 +58,8 @@ private[akkaeffect] object Persistence {
       ) = {
         val receive = for {
           recovering <- recoveryStarted(seqNr, none)
-          receive    <- recovering.completed(seqNr, journaller, snapshotter)
+          context     = Recovering.RecoveryContext(seqNr, journaller, snapshotter)
+          receive    <- recovering.completed(context)
         } yield Persistence.receive[F, S, E, C](receive)
         receive.toReleasable
       }
@@ -113,8 +114,9 @@ private[akkaeffect] object Persistence {
           .foldMapM(_.release)
           .toResource
           .productR {
+            val context = Recovering.RecoveryContext(seqNr, journaller, snapshotter)
             recovering
-              .completed(seqNr, journaller, snapshotter)
+              .completed(context)
               .map(receive => Persistence.receive[F, S, E, C](receive))
           }
           .toReleasable

persistence/src/main/scala/com/evolutiongaming/akkaeffect/persistence/Recovering.scala

@@ -5,6 +5,8 @@ import cats.effect.Resource
 import cats.implicits.catsSyntaxApplicativeId
 import com.evolutiongaming.akkaeffect.{Envelope, Receive}
 
+import scala.annotation.nowarn
+
 /** Describes "Recovery" phase
   *
   * @tparam S
@@ -25,15 +27,54 @@ trait Recovering[F[_], S, E, +A] {
     * @see
     *   [[akka.persistence.RecoveryCompleted]]
     */
+  @deprecated("Use completed with RecoveryContext", "4.1.5")
   def completed(
     seqNr: SeqNr,
     journaller: Journaller[F, E],
     snapshotter: Snapshotter[F, S],
   ): Resource[F, A]
+
+  /** Called when recovery completed, resource will be released upon actor termination
+    *
+    * @see
+    *   [[akka.persistence.RecoveryCompleted]]
+    */
+  def completed(context: Recovering.RecoveryContext[F, S, E]): Resource[F, A] = {
+    @nowarn("msg=deprecated")
+    val a = completed(context.seqNr, context.journaller, context.snapshotter)
+    a
+  }
+
 }
 
 object Recovering {
 
+  /** Context containing information about recovery and provides access to journaller and snapshotter
+    */
+  trait RecoveryContext[F[_], -S, -E] {
+    def seqNr: SeqNr
+    def journaller: Journaller[F, E]
+    def snapshotter: Snapshotter[F, S]
+    def recoveredFromPersistence: Boolean
+  }
+  object RecoveryContext {
+
+    private case class Impl[F[_], S, E](
+      seqNr: SeqNr,
+      journaller: Journaller[F, E],
+      snapshotter: Snapshotter[F, S],
+      recoveredFromPersistence: Boolean,
+    ) extends RecoveryContext[F, S, E]
+
+    def apply[F[_], S, E](
+      seqNr: SeqNr,
+      journaller: Journaller[F, E],
+      snapshotter: Snapshotter[F, S],
+      recoveredFromPersistence: Boolean = true,
+    ): RecoveryContext[F, S, E] = Impl(seqNr, journaller, snapshotter, recoveredFromPersistence)
+
+  }
+
   def apply[S]: Apply[S] = new Apply[S]
 
   final private[Recovering] class Apply[S](private val b: Boolean = true) extends AnyVal {
@@ -91,9 +132,8 @@ object Recovering {
       ) = {
         val journaller1  = journaller.convert(ef)
         val snapshotter1 = snapshotter.convert(sf)
-        self
-          .completed(seqNr, journaller1, snapshotter1)
-          .flatMap(af)
+        val context1     = RecoveryContext(seqNr, journaller1, snapshotter1)
+        self.completed(context1).flatMap(af)
       }
     }
 
@@ -105,10 +145,10 @@ object Recovering {
         seqNr: SeqNr,
         journaller: Journaller[F, E],
         snapshotter: Snapshotter[F, S],
-      ) =
-        self
-          .completed(seqNr, journaller, snapshotter)
-          .map(f)
+      ) = {
+        val context = RecoveryContext(seqNr, journaller, snapshotter)
+        self.completed(context).map(f)
+      }
     }
 
     def mapM[A1](
@@ -121,10 +161,10 @@ object Recovering {
         seqNr: SeqNr,
         journaller: Journaller[F, E],
         snapshotter: Snapshotter[F, S],
-      ) =
-        self
-          .completed(seqNr, journaller, snapshotter)
-          .flatMap(f)
+      ) = {
+        val context = RecoveryContext(seqNr, journaller, snapshotter)
+        self.completed(context).flatMap(f)
+      }
     }
   }
 
@@ -143,10 +183,10 @@ object Recovering {
           seqNr: SeqNr,
           journaller: Journaller[F, E1],
           snapshotter: Snapshotter[F, S1],
-        ) =
-          self
-            .completed(seqNr, journaller, snapshotter)
-            .map(_.convert(cf, _.pure[F]))
+        ) = {
+          val context = RecoveryContext(seqNr, journaller, snapshotter)
+          self.completed(context).map(_.convert(cf, _.pure[F]))
+        }
       }
 
     def typeless(ef: Any => F[E], cf: Any => F[C])(implicit

persistence/src/test/scala/com/evolutiongaming/akkaeffect/persistence/InstrumentEventSourced.scala

@@ -111,7 +111,8 @@ object InstrumentEventSourced {
             }
 
             for {
-              receive <- recovering.completed(seqNr, journaller1, snapshotter1)
+              context <- Recovering.RecoveryContext(seqNr, journaller1, snapshotter1).pure[Resource[F, *]]
+              receive <- recovering.completed(context)
               _       <- resource(Action.ReceiveAllocated(seqNr), Action.ReceiveReleased)
             } yield Receive[Envelope[C]] { envelope =>
               for {

version.sbt

@@ -1 +1 @@
-ThisBuild / version := "4.1.5-SNAPSHOT"
+ThisBuild / version := "4.1.5"