feat: separate global and local store times

We need to be able to control store local time using `TimeService` so that we can run multiple `Store`s per thread/process each with different pace/time.

Local time will initialize global time so if we are running code for production with only 1 store, local and global times will match.

Author: binier

src/action/action_meta.rs

@@ -7,7 +7,7 @@ use super::{ActionId, ActionWithMeta};
 pub type RecursionDepth = u32;
 
 /// Action with additional metadata like: id.
-#[derive(Debug, Clone)]
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ActionMeta {
     id: ActionId,
@@ -26,6 +26,14 @@ impl ActionMeta {
         Self { id, depth }
     }
 
+    #[inline(always)]
+    pub fn zero_custom(time: Timestamp) -> Self {
+        Self {
+            id: ActionId::new_unchecked(time.into()),
+            depth: 0,
+        }
+    }
+
     #[inline(always)]
     pub fn id(&self) -> ActionId {
         self.id

src/lib.rs

@@ -16,7 +16,7 @@ mod service;
 pub use service::{Service, TimeService};
 
 mod store;
-pub use store::{Store, monotonic_to_time};
+pub use store::{monotonic_to_time, Store};
 
 mod sub_store;
 pub use sub_store::SubStore;

src/service.rs

@@ -1,11 +1,10 @@
-use crate::{Instant, store::monotonic_time};
+use crate::Instant;
 
 pub trait Service: TimeService {}
 
 /// Time service.
 pub trait TimeService {
-    /// NOTE this should be deprecated as monotonic time now is inherited from Rust library.
     fn monotonic_time(&mut self) -> Instant {
-        monotonic_time()
+        Instant::now()
     }
 }

src/store.rs

@@ -41,17 +41,9 @@ impl<T: Clone> Clone for StateWrapper<T> {
 /// Monotonic and system time reference points.
 static INITIAL_TIME: OnceLock<(Instant, SystemTime)> = OnceLock::new();
 
-/// Monotonic timer current value
-pub(crate) fn monotonic_time() -> Instant {
-    Instant::now()
-}
-
-
 /// Converts monotonic time to nanoseconds since Unix epoch.
 pub fn monotonic_to_time(time: Instant) -> u64 {
-    let (monotonic, system) = INITIAL_TIME.get_or_init(|| {
-        (monotonic_time(), SystemTime::now())
-    });
+    let (monotonic, system) = INITIAL_TIME.get_or_init(|| (Instant::now(), SystemTime::now()));
     let time_passed = time.duration_since(*monotonic);
     system
         .duration_since(SystemTime::UNIX_EPOCH)
@@ -93,16 +85,18 @@ where
     pub fn new(
         reducer: Reducer<State, Action>,
         effects: Effects<State, Service, Action>,
-        service: Service,
+        mut service: Service,
         initial_time: SystemTime,
         initial_state: State,
     ) -> Self {
-        let initial_monotonic_time = monotonic_time();
+        let initial_monotonic_time = service.monotonic_time();
         let initial_time_nanos = initial_time
             .duration_since(SystemTime::UNIX_EPOCH)
             .map(|x| x.as_nanos())
             .unwrap_or(0);
 
+        INITIAL_TIME.get_or_init(move || (initial_monotonic_time, initial_time));
+
         Self {
             reducer,
             effects,
@@ -175,7 +169,7 @@ where
 
     /// Dispatches action without checking the enabling condition.
     fn dispatch_enabled(&mut self, action: Action) {
-        let monotonic_time = monotonic_time();
+        let monotonic_time = self.service.monotonic_time();
         let time_passed = monotonic_time
             .duration_since(self.monotonic_time)
             .as_nanos();

src/timestamp.rs

@@ -4,7 +4,7 @@ pub use std::time::{Instant, SystemTime};
 #[cfg(target_arch = "wasm32")]
 pub use wasm_timer::{Instant, SystemTime};
 
-use crate::{monotonic_to_time, store::monotonic_time};
+use crate::monotonic_to_time;
 
 /// Time in nanoseconds from [std::time::UNIX_EPOCH].
 ///
@@ -33,8 +33,8 @@ impl Timestamp {
     }
 
     #[inline(always)]
-    pub fn now() -> Self {
-        Timestamp::new(monotonic_to_time(monotonic_time()))
+    pub fn global_now() -> Self {
+        Timestamp::new(monotonic_to_time(Instant::now()))
     }
 
     pub fn checked_sub(self, rhs: Timestamp) -> Option<Duration> {