pkce-std 0.2.1

Handling Proof Key for Code Exchange.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! PKCE code challenge methods.
//!
//! As per the [standard](https://datatracker.ietf.org/doc/html/rfc7636#section-4.2),
//! there are two methods: plain and SHA-256.
//!
//! The former is discouraged and is only used as the last resort,
//! while the latter is recommended and is marked as the default.
//!
//! # Examples
//!
//! ```
//! use pkce_std::method::Method;
//!
//! let string = "S256";
//!
//! let method: Method = string.parse().unwrap();
//!
//! assert_eq!(method, Method::Sha256);
//! ```

use std::str::FromStr;

#[cfg(feature = "diagnostics")]
use miette::Diagnostic;

#[cfg(feature = "serde")]
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};

use thiserror::Error;

/// Represents errors that can occur when parsing PKCE methods.
#[derive(Debug, Error)]
#[error("unknown method `{unknown}`")]
#[cfg_attr(
    feature = "diagnostics",
    derive(Diagnostic),
    diagnostic(
        code(pkce_std::method),
        help("expected either `{PLAIN}` (discouraged) or `{SHA256}` (recommended)")
    )
)]
pub struct Error {
    /// The unknown method.
    pub unknown: String,
}

impl Error {
    /// Constructs [`Self`].
    pub const fn new(unknown: String) -> Self {
        Self { unknown }
    }
}

/// The `plain` literal.
pub const PLAIN: &str = "plain";

/// The `S256` literal.
pub const SHA256: &str = "S256";

/// Represents PKCE code challenge methods.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum Method {
    /// The plain method, which is discouraged and only used as the last resort.
    Plain,
    /// The SHA-256 method, which is recommended and marked as the default.
    #[default]
    Sha256,
}

#[cfg(feature = "serde")]
impl Serialize for Method {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        self.static_str().serialize(serializer)
    }
}

#[cfg(feature = "serde")]
impl<'de> Deserialize<'de> for Method {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let string = <&str>::deserialize(deserializer)?;

        string.parse().map_err(de::Error::custom)
    }
}

type StaticStr = &'static str;

impl Method {
    /// Returns the static string representation of the method.
    pub const fn static_str(&self) -> StaticStr {
        match self {
            Self::Plain => PLAIN,
            Self::Sha256 => SHA256,
        }
    }
}

impl FromStr for Method {
    type Err = Error;

    fn from_str(string: &str) -> Result<Self, Self::Err> {
        match string {
            PLAIN => Ok(Self::Plain),
            SHA256 => Ok(Self::Sha256),
            _ => Err(Self::Err::new(string.to_owned())),
        }
    }
}