typed-openrpc 0.1.1

#![cfg(feature = "proc-macro")]

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use typed_openrpc::{rpc_method, MethodDoc, Registry};

#[derive(Serialize, Deserialize, JsonSchema)]
struct EchoParams {
    message: String,
}

#[derive(Serialize, Deserialize, JsonSchema)]
struct EchoResult {
    echoed: String,
}

#[rpc_method]
fn echo(params: EchoParams) -> EchoResult {
    EchoResult {
        echoed: params.message,
    }
}

#[rpc_method(summary = "Echo the message in uppercase")]
fn loud_echo(params: EchoParams) -> EchoResult {
    let echoed = params.message.to_uppercase();
    EchoResult { echoed }
}

#[rpc_method(name = "custom.echo", summary = "Echo with a custom name")]
fn custom_echo(params: EchoParams) -> EchoResult {
    EchoResult {
        echoed: format!("custom: {}", params.message),
    }
}

#[test]
fn rpc_method_macro_produces_method_doc() {
    let call_result = echo(EchoParams {
        message: "hi".to_string(),
    });
    assert_eq!(call_result.echoed, "hi");

    let doc: MethodDoc = echo_method_doc();

    assert_eq!(doc.name, "echo");
    assert!(doc.summary.is_empty());
    assert!(doc.tags.is_empty());
}

#[test]
fn openrpc_doc_contains_macro_method() {
    let mut registry = Registry::new();
    registry.register(echo_method_doc());

    let doc = registry.generate_openrpc_doc();
    let methods = doc["methods"].as_array().expect("methods array");

    assert_eq!(methods.len(), 1);
    let method = &methods[0];
    assert_eq!(method["name"], "echo");
    assert_eq!(method["summary"], "");
}

#[test]
fn rpc_method_macro_allows_overrides() {
    let result = loud_echo(EchoParams {
        message: "hi".to_string(),
    });
    assert_eq!(result.echoed, "HI");

    let doc = loud_echo_method_doc();
    assert_eq!(doc.name, "loud_echo");
    assert_eq!(doc.summary, "Echo the message in uppercase");
}

#[test]
fn rpc_method_macro_allows_custom_name() {
    let output = custom_echo(EchoParams {
        message: "hello".to_string(),
    });
    assert_eq!(output.echoed, "custom: hello");

    let doc = custom_echo_method_doc();
    assert_eq!(doc.name, "custom.echo");
    assert_eq!(doc.summary, "Echo with a custom name");
}