method.rs

use std::sync::Arc;

use async_trait::async_trait;
use shield::{Method, MethodAction, ShieldError, User, erased_method};

use crate::{
    actions::{EmailSignInAction, EmailSignInCallbackAction},
    options::EmailOptions,
    provider::EmailProvider,
    storage::EmailStorage,
};

pub const EMAIL_METHOD_ID: &str = "email";

pub struct EmailMethod<U: User> {
    options: EmailOptions,
    storage: Arc<dyn EmailStorage<U>>,
}

impl<U: User> EmailMethod<U> {
    pub fn new<S: EmailStorage<U> + 'static>(options: EmailOptions, storage: S) -> Self {
        Self {
            options,
            storage: Arc::new(storage),
        }
    }
}

#[async_trait]
impl<U: User + 'static> Method for EmailMethod<U> {
    type Provider = EmailProvider;
    type Connection = ();
    type Session = ();

    fn id(&self) -> String {
        EMAIL_METHOD_ID.to_owned()
    }

    fn actions(&self) -> Vec<Box<dyn MethodAction<Self::Provider, Self::Session>>> {
        vec![
            Box::new(EmailSignInAction::new(
                self.options.clone(),
                self.storage.clone(),
            )),
            Box::new(EmailSignInCallbackAction::new(
                self.options.clone(),
                self.storage.clone(),
            )),
        ]
    }

    async fn providers(&self) -> Result<Vec<Self::Provider>, ShieldError> {
        Ok(vec![EmailProvider])
    }

    async fn user_connections(
        &self,
        _user_id: &str,
        _provider_id: Option<&str>,
    ) -> Result<Vec<Self::Connection>, ShieldError> {
        Ok(vec![])
    }
}

erased_method!(EmailMethod, <U: User>);