use serde::de::Error as _;
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::value::RawValue;
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Viewer {
pub key: ViewerKey,
pub server: ServerInfo,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ViewerKey {
pub id: String,
#[serde(default)]
pub label: Option<String>,
pub role: Role,
#[serde(default)]
pub expires_at: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub enum Role {
ReadWrite,
ReadOnly,
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ServerInfo {
pub version: String,
pub api_version: u32,
#[serde(default, deserialize_with = "optional_bytes")]
pub max_item_bytes: Option<u64>,
#[serde(default)]
pub source_url: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Workspace {
pub name: String,
#[serde(deserialize_with = "bytes")]
pub quota_bytes: u64,
#[serde(deserialize_with = "bytes")]
pub used_bytes: u64,
pub item_count: u64,
pub encryption: Encryption,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Encryption {
pub state: EncryptionState,
#[serde(default)]
pub key_id: Option<String>,
#[serde(default)]
pub header: Option<Box<RawValue>>,
#[serde(default)]
pub rewrite: Option<RewriteSession>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub enum EncryptionState {
Plaintext,
Sealed,
Rewriting,
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct RewriteSession {
pub kind: String,
pub holder: String,
pub lease_expires_at: String,
pub new_key_id: String,
#[serde(default)]
pub staged_ids: Vec<String>,
pub source_items: u64,
#[serde(default)]
pub new_header: Option<Box<RawValue>>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Item {
pub id: String,
pub meta: Box<RawValue>,
#[serde(deserialize_with = "bytes")]
pub stored_bytes: u64,
pub received_at: String,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PutOutcome {
pub item: Item,
pub created: bool,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct UploadTicket {
pub upload_id: String,
pub expires_at: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BeginUpload<'a> {
pub id: &'a str,
pub meta: &'a RawValue,
pub size: String,
pub expected_key_id: Option<String>,
pub in_rewrite: bool,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct Resolved {
pub result: String,
#[serde(default)]
pub id: Option<String>,
#[serde(default)]
pub candidates: Vec<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct Cleaned {
pub removed: usize,
}
fn bytes<'de, D: Deserializer<'de>>(deserializer: D) -> Result<u64, D::Error> {
let text = String::deserialize(deserializer)?;
text.parse()
.map_err(|_| D::Error::custom(format!("`{text}` is not a byte count")))
}
fn optional_bytes<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<u64>, D::Error> {
match Option::<String>::deserialize(deserializer)? {
Some(text) => text
.parse()
.map(Some)
.map_err(|_| D::Error::custom(format!("`{text}` is not a byte count"))),
None => Ok(None),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_viewer_reads_as_the_server_sends_it() {
let viewer: Viewer = serde_json::from_str(
r#"{"key":{"expiresAt":null,"id":"052a09a4bd92","label":"curl","role":"readWrite"},"server":{"apiVersion":1,"maxItemBytes":null,"sourceUrl":"https://github.com/joelee/passalong-server","version":"0.1.0"}}"#,
)
.unwrap();
assert_eq!(viewer.key.id, "052a09a4bd92");
assert_eq!(viewer.key.role, Role::ReadWrite);
assert_eq!(viewer.server.max_item_bytes, None);
let limited: ServerInfo = serde_json::from_str(
r#"{"version":"9","apiVersion":1,"maxItemBytes":"18446744073709551615","later":true}"#,
)
.unwrap();
assert_eq!(limited.max_item_bytes, Some(u64::MAX));
assert!(
serde_json::from_str::<ServerInfo>(
r#"{"version":"9","apiVersion":1,"maxItemBytes":"-1"}"#
)
.is_err()
);
}
#[test]
fn a_workspace_keeps_its_header_as_it_was_written() {
let workspace: Workspace = serde_json::from_str(
r#"{"name":"home","quotaBytes":"21474836480","usedBytes":"5","itemCount":1,"encryption":{"state":"sealed","keyId":"0011223344556677","header":{ "b": 1, "a": [2] }}}"#,
)
.unwrap();
assert_eq!(workspace.quota_bytes, 21_474_836_480);
assert_eq!(workspace.encryption.state, EncryptionState::Sealed);
assert_eq!(
workspace.encryption.header.unwrap().get(),
r#"{ "b": 1, "a": [2] }"#
);
let other: Encryption = serde_json::from_str(r#"{"state":"somethingNew"}"#).unwrap();
assert_eq!(other.state, EncryptionState::Unknown);
}
}