jwt_verify/verifier/
factory.rs

1use crate::cognito::config::VerifierConfig;
2use crate::common::error::JwtError;
3use crate::oidc::OidcProviderConfig;
4use crate::verifier::{JwtVerifier, IdTokenClaims, AccessTokenClaims};
5
6/// Enum representing the type of JWT verifier to create
7#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum VerifierType {
9    /// AWS Cognito JWT verifier
10    Cognito,
11    /// OIDC-compatible JWT verifier
12    Oidc,
13}
14
15/// JWT verifier enum that can hold either a Cognito or OIDC verifier
16///
17/// This enum implements the JwtVerifier trait and delegates to the appropriate
18/// verifier implementation based on the variant.
19#[derive(Debug)]
20pub enum JwtVerifierEnum {
21    /// AWS Cognito JWT verifier
22    Cognito(crate::cognito::CognitoJwtVerifier),
23    /// OIDC-compatible JWT verifier
24    Oidc(crate::oidc::OidcJwtVerifier),
25}
26
27impl JwtVerifier for JwtVerifierEnum {
28    async fn verify_id_token(&self, token: &str) -> Result<Box<dyn IdTokenClaims>, JwtError> {
29        match self {
30            JwtVerifierEnum::Cognito(verifier) => verifier.verify_id_token(token).await,
31            JwtVerifierEnum::Oidc(verifier) => verifier.verify_id_token(token).await,
32        }
33    }
34
35    async fn verify_access_token(
36        &self,
37        token: &str,
38    ) -> Result<Box<dyn AccessTokenClaims>, JwtError> {
39        match self {
40            JwtVerifierEnum::Cognito(verifier) => verifier.verify_access_token(token).await,
41            JwtVerifierEnum::Oidc(verifier) => verifier.verify_access_token(token).await,
42        }
43    }
44}
45
46/// Factory for creating JWT verifiers
47///
48/// This factory provides methods for creating different types of JWT verifiers
49/// based on configuration.
50///
51/// # Examples
52///
53/// ```
54/// use jwt_verify::verifier::{VerifierType, VerifierFactory};
55/// use jwt_verify::VerifierConfig;
56///
57/// // Create a Cognito verifier
58/// let config = VerifierConfig::new("us-west-2", "abcdefg123456", &["client1".to_string()], None).unwrap();
59/// let verifier = VerifierFactory::create_cognito(config).unwrap();
60///
61/// // Create an OIDC verifier
62/// let oidc_config = OidcProviderConfig::new(
63///     "https://accounts.example.com",
64///     Some("https://accounts.example.com/.well-known/jwks.json"),
65///     &["client1".to_string()],
66/// ).unwrap();
67/// let oidc_verifier = VerifierFactory::create_oidc(vec![oidc_config]).unwrap();
68/// ```
69pub struct VerifierFactory;
70
71impl VerifierFactory {
72    /// Create a JWT verifier of the specified type
73    ///
74    /// # Parameters
75    ///
76    /// * `verifier_type` - The type of verifier to create
77    /// * `config` - The configuration for the verifier
78    ///
79    /// # Returns
80    ///
81    /// Returns a `Result` containing a JWT verifier if successful, or a `JwtError`
82    /// if creation fails.
83    pub fn create(
84        verifier_type: VerifierType,
85        config: VerifierConfig,
86    ) -> Result<JwtVerifierEnum, JwtError> {
87        match verifier_type {
88            VerifierType::Cognito => Self::create_cognito(config),
89            VerifierType::Oidc => Err(JwtError::ConfigurationError {
90                parameter: Some("verifier_type".to_string()),
91                error: "Cannot create OIDC verifier from Cognito config. Use create_oidc instead."
92                    .to_string(),
93            }),
94        }
95    }
96
97    /// Create a Cognito JWT verifier
98    ///
99    /// # Parameters
100    ///
101    /// * `config` - The configuration for the verifier
102    ///
103    /// # Returns
104    ///
105    /// Returns a `Result` containing a JWT verifier if successful, or a `JwtError`
106    /// if creation fails.
107    pub fn create_cognito(config: VerifierConfig) -> Result<JwtVerifierEnum, JwtError> {
108        let verifier = crate::cognito::CognitoJwtVerifier::new(vec![config])?;
109        Ok(JwtVerifierEnum::Cognito(verifier))
110    }
111
112    /// Create an OIDC JWT verifier
113    ///
114    /// # Parameters
115    ///
116    /// * `configs` - The configurations for the verifier
117    ///
118    /// # Returns
119    ///
120    /// Returns a `Result` containing a JWT verifier if successful, or a `JwtError`
121    /// if creation fails.
122    pub fn create_oidc(configs: Vec<OidcProviderConfig>) -> Result<JwtVerifierEnum, JwtError> {
123        let verifier = crate::oidc::OidcJwtVerifier::new(configs)?;
124        Ok(JwtVerifierEnum::Oidc(verifier))
125    }
126}