leptos-sync-core 0.9.0

Core synchronization library for Leptos applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Last-Write-Wins Register implementation

use super::{replica_id::ReplicaId, traits::{CRDT, Mergeable}};
use serde::{Deserialize, Serialize};

/// Last-Write-Wins Register
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct LwwRegister<T> {
    value: T,
    timestamp: chrono::DateTime<chrono::Utc>,
    replica_id: ReplicaId,
}

impl<T: Default> Default for LwwRegister<T> {
    fn default() -> Self {
        Self {
            value: T::default(),
            timestamp: chrono::Utc::now(),
            replica_id: ReplicaId::default(),
        }
    }
}

impl<T> LwwRegister<T> {
    pub fn new(value: T, replica_id: ReplicaId) -> Self {
        Self {
            value,
            timestamp: chrono::Utc::now(),
            replica_id,
        }
    }

    pub fn value(&self) -> &T {
        &self.value
    }

    pub fn timestamp(&self) -> chrono::DateTime<chrono::Utc> {
        self.timestamp
    }

    pub fn replica_id(&self) -> ReplicaId {
        self.replica_id
    }

    pub fn update(&mut self, value: T, replica_id: ReplicaId) {
        self.value = value;
        self.timestamp = chrono::Utc::now();
        self.replica_id = replica_id;
    }

    pub fn with_timestamp(mut self, timestamp: chrono::DateTime<chrono::Utc>) -> Self {
        self.timestamp = timestamp;
        self
    }
}

impl<T: Clone + PartialEq + Send + Sync> Mergeable for LwwRegister<T> {
    type Error = std::io::Error;
    
    fn merge(&mut self, other: &Self) -> Result<(), Self::Error> {
        if other.timestamp > self.timestamp || 
           (other.timestamp == self.timestamp && other.replica_id.0 > self.replica_id.0) {
            self.value = other.value.clone();
            self.timestamp = other.timestamp;
            self.replica_id = other.replica_id;
        }
        Ok(())
    }
    
    fn has_conflict(&self, other: &Self) -> bool {
        self.timestamp == other.timestamp && self.replica_id != other.replica_id
    }
}

impl<T> CRDT for LwwRegister<T> {
    fn replica_id(&self) -> &ReplicaId {
        &self.replica_id
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_lww_register_creation() {
        let replica_id = ReplicaId::default();
        let register = LwwRegister::new("test_value", replica_id);
        
        assert_eq!(register.value(), &"test_value");
        assert_eq!(register.replica_id(), replica_id);
    }

    #[test]
    fn test_lww_register_update() {
        let replica_id = ReplicaId::default();
        let mut register = LwwRegister::new("old_value", replica_id);
        
        register.update("new_value", replica_id);
        assert_eq!(register.value(), &"new_value");
    }

    #[test]
    fn test_lww_register_merge() {
        let mut reg1 = LwwRegister::new("value1", ReplicaId::default());
        let reg2 = LwwRegister::new("value2", ReplicaId::default());
        
        // Wait a bit to ensure different timestamps
        std::thread::sleep(std::time::Duration::from_millis(1));
        
        reg1.merge(&reg2).unwrap();
        assert_eq!(reg1.value(), &"value2");
    }

    #[test]
    fn test_lww_register_conflict_detection() {
        let replica_id1 = ReplicaId::default();
        let replica_id2 = ReplicaId::default();
        
        // Create registers with same timestamp but different replica IDs
        let timestamp = chrono::Utc::now();
        let reg1 = LwwRegister::new("value1", replica_id1).with_timestamp(timestamp);
        let reg2 = LwwRegister::new("value2", replica_id2).with_timestamp(timestamp);
        
        assert!(reg1.has_conflict(&reg2));
    }

    #[test]
    fn test_lww_register_serialization() {
        let replica_id = ReplicaId::default();
        let register = LwwRegister::new("test", replica_id);
        
        let serialized = serde_json::to_string(&register).unwrap();
        let deserialized: LwwRegister<String> = serde_json::from_str(&serialized).unwrap();
        
        assert_eq!(register.value(), deserialized.value());
        assert_eq!(register.replica_id(), deserialized.replica_id());
    }
}