better-auth-api 1.0.0-alpha.5

Plugin implementations for better-auth
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

use super::*;
use better_auth_core::{
    AuthRecordFields, CreateAccount,
    store::{
        StatelessSchema,
        database_hooks::{
            DatabaseHookContext, DatabaseHookControl, DatabaseHookUpdate, DatabaseHooks,
        },
    },
    wire::{AccountView, SessionView, UserView},
};

pub(super) struct Hooks(pub Arc<State>);

#[async_trait::async_trait]
impl better_auth_core::AuthPlugin<StatelessSchema> for Hooks {
    fn name(&self) -> &'static str {
        "native-profile-contract-hooks"
    }
    fn routes(&self) -> Vec<better_auth_core::AuthRoute> {
        Vec::new()
    }
    async fn on_init(
        &self,
        context: &mut better_auth_core::AuthInitContext<StatelessSchema>,
    ) -> AuthResult<()> {
        context.register_database_hook(Arc::new(Self(self.0.clone())));
        Ok(())
    }
    async fn on_request(
        &self,
        _: &better_auth_core::AuthRequest,
        _: &better_auth_core::AuthContext<StatelessSchema>,
    ) -> AuthResult<Option<better_auth_core::AuthResponse>> {
        Ok(None)
    }
}

impl Hooks {
    fn event(&self, model: &str, phase: &str, data: FieldMap) -> AuthResult<()> {
        self.0.generated_record_dates(&data, model == "session")?;
        if model == "session" && phase == "before" {
            let token = data.get("token").unwrap().as_str().unwrap();
            self.0.remember(token, "session-token");
            self.0.tracking.lock().unwrap().session_token = Some(token.into());
        }
        self.0
            .log
            .event(json!({"kind": "hook", "model": model, "phaseInHook": phase,
            "data": observe::native(&data.into())?}));
        Ok(())
    }
}

#[better_auth_core::database_hooks()]
impl DatabaseHooks<StatelessSchema> for Hooks {
    async fn before_create_user(
        &self,
        data: &mut FieldMap,
        _: &DatabaseHookContext<'_, StatelessSchema>,
    ) -> AuthResult<DatabaseHookUpdate<FieldMap>> {
        self.event("user", "before", data.clone())?;
        Ok(DatabaseHookUpdate::Continue)
    }
    async fn after_create_user(
        &self,
        data: Option<&UserView>,
        _: &DatabaseHookContext<'_, StatelessSchema>,
    ) -> AuthResult<()> {
        self.event("user", "after", data.unwrap().field_values()?)
    }
    async fn before_create_account(
        &self,
        data: &mut CreateAccount,
        _: &DatabaseHookContext<'_, StatelessSchema>,
    ) -> AuthResult<DatabaseHookControl> {
        self.event("account", "before", data.fields()?)?;
        Ok(DatabaseHookControl::Continue)
    }
    async fn after_create_account(
        &self,
        data: Option<&AccountView>,
        _: &DatabaseHookContext<'_, StatelessSchema>,
    ) -> AuthResult<()> {
        self.event("account", "after", data.unwrap().field_values()?)
    }
    async fn before_create_session(
        &self,
        data: &mut FieldMap,
        _: &DatabaseHookContext<'_, StatelessSchema>,
    ) -> AuthResult<DatabaseHookUpdate<FieldMap>> {
        self.event("session", "before", data.clone())?;
        Ok(DatabaseHookUpdate::Continue)
    }
    async fn after_create_session(
        &self,
        data: Option<&SessionView>,
        _: &DatabaseHookContext<'_, StatelessSchema>,
    ) -> AuthResult<()> {
        self.event("session", "after", FieldMap::from(data.unwrap().clone()))
    }
}