+13

crates/tandem-core/src/model.rs

reviewed

··· 1 1 + //! Data model for Tandem 2 2 + 3 3 + use serde::{Deserialize, Serialize}; 4 4 + use uuid::Uuid; 5 5 + use chrono::{DateTime, Utc}; 6 6 + 7 7 + #[derive(Debug, Clone, Serialize, Deserialize)] 8 8 + pub struct Repository { 9 9 + pub id: Uuid, 10 10 + pub name: String, 11 11 + pub created_at: DateTime<Utc>, 12 12 + pub updated_at: DateTime<Utc>, 13 13 + }

+255

crates/tandem-core/src/types.rs

reviewed

··· 1 1 + //! Core types for Tandem 2 2 + 3 3 + use chrono::{DateTime, Utc}; 4 4 + use serde::{Deserialize, Serialize}; 5 5 + use std::fmt; 6 6 + use std::str::FromStr; 7 7 + use uuid::Uuid; 8 8 + 9 9 + /// Stable identifier for a change, persists across rebases 10 10 + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] 11 11 + pub struct ChangeId(pub [u8; 32]); 12 12 + 13 13 + impl ChangeId { 14 14 + /// Create a new random ChangeId 15 15 + pub fn new() -> Self { 16 16 + let mut bytes = [0u8; 32]; 17 17 + rand::Rng::fill(&mut rand::thread_rng(), &mut bytes); 18 18 + ChangeId(bytes) 19 19 + } 20 20 + } 21 21 + 22 22 + impl Default for ChangeId { 23 23 + fn default() -> Self { 24 24 + Self::new() 25 25 + } 26 26 + } 27 27 + 28 28 + impl fmt::Display for ChangeId { 29 29 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 30 30 + write!(f, "{}", hex::encode(self.0)) 31 31 + } 32 32 + } 33 33 + 34 34 + impl FromStr for ChangeId { 35 35 + type Err = String; 36 36 + 37 37 + fn from_str(s: &str) -> Result<Self, Self::Err> { 38 38 + let bytes = hex::decode(s).map_err(|e| format!("Invalid hex: {}", e))?; 39 39 + if bytes.len() != 32 { 40 40 + return Err(format!("Expected 32 bytes, got {}", bytes.len())); 41 41 + } 42 42 + let mut arr = [0u8; 32]; 43 43 + arr.copy_from_slice(&bytes); 44 44 + Ok(ChangeId(arr)) 45 45 + } 46 46 + } 47 47 + 48 48 + /// Content-addressed tree hash 49 49 + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] 50 50 + pub struct TreeHash(pub [u8; 20]); 51 51 + 52 52 + impl TreeHash { 53 53 + /// Create TreeHash from hex string (for compatibility with object_store) 54 54 + pub fn new(hash: String) -> Self { 55 55 + assert_eq!(hash.len(), 40, "TreeHash must be 40 characters"); 56 56 + TreeHash::from_str(&hash).expect("Invalid hex string") 57 57 + } 58 58 + 59 59 + /// Get hex string representation (for compatibility with object_store) 60 60 + pub fn as_str(&self) -> String { 61 61 + self.to_string() 62 62 + } 63 63 + } 64 64 + 65 65 + impl fmt::Display for TreeHash { 66 66 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 67 67 + write!(f, "{}", hex::encode(self.0)) 68 68 + } 69 69 + } 70 70 + 71 71 + impl FromStr for TreeHash { 72 72 + type Err = String; 73 73 + 74 74 + fn from_str(s: &str) -> Result<Self, Self::Err> { 75 75 + let bytes = hex::decode(s).map_err(|e| format!("Invalid hex: {}", e))?; 76 76 + if bytes.len() != 20 { 77 77 + return Err(format!("Expected 20 bytes, got {}", bytes.len())); 78 78 + } 79 79 + let mut arr = [0u8; 20]; 80 80 + arr.copy_from_slice(&bytes); 81 81 + Ok(TreeHash(arr)) 82 82 + } 83 83 + } 84 84 + 85 85 + /// Content-addressed blob hash 86 86 + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] 87 87 + pub struct BlobHash(pub [u8; 20]); 88 88 + 89 89 + impl BlobHash { 90 90 + /// Create BlobHash from hex string (for compatibility with object_store) 91 91 + pub fn new(hash: String) -> Self { 92 92 + assert_eq!(hash.len(), 40, "BlobHash must be 40 characters"); 93 93 + BlobHash::from_str(&hash).expect("Invalid hex string") 94 94 + } 95 95 + 96 96 + /// Get hex string representation (for compatibility with object_store) 97 97 + pub fn as_str(&self) -> String { 98 98 + self.to_string() 99 99 + } 100 100 + } 101 101 + 102 102 + impl fmt::Display for BlobHash { 103 103 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 104 104 + write!(f, "{}", hex::encode(self.0)) 105 105 + } 106 106 + } 107 107 + 108 108 + impl FromStr for BlobHash { 109 109 + type Err = String; 110 110 + 111 111 + fn from_str(s: &str) -> Result<Self, Self::Err> { 112 112 + let bytes = hex::decode(s).map_err(|e| format!("Invalid hex: {}", e))?; 113 113 + if bytes.len() != 20 { 114 114 + return Err(format!("Expected 20 bytes, got {}", bytes.len())); 115 115 + } 116 116 + let mut arr = [0u8; 20]; 117 117 + arr.copy_from_slice(&bytes); 118 118 + Ok(BlobHash(arr)) 119 119 + } 120 120 + } 121 121 + 122 122 + /// User identity 123 123 + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] 124 124 + pub struct Identity { 125 125 + pub email: String, 126 126 + pub name: Option<String>, 127 127 + } 128 128 + 129 129 + /// The fundamental unit - identity persists across rebases 130 130 + #[derive(Debug, Clone, Serialize, Deserialize)] 131 131 + pub struct Change { 132 132 + pub id: ChangeId, 133 133 + pub tree: TreeHash, 134 134 + pub parents: Vec<ChangeId>, 135 135 + pub description: String, 136 136 + pub author: Identity, 137 137 + pub timestamp: DateTime<Utc>, 138 138 + } 139 139 + 140 140 + /// Record stored in Y.Doc - append-only with unique keys 141 141 + #[derive(Debug, Clone, Serialize, Deserialize)] 142 142 + pub struct ChangeRecord { 143 143 + pub record_id: Uuid, 144 144 + pub change_id: ChangeId, 145 145 + pub tree: TreeHash, 146 146 + pub parents: Vec<ChangeId>, 147 147 + pub description: String, 148 148 + pub author: Identity, 149 149 + pub timestamp: DateTime<Utc>, 150 150 + pub visible: bool, // false = abandoned/hidden 151 151 + } 152 152 + 153 153 + impl ChangeRecord { 154 154 + /// Create a ChangeRecord from a Change 155 155 + pub fn from_change(change: &Change) -> Self { 156 156 + ChangeRecord { 157 157 + record_id: Uuid::new_v4(), 158 158 + change_id: change.id, 159 159 + tree: change.tree, 160 160 + parents: change.parents.clone(), 161 161 + description: change.description.clone(), 162 162 + author: change.author.clone(), 163 163 + timestamp: change.timestamp, 164 164 + visible: true, 165 165 + } 166 166 + } 167 167 + } 168 168 + 169 169 + /// Rules for bookmark protection 170 170 + #[derive(Debug, Clone, Default, Serialize, Deserialize)] 171 171 + pub struct BookmarkRules { 172 172 + pub require_ci: bool, 173 173 + pub require_review: bool, 174 174 + } 175 175 + 176 176 + /// Named pointer to a change 177 177 + #[derive(Debug, Clone, Serialize, Deserialize)] 178 178 + pub struct Bookmark { 179 179 + pub name: String, 180 180 + pub target: ChangeId, 181 181 + pub protected: bool, 182 182 + pub rules: BookmarkRules, 183 183 + } 184 184 + 185 185 + /// Presence information for a user 186 186 + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] 187 187 + pub struct PresenceInfo { 188 188 + pub user_id: String, 189 189 + pub change_id: ChangeId, 190 190 + pub device: String, 191 191 + pub timestamp: DateTime<Utc>, 192 192 + } 193 193 + 194 194 + #[cfg(test)] 195 195 + mod tests { 196 196 + use super::*; 197 197 + 198 198 + #[test] 199 199 + fn test_change_id_new() { 200 200 + let id1 = ChangeId::new(); 201 201 + let id2 = ChangeId::new(); 202 202 + assert_ne!(id1, id2); 203 203 + } 204 204 + 205 205 + #[test] 206 206 + fn test_change_id_display_parse() { 207 207 + let id = ChangeId::new(); 208 208 + let hex_str = id.to_string(); 209 209 + assert_eq!(hex_str.len(), 64); // 32 bytes * 2 chars per byte 210 210 + let parsed = ChangeId::from_str(&hex_str).unwrap(); 211 211 + assert_eq!(id, parsed); 212 212 + } 213 213 + 214 214 + #[test] 215 215 + fn test_tree_hash_display_parse() { 216 216 + let hash = TreeHash([1u8; 20]); 217 217 + let hex_str = hash.to_string(); 218 218 + assert_eq!(hex_str.len(), 40); // 20 bytes * 2 chars per byte 219 219 + let parsed = TreeHash::from_str(&hex_str).unwrap(); 220 220 + assert_eq!(hash, parsed); 221 221 + } 222 222 + 223 223 + #[test] 224 224 + fn test_blob_hash_display_parse() { 225 225 + let hash = BlobHash([2u8; 20]); 226 226 + let hex_str = hash.to_string(); 227 227 + assert_eq!(hex_str.len(), 40); // 20 bytes * 2 chars per byte 228 228 + let parsed = BlobHash::from_str(&hex_str).unwrap(); 229 229 + assert_eq!(hash, parsed); 230 230 + } 231 231 + 232 232 + #[test] 233 233 + fn test_change_record_from_change() { 234 234 + let change = Change { 235 235 + id: ChangeId::new(), 236 236 + tree: TreeHash([0u8; 20]), 237 237 + parents: vec![], 238 238 + description: "Test change".to_string(), 239 239 + author: Identity { 240 240 + email: "test@example.com".to_string(), 241 241 + name: Some("Test User".to_string()), 242 242 + }, 243 243 + timestamp: Utc::now(), 244 244 + }; 245 245 + 246 246 + let record = ChangeRecord::from_change(&change); 247 247 + assert_eq!(record.change_id, change.id); 248 248 + assert_eq!(record.tree, change.tree); 249 249 + assert_eq!(record.parents, change.parents); 250 250 + assert_eq!(record.description, change.description); 251 251 + assert_eq!(record.author, change.author); 252 252 + assert_eq!(record.timestamp, change.timestamp); 253 253 + assert_eq!(record.visible, true); 254 254 + } 255 255 + }