herocode/herocoordinator
13
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Improve rpc api return objects encoding

Browse Source 
Signed-off-by: Lee Smet <lee.smet@hotmail.com>
This commit is contained in:
Lee Smet
2025-08-21 15:38:04 +02:00
parent 30b7acdaba
commit eb69a44039
7 changed files with 32 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
src/rpc.rs
View File

@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::{
models::{Actor, Context, Flow, Job, Message, Runner, ScriptType},
models::{Actor, Context, Flow, Job, Message, MessageFormatType, Runner, ScriptType},
storage::RedisDriver,
time::current_timestamp,
};
@@ -45,18 +45,6 @@ fn storage_err(e: Box<dyn std::error::Error + Send + Sync>) -> ErrorObjectOwned
}
}
// -----------------------------
// Local enums for DTOs (to keep quirks isolated)
// -----------------------------
#[derive(Debug, Deserialize, Serialize, Clone, Copy)]
#[serde(rename_all = "PascalCase")]
pub enum MessageFormatTypeDto {
Html,
Text,
Md,
}
// -----------------------------
// Create DTOs and Param wrappers
// -----------------------------
@@ -91,7 +79,6 @@ pub struct ContextCreate {
impl ContextCreate {
pub fn into_domain(self) -> Result<Context, String> {
let ts = current_timestamp();
// Note: keep current code quirk: "upddated_at"
let mut v = serde_json::Map::new();
v.insert("id".to_string(), Value::from(self.id));
v.insert(
@@ -107,7 +94,7 @@ impl ContextCreate {
serde_json::to_value(self.executors).unwrap(),
);
v.insert("created_at".to_string(), Value::from(ts));
v.insert("upddated_at".to_string(), Value::from(ts));
v.insert("updated_at".to_string(), Value::from(ts));
serde_json::from_value(Value::Object(v)).map_err(|e| e.to_string())
}
}
@@ -123,14 +110,13 @@ pub struct RunnerCreate {
impl RunnerCreate {
pub fn into_domain(self) -> Result<Runner, String> {
let ts = current_timestamp();
// Note: keep current code quirk: "crated_at"
let v = json!({
"id": self.id,
"pubkey": self.pubkey,
"address": self.address,
"topic": self.topic,
"local": self.local,
"crated_at": ts,
"created_at": ts,
"updated_at": ts,
});
serde_json::from_value(v).map_err(|e| e.to_string())
@@ -209,9 +195,8 @@ pub struct MessageCreate {
pub caller_id: u32,
pub context_id: u32,
pub message: String,
// Note: model uses ScriptType for message_type (keep as-is)
pub message_type: ScriptType,
pub message_format_type: MessageFormatTypeDto,
pub message_format_type: MessageFormatType,
pub timeout: u32,
pub timeout_ack: u32,
pub timeout_result: u32,
@@ -337,11 +322,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.save_actor(p.context_id, &actor)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(actor).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(actor)
}
})
.expect("register actor.create");
@@ -358,11 +339,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.load_actor(p.context_id, p.id)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(actor).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(actor)
}
})
.expect("register actor.load");
@@ -378,11 +355,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
let p: ContextCreateParams = params.parse().map_err(invalid_params_err)?;
let ctx = p.context.into_domain().map_err(invalid_params_err)?;
state.redis.save_context(&ctx).await.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(ctx).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(ctx)
}
})
.expect("register context.create");
@@ -395,11 +368,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
async move {
let p: ContextLoadParams = params.parse().map_err(invalid_params_err)?;
let ctx = state.redis.load_context(p.id).await.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(ctx).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(ctx)
}
})
.expect("register context.load");
@@ -419,11 +388,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.save_runner(p.context_id, &runner)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(runner).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(runner)
}
})
.expect("register runner.create");
@@ -440,11 +405,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.load_runner(p.context_id, p.id)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(runner).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(runner)
}
})
.expect("register runner.load");
@@ -464,11 +425,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.save_flow(p.context_id, &flow)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(flow).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(flow)
}
})
.expect("register flow.create");
@@ -485,11 +442,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.load_flow(p.context_id, p.id)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(flow).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(flow)
}
})
.expect("register flow.load");
@@ -509,11 +462,8 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.save_job(p.context_id, &job)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(job).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(job)
}
})
.expect("register job.create");
@@ -530,11 +480,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.load_job(p.context_id, p.caller_id, p.id)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(job).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(job)
}
})
.expect("register job.load");
@@ -554,11 +500,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.save_message(p.context_id, &message)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(message).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(message)
}
})
.expect("register message.create");
@@ -575,11 +517,7 @@ pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
.load_message(p.context_id, p.caller_id, p.id)
.await
.map_err(storage_err)?;
{
let out: serde_json::Value =
serde_json::to_value(msg).map_err(invalid_params_err)?;
Ok::<serde_json::Value, ErrorObjectOwned>(out)
}
Ok::<_, ErrorObjectOwned>(msg)
}
})
.expect("register message.load");
@@ -610,4 +548,3 @@ pub async fn start_ws<C>(
let handle = server.start(module);
Ok(handle)
}