zbrox.com
1use jacquard_common::{CowStr, IntoStatic};
2use serde::{Deserialize, Serialize};
3
4#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
5pub struct Claims<'a> {
6 #[serde(flatten)]
7 pub registered: RegisteredClaims<'a>,
8 #[serde(flatten)]
9 #[serde(borrow)]
10 pub public: PublicClaims<'a>,
11}
12
13#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
14
15pub struct RegisteredClaims<'a> {
16 #[serde(borrow)]
17 #[serde(skip_serializing_if = "Option::is_none")]
18 pub iss: Option<CowStr<'a>>,
19 #[serde(skip_serializing_if = "Option::is_none")]
20 pub sub: Option<CowStr<'a>>,
21 #[serde(skip_serializing_if = "Option::is_none")]
22 pub aud: Option<RegisteredClaimsAud<'a>>,
23 #[serde(skip_serializing_if = "Option::is_none")]
24 pub exp: Option<i64>,
25 #[serde(skip_serializing_if = "Option::is_none")]
26 pub nbf: Option<i64>,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub iat: Option<i64>,
29 #[serde(skip_serializing_if = "Option::is_none")]
30 pub jti: Option<CowStr<'a>>,
31}
32
33#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
34
35pub struct PublicClaims<'a> {
36 #[serde(borrow)]
37 #[serde(skip_serializing_if = "Option::is_none")]
38 pub htm: Option<CowStr<'a>>,
39 #[serde(skip_serializing_if = "Option::is_none")]
40 pub htu: Option<CowStr<'a>>,
41 #[serde(skip_serializing_if = "Option::is_none")]
42 pub ath: Option<CowStr<'a>>,
43 #[serde(skip_serializing_if = "Option::is_none")]
44 pub nonce: Option<CowStr<'a>>,
45}
46
47impl<'a> From<RegisteredClaims<'a>> for Claims<'a> {
48 fn from(registered: RegisteredClaims<'a>) -> Self {
49 Self {
50 registered,
51 public: PublicClaims::default(),
52 }
53 }
54}
55
56#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum RegisteredClaimsAud<'a> {
59 #[serde(borrow)]
60 Single(CowStr<'a>),
61 Multiple(Vec<CowStr<'a>>),
62}
63
64impl IntoStatic for RegisteredClaims<'_> {
65 type Output = RegisteredClaims<'static>;
66 fn into_static(self) -> Self::Output {
67 RegisteredClaims {
68 iss: self.iss.map(IntoStatic::into_static),
69 sub: self.sub.map(IntoStatic::into_static),
70 aud: self.aud.map(IntoStatic::into_static),
71 exp: self.exp,
72 nbf: self.nbf,
73 iat: self.iat,
74 jti: self.jti.map(IntoStatic::into_static),
75 }
76 }
77}
78
79impl IntoStatic for PublicClaims<'_> {
80 type Output = PublicClaims<'static>;
81 fn into_static(self) -> Self::Output {
82 PublicClaims {
83 htm: self.htm.map(IntoStatic::into_static),
84 htu: self.htu.map(IntoStatic::into_static),
85 ath: self.ath.map(IntoStatic::into_static),
86 nonce: self.nonce.map(IntoStatic::into_static),
87 }
88 }
89}
90
91impl IntoStatic for RegisteredClaimsAud<'_> {
92 type Output = RegisteredClaimsAud<'static>;
93 fn into_static(self) -> Self::Output {
94 match self {
95 RegisteredClaimsAud::Single(s) => RegisteredClaimsAud::Single(s.into_static()),
96 RegisteredClaimsAud::Multiple(v) => {
97 RegisteredClaimsAud::Multiple(v.into_iter().map(IntoStatic::into_static).collect())
98 }
99 }
100 }
101}