...

heromodels/src/models/core/comment.rs

@@ -0,0 +1,57 @@
+use serde::{Deserialize, Serialize};
+use crate::models::core::model::{Model, BaseModelData, IndexKey};
+
+/// Represents a comment on a model
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Comment {
+    pub base_data: BaseModelData,
+    pub user_id: u32,
+    pub content: String,
+}
+
+impl Comment {
+    /// Create a new comment
+    pub fn new(id: u32) -> Self {
+        Self {
+            base_data: BaseModelData::new(id),
+            user_id: 0,
+            content: String::new(),
+        }
+    }
+
+    /// Set the user ID
+    pub fn user_id(mut self, id: u32) -> Self {
+        self.user_id = id;
+        self
+    }
+        
+    /// Set the content
+    pub fn content(mut self, content: impl ToString) -> Self {
+        self.content = content.to_string();
+        self
+    }
+}
+
+// Implement the Model trait for Comment
+impl Model for Comment {
+    fn db_prefix() -> &'static str {
+        "comment"
+    }
+    
+    fn get_id(&self) -> u32 {
+        self.base_data.id
+    }
+    
+    fn base_data_mut(&mut self) -> &mut BaseModelData {
+        &mut self.base_data
+    }
+    
+    fn db_keys(&self) -> Vec<IndexKey> {
+        vec![
+            IndexKey {
+                name: "user_id",
+                value: self.user_id.to_string(),
+            },
+        ]
+    }
+}

heromodels/src/models/core/mod.rs

@@ -0,0 +1,7 @@
+// Export submodules
+pub mod model;
+pub mod comment;
+
+// Re-export key types for convenience
+pub use model::{Model, BaseModelData, IndexKey, IndexKeyBuilder};
+pub use comment::Comment;

heromodels/src/models/core/model.rs

@@ -0,0 +1,201 @@
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+
+/// Represents an index key for a model
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IndexKey {
+    /// The name of the index key
+    pub name: &'static str,
+    
+    /// The value of the index key for a specific model instance
+    pub value: String,
+}
+
+/// Builder for IndexKey
+pub struct IndexKeyBuilder {
+    name: &'static str,
+    value: String,
+}
+
+impl IndexKeyBuilder {
+    /// Create a new IndexKeyBuilder
+    pub fn new(name: &'static str) -> Self {
+        Self {
+            name,
+            value: String::new(),
+        }
+    }
+    
+    /// Set the value for this index key
+    pub fn value(mut self, value: impl ToString) -> Self {
+        self.value = value.to_string();
+        self
+    }
+    
+    /// Build the IndexKey
+    pub fn build(self) -> IndexKey {
+        IndexKey {
+            name: self.name,
+            value: self.value,
+        }
+    }
+}
+
+/// Unified trait for all models
+pub trait Model: Debug + Clone + Serialize + for<'de> Deserialize<'de> + Send + Sync + 'static {
+    /// Get the database prefix for this model type
+    fn db_prefix() -> &'static str where Self: Sized;
+    
+    /// Returns a list of index keys for this model instance
+    /// These keys will be used to create additional indexes in the TST
+    /// The default implementation returns an empty vector
+    /// Override this method to provide custom indexes
+    fn db_keys(&self) -> Vec<IndexKey> {
+        Vec::new()
+    }
+    
+    /// Get the unique ID for this model
+    fn get_id(&self) -> u32;
+    
+    /// Get a mutable reference to the base_data field
+    fn base_data_mut(&mut self) -> &mut BaseModelData;
+    
+    /// Set the ID for this model
+    fn id(mut self, id: u32) -> Self where Self: Sized {
+        self.base_data_mut().id = id;
+        self
+    }
+    
+    /// Build the model, updating the modified timestamp
+    fn build(mut self) -> Self where Self: Sized {
+        self.base_data_mut().update_modified();
+        self
+    }
+}
+
+/// Base struct that all models should include
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BaseModelData {
+    /// Unique incremental ID per circle
+    pub id: u32,
+    
+    /// Unix epoch timestamp for creation time
+    pub created_at: i64,
+    
+    /// Unix epoch timestamp for last modification time
+    pub modified_at: i64,
+    
+    /// List of comment IDs referencing Comment objects
+    pub comments: Vec<u32>,
+}
+
+impl BaseModelData {
+    /// Create a new BaseModelData instance
+    pub fn new(id: u32) -> Self {
+        let now = chrono::Utc::now().timestamp();
+        Self {
+            id,
+            created_at: now,
+            modified_at: now,
+            comments: Vec::new(),
+        }
+    }
+    
+    /// Create a new BaseModelDataBuilder
+    pub fn builder(id: u32) -> BaseModelDataBuilder {
+        BaseModelDataBuilder::new(id)
+    }
+    
+    /// Add a comment to this model
+    pub fn add_comment(&mut self, comment_id: u32) {
+        self.comments.push(comment_id);
+        self.modified_at = chrono::Utc::now().timestamp();
+    }
+    
+    /// Remove a comment from this model
+    pub fn remove_comment(&mut self, comment_id: u32) {
+        self.comments.retain(|&id| id != comment_id);
+        self.update_modified();
+    }
+    
+    /// Update the modified timestamp
+    pub fn update_modified(&mut self) {
+        self.modified_at = chrono::Utc::now().timestamp();
+    }
+}
+
+/// Builder for BaseModelData
+pub struct BaseModelDataBuilder {
+    id: u32,
+    created_at: Option<i64>,
+    modified_at: Option<i64>,
+    comments: Vec<u32>,
+}
+
+impl BaseModelDataBuilder {
+    /// Create a new BaseModelDataBuilder
+    pub fn new(id: u32) -> Self {
+        Self {
+            id,
+            created_at: None,
+            modified_at: None,
+            comments: Vec::new(),
+        }
+    }
+    
+    /// Set the created_at timestamp
+    pub fn created_at(mut self, timestamp: i64) -> Self {
+        self.created_at = Some(timestamp);
+        self
+    }
+    
+    /// Set the modified_at timestamp
+    pub fn modified_at(mut self, timestamp: i64) -> Self {
+        self.modified_at = Some(timestamp);
+        self
+    }
+    
+    /// Add a comment ID
+    pub fn add_comment(mut self, comment_id: u32) -> Self {
+        self.comments.push(comment_id);
+        self
+    }
+    
+    /// Add multiple comment IDs
+    pub fn add_comments(mut self, comment_ids: Vec<u32>) -> Self {
+        self.comments.extend(comment_ids);
+        self
+    }
+    
+    /// Build the BaseModelData
+    pub fn build(self) -> BaseModelData {
+        let now = chrono::Utc::now().timestamp();
+        BaseModelData {
+            id: self.id,
+            created_at: self.created_at.unwrap_or(now),
+            modified_at: self.modified_at.unwrap_or(now),
+            comments: self.comments,
+        }
+    }
+}
+
+/// Macro to implement Model for a struct that contains a base_data field of type BaseModelData
+#[macro_export]
+macro_rules! impl_model {
+    // Basic implementation with default db_keys
+    ($type:ty, $prefix:expr) => {
+        impl $crate::core::model::Model for $type {
+            fn db_prefix() -> &'static str {
+                $prefix
+            }
+            
+            fn get_id(&self) -> u32 {
+                self.base_data.id
+            }
+            
+            fn base_data_mut(&mut self) -> &mut $crate::core::model::BaseModelData {
+                &mut self.base_data
+            }
+        }
+    };
+}

heromodels/src/models/lib.rs

@@ -0,0 +1,11 @@
+// Export core module
+pub mod core;
+
+// Export userexample module
+pub mod userexample;
+
+// Re-export key types for convenience
+pub use core::*;
+pub use core::model::{Model, BaseModelData, IndexKey};
+pub use core::Comment;
+pub use userexample::User;

heromodels/src/models/mod.rs

@@ -0,0 +1,8 @@
+// Export submodules
+pub mod core;
+pub mod userexample;
+
+// Re-export key types for convenience
+pub use core::model::{Model, BaseModelData, IndexKey};
+pub use core::Comment;
+pub use userexample::User;

heromodels/src/models/userexample/mod.rs

@@ -0,0 +1,5 @@
+// Export user module
+pub mod user;
+
+// Re-export User for convenience
+pub use user::User;

heromodels/src/models/userexample/user.rs

@@ -0,0 +1,111 @@
+use serde::{Deserialize, Serialize};
+use crate::models::core::model::{Model, BaseModelData, IndexKey};
+
+/// Represents a user in the system
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct User {
+    /// Base model data
+    pub base_data: BaseModelData,
+    
+    /// User's username
+    pub username: String,
+    
+    /// User's email address
+    pub email: String,
+    
+    /// User's full name
+    pub full_name: String,
+    
+    /// Whether the user is active
+    pub is_active: bool,
+}
+
+impl User {
+    /// Create a new user
+    pub fn new(id: u32) -> Self {
+        Self {
+            base_data: BaseModelData::new(id),
+            username: String::new(),
+            email: String::new(),
+            full_name: String::new(),
+            is_active: true,
+        }
+    }
+    
+    /// Set the username
+    pub fn username(mut self, username: impl ToString) -> Self {
+        self.username = username.to_string();
+        
+        self
+    }
+    
+    /// Set the email
+    pub fn email(mut self, email: impl ToString) -> Self {
+        self.email = email.to_string();
+        
+        self
+    }
+    
+    /// Set the full name
+    pub fn full_name(mut self, full_name: impl ToString) -> Self {
+        self.full_name = full_name.to_string();
+        
+        self
+    }
+    
+    /// Set whether the user is active
+    pub fn is_active(mut self, is_active: bool) -> Self {
+        self.is_active = is_active;
+        
+        self
+    }
+    
+    /// Add a comment ID
+    pub fn add_comment(mut self, comment_id: u32) -> Self {
+        self.base_data.add_comment(comment_id);
+        self
+    }
+
+    /// Deactivate the user
+    pub fn deactivate(&mut self) {
+        self.is_active = false;
+    }
+    
+    /// Activate the user
+    pub fn activate(&mut self) {
+        self.is_active = true;
+    }
+}
+
+// Implement the Model trait for User
+impl Model for User {
+    fn db_prefix() -> &'static str {
+        "user"
+    }
+    
+    fn get_id(&self) -> u32 {
+        self.base_data.id
+    }
+    
+    //WHY?
+    fn base_data_mut(&mut self) -> &mut BaseModelData {
+        &mut self.base_data
+    }
+    
+    fn db_keys(&self) -> Vec<IndexKey> {
+        vec![
+            IndexKey {
+                name: "username",
+                value: self.username.clone(),
+            },
+            IndexKey {
+                name: "email",
+                value: self.email.clone(),
+            },
+            IndexKey {
+                name: "is_active",
+                value: self.is_active.to_string(),
+            },
+        ]
+    }
+}