herocode/osiris
Archived
14
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure Osiris: separate core, client, and server crates to avoid circular dependencies

Browse Source
This commit is contained in:
Timur Gordon
2025-11-04 13:08:43 +01:00
parent ae846ea734
commit 5d82959457
86 changed files with 601 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
client/Cargo.toml
View File

@@ -6,9 +6,18 @@ edition = "2021"
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
reqwest = { version = "0.11", features = ["json"] }
reqwest = { version = "0.12", default-features = false, features = ["json"] }
anyhow = "1.0"
thiserror = "1.0"
chrono = "0.4"
hero-supervisor-openrpc-client = { path = "../../supervisor/clients/openrpc" }
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
uuid = { version = "1.0", features = ["v4"] }
[target.'cfg(target_arch = "wasm32")'.dependencies]
uuid = { version = "1.0", features = ["v4", "js"] }
getrandom = { version = "0.2", features = ["js"] }
[dev-dependencies]
tokio = { version = "1.23", features = ["full", "macros"] }

69
client/src/communication.rs
View File

@@ -1,4 +1,4 @@
//! Communication query methods (email verification, etc.)
//! Communication methods (queries and commands)
use serde::{Deserialize, Serialize};
use crate::{OsirisClient, OsirisClientError};
@@ -24,14 +24,77 @@ pub enum VerificationStatus {
Failed,
}
// ========== Request/Response Models ==========
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SendVerificationRequest {
pub email: String,
pub verification_url: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SendVerificationResponse {
pub verification_id: String,
pub email: String,
pub expires_at: i64,
}
// ========== Client Methods ==========
impl OsirisClient {
/// Get verification by ID
// ========== Query Methods ==========
/// Get verification by ID (query)
pub async fn get_verification(&self, verification_id: &str) -> Result<Verification, OsirisClientError> {
self.get("verification", verification_id).await
}
/// Get verification by email
/// Get verification by email (query)
pub async fn get_verification_by_email(&self, email: &str) -> Result<Vec<Verification>, OsirisClientError> {
self.query("verification", &format!("email={}", email)).await
}
/// Get verification status - alias for get_verification (query)
pub async fn get_verification_status(&self, verification_id: &str) -> Result<Verification, OsirisClientError> {
self.get_verification(verification_id).await
}
// ========== Command Methods ==========
/// Send verification email (command)
pub async fn send_verification_email(
&self,
request: SendVerificationRequest,
) -> Result<SendVerificationResponse, OsirisClientError> {
let email = &request.email;
let verification_url = request.verification_url.as_deref().unwrap_or("");
// Generate verification code
let verification_id = format!("ver_{}", uuid::Uuid::new_v4());
let code = format!("{:06}", (uuid::Uuid::new_v4().as_u128() % 1_000_000));
let script = format!(r#"
// Send email verification
let email = "{}";
let code = "{}";
let verification_url = "{}";
let verification_id = "{}";
// TODO: Implement actual email sending logic
print("Sending verification email to: " + email);
print("Verification code: " + code);
print("Verification URL: " + verification_url);
// Return verification details
verification_id
"#, email, code, verification_url, verification_id);
let _response = self.execute_script(&script).await?;
Ok(SendVerificationResponse {
verification_id,
email: request.email,
expires_at: chrono::Utc::now().timestamp() + 3600, // 1 hour
})
}
}

66
client/src/kyc.rs
View File

@@ -1,4 +1,4 @@
//! KYC query methods
//! KYC methods (queries and commands)
use serde::{Deserialize, Serialize};
use crate::{OsirisClient, OsirisClientError};
@@ -25,7 +25,26 @@ pub enum KycSessionStatus {
Expired,
}
// ========== Request/Response Models ==========
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KycVerificationRequest {
pub resident_id: String,
pub callback_url: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KycVerificationResponse {
pub session_id: String,
pub kyc_url: String,
pub expires_at: i64,
}
// ========== Client Methods ==========
impl OsirisClient {
// ========== Query Methods ==========
/// Get KYC session by ID
pub async fn get_kyc_session(&self, session_id: &str) -> Result<KycSession, OsirisClientError> {
self.get("kyc_session", session_id).await
@@ -35,4 +54,49 @@ impl OsirisClient {
pub async fn list_kyc_sessions_by_resident(&self, resident_id: &str) -> Result<Vec<KycSession>, OsirisClientError> {
self.query("kyc_session", &format!("resident_id={}", resident_id)).await
}
// ========== Command Methods ==========
/// Start KYC verification (command)
pub async fn start_kyc_verification(
&self,
request: KycVerificationRequest,
) -> Result<KycVerificationResponse, OsirisClientError> {
let resident_id = &request.resident_id;
let callback_url = request.callback_url.as_deref().unwrap_or("");
// Generate session ID
let session_id = format!("kyc_{}", uuid::Uuid::new_v4());
let script = format!(r#"
// Start KYC verification
let resident_id = "{}";
let callback_url = "{}";
let session_id = "{}";
// TODO: Implement actual KYC provider integration
print("Starting KYC verification for resident: " + resident_id);
print("Session ID: " + session_id);
print("Callback URL: " + callback_url);
// Return session details
session_id
"#, resident_id, callback_url, session_id);
let _response = self.execute_script(&script).await?;
Ok(KycVerificationResponse {
session_id,
kyc_url: "https://kyc.example.com/verify".to_string(),
expires_at: chrono::Utc::now().timestamp() + 86400,
})
}
/// Check KYC status (query)
pub async fn check_kyc_status(
&self,
session_id: String,
) -> Result<KycSession, OsirisClientError> {
self.get_kyc_session(&session_id).await
}
}

256
client/src/lib.rs
View File

@@ -1,9 +1,13 @@
//! Osiris Client - Query API for Osiris data structures
//! Osiris Client - Unified CQRS Client
//!
//! This client provides read-only access to Osiris data via REST API.
//! Follows CQRS pattern: queries go through this client, commands go through Rhai scripts.
//! This client provides both:
//! - Commands (writes) via Rhai scripts to Hero Supervisor
//! - Queries (reads) via REST API to Osiris server
//!
//! Follows CQRS pattern with a single unified interface.
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use thiserror::Error;
pub mod kyc;
@@ -24,30 +28,122 @@ pub enum OsirisClientError {
#[error("Deserialization failed: {0}")]
DeserializationFailed(String),
#[error("Configuration error: {0}")]
ConfigError(String),
#[error("Command execution failed: {0}")]
CommandFailed(String),
}
/// Osiris client for querying data
/// Osiris client with CQRS support
#[derive(Clone, Debug)]
pub struct OsirisClient {
base_url: String,
// Query side (Osiris REST API)
osiris_url: String,
// Command side (Supervisor + Rhai)
supervisor_url: Option<String>,
runner_name: String,
supervisor_secret: Option<String>,
timeout: u64,
// HTTP client
client: reqwest::Client,
}
impl OsirisClient {
/// Create a new Osiris client
pub fn new(base_url: impl Into<String>) -> Self {
/// Builder for OsirisClient
#[derive(Clone, Debug, Default)]
pub struct OsirisClientBuilder {
osiris_url: Option<String>,
supervisor_url: Option<String>,
runner_name: Option<String>,
supervisor_secret: Option<String>,
timeout: u64,
}
impl OsirisClientBuilder {
/// Create a new builder
pub fn new() -> Self {
Self {
base_url: base_url.into(),
osiris_url: None,
supervisor_url: None,
runner_name: None,
supervisor_secret: None,
timeout: 30,
}
}
/// Set the Osiris server URL (for queries)
pub fn osiris_url(mut self, url: impl Into<String>) -> Self {
self.osiris_url = Some(url.into());
self
}
/// Set the Supervisor URL (for commands)
pub fn supervisor_url(mut self, url: impl Into<String>) -> Self {
self.supervisor_url = Some(url.into());
self
}
/// Set the runner name (default: "osiris")
pub fn runner_name(mut self, name: impl Into<String>) -> Self {
self.runner_name = Some(name.into());
self
}
/// Set the supervisor authentication secret
pub fn supervisor_secret(mut self, secret: impl Into<String>) -> Self {
self.supervisor_secret = Some(secret.into());
self
}
/// Set the timeout in seconds (default: 30)
pub fn timeout(mut self, timeout: u64) -> Self {
self.timeout = timeout;
self
}
/// Build the OsirisClient
pub fn build(self) -> Result<OsirisClient, OsirisClientError> {
let osiris_url = self.osiris_url
.ok_or_else(|| OsirisClientError::ConfigError("osiris_url is required".to_string()))?;
Ok(OsirisClient {
osiris_url,
supervisor_url: self.supervisor_url,
runner_name: self.runner_name.unwrap_or_else(|| "osiris".to_string()),
supervisor_secret: self.supervisor_secret,
timeout: self.timeout,
client: reqwest::Client::new(),
})
}
}
impl OsirisClient {
/// Create a new Osiris client (query-only)
pub fn new(osiris_url: impl Into<String>) -> Self {
Self {
osiris_url: osiris_url.into(),
supervisor_url: None,
runner_name: "osiris".to_string(),
supervisor_secret: None,
timeout: 30,
client: reqwest::Client::new(),
}
}
/// Create a builder for full CQRS configuration
pub fn builder() -> OsirisClientBuilder {
OsirisClientBuilder::new()
}
/// Generic GET request for any struct by ID
pub async fn get<T>(&self, struct_name: &str, id: &str) -> Result<T, OsirisClientError>
where
T: for<'de> Deserialize<'de>,
{
let url = format!("{}/api/{}/{}", self.base_url, struct_name, id);
let url = format!("{}/api/{}/{}", self.osiris_url, struct_name, id);
let response = self.client
.get(&url)
@@ -71,7 +167,7 @@ impl OsirisClient {
where
T: for<'de> Deserialize<'de>,
{
let url = format!("{}/api/{}", self.base_url, struct_name);
let url = format!("{}/api/{}", self.osiris_url, struct_name);
let response = self.client
.get(&url)
@@ -91,7 +187,7 @@ impl OsirisClient {
where
T: for<'de> Deserialize<'de>,
{
let url = format!("{}/api/{}?{}", self.base_url, struct_name, query);
let url = format!("{}/api/{}?{}", self.osiris_url, struct_name, query);
let response = self.client
.get(&url)
@@ -105,6 +201,114 @@ impl OsirisClient {
Ok(data)
}
// ========== Command Methods (Supervisor + Rhai) ==========
/// Execute a Rhai script via the Supervisor
pub async fn execute_script(&self, script: &str) -> Result<RunJobResponse, OsirisClientError> {
let supervisor_url = self.supervisor_url.as_ref()
.ok_or_else(|| OsirisClientError::ConfigError("supervisor_url not configured for commands".to_string()))?;
let secret = self.supervisor_secret.as_ref()
.ok_or_else(|| OsirisClientError::ConfigError("supervisor_secret not configured for commands".to_string()))?;
// Use supervisor client for native builds
#[cfg(not(target_arch = "wasm32"))]
{
use hero_supervisor_openrpc_client::{SupervisorClient, JobBuilder};
let supervisor_client = SupervisorClient::new(supervisor_url)
.map_err(|e| OsirisClientError::CommandFailed(e.to_string()))?;
let job = JobBuilder::new()
.runner_name(&self.runner_name)
.script(script)
.timeout(self.timeout)
.build();
let result = supervisor_client.run_job(secret, job)
.await
.map_err(|e| OsirisClientError::CommandFailed(e.to_string()))?;
// Convert JobResult to RunJobResponse
match result {
hero_supervisor_openrpc_client::JobResult::Success { success } => {
Ok(RunJobResponse {
job_id: success.clone(),
status: "completed".to_string(),
})
}
hero_supervisor_openrpc_client::JobResult::Error { error } => {
Err(OsirisClientError::CommandFailed(error))
}
}
}
// Use WASM client for browser builds
#[cfg(target_arch = "wasm32")]
{
use hero_supervisor_openrpc_client::wasm::{WasmSupervisorClient, WasmJobBuilder};
let supervisor_client = WasmSupervisorClient::new(supervisor_url.clone());
let job = WasmJobBuilder::new()
.runner_name(&self.runner_name)
.script(script)
.timeout(self.timeout as i32)
.build();
let result_str = supervisor_client.run_job(secret.clone(), job)
.await
.map_err(|e| OsirisClientError::CommandFailed(format!("{:?}", e)))?;
// Parse the result
let result: serde_json::Value = serde_json::from_str(&result_str)
.map_err(|e| OsirisClientError::DeserializationFailed(e.to_string()))?;
if let Some(success) = result.get("success") {
Ok(RunJobResponse {
job_id: success.as_str().unwrap_or("unknown").to_string(),
status: "completed".to_string(),
})
} else if let Some(error) = result.get("error") {
Err(OsirisClientError::CommandFailed(error.as_str().unwrap_or("unknown error").to_string()))
} else {
Err(OsirisClientError::DeserializationFailed("Invalid response format".to_string()))
}
}
}
/// Execute a Rhai script template with variable substitution
pub async fn execute_template(&self, template: &str, variables: &HashMap<String, String>) -> Result<RunJobResponse, OsirisClientError> {
let script = substitute_variables(template, variables);
self.execute_script(&script).await
}
}
// ========== Helper Structures ==========
#[derive(Serialize)]
struct RunJobRequest {
runner_name: String,
script: String,
timeout: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
env: Option<HashMap<String, String>>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct RunJobResponse {
pub job_id: String,
pub status: String,
}
/// Helper function to substitute variables in a Rhai script template
pub fn substitute_variables(template: &str, variables: &HashMap<String, String>) -> String {
let mut result = template.to_string();
for (key, value) in variables {
let placeholder = format!("{{{{ {} }}}}", key);
result = result.replace(&placeholder, value);
}
result
}
#[cfg(test)]
@@ -114,6 +318,32 @@ mod tests {
#[test]
fn test_client_creation() {
let client = OsirisClient::new("http://localhost:8080");
assert_eq!(client.base_url, "http://localhost:8080");
assert_eq!(client.osiris_url, "http://localhost:8080");
}
#[test]
fn test_builder() {
let client = OsirisClient::builder()
.osiris_url("http://localhost:8081")
.supervisor_url("http://localhost:3030")
.supervisor_secret("test_secret")
.runner_name("osiris")
.build()
.unwrap();
assert_eq!(client.osiris_url, "http://localhost:8081");
assert_eq!(client.supervisor_url, Some("http://localhost:3030".to_string()));
assert_eq!(client.runner_name, "osiris");
}
#[test]
fn test_substitute_variables() {
let template = "let x = {{ value }}; let y = {{ name }};";
let mut vars = HashMap::new();
vars.insert("value".to_string(), "42".to_string());
vars.insert("name".to_string(), "\"test\"".to_string());
let result = substitute_variables(template, &vars);
assert_eq!(result, "let x = 42; let y = \"test\";");
}
}

37
client/src/scripts/kyc_verification.rhai Normal file
View File

@@ -0,0 +1,37 @@
// KYC verification script template
// Variables: {{resident_id}}, {{callback_url}}
print("=== Starting KYC Verification ===");
print("Resident ID: {{resident_id}}");
// Get freezone context
let freezone_pubkey = "04e58314c13ea3f9caed882001a5090797b12563d5f9bbd7f16efe020e060c780b446862311501e2e9653416527d2634ff8a8050ff3a085baccd7ddcb94185ff56";
let freezone_ctx = get_context([freezone_pubkey]);
// Get KYC client from context
let kyc_client = freezone_ctx.get("kyc_client");
if kyc_client == () {
print("ERROR: KYC client not configured");
return #{
success: false,
error: "KYC client not configured"
};
}
// Create KYC session
let session = kyc_client.create_session(
"{{resident_id}}",
"{{callback_url}}"
);
print("✓ KYC session created");
print(" Session ID: " + session.session_id);
print(" KYC URL: " + session.kyc_url);
// Return response
#{
success: true,
session_id: session.session_id,
kyc_url: session.kyc_url,
expires_at: session.expires_at
}