use super::{ProtoElemJson, ProtoElemSeed};
use crate::map_codec::MapStorage;
use crate::ProtoList;
use alloc::vec::Vec;
use core::fmt::Display;
use core::marker::PhantomData;
use core::str::FromStr;
use serde::de::{DeserializeOwned, DeserializeSeed, Deserializer};
use serde::{Deserialize, Serialize, Serializer};
#[doc(hidden)]
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum ViewJsonErrorReason {
#[error("protobuf JSON serialization of this view is disabled")]
Denied,
}
pub trait ProtoBytesJson: crate::ProtoBytes {
fn serialize_json<S: Serializer>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>;
fn deserialize_json<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
}
pub trait ProtoStringJson: crate::ProtoString {
fn serialize_json<S: Serializer>(text: &str, serializer: S) -> Result<S::Ok, S::Error>;
fn deserialize_json<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
}
macro_rules! policy_plumbing {
(
trait: $trait:ident,
borrowed: $borrowed:ty,
owned: $owned:ident,
singular: $singular:ident,
optional: $optional:ident,
adapter: $adapter:ident,
seq_adapter: $seq_adapter:ident,
seed: $seed:ident,
$(,)?
) => {
struct $owned<T>(T);
impl<'de, T: $trait> Deserialize<'de> for $owned<T> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
T::deserialize_json(d).map($owned)
}
}
#[doc(hidden)]
pub mod $singular {
use super::$trait;
use serde::{Deserializer, Serializer};
pub fn serialize<T: $trait, S: Serializer>(value: &T, s: S) -> Result<S::Ok, S::Error> {
T::serialize_json(value.as_ref(), s)
}
pub fn deserialize<'de, T: $trait, D: Deserializer<'de>>(d: D) -> Result<T, D::Error> {
<Option<super::$owned<T>> as serde::Deserialize>::deserialize(d)
.map(|value| value.map(|owned| owned.0).unwrap_or_default())
}
}
#[doc(hidden)]
pub mod $optional {
use super::$trait;
use serde::{Deserializer, Serializer};
pub fn serialize<T: $trait, S: Serializer>(
value: &Option<T>,
s: S,
) -> Result<S::Ok, S::Error> {
match value {
Some(v) => T::serialize_json(v.as_ref(), s),
None => s.serialize_none(),
}
}
pub fn deserialize<'de, T: $trait, D: Deserializer<'de>>(
d: D,
) -> Result<Option<T>, D::Error> {
<Option<super::$owned<T>> as serde::Deserialize>::deserialize(d)
.map(|value| value.map(|owned| owned.0))
}
}
#[doc(hidden)]
pub struct $adapter<'a, T: ?Sized>(&'a $borrowed, PhantomData<fn() -> T>);
impl<'a, T: $trait> $adapter<'a, T> {
pub fn new(value: &'a $borrowed) -> Self {
Self(value, PhantomData)
}
}
impl<T: $trait> Serialize for $adapter<'_, T> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
T::serialize_json(self.0, s)
}
}
#[doc(hidden)]
pub struct $seq_adapter<'a, T: ?Sized>(&'a [&'a $borrowed], PhantomData<fn() -> T>);
impl<'a, T: $trait> $seq_adapter<'a, T> {
pub fn new(elements: &'a [&'a $borrowed]) -> Self {
Self(elements, PhantomData)
}
}
impl<T: $trait> Serialize for $seq_adapter<'_, T> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeSeq as _;
let mut seq = s.serialize_seq(Some(self.0.len()))?;
for element in self.0 {
seq.serialize_element(&$adapter::<T>::new(element))?;
}
seq.end()
}
}
#[doc(hidden)]
pub struct $seed<T>(PhantomData<fn() -> T>);
impl<T> $seed<T> {
pub fn new() -> Self {
Self(PhantomData)
}
}
impl<T> Default for $seed<T> {
fn default() -> Self {
Self::new()
}
}
impl<'de, T: $trait> DeserializeSeed<'de> for $seed<T> {
type Value = T;
fn deserialize<D: Deserializer<'de>>(self, d: D) -> Result<T, D::Error> {
T::deserialize_json(d)
}
}
};
}
policy_plumbing! {
trait: ProtoBytesJson,
borrowed: [u8],
owned: OwnedBytes,
singular: bytes_policy,
optional: opt_bytes_policy,
adapter: BytesPolicyJson,
seq_adapter: BytesPolicySeqJson,
seed: BytesPolicySeed,
}
policy_plumbing! {
trait: ProtoStringJson,
borrowed: str,
owned: OwnedString,
singular: string_policy,
optional: opt_string_policy,
adapter: StringPolicyJson,
seq_adapter: StringPolicySeqJson,
seed: StringPolicySeed,
}
type Marker<T> = PhantomData<fn() -> T>;
trait ValueCodec<V> {
fn serialize<S: Serializer>(value: &V, s: S) -> Result<S::Ok, S::Error>;
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<V, D::Error>;
}
struct BytesValues;
impl<V: ProtoBytesJson> ValueCodec<V> for BytesValues {
fn serialize<S: Serializer>(value: &V, s: S) -> Result<S::Ok, S::Error> {
V::serialize_json(value.as_ref(), s)
}
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<V, D::Error> {
V::deserialize_json(d)
}
}
struct StringValues;
impl<V: ProtoStringJson> ValueCodec<V> for StringValues {
fn serialize<S: Serializer>(value: &V, s: S) -> Result<S::Ok, S::Error> {
V::serialize_json(value.as_ref(), s)
}
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<V, D::Error> {
V::deserialize_json(d)
}
}
struct Elem<VC, V>(V, Marker<VC>);
impl<VC: ValueCodec<V>, V> ProtoElemJson for Elem<VC, V> {
fn serialize_proto_json<S: Serializer>(v: &Self, s: S) -> Result<S::Ok, S::Error> {
VC::serialize(&v.0, s)
}
fn deserialize_proto_json<'de, D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
VC::deserialize(d).map(|v| Elem(v, PhantomData))
}
}
struct ValueJson<'a, VC, V>(&'a V, Marker<VC>);
impl<VC: ValueCodec<V>, V> Serialize for ValueJson<'_, VC, V> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
VC::serialize(self.0, s)
}
}
fn serialize_seq<VC: ValueCodec<T>, T, S: Serializer>(v: &[T], s: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeSeq as _;
let mut seq = s.serialize_seq(Some(v.len()))?;
for element in v {
seq.serialize_element(&ValueJson::<VC, T>(element, PhantomData))?;
}
seq.end()
}
fn deserialize_vec<'de, VC, T, D>(d: D) -> Result<Vec<T>, D::Error>
where
VC: ValueCodec<T>,
D: Deserializer<'de>,
{
struct Vis<VC, T>(Marker<(VC, T)>);
impl<'de, VC: ValueCodec<T>, T> serde::de::Visitor<'de> for Vis<VC, T> {
type Value = Vec<T>;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("an array or null")
}
fn visit_unit<E>(self) -> Result<Vec<T>, E> {
Ok(Vec::new())
}
fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Vec<T>, A::Error> {
let mut out = Vec::with_capacity(super::clamp_size_hint(seq.size_hint()));
while let Some(element) =
seq.next_element_seed(ProtoElemSeed::<Elem<VC, T>>(PhantomData))?
{
out.push(element.0);
}
Ok(out)
}
crate::reject_other_json_kinds!(
bool, i64, u64, i128, u128, f64, str, string, bytes, byte_buf, map
);
}
d.deserialize_any(Vis::<VC, T>(PhantomData))
}
fn deserialize_list<'de, VC, T, C, D>(d: D) -> Result<C, D::Error>
where
VC: ValueCodec<T>,
C: ProtoList<T>,
D: Deserializer<'de>,
{
struct Vis<VC, T, C>(Marker<(VC, T, C)>);
impl<'de, VC: ValueCodec<T>, T, C: ProtoList<T>> serde::de::Visitor<'de> for Vis<VC, T, C> {
type Value = C;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("an array or null")
}
fn visit_unit<E>(self) -> Result<C, E> {
Ok(C::default())
}
fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<C, A::Error> {
let mut out = C::default();
while let Some(element) =
seq.next_element_seed(ProtoElemSeed::<Elem<VC, T>>(PhantomData))?
{
ProtoList::push(&mut out, element.0);
}
Ok(out)
}
crate::reject_other_json_kinds!(
bool, i64, u64, i128, u128, f64, str, string, bytes, byte_buf, map
);
}
d.deserialize_any(Vis::<VC, T, C>(PhantomData))
}
trait KeyCodec<K> {
fn serialize<S: Serializer>(key: &K, s: S) -> Result<S::Ok, S::Error>;
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<K, D::Error>;
}
struct DisplayKeys;
impl<K: Display + FromStr> KeyCodec<K> for DisplayKeys {
fn serialize<S: Serializer>(key: &K, s: S) -> Result<S::Ok, S::Error> {
s.collect_str(key)
}
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<K, D::Error> {
super::guarded_key::KeySeed::<K>(PhantomData).deserialize(d)
}
}
struct SerdeKeys;
impl<K: Serialize + DeserializeOwned> KeyCodec<K> for SerdeKeys {
fn serialize<S: Serializer>(key: &K, s: S) -> Result<S::Ok, S::Error> {
key.serialize(s)
}
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<K, D::Error> {
K::deserialize(d)
}
}
struct PolicyKeys;
impl<K: ProtoStringJson> KeyCodec<K> for PolicyKeys {
fn serialize<S: Serializer>(key: &K, s: S) -> Result<S::Ok, S::Error> {
K::serialize_json(key.as_ref(), s)
}
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<K, D::Error> {
K::deserialize_json(d)
}
}
struct Base64Keys;
impl<K: AsRef<[u8]> + From<Vec<u8>>> KeyCodec<K> for Base64Keys {
fn serialize<S: Serializer>(key: &K, s: S) -> Result<S::Ok, S::Error> {
super::bytes::serialize(key.as_ref(), s)
}
fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<K, D::Error> {
struct Vis;
impl serde::de::Visitor<'_> for Vis {
type Value = Vec<u8>;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("a base64 map key string")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Vec<u8>, E> {
let mut out = alloc::vec![0; crate::json_helpers::bytes::max_decoded_len(v)];
match crate::json_helpers::bytes::decode_into::<E>(v, &mut out) {
Ok(len) => {
out.truncate(len);
Ok(out)
}
Err(error) => {
#[cfg(feature = "zeroize")]
zeroize::Zeroize::zeroize(&mut out);
Err(error)
}
}
}
#[cfg(feature = "zeroize")]
fn visit_string<E: serde::de::Error>(
self,
v: alloc::string::String,
) -> Result<Vec<u8>, E> {
let v = zeroize::Zeroizing::new(v);
self.visit_str(&v)
}
}
d.deserialize_str(Vis).map(K::from)
}
}
struct KeyJson<'a, KC, K>(&'a K, Marker<KC>);
impl<KC: KeyCodec<K>, K> Serialize for KeyJson<'_, KC, K> {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
KC::serialize(self.0, s)
}
}
struct CodecKeySeed<KC, K>(Marker<(KC, K)>);
impl<'de, KC: KeyCodec<K>, K> DeserializeSeed<'de> for CodecKeySeed<KC, K> {
type Value = K;
fn deserialize<D: Deserializer<'de>>(self, d: D) -> Result<K, D::Error> {
KC::deserialize(d)
}
}
fn serialize_map<KC, VC, C, S>(m: &C, s: S) -> Result<S::Ok, S::Error>
where
C: MapStorage,
KC: KeyCodec<C::Key>,
VC: ValueCodec<C::Value>,
S: Serializer,
{
use serde::ser::SerializeMap as _;
let mut map = s.serialize_map(Some(m.storage_len()))?;
for (k, v) in m.storage_iter() {
map.serialize_entry(
&KeyJson::<KC, C::Key>(k, PhantomData),
&ValueJson::<VC, C::Value>(v, PhantomData),
)?;
}
map.end()
}
fn deserialize_map<'de, KC, VC, C, D>(d: D) -> Result<C, D::Error>
where
C: MapStorage + Default,
KC: KeyCodec<C::Key>,
VC: ValueCodec<C::Value>,
D: Deserializer<'de>,
{
struct Vis<KC, VC, C>(Marker<(KC, VC, C)>);
impl<'de, KC, VC, C> serde::de::Visitor<'de> for Vis<KC, VC, C>
where
C: MapStorage + Default,
KC: KeyCodec<C::Key>,
VC: ValueCodec<C::Value>,
{
type Value = C;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("a JSON object with string keys, or null")
}
fn visit_unit<E>(self) -> Result<C, E> {
Ok(C::default())
}
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<C, A::Error> {
let mut out = C::default();
while let Some(k) = map.next_key_seed(CodecKeySeed::<KC, C::Key>(PhantomData))? {
let k = crate::erasing::Erasing::new(k, C::storage_erase_key);
let v = map.next_value_seed(ProtoElemSeed::<Elem<VC, C::Value>>(PhantomData))?;
out.storage_insert(k.into_inner(), v.0);
}
Ok(out)
}
crate::reject_other_json_kinds!(
bool, i64, u64, i128, u128, f64, str, string, bytes, byte_buf, seq
);
}
d.deserialize_any(Vis::<KC, VC, C>(PhantomData))
}
macro_rules! policy_seq_modules {
($vec:ident, $list:ident, $trait:ident, $codec:ty) => {
#[doc = concat!(
"Serde with-module for a `repeated` field whose element type implements [`",
stringify!($trait),
"`], stored in a `Vec`. JSON `null` deserializes to an empty list, and a `null` ",
"element is rejected."
)]
#[doc(hidden)]
pub mod $vec {
use super::$trait;
use alloc::vec::Vec;
use serde::{Deserializer, Serializer};
pub fn serialize<T: $trait, S: Serializer>(v: &[T], s: S) -> Result<S::Ok, S::Error> {
super::serialize_seq::<$codec, T, S>(v, s)
}
pub fn deserialize<'de, T, C, D>(d: D) -> Result<C, D::Error>
where
T: $trait,
C: From<Vec<T>>,
D: Deserializer<'de>,
{
super::deserialize_vec::<$codec, T, D>(d).map(C::from)
}
}
#[doc = concat!(
"Serde with-module for a `repeated` field whose element type implements [`",
stringify!($trait),
"`], stored in a custom [`ProtoList`](crate::ProtoList) collection. Elements ",
"are pushed straight into the collection, with no intermediate `Vec`. JSON ",
"`null` deserializes to an empty list, and a `null` element is rejected."
)]
#[doc(hidden)]
pub mod $list {
use super::$trait;
use crate::ProtoList;
use serde::{Deserializer, Serializer};
pub fn serialize<T: $trait, S: Serializer>(v: &[T], s: S) -> Result<S::Ok, S::Error> {
super::serialize_seq::<$codec, T, S>(v, s)
}
pub fn deserialize<'de, T, C, D>(d: D) -> Result<C, D::Error>
where
T: $trait,
C: ProtoList<T>,
D: Deserializer<'de>,
{
super::deserialize_list::<$codec, T, C, D>(d)
}
}
};
}
policy_seq_modules!(
repeated_bytes_policy,
list_bytes_policy,
ProtoBytesJson,
super::BytesValues
);
policy_seq_modules!(
repeated_string_policy,
list_string_policy,
ProtoStringJson,
super::StringValues
);
macro_rules! policy_map_module {
(
$name:ident, $trait:ident, $value_codec:ty, $key_codec:ty, $keys:literal,
[$($key_bounds:tt)*]
) => {
#[doc = concat!(
"Serde with-module for a `map` field whose value type implements [`",
stringify!($trait),
"`] and whose keys are ",
$keys,
". JSON `null` deserializes to an empty map, and a `null` value is rejected."
)]
#[doc(hidden)]
pub mod $name {
use super::*;
pub fn serialize<C, S>(m: &C, s: S) -> Result<S::Ok, S::Error>
where
C: MapStorage,
C::Value: $trait,
S: Serializer,
$($key_bounds)*
{
super::serialize_map::<$key_codec, $value_codec, C, S>(m, s)
}
pub fn deserialize<'de, C, D>(d: D) -> Result<C, D::Error>
where
C: MapStorage + Default,
C::Value: $trait,
D: Deserializer<'de>,
$($key_bounds)*
{
super::deserialize_map::<$key_codec, $value_codec, C, D>(d)
}
}
};
}
macro_rules! policy_map_modules {
($trait:ident, $value_codec:ty, $display:ident, $str_key:ident, $policy_key:ident, $bytes_key:ident) => {
policy_map_module!(
$display, $trait, $value_codec, super::DisplayKeys,
"integers, `bool` or `String`, written with `Display` and read with `FromStr` (a key's `ProtoStringJson` policy is not consulted: use the `_policy_key` variant for a policy key)",
[C::Key: Display + FromStr,]
);
policy_map_module!(
$str_key, $trait, $value_codec, super::SerdeKeys,
"a custom string type without a JSON policy, through its own `serde` impls (a key's `ProtoStringJson` policy is not consulted: use the `_policy_key` variant for a policy key)",
[C::Key: serde::Serialize + serde::de::DeserializeOwned,]
);
policy_map_module!(
$policy_key, $trait, $value_codec, super::PolicyKeys,
"a string type that implements [`ProtoStringJson`], through its policy",
[C::Key: ProtoStringJson,]
);
policy_map_module!(
$bytes_key, $trait, $value_codec, super::Base64Keys,
"`string` keys normalized to bytes (`Vec<u8>` or `Bytes`), as base64",
[C::Key: AsRef<[u8]> + From<alloc::vec::Vec<u8>>,]
);
};
}
policy_map_modules!(
ProtoBytesJson,
super::BytesValues,
map_bytes_policy,
map_bytes_policy_serde_key,
map_bytes_policy_policy_key,
map_bytes_policy_bytes_key
);
policy_map_modules!(
ProtoStringJson,
super::StringValues,
map_string_policy,
map_string_policy_serde_key,
map_string_policy_policy_key,
map_string_policy_bytes_key
);
#[doc(hidden)]
pub mod policy_str_key_map {
use super::{ProtoStringJson, StringPolicyJson, StringPolicySeed};
use crate::json_helpers::{ProtoElemJson, ProtoElemSeed, ProtoJson};
use crate::map_codec::MapStorage;
use serde::{Deserializer, Serializer};
pub fn serialize<C, S>(m: &C, s: S) -> Result<S::Ok, S::Error>
where
C: MapStorage,
C::Key: ProtoStringJson,
C::Value: ProtoElemJson,
S: Serializer,
{
use serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(m.storage_len()))?;
for (k, v) in m.storage_iter() {
map.serialize_entry(&StringPolicyJson::<C::Key>::new(k.as_ref()), &ProtoJson(v))?;
}
map.end()
}
pub fn deserialize<'de, C, D>(d: D) -> Result<C, D::Error>
where
C: MapStorage + Default,
C::Key: ProtoStringJson,
C::Value: ProtoElemJson,
D: Deserializer<'de>,
{
struct Vis<C>(core::marker::PhantomData<C>);
impl<'de, C> serde::de::Visitor<'de> for Vis<C>
where
C: MapStorage + Default,
C::Key: ProtoStringJson,
C::Value: ProtoElemJson,
{
type Value = C;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("a JSON object with string keys, or null")
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(C::default())
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
mut map: A,
) -> Result<Self::Value, A::Error> {
let mut out = C::default();
while let Some(k) = map.next_key_seed(StringPolicySeed::<C::Key>::new())? {
let k = crate::erasing::Erasing::new(k, C::storage_erase_key);
let v =
map.next_value_seed(ProtoElemSeed::<C::Value>(core::marker::PhantomData))?;
out.storage_insert(k.into_inner(), v);
}
Ok(out)
}
crate::reject_other_json_kinds!(
bool, i64, u64, i128, u128, f64, str, string, bytes, byte_buf, seq
);
}
d.deserialize_any(Vis::<C>(core::marker::PhantomData))
}
}
#[cfg(test)]
mod tests;