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

14
specs/openrpc.json
View File

@@ -452,7 +452,7 @@
"readers",
"executors",
"created_at",
"upddated_at"
"updated_at"
],
"properties": {
"id": {
@@ -484,10 +484,9 @@
"type": "integer",
"format": "int64"
},
"upddated_at": {
"updated_at": {
"type": "integer",
"format": "int64",
"description": "Typo retained intentionally"
"format": "int64"
}
}
},
@@ -499,7 +498,7 @@
"address",
"topic",
"local",
"crated_at",
"created_at",
"updated_at"
],
"properties": {
@@ -519,10 +518,9 @@
"local": {
"type": "boolean"
},
"crated_at": {
"created_at": {
"type": "integer",
"format": "int64",
"description": "Typo retained intentionally"
"format": "int64"
},
"updated_at": {
"type": "integer",

2
src/models.rs
View File

@@ -10,6 +10,6 @@ pub use actor::Actor;
pub use context::Context;
pub use flow::Flow;
pub use job::Job;
pub use message::Message;
pub use message::{Message, MessageFormatType, MessageStatus, MessageType};
pub use runner::Runner;
pub use script_type::ScriptType;

4
src/models/job.rs
View File

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
use crate::{models::ScriptType, time::Timestamp};
#[derive(Serialize, Deserialize)]
#[derive(Clone, Serialize, Deserialize)]
pub struct Job {
/// Job Id, this is given by the actor who created the job
id: u32,
@@ -28,7 +28,7 @@ pub struct Job {
status: JobStatus,
}
#[derive(Serialize, Deserialize)]
#[derive(Clone, Serialize, Deserialize)]
pub enum JobStatus {
Dispatched,
WaitingForPrerequisites,

8
src/models/message.rs
View File

@@ -5,7 +5,7 @@ use crate::{
time::Timestamp,
};
#[derive(Serialize, Deserialize)]
#[derive(Clone, Serialize, Deserialize)]
pub struct Message {
/// Unique ID for the message, set by the caller
id: u32,
@@ -29,14 +29,14 @@ pub struct Message {
status: MessageStatus,
}
#[derive(Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageType {
Job,
Chat,
Mail,
}
#[derive(Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageStatus {
Dispatched,
Acknowledged,
@@ -44,7 +44,7 @@ pub enum MessageStatus {
Processed,
}
#[derive(Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageFormatType {
Html,
Text,

2
src/models/runner.rs
View File

@@ -19,7 +19,7 @@ pub struct Runner {
updated_at: Timestamp,
}
#[derive(Serialize, Deserialize)]
#[derive(Serialize, Deserialize, Clone)]
pub enum RunnerType {
V,
Python,

2
src/models/script_type.rs
View File

@@ -1,6 +1,6 @@
use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize, Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum ScriptType {
Osis,
Sal,

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)
}