update README

Author: fupelaqu

README.md

@@ -79,7 +79,7 @@ trait EntityBehavior[C <: Command, S <: State, E <: Event, R <: CommandResult]
   /** @return
     *   number of events before saving a snapshot of the current actor entity state. If multiple
     *   events are persisted with a single Effect the snapshot will happen after all of the events
-    *   are persisted rather than precisely every `numberOfEvents`
+    *   are persisted rather than precisely every `snapshotInterval`
     */
   def snapshotInterval: Int = 10
 
@@ -89,9 +89,8 @@ trait EntityBehavior[C <: Command, S <: State, E <: Event, R <: CommandResult]
   def numberOfSnapshots: Int = 2
 
   /** @return
-    *   the key used to define the Entity Type Key of this actor that uniquely identifies the type
-    *   of entity in this cluster and is then used to retrieve an EntityRef for a given entity
-    *   identifier
+    *   the key used to define the Entity Type Key of this entity actor that uniquely identifies the type
+    *   of entity in the cluster
     */
   def persistenceId: String
 
@@ -112,7 +111,7 @@ trait EntityBehavior[C <: Command, S <: State, E <: Event, R <: CommandResult]
     *   - actor system
     * @param maybeRole
     *   - an optional node role required to start this entity
-    * @param c
+    * @param c - runtime class of C
     * -
     * @return
     */

core/src/main/scala/app/softnetwork/persistence/typed/EntityBehavior.scala

@@ -5,10 +5,16 @@ hide empty members
 package app.softnetwork.persistence.message {
     abstract CommandResult << (T,orchid) trait >>
     abstract Command << (T,orchid) trait >>
+    abstract EntityCommand << (T,orchid) trait >> extends Command{
+        +def id: String
+    }
+    note right of EntityCommand::id
+        the entity identifier
+    end note
     abstract CommandWithReply <R: CommandResult> <<(T,orchid) trait >>{
       +replyTo: ActorRef[R]
     }
-    note right: a command which includes \na reference to the actor identity \nto whom a response has to be sent
+    note right of CommandWithReply: a command which includes \na reference to the actor identity \nto whom a response has to be sent
     Command <|-- CommandWithReply
 
     abstract CommandWrapper <C: Command, R: CommandResult> <<(T,orchid) trait >> extends CommandWithReply {

docs/diagrams/out/Command.svg

@@ -5,16 +5,16 @@ skinparam BoxPadding 10
 skinparam sequenceMessageAlign center
 skinparam monochrome true
 
-participant Consumer as c
+participant Sender as s
 control "Entity Pattern" as ep
 participant "Cluster Sharding" as cs
 entity "Entity Behavior" as eb
 database Journal as j
 
-c -> ep++: ? (**entityId**: String, **cmd**: Command)
+s -> ep++: ? (**entityId**: String, **cmd**: Command)
 ep -> ep : ref(**entityId**)
-ep -> cs++: entityRefFor(**entityId**)
-return recipient
+ep -> cs++: entityRefFor(entityTypeKey, **entityId**)
+return entity reference
 ep -> eb++: ? **cmd**
 
 opt recovering from latest saved snapshot

docs/diagrams/out/EntityBehavior.svg

@@ -10,31 +10,41 @@ package app.softnetwork {
             +<<recursive>>retry(n: Int)(fn: => Future[T]): Future[T]
         }
     }
-    package persistence.typed.scaladsl {
-        abstract Patterns <C: Command, R: CommandResult> <<(T,orchid) trait>>{
-            <<type>> Recipient
-            <<implicit>> command2Request(command: C): ActorRef[R] => C
-            timeout: Timeout
-            -recipientRef(recipient: Recipient): akka.actor.typed.RecipientRef[C]
-            +?(recipient: Recipient, command: C): Future[R] = recipientRef(recipient) ? command
-            +!(recipient: Recipient, command: C): Unit = recipientRef(recipient) ! command
-            <<implicit>> key2Recipient[T](key: T): Recipient
-            #lookup[T](key: T): Future[Option[Recipient]]
-            +??[T](key: T, command: C): Future[R]
-            +?![T](key: T, command: C): Unit
-            +*?[T](keys: List[T], command: C): Future[List[R]]
-            +*![T](keys: List[T], command: C): Unit
+    package persistence.typed {
+        abstract class CommandTypeKey <C: Command> <<(T,orchid) trait >> {
+            +def TypeKey(implicit c: ClassTag[C]): EntityTypeKey[C]
         }
-        Retryable <|-- Patterns: <<bind>> <R -> T>
-        abstract EntityPattern <C: Command, R: CommandResult> <<(T,orchid) trait>> extends Patterns{
-            <<type>> Recipient = String
+        note left of CommandTypeKey::TypeKey
+            A key that uniquely identifies
+            the type of entity in the cluster
+        end note
+        package scaladsl {
+            abstract Patterns <C: Command, R: CommandResult> <<(T,orchid) trait>>{
+                <<type>> Recipient
+                <<implicit>> command2Request(command: C): ActorRef[R] => C
+                timeout: Timeout
+                -recipientRef(recipient: Recipient): akka.actor.typed.RecipientRef[C]
+                +?(recipient: Recipient, command: C): Future[R] = recipientRef(recipient) ? command
+                +!(recipient: Recipient, command: C): Unit = recipientRef(recipient) ! command
+                <<implicit>> key2Recipient[T](key: T): Recipient
+                #lookup[T](key: T): Future[Option[Recipient]]
+                +??[T](key: T, command: C): Future[R]
+                +?![T](key: T, command: C): Unit
+                +*?[T](keys: List[T], command: C): Future[List[R]]
+                +*![T](keys: List[T], command: C): Unit
+            }
+            Retryable <|-- Patterns: <<bind>> <R -> T>
+            abstract EntityPattern <C: Command, R: CommandResult> <<(T,orchid) trait>> extends Patterns{
+                <<type>> Recipient = String
+            }
+            CommandTypeKey <|.. EntityPattern : <<self>>
+            abstract SingletonPattern <C: Command, R: CommandResult> <<(T,orchid) trait>> extends Patterns
+            class RecipientPattern {
+              entityId: String
+              ref(): EntityRef[C]
+            }
+            EntityPattern +-- RecipientPattern: <<implicit>>
         }
-        abstract SingletonPattern <C: Command, R: CommandResult> <<(T,orchid) trait>> extends Patterns
-        class RecipientPattern {
-          entityId: String
-          ref(): EntityRef[C]
-        }
-        EntityPattern +-- RecipientPattern: <<implicit>>
     }
 }
 @enduml