use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum NavigateOp {
Push,
Replace,
Back,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum NoEffect {}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Effect<X = NoEffect> {
Http {
method: String,
path: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
body: Option<Value>,
#[serde(default)]
auth: bool,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
headers: BTreeMap<String, String>,
},
Timer {
after_ms: u64,
},
CancelTimer {
timer_id: u64,
},
Store {
key: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
value: Option<Value>,
},
Secure {
key: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
value: Option<String>,
},
Random {
n: u32,
},
Navigate {
op: NavigateOp,
#[serde(default)]
url: String,
},
OpenAuthBrowser {
url: String,
},
Reload {},
LoadBlob {
name: String,
},
Span {
name: String,
ms: u64,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
tags: BTreeMap<String, String>,
},
Log {
level: String,
msg: String,
},
Report {
error: String,
},
#[serde(untagged)]
App(X),
}
impl<X> Effect<X> {
#[must_use]
pub fn http(method: &str, path: &str) -> Self {
Self::Http {
method: method.to_owned(),
path: path.to_owned(),
body: None,
auth: false,
headers: BTreeMap::new(),
}
}
}
pub const BUILT_IN_EFFECT_NAMES: [&str; 13] = [
"Http",
"Timer",
"CancelTimer",
"Store",
"Secure",
"Random",
"Navigate",
"OpenAuthBrowser",
"Reload",
"LoadBlob",
"Span",
"Log",
"Report",
];
#[must_use]
pub fn builtin_collision<X: Serialize>(effect: &X) -> Option<String> {
let name: String = match serde_json::to_value(effect).ok()? {
Value::String(name) => name,
Value::Object(map) if map.len() == 1 => map.keys().next()?.clone(),
_ => return None,
};
BUILT_IN_EFFECT_NAMES
.contains(&name.as_str())
.then_some(name)
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EffectReq<X = NoEffect> {
pub id: u64,
#[serde(flatten)]
pub effect: Effect<X>,
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct HttpReply {
pub status: u16,
#[serde(default)]
pub body: Value,
#[serde(default)]
pub sent: u64,
#[serde(default)]
pub recv: u64,
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::*;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum Mine {
Vibrate { ms: u32 },
Beep,
}
#[test]
fn built_in_and_app_effects_serialize_flat_next_to_the_id() {
let built_in: EffectReq<Mine> = EffectReq {
id: 3,
effect: Effect::http("GET", "/x"),
};
let mine: EffectReq<Mine> = EffectReq {
id: 4,
effect: Effect::App(Mine::Vibrate { ms: 20 }),
};
assert_eq!(
json!({"id": 3, "Http": {"method": "GET", "path": "/x", "auth": false}}),
serde_json::to_value(&built_in).unwrap()
);
assert_eq!(
json!({"id": 4, "Vibrate": {"ms": 20}}),
serde_json::to_value(&mine).unwrap()
);
}
#[test]
fn app_effects_named_like_a_built_in_are_detected() {
#[derive(Serialize)]
enum Clash {
Timer { after_ms: u64 },
Log,
}
assert_eq!(
Some("Timer".to_owned()),
builtin_collision(&Clash::Timer { after_ms: 1 })
);
assert_eq!(Some("Log".to_owned()), builtin_collision(&Clash::Log));
assert_eq!(None, builtin_collision(&Mine::Beep));
assert_eq!(None, builtin_collision(&Mine::Vibrate { ms: 1 }));
}
#[test]
fn a_flat_effect_reads_back_to_the_same_variant() {
let built_in: EffectReq<Mine> =
serde_json::from_value(json!({"id": 1, "Timer": {"after_ms": 5}})).unwrap();
let mine: EffectReq<Mine> = serde_json::from_value(json!({"id": 2, "Beep": null})).unwrap();
assert_eq!(Effect::Timer { after_ms: 5 }, built_in.effect);
assert_eq!(Effect::App(Mine::Beep), mine.effect);
}
}