add heroledger models

heromodels/src/models/heroledger/mod.rs

@@ -7,6 +7,7 @@ pub mod dnsrecord;
 pub mod secretbox;
 pub mod signature;
 pub mod user_kvs;
+pub mod rhai;
 
 // Re-export key types for convenience
 pub use user::{User, UserStatus, UserProfile, KYCInfo, KYCStatus, SecretBox};

heromodels/src/models/heroledger/rhai.rs

@@ -0,0 +1,330 @@
+use ::rhai::plugin::*;
+use ::rhai::{Array, Dynamic, Engine, EvalAltResult, Map, Module};
+use std::mem;
+
+use crate::models::heroledger::*;
+
+// ============================================================================
+// User Module
+// ============================================================================
+
+type RhaiUser = User;
+
+#[export_module]
+mod rhai_user_module {
+    use super::RhaiUser;
+
+    #[rhai_fn(name = "new_user", return_raw)]
+    pub fn new_user() -> Result<RhaiUser, Box<EvalAltResult>> {
+        Ok(User::new(0))
+    }
+
+    #[rhai_fn(name = "username", return_raw)]
+    pub fn set_username(
+        user: &mut RhaiUser,
+        username: String,
+    ) -> Result<RhaiUser, Box<EvalAltResult>> {
+        let owned = std::mem::take(user);
+        *user = owned.username(username);
+        Ok(user.clone())
+    }
+
+    #[rhai_fn(name = "add_email", return_raw)]
+    pub fn add_email(
+        user: &mut RhaiUser,
+        email: String,
+    ) -> Result<RhaiUser, Box<EvalAltResult>> {
+        let owned = std::mem::take(user);
+        *user = owned.add_email(email);
+        Ok(user.clone())
+    }
+
+    #[rhai_fn(name = "pubkey", return_raw)]
+    pub fn set_pubkey(
+        user: &mut RhaiUser,
+        pubkey: String,
+    ) -> Result<RhaiUser, Box<EvalAltResult>> {
+        let owned = std::mem::take(user);
+        *user = owned.pubkey(pubkey);
+        Ok(user.clone())
+    }
+
+    #[rhai_fn(name = "status", return_raw)]
+    pub fn set_status(
+        user: &mut RhaiUser,
+        status: String,
+    ) -> Result<RhaiUser, Box<EvalAltResult>> {
+        let status_enum = match status.as_str() {
+            "Active" => UserStatus::Active,
+            "Inactive" => UserStatus::Inactive,
+            "Suspended" => UserStatus::Suspended,
+            "Archived" => UserStatus::Archived,
+            _ => return Err(format!("Invalid user status: {}", status).into()),
+        };
+        let owned = std::mem::take(user);
+        *user = owned.status(status_enum);
+        Ok(user.clone())
+    }
+
+    #[rhai_fn(name = "save_user", return_raw)]
+    pub fn save_user(user: &mut RhaiUser) -> Result<RhaiUser, Box<EvalAltResult>> {
+        // This would integrate with the database save functionality
+        // For now, just return the user as-is
+        Ok(user.clone())
+    }
+
+    // Getters
+    #[rhai_fn(name = "get_id")]
+    pub fn get_id(user: &mut RhaiUser) -> i64 {
+        user.base_data.id as i64
+    }
+
+    #[rhai_fn(name = "get_username")]
+    pub fn get_username(user: &mut RhaiUser) -> String {
+        user.username.clone().unwrap_or_else(|| String::new())
+    }
+
+    #[rhai_fn(name = "get_email")]
+    pub fn get_email(user: &mut RhaiUser) -> String {
+        if let Some(first_email) = user.email.first() {
+            first_email.clone()
+        } else {
+            String::new()
+        }
+    }
+
+    #[rhai_fn(name = "get_pubkey")]
+    pub fn get_pubkey(user: &mut RhaiUser) -> String {
+        user.pubkey.clone().unwrap_or_else(|| String::new())
+    }
+}
+
+// ============================================================================
+// Group Module
+// ============================================================================
+
+type RhaiGroup = Group;
+
+#[export_module]
+mod rhai_group_module {
+    use super::RhaiGroup;
+
+    #[rhai_fn(name = "new_group", return_raw)]
+    pub fn new_group() -> Result<RhaiGroup, Box<EvalAltResult>> {
+        Ok(Group::new(0))
+    }
+
+    #[rhai_fn(name = "name", return_raw)]
+    pub fn set_name(
+        group: &mut RhaiGroup,
+        name: String,
+    ) -> Result<RhaiGroup, Box<EvalAltResult>> {
+        let owned = std::mem::take(group);
+        *group = owned.name(name);
+        Ok(group.clone())
+    }
+
+    #[rhai_fn(name = "description", return_raw)]
+    pub fn set_description(
+        group: &mut RhaiGroup,
+        description: String,
+    ) -> Result<RhaiGroup, Box<EvalAltResult>> {
+        let owned = std::mem::take(group);
+        *group = owned.description(description);
+        Ok(group.clone())
+    }
+
+    #[rhai_fn(name = "visibility", return_raw)]
+    pub fn set_visibility(
+        group: &mut RhaiGroup,
+        visibility: String,
+    ) -> Result<RhaiGroup, Box<EvalAltResult>> {
+        let visibility_enum = match visibility.as_str() {
+            "Public" => Visibility::Public,
+            "Private" => Visibility::Private,
+            _ => return Err(format!("Invalid visibility: {}", visibility).into()),
+        };
+        let owned = std::mem::take(group);
+        *group = owned.visibility(visibility_enum);
+        Ok(group.clone())
+    }
+
+    #[rhai_fn(name = "save_group", return_raw)]
+    pub fn save_group(group: &mut RhaiGroup) -> Result<RhaiGroup, Box<EvalAltResult>> {
+        Ok(group.clone())
+    }
+
+    // Getters
+    #[rhai_fn(name = "get_id")]
+    pub fn get_id(group: &mut RhaiGroup) -> i64 {
+        group.base_data.id as i64
+    }
+
+    #[rhai_fn(name = "get_name")]
+    pub fn get_name(group: &mut RhaiGroup) -> String {
+        group.name.clone().unwrap_or_else(|| String::new())
+    }
+
+    #[rhai_fn(name = "get_description")]
+    pub fn get_description(group: &mut RhaiGroup) -> String {
+        group.description.clone().unwrap_or_else(|| String::new())
+    }
+}
+
+// ============================================================================
+// Account Module (from money.rs)
+// ============================================================================
+
+type RhaiAccount = Account;
+
+#[export_module]
+mod rhai_account_module {
+    use super::RhaiAccount;
+
+    #[rhai_fn(name = "new_account", return_raw)]
+    pub fn new_account() -> Result<RhaiAccount, Box<EvalAltResult>> {
+        Ok(Account::new(0))
+    }
+
+    #[rhai_fn(name = "owner_id", return_raw)]
+    pub fn set_owner_id(
+        account: &mut RhaiAccount,
+        owner_id: i64,
+    ) -> Result<RhaiAccount, Box<EvalAltResult>> {
+        let owned = std::mem::take(account);
+        *account = owned.owner_id(owner_id as u32);
+        Ok(account.clone())
+    }
+
+    #[rhai_fn(name = "address", return_raw)]
+    pub fn set_address(
+        account: &mut RhaiAccount,
+        address: String,
+    ) -> Result<RhaiAccount, Box<EvalAltResult>> {
+        let owned = std::mem::take(account);
+        *account = owned.address(address);
+        Ok(account.clone())
+    }
+
+    #[rhai_fn(name = "currency", return_raw)]
+    pub fn set_currency(
+        account: &mut RhaiAccount,
+        currency: String,
+    ) -> Result<RhaiAccount, Box<EvalAltResult>> {
+        let owned = std::mem::take(account);
+        *account = owned.currency(currency);
+        Ok(account.clone())
+    }
+
+    #[rhai_fn(name = "save_account", return_raw)]
+    pub fn save_account(account: &mut RhaiAccount) -> Result<RhaiAccount, Box<EvalAltResult>> {
+        Ok(account.clone())
+    }
+
+    // Getters
+    #[rhai_fn(name = "get_id")]
+    pub fn get_id(account: &mut RhaiAccount) -> i64 {
+        account.base_data.id as i64
+    }
+
+    #[rhai_fn(name = "get_address")]
+    pub fn get_address(account: &mut RhaiAccount) -> String {
+        account.address.clone()
+    }
+
+    #[rhai_fn(name = "get_currency")]
+    pub fn get_currency(account: &mut RhaiAccount) -> String {
+        account.currency.clone()
+    }
+}
+
+// ============================================================================
+// DNS Zone Module
+// ============================================================================
+
+type RhaiDNSZone = DNSZone;
+
+#[export_module]
+mod rhai_dns_zone_module {
+    use super::RhaiDNSZone;
+
+    #[rhai_fn(name = "new_dns_zone", return_raw)]
+    pub fn new_dns_zone() -> Result<RhaiDNSZone, Box<EvalAltResult>> {
+        Ok(DNSZone::new(0))
+    }
+
+    #[rhai_fn(name = "name", return_raw)]
+    pub fn set_name(
+        zone: &mut RhaiDNSZone,
+        name: String,
+    ) -> Result<RhaiDNSZone, Box<EvalAltResult>> {
+        let owned = std::mem::take(zone);
+        *zone = owned.name(name);
+        Ok(zone.clone())
+    }
+
+    #[rhai_fn(name = "description", return_raw)]
+    pub fn set_description(
+        zone: &mut RhaiDNSZone,
+        description: String,
+    ) -> Result<RhaiDNSZone, Box<EvalAltResult>> {
+        let owned = std::mem::take(zone);
+        *zone = owned.description(description);
+        Ok(zone.clone())
+    }
+
+    #[rhai_fn(name = "save_dns_zone", return_raw)]
+    pub fn save_dns_zone(zone: &mut RhaiDNSZone) -> Result<RhaiDNSZone, Box<EvalAltResult>> {
+        Ok(zone.clone())
+    }
+
+    // Setters
+    #[rhai_fn(name = "set_domain")]
+    pub fn set_domain(zone: &mut RhaiDNSZone, domain: &str) {
+        let owned = std::mem::take(zone);
+        *zone = owned.domain(domain);
+    }
+
+    // Getters
+    #[rhai_fn(name = "get_id")]
+    pub fn get_id(zone: &mut RhaiDNSZone) -> i64 {
+        zone.base_data.id as i64
+    }
+
+    #[rhai_fn(name = "get_domain")]
+    pub fn get_domain(zone: &mut RhaiDNSZone) -> String {
+        zone.domain.clone()
+    }
+}
+
+// ============================================================================
+// Registration Functions
+// ============================================================================
+// Registration functions
+pub fn register_user_functions(engine: &mut Engine) {
+    let module = exported_module!(user_module);
+    engine.register_static_module("user", module.into());
+}
+
+pub fn register_group_functions(engine: &mut Engine) {
+    let module = exported_module!(group_module);
+    engine.register_static_module("group", module.into());
+}
+
+pub fn register_account_functions(engine: &mut Engine) {
+    let module = exported_module!(account_module);
+    engine.register_static_module("account", module.into());
+}
+
+pub fn register_dnszone_functions(engine: &mut Engine) {
+    let module = exported_module!(dnszone_module);
+    engine.register_static_module("dnszone", module.into());
+}
+
+/// Register all heroledger Rhai modules with the engine
+pub fn register_heroledger_rhai_modules(engine: &mut Engine) {
+    register_user_functions(engine);
+    register_group_functions(engine);
+    register_account_functions(engine);
+    register_dnszone_functions(engine);
+}

heromodels/src/models/object/mod.rs

@@ -1,5 +1,6 @@
-// Export contact module
+// Export object module
 pub mod object;
+pub mod object_rhai_dsl;
 
-// Re-export contact, Group from the inner contact module (contact.rs) within src/models/contact/mod.rs
+// Re-export Object from the inner object module (object.rs) within src/models/object/mod.rs
 pub use self::object::Object;

heromodels/src/models/object/object_rhai_dsl.rs

@@ -0,0 +1,56 @@
+use rhai::plugin::*;
+use rhai::{CustomType, Dynamic, Engine, EvalAltResult, Module};
+use super::Object;
+
+type RhaiObject = Object;
+
+#[export_module]
+pub mod generated_rhai_module {
+    use super::*;
+
+    /// Create a new Object
+    #[rhai_fn(name = "new_object")]
+    pub fn new_object() -> RhaiObject {
+        Object::new()
+    }
+
+    /// Set the title of an Object
+    #[rhai_fn(name = "object_title")]
+    pub fn object_title(
+        object: &mut RhaiObject,
+        title: String,
+    ) -> RhaiObject {
+        let mut result = object.clone();
+        result.title = title;
+        result
+    }
+
+    /// Set the description of an Object
+    #[rhai_fn(name = "object_description")]
+    pub fn object_description(
+        object: &mut RhaiObject,
+        description: String,
+    ) -> RhaiObject {
+        let mut result = object.clone();
+        result.description = description;
+        result
+    }
+
+    /// Get the ID of an Object
+    #[rhai_fn(name = "get_object_id")]
+    pub fn get_object_id(object: &mut RhaiObject) -> i64 {
+        object.id() as i64
+    }
+
+    /// Get the title of an Object
+    #[rhai_fn(name = "get_object_title")]
+    pub fn get_object_title(object: &mut RhaiObject) -> String {
+        object.title.clone()
+    }
+
+    /// Get the description of an Object
+    #[rhai_fn(name = "get_object_description")]
+    pub fn get_object_description(object: &mut RhaiObject) -> String {
+        object.description.clone()
+    }
+}