feat: Add reminder functionality to ContractSigner model

- Added `last_reminder_mail_sent_at` field to track reminder
  timestamps.
- Implemented `can_send_reminder` to check if a reminder can be
  sent based on a 30-minute cooldown.
- Added `reminder_cooldown_remaining` to get remaining cooldown
  time.
- Added `mark_reminder_sent` to update reminder timestamp.
- Added example demonstrating reminder functionality in
  `legal_contract_example.rs`.
- Added tests for reminder functionality in
  `test_reminder_functionality.rs`.
- Updated Rhai scripts to include reminder-related functions and
  tests.
- Improved formatting and clarity in example code.

heromodels/src/models/legal/contract.rs

@@ -1,7 +1,7 @@
 use heromodels_core::BaseModelData;
 use heromodels_derive::model;
-use std::fmt;
 use serde::{Deserialize, Serialize};
+use std::fmt;
 
 // --- Enums ---
 
@@ -86,6 +86,7 @@ pub struct ContractSigner {
     pub status: SignerStatus,
     pub signed_at: Option<u64>, // Timestamp
     pub comments: Option<String>,
+    pub last_reminder_mail_sent_at: Option<u64>, // Unix timestamp of last reminder sent
 }
 
 impl ContractSigner {
@@ -97,6 +98,7 @@ impl ContractSigner {
             status: SignerStatus::default(),
             signed_at: None,
             comments: None,
+            last_reminder_mail_sent_at: None,
         }
     }
 
@@ -109,7 +111,7 @@ impl ContractSigner {
         self.signed_at = Some(signed_at);
         self
     }
-    
+
     pub fn clear_signed_at(mut self) -> Self {
         self.signed_at = None;
         self
@@ -124,6 +126,48 @@ impl ContractSigner {
         self.comments = None;
         self
     }
+
+    pub fn last_reminder_mail_sent_at(mut self, timestamp: u64) -> Self {
+        self.last_reminder_mail_sent_at = Some(timestamp);
+        self
+    }
+
+    pub fn clear_last_reminder_mail_sent_at(mut self) -> Self {
+        self.last_reminder_mail_sent_at = None;
+        self
+    }
+
+    /// Helper method to check if a reminder can be sent (30-minute rate limiting)
+    pub fn can_send_reminder(&self, current_timestamp: u64) -> bool {
+        match self.last_reminder_mail_sent_at {
+            None => true, // No reminder sent yet
+            Some(last_sent) => {
+                let thirty_minutes_in_seconds = 30 * 60; // 30 minutes = 1800 seconds
+                current_timestamp >= last_sent + thirty_minutes_in_seconds
+            }
+        }
+    }
+
+    /// Helper method to get remaining cooldown time in seconds
+    pub fn reminder_cooldown_remaining(&self, current_timestamp: u64) -> Option<u64> {
+        match self.last_reminder_mail_sent_at {
+            None => None, // No cooldown if no reminder sent yet
+            Some(last_sent) => {
+                let thirty_minutes_in_seconds = 30 * 60; // 30 minutes = 1800 seconds
+                let cooldown_end = last_sent + thirty_minutes_in_seconds;
+                if current_timestamp < cooldown_end {
+                    Some(cooldown_end - current_timestamp)
+                } else {
+                    None // Cooldown has expired
+                }
+            }
+        }
+    }
+
+    /// Helper method to update the reminder timestamp to current time
+    pub fn mark_reminder_sent(&mut self, current_timestamp: u64) {
+        self.last_reminder_mail_sent_at = Some(current_timestamp);
+    }
 }
 
 // --- Main Contract Model ---
@@ -139,21 +183,21 @@ pub struct Contract {
 
     pub title: String,
     pub description: String,
-    
+
     #[index]
     pub contract_type: String,
-    
+
     #[index]
     pub status: crate::models::ContractStatus, // Use re-exported path for #[model] macro
-    
+
     pub created_by: String,
     pub terms_and_conditions: String,
-    
+
     pub start_date: Option<u64>,
     pub end_date: Option<u64>,
     pub renewal_period_days: Option<i32>,
     pub next_renewal_date: Option<u64>,
-    
+
     pub signers: Vec<ContractSigner>,
     pub revisions: Vec<ContractRevision>,
     pub current_version: u32,
@@ -217,7 +261,7 @@ impl Contract {
         self.start_date = Some(start_date);
         self
     }
-    
+
     pub fn clear_start_date(mut self) -> Self {
         self.start_date = None;
         self
@@ -257,7 +301,7 @@ impl Contract {
         self.signers.push(signer);
         self
     }
-    
+
     pub fn signers(mut self, signers: Vec<ContractSigner>) -> Self {
         self.signers = signers;
         self
@@ -272,7 +316,7 @@ impl Contract {
         self.revisions = revisions;
         self
     }
-    
+
     pub fn current_version(mut self, version: u32) -> Self {
         self.current_version = version;
         self
@@ -287,7 +331,7 @@ impl Contract {
         self.last_signed_date = None;
         self
     }
-    
+
     // Example methods for state changes
     pub fn set_status(&mut self, status: crate::models::ContractStatus) {
         self.status = status;

heromodels/src/models/legal/rhai.rs

@@ -1,51 +1,60 @@
-use rhai::{
-    Dynamic, Engine, EvalAltResult, NativeCallContext, Position, Module, Array,
-};
+use rhai::{Array, Dynamic, Engine, EvalAltResult, Module, NativeCallContext, Position};
 use std::sync::Arc;
 
 use crate::db::hero::OurDB; // Updated path based on compiler suggestion
 // use heromodels_core::BaseModelData; // Removed as fields are accessed via contract.base_data directly
-use crate::models::legal::{Contract, ContractRevision, ContractSigner, ContractStatus, SignerStatus};
+use crate::models::legal::{
+    Contract, ContractRevision, ContractSigner, ContractStatus, SignerStatus,
+};
 
 use crate::db::Collection; // Import the Collection trait
 
 // --- Helper Functions for ID and Timestamp Conversion ---
-fn i64_to_u32(val: i64, context_pos: Position, field_name: &str, object_name: &str) -> Result<u32, Box<EvalAltResult>> {
+fn i64_to_u32(
+    val: i64,
+    context_pos: Position,
+    field_name: &str,
+    object_name: &str,
+) -> Result<u32, Box<EvalAltResult>> {
     val.try_into().map_err(|_e| {
         Box::new(EvalAltResult::ErrorArithmetic(
             format!(
                 "Conversion error for field '{}' in object '{}': cannot convert i64 ({}) to u32",
-                field_name,
-                object_name,
-                val
+                field_name, object_name, val
             ),
             context_pos,
         ))
     })
 }
 
-fn i64_to_u64(val: i64, context_pos: Position, field_name: &str, object_name: &str) -> Result<u64, Box<EvalAltResult>> {
+fn i64_to_u64(
+    val: i64,
+    context_pos: Position,
+    field_name: &str,
+    object_name: &str,
+) -> Result<u64, Box<EvalAltResult>> {
     val.try_into().map_err(|_e| {
         Box::new(EvalAltResult::ErrorArithmetic(
             format!(
                 "Conversion error for field '{}' in object '{}': cannot convert i64 ({}) to u64",
-                field_name,
-                object_name,
-                val
+                field_name, object_name, val
             ),
             context_pos,
         ))
     })
 }
 
-fn i64_to_i32(val: i64, context_pos: Position, field_name: &str, object_name: &str) -> Result<i32, Box<EvalAltResult>> {
+fn i64_to_i32(
+    val: i64,
+    context_pos: Position,
+    field_name: &str,
+    object_name: &str,
+) -> Result<i32, Box<EvalAltResult>> {
     val.try_into().map_err(|_e| {
         Box::new(EvalAltResult::ErrorArithmetic(
             format!(
                 "Conversion error for field '{}' in object '{}': cannot convert i64 ({}) to i32",
-                field_name,
-                object_name,
-                val
+                field_name, object_name, val
             ),
             context_pos,
         ))
@@ -73,193 +82,608 @@ pub fn register_legal_rhai_module(engine: &mut Engine, db: Arc<OurDB>) {
     engine.register_static_module("SignerStatusConstants", signer_status_module.into());
     engine.register_type_with_name::<SignerStatus>("SignerStatus"); // Expose the type itself
 
-    // --- ContractRevision --- 
+    // --- ContractRevision ---
     engine.register_type_with_name::<ContractRevision>("ContractRevision");
     engine.register_fn(
         "new_contract_revision",
-        move |context: NativeCallContext, version_i64: i64, content: String, created_at_i64: i64, created_by: String| -> Result<ContractRevision, Box<EvalAltResult>> {
-            let version = i64_to_u32(version_i64, context.position(), "version", "new_contract_revision")?;
-            let created_at = i64_to_u64(created_at_i64, context.position(), "created_at", "new_contract_revision")?;
-            Ok(ContractRevision::new(version, content, created_at, created_by))
-        }
+        move |context: NativeCallContext,
+              version_i64: i64,
+              content: String,
+              created_at_i64: i64,
+              created_by: String|
+              -> Result<ContractRevision, Box<EvalAltResult>> {
+            let version = i64_to_u32(
+                version_i64,
+                context.position(),
+                "version",
+                "new_contract_revision",
+            )?;
+            let created_at = i64_to_u64(
+                created_at_i64,
+                context.position(),
+                "created_at",
+                "new_contract_revision",
+            )?;
+            Ok(ContractRevision::new(
+                version, content, created_at, created_by,
+            ))
+        },
+    );
+    engine.register_fn(
+        "comments",
+        |mut revision: ContractRevision, comments: String| -> ContractRevision {
+            revision.comments = Some(comments);
+            revision
+        },
+    );
+    engine.register_get(
+        "version",
+        |revision: &mut ContractRevision| -> Result<i64, Box<EvalAltResult>> {
+            Ok(revision.version as i64)
+        },
+    );
+    engine.register_get(
+        "content",
+        |revision: &mut ContractRevision| -> Result<String, Box<EvalAltResult>> {
+            Ok(revision.content.clone())
+        },
+    );
+    engine.register_get(
+        "created_at",
+        |revision: &mut ContractRevision| -> Result<i64, Box<EvalAltResult>> {
+            Ok(revision.created_at as i64)
+        },
+    );
+    engine.register_get(
+        "created_by",
+        |revision: &mut ContractRevision| -> Result<String, Box<EvalAltResult>> {
+            Ok(revision.created_by.clone())
+        },
+    );
+    engine.register_get(
+        "comments",
+        |revision: &mut ContractRevision| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(revision
+                .comments
+                .clone()
+                .map_or(Dynamic::UNIT, Dynamic::from))
+        },
     );
-    engine.register_fn("comments", |mut revision: ContractRevision, comments: String| -> ContractRevision {
-        revision.comments = Some(comments);
-        revision
-    });
-    engine.register_get("version", |revision: &mut ContractRevision| -> Result<i64, Box<EvalAltResult>> { Ok(revision.version as i64) });
-    engine.register_get("content", |revision: &mut ContractRevision| -> Result<String, Box<EvalAltResult>> { Ok(revision.content.clone()) });
-    engine.register_get("created_at", |revision: &mut ContractRevision| -> Result<i64, Box<EvalAltResult>> { Ok(revision.created_at as i64) });
-    engine.register_get("created_by", |revision: &mut ContractRevision| -> Result<String, Box<EvalAltResult>> { Ok(revision.created_by.clone()) });
-    engine.register_get("comments", |revision: &mut ContractRevision| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(revision.comments.clone().map_or(Dynamic::UNIT, Dynamic::from))
-    });
 
-    // --- ContractSigner --- 
+    // --- ContractSigner ---
     engine.register_type_with_name::<ContractSigner>("ContractSigner");
     engine.register_fn(
         "new_contract_signer",
         |id: String, name: String, email: String| -> ContractSigner {
             ContractSigner::new(id, name, email)
-        }
+        },
+    );
+    engine.register_fn(
+        "status",
+        |signer: ContractSigner, status: SignerStatus| -> ContractSigner { signer.status(status) },
+    );
+    engine.register_fn(
+        "signed_at",
+        |context: NativeCallContext,
+         signer: ContractSigner,
+         signed_at_i64: i64|
+         -> Result<ContractSigner, Box<EvalAltResult>> {
+            let signed_at_u64 = i64_to_u64(
+                signed_at_i64,
+                context.position(),
+                "signed_at",
+                "ContractSigner.signed_at",
+            )?;
+            Ok(signer.signed_at(signed_at_u64))
+        },
+    );
+    engine.register_fn(
+        "clear_signed_at",
+        |signer: ContractSigner| -> ContractSigner { signer.clear_signed_at() },
+    );
+    engine.register_fn(
+        "comments",
+        |signer: ContractSigner, comments: String| -> ContractSigner { signer.comments(comments) },
+    );
+    engine.register_fn(
+        "clear_comments",
+        |signer: ContractSigner| -> ContractSigner { signer.clear_comments() },
     );
-    engine.register_fn("status", |signer: ContractSigner, status: SignerStatus| -> ContractSigner { signer.status(status) });
-    engine.register_fn("signed_at", |context: NativeCallContext, signer: ContractSigner, signed_at_i64: i64| -> Result<ContractSigner, Box<EvalAltResult>> {
-        let signed_at_u64 = i64_to_u64(signed_at_i64, context.position(), "signed_at", "ContractSigner.signed_at")?;
-        Ok(signer.signed_at(signed_at_u64))
-    });
-    engine.register_fn("clear_signed_at", |signer: ContractSigner| -> ContractSigner { signer.clear_signed_at() });
-    engine.register_fn("comments", |signer: ContractSigner, comments: String| -> ContractSigner { signer.comments(comments) });
-    engine.register_fn("clear_comments", |signer: ContractSigner| -> ContractSigner { signer.clear_comments() });
 
-    engine.register_get("id", |signer: &mut ContractSigner| -> Result<String, Box<EvalAltResult>> { Ok(signer.id.clone()) });
-    engine.register_get("name", |signer: &mut ContractSigner| -> Result<String, Box<EvalAltResult>> { Ok(signer.name.clone()) });
-    engine.register_get("email", |signer: &mut ContractSigner| -> Result<String, Box<EvalAltResult>> { Ok(signer.email.clone()) });
-    engine.register_get("status", |signer: &mut ContractSigner| -> Result<SignerStatus, Box<EvalAltResult>> { Ok(signer.status.clone()) });
-    engine.register_get("signed_at_ts", |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(signer.signed_at.map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
-    });
-    engine.register_get("comments", |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(signer.comments.clone().map_or(Dynamic::UNIT, Dynamic::from))
-    });
-    engine.register_get("signed_at", |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(signer.signed_at.map_or(Dynamic::UNIT, |ts| Dynamic::from(ts)))
-    });
+    // Reminder functionality
+    engine.register_fn(
+        "last_reminder_mail_sent_at",
+        |context: NativeCallContext,
+         signer: ContractSigner,
+         timestamp_i64: i64|
+         -> Result<ContractSigner, Box<EvalAltResult>> {
+            let timestamp_u64 = i64_to_u64(
+                timestamp_i64,
+                context.position(),
+                "timestamp",
+                "ContractSigner.last_reminder_mail_sent_at",
+            )?;
+            Ok(signer.last_reminder_mail_sent_at(timestamp_u64))
+        },
+    );
+    engine.register_fn(
+        "clear_last_reminder_mail_sent_at",
+        |signer: ContractSigner| -> ContractSigner { signer.clear_last_reminder_mail_sent_at() },
+    );
 
-    // --- Contract --- 
+    // Helper methods for reminder logic
+    engine.register_fn(
+        "can_send_reminder",
+        |context: NativeCallContext,
+         signer: &mut ContractSigner,
+         current_timestamp_i64: i64|
+         -> Result<bool, Box<EvalAltResult>> {
+            let current_timestamp = i64_to_u64(
+                current_timestamp_i64,
+                context.position(),
+                "current_timestamp",
+                "ContractSigner.can_send_reminder",
+            )?;
+            Ok(signer.can_send_reminder(current_timestamp))
+        },
+    );
+
+    engine.register_fn(
+        "reminder_cooldown_remaining",
+        |context: NativeCallContext,
+         signer: &mut ContractSigner,
+         current_timestamp_i64: i64|
+         -> Result<Dynamic, Box<EvalAltResult>> {
+            let current_timestamp = i64_to_u64(
+                current_timestamp_i64,
+                context.position(),
+                "current_timestamp",
+                "ContractSigner.reminder_cooldown_remaining",
+            )?;
+            Ok(signer
+                .reminder_cooldown_remaining(current_timestamp)
+                .map_or(Dynamic::UNIT, |remaining| Dynamic::from(remaining as i64)))
+        },
+    );
+
+    engine.register_fn(
+        "mark_reminder_sent",
+        |context: NativeCallContext,
+         signer: &mut ContractSigner,
+         current_timestamp_i64: i64|
+         -> Result<(), Box<EvalAltResult>> {
+            let current_timestamp = i64_to_u64(
+                current_timestamp_i64,
+                context.position(),
+                "current_timestamp",
+                "ContractSigner.mark_reminder_sent",
+            )?;
+            signer.mark_reminder_sent(current_timestamp);
+            Ok(())
+        },
+    );
+
+    engine.register_get(
+        "id",
+        |signer: &mut ContractSigner| -> Result<String, Box<EvalAltResult>> {
+            Ok(signer.id.clone())
+        },
+    );
+    engine.register_get(
+        "name",
+        |signer: &mut ContractSigner| -> Result<String, Box<EvalAltResult>> {
+            Ok(signer.name.clone())
+        },
+    );
+    engine.register_get(
+        "email",
+        |signer: &mut ContractSigner| -> Result<String, Box<EvalAltResult>> {
+            Ok(signer.email.clone())
+        },
+    );
+    engine.register_get(
+        "status",
+        |signer: &mut ContractSigner| -> Result<SignerStatus, Box<EvalAltResult>> {
+            Ok(signer.status.clone())
+        },
+    );
+    engine.register_get(
+        "signed_at_ts",
+        |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(signer
+                .signed_at
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
+        },
+    );
+    engine.register_get(
+        "comments",
+        |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(signer.comments.clone().map_or(Dynamic::UNIT, Dynamic::from))
+        },
+    );
+    engine.register_get(
+        "signed_at",
+        |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(signer
+                .signed_at
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts)))
+        },
+    );
+    engine.register_get(
+        "last_reminder_mail_sent_at",
+        |signer: &mut ContractSigner| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(signer
+                .last_reminder_mail_sent_at
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
+        },
+    );
+
+    // --- Contract ---
     engine.register_type_with_name::<Contract>("Contract");
     engine.register_fn(
         "new_contract",
-        move |context: NativeCallContext, base_id_i64: i64, contract_id: String| -> Result<Contract, Box<EvalAltResult>> {
+        move |context: NativeCallContext,
+              base_id_i64: i64,
+              contract_id: String|
+              -> Result<Contract, Box<EvalAltResult>> {
             let base_id = i64_to_u32(base_id_i64, context.position(), "base_id", "new_contract")?;
             Ok(Contract::new(base_id, contract_id))
-        }
+        },
     );
 
     // Builder methods
-    engine.register_fn("title", |contract: Contract, title: String| -> Contract { contract.title(title) });
-    engine.register_fn("description", |contract: Contract, description: String| -> Contract { contract.description(description) });
-    engine.register_fn("contract_type", |contract: Contract, contract_type: String| -> Contract { contract.contract_type(contract_type) });
-    engine.register_fn("status", |contract: Contract, status: ContractStatus| -> Contract { contract.status(status) });
-    engine.register_fn("created_by", |contract: Contract, created_by: String| -> Contract { contract.created_by(created_by) });
-    engine.register_fn("terms_and_conditions", |contract: Contract, terms: String| -> Contract { contract.terms_and_conditions(terms) });
-
-    engine.register_fn("start_date", |context: NativeCallContext, contract: Contract, start_date_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
-        let start_date_u64 = i64_to_u64(start_date_i64, context.position(), "start_date", "Contract.start_date")?;
-        Ok(contract.start_date(start_date_u64))
+    engine.register_fn("title", |contract: Contract, title: String| -> Contract {
+        contract.title(title)
     });
-    engine.register_fn("clear_start_date", |contract: Contract| -> Contract { contract.clear_start_date() });
+    engine.register_fn(
+        "description",
+        |contract: Contract, description: String| -> Contract { contract.description(description) },
+    );
+    engine.register_fn(
+        "contract_type",
+        |contract: Contract, contract_type: String| -> Contract {
+            contract.contract_type(contract_type)
+        },
+    );
+    engine.register_fn(
+        "status",
+        |contract: Contract, status: ContractStatus| -> Contract { contract.status(status) },
+    );
+    engine.register_fn(
+        "created_by",
+        |contract: Contract, created_by: String| -> Contract { contract.created_by(created_by) },
+    );
+    engine.register_fn(
+        "terms_and_conditions",
+        |contract: Contract, terms: String| -> Contract { contract.terms_and_conditions(terms) },
+    );
 
-    engine.register_fn("end_date", |context: NativeCallContext, contract: Contract, end_date_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
-        let end_date_u64 = i64_to_u64(end_date_i64, context.position(), "end_date", "Contract.end_date")?;
-        Ok(contract.end_date(end_date_u64))
-    });
-    engine.register_fn("clear_end_date", |contract: Contract| -> Contract { contract.clear_end_date() });
-
-    engine.register_fn("renewal_period_days", |context: NativeCallContext, contract: Contract, days_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
-        let days_i32 = i64_to_i32(days_i64, context.position(), "renewal_period_days", "Contract.renewal_period_days")?;
-        Ok(contract.renewal_period_days(days_i32))
-    });
-    engine.register_fn("clear_renewal_period_days", |contract: Contract| -> Contract { contract.clear_renewal_period_days() });
-
-    engine.register_fn("next_renewal_date", |context: NativeCallContext, contract: Contract, date_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
-        let date_u64 = i64_to_u64(date_i64, context.position(), "next_renewal_date", "Contract.next_renewal_date")?;
-        Ok(contract.next_renewal_date(date_u64))
-    });
-    engine.register_fn("clear_next_renewal_date", |contract: Contract| -> Contract { contract.clear_next_renewal_date() });
-
-    engine.register_fn("add_signer", |contract: Contract, signer: ContractSigner| -> Contract { contract.add_signer(signer) });
-    engine.register_fn("signers", |contract: Contract, signers_array: Array| -> Contract {
-        let signers_vec = signers_array.into_iter().filter_map(|s| s.try_cast::<ContractSigner>()).collect();
-        contract.signers(signers_vec)
+    engine.register_fn(
+        "start_date",
+        |context: NativeCallContext,
+         contract: Contract,
+         start_date_i64: i64|
+         -> Result<Contract, Box<EvalAltResult>> {
+            let start_date_u64 = i64_to_u64(
+                start_date_i64,
+                context.position(),
+                "start_date",
+                "Contract.start_date",
+            )?;
+            Ok(contract.start_date(start_date_u64))
+        },
+    );
+    engine.register_fn("clear_start_date", |contract: Contract| -> Contract {
+        contract.clear_start_date()
     });
 
-    engine.register_fn("add_revision", |contract: Contract, revision: ContractRevision| -> Contract { contract.add_revision(revision) });
-    engine.register_fn("revisions", |contract: Contract, revisions_array: Array| -> Contract {
-        let revisions_vec = revisions_array.into_iter().filter_map(|r| r.try_cast::<ContractRevision>()).collect();
-        contract.revisions(revisions_vec)
+    engine.register_fn(
+        "end_date",
+        |context: NativeCallContext,
+         contract: Contract,
+         end_date_i64: i64|
+         -> Result<Contract, Box<EvalAltResult>> {
+            let end_date_u64 = i64_to_u64(
+                end_date_i64,
+                context.position(),
+                "end_date",
+                "Contract.end_date",
+            )?;
+            Ok(contract.end_date(end_date_u64))
+        },
+    );
+    engine.register_fn("clear_end_date", |contract: Contract| -> Contract {
+        contract.clear_end_date()
     });
 
-    engine.register_fn("current_version", |context: NativeCallContext, contract: Contract, version_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
-        let version_u32 = i64_to_u32(version_i64, context.position(), "current_version", "Contract.current_version")?;
-        Ok(contract.current_version(version_u32))
-    });
+    engine.register_fn(
+        "renewal_period_days",
+        |context: NativeCallContext,
+         contract: Contract,
+         days_i64: i64|
+         -> Result<Contract, Box<EvalAltResult>> {
+            let days_i32 = i64_to_i32(
+                days_i64,
+                context.position(),
+                "renewal_period_days",
+                "Contract.renewal_period_days",
+            )?;
+            Ok(contract.renewal_period_days(days_i32))
+        },
+    );
+    engine.register_fn(
+        "clear_renewal_period_days",
+        |contract: Contract| -> Contract { contract.clear_renewal_period_days() },
+    );
 
-    engine.register_fn("last_signed_date", |context: NativeCallContext, contract: Contract, date_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
-        let date_u64 = i64_to_u64(date_i64, context.position(), "last_signed_date", "Contract.last_signed_date")?;
-        Ok(contract.last_signed_date(date_u64))
+    engine.register_fn(
+        "next_renewal_date",
+        |context: NativeCallContext,
+         contract: Contract,
+         date_i64: i64|
+         -> Result<Contract, Box<EvalAltResult>> {
+            let date_u64 = i64_to_u64(
+                date_i64,
+                context.position(),
+                "next_renewal_date",
+                "Contract.next_renewal_date",
+            )?;
+            Ok(contract.next_renewal_date(date_u64))
+        },
+    );
+    engine.register_fn(
+        "clear_next_renewal_date",
+        |contract: Contract| -> Contract { contract.clear_next_renewal_date() },
+    );
+
+    engine.register_fn(
+        "add_signer",
+        |contract: Contract, signer: ContractSigner| -> Contract { contract.add_signer(signer) },
+    );
+    engine.register_fn(
+        "signers",
+        |contract: Contract, signers_array: Array| -> Contract {
+            let signers_vec = signers_array
+                .into_iter()
+                .filter_map(|s| s.try_cast::<ContractSigner>())
+                .collect();
+            contract.signers(signers_vec)
+        },
+    );
+
+    engine.register_fn(
+        "add_revision",
+        |contract: Contract, revision: ContractRevision| -> Contract {
+            contract.add_revision(revision)
+        },
+    );
+    engine.register_fn(
+        "revisions",
+        |contract: Contract, revisions_array: Array| -> Contract {
+            let revisions_vec = revisions_array
+                .into_iter()
+                .filter_map(|r| r.try_cast::<ContractRevision>())
+                .collect();
+            contract.revisions(revisions_vec)
+        },
+    );
+
+    engine.register_fn(
+        "current_version",
+        |context: NativeCallContext,
+         contract: Contract,
+         version_i64: i64|
+         -> Result<Contract, Box<EvalAltResult>> {
+            let version_u32 = i64_to_u32(
+                version_i64,
+                context.position(),
+                "current_version",
+                "Contract.current_version",
+            )?;
+            Ok(contract.current_version(version_u32))
+        },
+    );
+
+    engine.register_fn(
+        "last_signed_date",
+        |context: NativeCallContext,
+         contract: Contract,
+         date_i64: i64|
+         -> Result<Contract, Box<EvalAltResult>> {
+            let date_u64 = i64_to_u64(
+                date_i64,
+                context.position(),
+                "last_signed_date",
+                "Contract.last_signed_date",
+            )?;
+            Ok(contract.last_signed_date(date_u64))
+        },
+    );
+    engine.register_fn("clear_last_signed_date", |contract: Contract| -> Contract {
+        contract.clear_last_signed_date()
     });
-    engine.register_fn("clear_last_signed_date", |contract: Contract| -> Contract { contract.clear_last_signed_date() });
 
     // Getters for Contract
-    engine.register_get("id", |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> { Ok(contract.base_data.id as i64) });
-    engine.register_get("created_at_ts", |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> { Ok(contract.base_data.created_at as i64) });
-    engine.register_get("updated_at_ts", |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> { Ok(contract.base_data.modified_at as i64) });
-    engine.register_get("contract_id", |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> { Ok(contract.contract_id.clone()) });
-    engine.register_get("title", |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> { Ok(contract.title.clone()) });
-    engine.register_get("description", |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> { Ok(contract.description.clone()) });
-    engine.register_get("contract_type", |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> { Ok(contract.contract_type.clone()) });
-    engine.register_get("status", |contract: &mut Contract| -> Result<ContractStatus, Box<EvalAltResult>> { Ok(contract.status.clone()) });
-    engine.register_get("created_by", |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> { Ok(contract.created_by.clone()) });
-    engine.register_get("terms_and_conditions", |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> { Ok(contract.terms_and_conditions.clone()) });
-    
-    engine.register_get("start_date", |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(contract.start_date.map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
-    });
-    engine.register_get("end_date", |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(contract.end_date.map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
-    });
-    engine.register_get("renewal_period_days", |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(contract.renewal_period_days.map_or(Dynamic::UNIT, |days| Dynamic::from(days as i64)))
-    });
-    engine.register_get("next_renewal_date", |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(contract.next_renewal_date.map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
-    });
-    engine.register_get("last_signed_date", |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
-        Ok(contract.last_signed_date.map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
-    });
+    engine.register_get(
+        "id",
+        |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> {
+            Ok(contract.base_data.id as i64)
+        },
+    );
+    engine.register_get(
+        "created_at_ts",
+        |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> {
+            Ok(contract.base_data.created_at as i64)
+        },
+    );
+    engine.register_get(
+        "updated_at_ts",
+        |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> {
+            Ok(contract.base_data.modified_at as i64)
+        },
+    );
+    engine.register_get(
+        "contract_id",
+        |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> {
+            Ok(contract.contract_id.clone())
+        },
+    );
+    engine.register_get(
+        "title",
+        |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> {
+            Ok(contract.title.clone())
+        },
+    );
+    engine.register_get(
+        "description",
+        |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> {
+            Ok(contract.description.clone())
+        },
+    );
+    engine.register_get(
+        "contract_type",
+        |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> {
+            Ok(contract.contract_type.clone())
+        },
+    );
+    engine.register_get(
+        "status",
+        |contract: &mut Contract| -> Result<ContractStatus, Box<EvalAltResult>> {
+            Ok(contract.status.clone())
+        },
+    );
+    engine.register_get(
+        "created_by",
+        |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> {
+            Ok(contract.created_by.clone())
+        },
+    );
+    engine.register_get(
+        "terms_and_conditions",
+        |contract: &mut Contract| -> Result<String, Box<EvalAltResult>> {
+            Ok(contract.terms_and_conditions.clone())
+        },
+    );
 
-    engine.register_get("current_version", |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> { Ok(contract.current_version as i64) });
+    engine.register_get(
+        "start_date",
+        |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(contract
+                .start_date
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
+        },
+    );
+    engine.register_get(
+        "end_date",
+        |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(contract
+                .end_date
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
+        },
+    );
+    engine.register_get(
+        "renewal_period_days",
+        |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(contract
+                .renewal_period_days
+                .map_or(Dynamic::UNIT, |days| Dynamic::from(days as i64)))
+        },
+    );
+    engine.register_get(
+        "next_renewal_date",
+        |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(contract
+                .next_renewal_date
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
+        },
+    );
+    engine.register_get(
+        "last_signed_date",
+        |contract: &mut Contract| -> Result<Dynamic, Box<EvalAltResult>> {
+            Ok(contract
+                .last_signed_date
+                .map_or(Dynamic::UNIT, |ts| Dynamic::from(ts as i64)))
+        },
+    );
 
-    engine.register_get("signers", |contract: &mut Contract| -> Result<Array, Box<EvalAltResult>> {
-        let rhai_array = contract.signers.iter().cloned().map(Dynamic::from).collect::<Array>();
-        Ok(rhai_array)
-    });
-    engine.register_get("revisions", |contract: &mut Contract| -> Result<Array, Box<EvalAltResult>> {
-        let rhai_array = contract.revisions.iter().cloned().map(Dynamic::from).collect::<Array>();
-        Ok(rhai_array)
-    });
+    engine.register_get(
+        "current_version",
+        |contract: &mut Contract| -> Result<i64, Box<EvalAltResult>> {
+            Ok(contract.current_version as i64)
+        },
+    );
+
+    engine.register_get(
+        "signers",
+        |contract: &mut Contract| -> Result<Array, Box<EvalAltResult>> {
+            let rhai_array = contract
+                .signers
+                .iter()
+                .cloned()
+                .map(Dynamic::from)
+                .collect::<Array>();
+            Ok(rhai_array)
+        },
+    );
+    engine.register_get(
+        "revisions",
+        |contract: &mut Contract| -> Result<Array, Box<EvalAltResult>> {
+            let rhai_array = contract
+                .revisions
+                .iter()
+                .cloned()
+                .map(Dynamic::from)
+                .collect::<Array>();
+            Ok(rhai_array)
+        },
+    );
 
     // Method set_status
-    engine.register_fn("set_contract_status", |contract: &mut Contract, status: ContractStatus| {
-        contract.set_status(status);
-    });
+    engine.register_fn(
+        "set_contract_status",
+        |contract: &mut Contract, status: ContractStatus| {
+            contract.set_status(status);
+        },
+    );
 
     // --- Database Interaction ---
     let captured_db_for_set = Arc::clone(&db);
-    engine.register_fn("set_contract", 
+    engine.register_fn(
+        "set_contract",
         move |contract: Contract| -> Result<(), Box<EvalAltResult>> {
             captured_db_for_set.set(&contract).map(|_| ()).map_err(|e| {
                 Box::new(EvalAltResult::ErrorRuntime(
-                    format!("Failed to set Contract (ID: {}): {}", contract.base_data.id, e).into(),
+                    format!(
+                        "Failed to set Contract (ID: {}): {}",
+                        contract.base_data.id, e
+                    )
+                    .into(),
                     Position::NONE,
                 ))
             })
-    });
+        },
+    );
 
     let captured_db_for_get = Arc::clone(&db);
-    engine.register_fn("get_contract_by_id", 
+    engine.register_fn(
+        "get_contract_by_id",
         move |context: NativeCallContext, id_i64: i64| -> Result<Contract, Box<EvalAltResult>> {
             let id_u32 = i64_to_u32(id_i64, context.position(), "id", "get_contract_by_id")?;
-            
-            captured_db_for_get.get_by_id(id_u32)
-                .map_err(|e| Box::new(EvalAltResult::ErrorRuntime(
-                    format!("Error getting Contract (ID: {}): {}", id_u32, e).into(),
-                    Position::NONE,
-                )))?
-                .ok_or_else(|| Box::new(EvalAltResult::ErrorRuntime(
-                    format!("Contract with ID {} not found", id_u32).into(),
-                    Position::NONE,
-                )))
-    });
+
+            captured_db_for_get
+                .get_by_id(id_u32)
+                .map_err(|e| {
+                    Box::new(EvalAltResult::ErrorRuntime(
+                        format!("Error getting Contract (ID: {}): {}", id_u32, e).into(),
+                        Position::NONE,
+                    ))
+                })?
+                .ok_or_else(|| {
+                    Box::new(EvalAltResult::ErrorRuntime(
+                        format!("Contract with ID {} not found", id_u32).into(),
+                        Position::NONE,
+                    ))
+                })
+        },
+    );
 }