Newer
Older
use crate::error::CallError;
use alloc::collections::BTreeMap;
use serde::de::{self, Deserializer, Unexpected, Visitor};
use serde::ser::Serializer;
use serde::{Deserialize, Serialize};
use serde_json::{value::RawValue, Value as JsonValue};
use std::fmt;
/// JSON-RPC parameter values for subscriptions.
#[derive(Serialize, Deserialize, Debug)]
pub struct JsonRpcNotificationParams<'a> {
/// Subscription ID
pub subscription: u64,
/// Result.
#[serde(borrow)]
pub result: &'a RawValue,
}
/// JSON-RPC parameter values for subscriptions with support for number and strings.
#[derive(Deserialize, Debug)]
pub struct JsonRpcNotificationParamsAlloc<T> {
/// Subscription ID
pub subscription: SubscriptionId,
/// Result.
pub result: T,
}
/// JSON-RPC v2 marker type.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
pub struct TwoPointZero;
struct TwoPointZeroVisitor;
impl<'de> Visitor<'de> for TwoPointZeroVisitor {
type Value = TwoPointZero;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str(r#"a string "2.0""#)
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
match s {
"2.0" => Ok(TwoPointZero),
_ => Err(de::Error::invalid_value(Unexpected::Str(s), &self)),
}
}
}
impl<'de> Deserialize<'de> for TwoPointZero {
fn deserialize<D>(deserializer: D) -> Result<TwoPointZero, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(TwoPointZeroVisitor)
}
}
impl Serialize for TwoPointZero {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str("2.0")
}
}
/// Parameters sent with the RPC request
#[derive(Clone, Copy, Debug)]
pub struct RpcParams<'a>(Option<&'a str>);
impl<'a> RpcParams<'a> {
/// Create params
pub fn new(raw: Option<&'a str>) -> Self {
Self(raw)
}
/// Attempt to parse all parameters as array or map into type T
pub fn parse<T>(self) -> Result<T, CallError>
where
T: Deserialize<'a>,
{
let params = self.0.unwrap_or("null");
serde_json::from_str(params).map_err(|_| CallError::InvalidParams)
}
/// Attempt to parse only the first parameter from an array into type T
pub fn one<T>(self) -> Result<T, CallError>
where
T: Deserialize<'a>,
{
self.parse::<[T; 1]>().map(|[res]| res)
}
}
/// [Serializable JSON-RPC parameters](https://www.jsonrpc.org/specification#parameter_structures)
///
/// If your type implement `Into<JsonValue>` call that favor of `serde_json::to:value` to
/// construct the parameters. Because `serde_json::to_value` serializes the type which
/// allocates whereas `Into<JsonValue>` doesn't in most cases.
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#[serde(untagged)]
pub enum JsonRpcParams<'a> {
/// No params.
NoParams,
/// Positional params (heap allocated)
Array(Vec<JsonValue>),
/// Positional params (slice)
ArrayRef(&'a [JsonValue]),
/// Params by name.
Map(BTreeMap<&'a str, JsonValue>),
}
impl<'a> From<BTreeMap<&'a str, JsonValue>> for JsonRpcParams<'a> {
fn from(map: BTreeMap<&'a str, JsonValue>) -> Self {
Self::Map(map)
}
}
impl<'a> From<Vec<JsonValue>> for JsonRpcParams<'a> {
fn from(arr: Vec<JsonValue>) -> Self {
Self::Array(arr)
}
}
impl<'a> From<&'a [JsonValue]> for JsonRpcParams<'a> {
fn from(slice: &'a [JsonValue]) -> Self {
Self::ArrayRef(slice)
}
}
/// Id of a subscription, communicated by the server.
#[derive(Debug, PartialEq, Clone, Hash, Eq, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
#[serde(untagged)]
pub enum SubscriptionId {
/// Numeric id
Num(u64),
/// String id
Str(String),
}
impl From<SubscriptionId> for JsonValue {
fn from(sub_id: SubscriptionId) -> Self {
match sub_id {
SubscriptionId::Num(n) => n.into(),
SubscriptionId::Str(s) => s.into(),
}
}
}
/// Request Id
#[derive(Debug, PartialEq, Clone, Hash, Eq, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
#[serde(untagged)]
pub enum Id<'a> {
/// Null
Null,
/// Numeric id
Number(u64),
/// String id
#[serde(borrow)]
Str(Cow<'a, str>),
impl<'a> Id<'a> {
/// If the Id is a number, returns the associated number. Returns None otherwise.
pub fn as_number(&self) -> Option<&u64> {
match self {
Id::Number(n) => Some(n),
_ => None,
}
}
/// If the Id is a String, returns the associated str. Returns None otherwise.
pub fn as_str(&self) -> Option<&str> {
match self {
Id::Str(s) => Some(s),
_ => None,
}
}
/// If the ID is Null, returns (). Returns None otherwise.
pub fn as_null(&self) -> Option<()> {
match self {
Id::Null => Some(()),
_ => None,
}
}
}
#[cfg(test)]
mod test {
use super::{Cow, Id, JsonRpcParams, JsonValue, RpcParams, SubscriptionId, TwoPointZero};
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
#[test]
fn id_deserialization() {
let s = r#""2""#;
let deserialized: Id = serde_json::from_str(s).unwrap();
assert_eq!(deserialized, Id::Str("2".into()));
let s = r#"2"#;
let deserialized: Id = serde_json::from_str(s).unwrap();
assert_eq!(deserialized, Id::Number(2));
let s = r#""2x""#;
let deserialized: Id = serde_json::from_str(s).unwrap();
assert_eq!(deserialized, Id::Str(Cow::const_str("2x")));
let s = r#"[1337]"#;
assert!(serde_json::from_str::<Id>(s).is_err());
let s = r#"[null, 0, 2, "3"]"#;
let deserialized: Vec<Id> = serde_json::from_str(s).unwrap();
assert_eq!(deserialized, vec![Id::Null, Id::Number(0), Id::Number(2), Id::Str("3".into())]);
}
#[test]
fn id_serialization() {
let d =
vec![Id::Null, Id::Number(0), Id::Number(2), Id::Number(3), Id::Str("3".into()), Id::Str("test".into())];
let serialized = serde_json::to_string(&d).unwrap();
assert_eq!(serialized, r#"[null,0,2,3,"3","test"]"#);
}
#[test]
fn params_serialize() {
let test_vector = &[
("null", JsonRpcParams::NoParams),
("[42,23]", JsonRpcParams::Array(serde_json::from_str("[42,23]").unwrap())),
(
r#"{"a":42,"b":null,"c":"aa"}"#,
JsonRpcParams::Map(serde_json::from_str(r#"{"a":42,"b":null,"c":"aa"}"#).unwrap()),
),
];
for (initial_ser, params) in test_vector {
let serialized = serde_json::to_string(params).unwrap();
assert_eq!(&serialized, initial_ser);
}
}
#[test]
fn params_parse() {
let none = RpcParams::new(None);
assert!(none.one::<u64>().is_err());
let array_params = RpcParams::new(Some("[1, 2, 3]"));
let arr: Result<[u64; 3], _> = array_params.parse();
assert!(arr.is_ok());
let arr: Result<(u64, u64, u64), _> = array_params.parse();
assert!(arr.is_ok());
let array_one = RpcParams::new(Some("[1]"));
let one: Result<u64, _> = array_one.one();
assert!(one.is_ok());
let object_params = RpcParams::new(Some(r#"{"beef":99,"dinner":0}"#));
let obj: Result<JsonValue, _> = object_params.parse();
assert!(obj.is_ok());
}
#[test]
fn two_point_zero_serde_works() {
let initial_ser = r#""2.0""#;
// The fact that it was deserialized is enough.
let two_point_zero: TwoPointZero = serde_json::from_str(initial_ser).unwrap();
let serialized = serde_json::to_string(&two_point_zero).unwrap();
assert_eq!(serialized, initial_ser);
}
#[test]
fn subscription_id_serde_works() {
let test_vector = &[("42", SubscriptionId::Num(42)), (r#""one""#, SubscriptionId::Str("one".into()))];
for (initial_ser, expected) in test_vector {
let id: SubscriptionId = serde_json::from_str(initial_ser).unwrap();
assert_eq!(&id, expected);
let serialized = serde_json::to_string(&id).unwrap();
assert_eq!(&serialized, initial_ser);
}
}