Refactor header claims (#1)

Simplify customization, bump to 2.0.0.

examples/custom_claims.rs

@@ -4,39 +4,42 @@ extern crate serde_derive;
 extern crate medallion;
 
 use std::default::Default;
-use medallion::{
-    DefaultHeader,
-    Token,
-};
+use medallion::{Payload, Header, Token};
 
-#[derive(Default, Serialize, Deserialize)]
+#[derive(Default, Serialize, Deserialize, PartialEq, Debug)]
 struct Custom {
-    sub: String,
+    user_id: String,
+    // useful if you want a None to not appear in the serialized JSON
+    #[serde(skip_serializing_if = "Option::is_none")]
+    email: Option<String>,
     rhino: bool,
 }
 
 fn new_token(user_id: &str, password: &str) -> Option<String> {
     // Dummy auth
     if password != "password" {
-        return None
+        return None;
     }
 
-    let header: DefaultHeader = Default::default();
-    let claims = Custom {
-        sub: user_id.into(),
-        rhino: true,
+    let header: Header<()> = Default::default();
+    let payload = Payload {
+        claims: Some(Custom {
+            user_id: user_id.into(),
+            rhino: true,
+            ..Default::default()
+        }),
         ..Default::default()
     };
-    let token = Token::new(header, claims);
+    let token = Token::new(header, payload);
 
-    token.signed(b"secret_key").ok()
+    token.sign(b"secret_key").ok()
 }
 
 fn login(token: &str) -> Option<String> {
-    let token = Token::<DefaultHeader, Custom>::parse(token).unwrap();
+    let token = Token::<(), Custom>::parse(token).unwrap();
 
     if token.verify(b"secret_key").unwrap() {
-        Some(token.claims.sub)
+        Some(token.payload.claims.unwrap().user_id)
     } else {
         None
     }

examples/custom_headers.rs

@@ -0,0 +1,49 @@
+// need this for custom derivation
+#[macro_use]
+extern crate serde_derive;
+extern crate medallion;
+
+use std::default::Default;
+use medallion::{DefaultPayload, Header, DefaultToken};
+
+#[derive(Default, Serialize, Deserialize, PartialEq, Debug)]
+struct Custom {
+    // useful if you want a None to not appear in the serialized JSON
+    #[serde(skip_serializing_if = "Option::is_none")]
+    kid: Option<String>,
+    typ: String,
+}
+
+fn new_token(sub: &str, password: &str) -> Option<String> {
+    // Dummy auth
+    if password != "password" {
+        return None;
+    }
+
+    let header = Header {
+        headers: Some(Custom { typ: "JWT".into(), ..Default::default() }),
+        ..Default::default()
+    };
+    let payload = DefaultPayload { sub: Some(sub.into()), ..Default::default() };
+    let token = DefaultToken::new(header, payload);
+
+    token.sign(b"secret_key").ok()
+}
+
+fn login(token: &str) -> Option<String> {
+    let token = DefaultToken::<Custom>::parse(token).unwrap();
+
+    if token.verify(b"secret_key").unwrap() {
+        Some(token.payload.sub.unwrap())
+    } else {
+        None
+    }
+}
+
+fn main() {
+    let token = new_token("Random User", "password").unwrap();
+
+    let logged_in_user = login(&*token).unwrap();
+
+    assert_eq!(logged_in_user, "Random User");
+}

examples/hs256.rs

@@ -1,34 +1,31 @@
 extern crate medallion;
 
 use std::default::Default;
-use medallion::{
-    DefaultHeader,
-    Registered,
-    Token,
-};
+use medallion::{Header, DefaultPayload, DefaultToken};
 
 fn new_token(user_id: &str, password: &str) -> Option<String> {
     // Dummy auth
     if password != "password" {
-        return None
+        return None;
     }
 
-    let header: DefaultHeader = Default::default();
-    let claims = Registered {
+    // can satisfy Header's generic parameter with an empty type
+    let header: Header<()> = Default::default();
+    let payload = DefaultPayload {
         iss: Some("example.com".into()),
         sub: Some(user_id.into()),
         ..Default::default()
     };
-    let token = Token::new(header, claims);
+    let token = DefaultToken::new(header, payload);
 
-    token.signed(b"secret_key").ok()
+    token.sign(b"secret_key").ok()
 }
 
 fn login(token: &str) -> Option<String> {
-    let token = Token::<DefaultHeader, Registered>::parse(token).unwrap();
+    let token: DefaultToken<()> = DefaultToken::parse(token).unwrap();
 
     if token.verify(b"secret_key").unwrap() {
-        token.claims.sub
+        token.payload.sub
     } else {
         None
     }

examples/rs256.rs

@@ -3,12 +3,7 @@ extern crate medallion;
 use std::default::Default;
 use std::fs::File;
 use std::io::{Error, Read};
-use medallion::{
-    Algorithm,
-    DefaultHeader,
-    Registered,
-    Token,
-};
+use medallion::{Algorithm, Header, DefaultPayload, DefaultToken};
 
 fn load_pem(keypath: &str) -> Result<String, Error> {
     let mut key_file = File::open(keypath)?;
@@ -20,28 +15,28 @@ fn load_pem(keypath: &str) -> Result<String, Error> {
 fn new_token(user_id: &str, password: &str) -> Option<String> {
     // Dummy auth
     if password != "password" {
-        return None
+        return None;
     }
 
-    let header: DefaultHeader = DefaultHeader {
-        alg: Algorithm::RS256,
-        ..Default::default()
-    };
-    let claims = Registered {
+    // can satisfy Header's generic parameter with an empty type
+    let header: Header<()> = Header { alg: Algorithm::RS256, ..Default::default() };
+    let payload: DefaultPayload = DefaultPayload {
         iss: Some("example.com".into()),
         sub: Some(user_id.into()),
         ..Default::default()
     };
-    let token = Token::new(header, claims);
+    let token = DefaultToken::new(header, payload);
 
-    token.signed(load_pem("./privateKey.pem").unwrap().as_bytes()).ok()
+    // this key was generated explicitly for these examples and is not used anywhere else
+    token.sign(load_pem("./privateKey.pem").unwrap().as_bytes()).ok()
 }
 
 fn login(token: &str) -> Option<String> {
-    let token = Token::<DefaultHeader, Registered>::parse(token).unwrap();
+    let token: DefaultToken<()> = DefaultToken::parse(token).unwrap();
 
+    // this key was generated explicitly for these examples and is not used anywhere else
     if token.verify(load_pem("./publicKey.pub").unwrap().as_bytes()).unwrap() {
-        token.claims.sub
+        token.payload.sub
     } else {
         None
     }