Skip to main content

rustbasic_passport/
store.rs

1use std::sync::Arc;
2
3use async_trait::async_trait;
4
5use crate::entity::{AccessToken, AuthCode, Client, DeviceCode, RefreshToken};
6use crate::error::Error;
7
8#[async_trait]
9pub trait ClientStore: Send + Sync {
10    async fn find_by_id(&self, id: &str) -> Result<Option<Client>, Error>;
11    async fn find_personal_access_client(&self) -> Result<Option<Client>, Error>;
12    async fn save(&self, client: &Client) -> Result<(), Error>;
13}
14
15#[async_trait]
16pub trait AccessTokenStore: Send + Sync {
17    async fn find_by_id(&self, id: &str) -> Result<Option<AccessToken>, Error>;
18    async fn save(&self, token: &AccessToken) -> Result<(), Error>;
19}
20
21#[async_trait]
22pub trait AuthCodeStore: Send + Sync {
23    async fn find_by_id(&self, id: &str) -> Result<Option<AuthCode>, Error>;
24    async fn save(&self, code: &AuthCode) -> Result<(), Error>;
25    /// Atomically revoke an auth code if it has not been revoked yet.
26    ///
27    /// Implementasi harus menjalankan operasi atomic pembanding-dan-set
28    /// (mis. `UPDATE ... SET revoked = 1 WHERE id = ? AND revoked = 0` dan
29    /// kembalikan `true` hanya jika ada baris yang ter-update). Ini wajib
30    /// agar auth code benar-benar sekali pakai, bahkan saat dua permintaan
31    /// tukar tiba bersamaan.
32    async fn revoke_if_unrevoked(&self, id: &str) -> Result<bool, Error>;
33}
34
35#[async_trait]
36pub trait RefreshTokenStore: Send + Sync {
37    async fn find_by_id(&self, id: &str) -> Result<Option<RefreshToken>, Error>;
38    async fn save(&self, token: &RefreshToken) -> Result<(), Error>;
39    /// Atomically revoke a refresh token if it has not been revoked yet.
40    ///
41    /// Sama seperti [`AuthCodeStore::revoke_if_unrevoked`]: wajib atomic
42    /// (`UPDATE ... SET revoked = 1 WHERE id = ? AND revoked = 0`) agar
43    /// rotasi refresh token aman terhadap penggunaan ganda secara konkuren.
44    async fn revoke_if_unrevoked(&self, id: &str) -> Result<bool, Error>;
45}
46
47#[async_trait]
48pub trait DeviceCodeStore: Send + Sync {
49    async fn find_by_device_code(&self, id: &str) -> Result<Option<DeviceCode>, Error>;
50    async fn find_by_user_code(&self, user_code: &str) -> Result<Option<DeviceCode>, Error>;
51    async fn save(&self, code: &DeviceCode) -> Result<(), Error>;
52}
53
54#[async_trait]
55pub trait UserProvider: Send + Sync {
56    async fn find_by_credentials(
57        &self,
58        identifier: &str,
59        password: &str,
60    ) -> Result<Option<String>, Error>;
61}
62
63pub trait Stores: Send + Sync + 'static {
64    fn clients(&self) -> &dyn ClientStore;
65    fn tokens(&self) -> &dyn AccessTokenStore;
66    fn auth_codes(&self) -> &dyn AuthCodeStore;
67    fn refresh_tokens(&self) -> &dyn RefreshTokenStore;
68    fn device_codes(&self) -> &dyn DeviceCodeStore;
69    fn users(&self) -> &dyn UserProvider;
70}
71
72pub struct StoreBundle<C, T, A, R, D, U> {
73    clients: C,
74    tokens: T,
75    auth_codes: A,
76    refresh_tokens: R,
77    device_codes: D,
78    users: U,
79}
80
81impl<C, T, A, R, D, U> StoreBundle<C, T, A, R, D, U> {
82    pub fn new(
83        clients: C,
84        tokens: T,
85        auth_codes: A,
86        refresh_tokens: R,
87        device_codes: D,
88        users: U,
89    ) -> Self {
90        Self {
91            clients,
92            tokens,
93            auth_codes,
94            refresh_tokens,
95            device_codes,
96            users,
97        }
98    }
99}
100
101impl<C, T, A, R, D, U> Stores for StoreBundle<C, T, A, R, D, U>
102where
103    C: ClientStore + 'static,
104    T: AccessTokenStore + 'static,
105    A: AuthCodeStore + 'static,
106    R: RefreshTokenStore + 'static,
107    D: DeviceCodeStore + 'static,
108    U: UserProvider + 'static,
109{
110    fn clients(&self) -> &dyn ClientStore {
111        &self.clients
112    }
113
114    fn tokens(&self) -> &dyn AccessTokenStore {
115        &self.tokens
116    }
117
118    fn auth_codes(&self) -> &dyn AuthCodeStore {
119        &self.auth_codes
120    }
121
122    fn refresh_tokens(&self) -> &dyn RefreshTokenStore {
123        &self.refresh_tokens
124    }
125
126    fn device_codes(&self) -> &dyn DeviceCodeStore {
127        &self.device_codes
128    }
129
130    fn users(&self) -> &dyn UserProvider {
131        &self.users
132    }
133}
134
135impl<S: Stores> Stores for Arc<S> {
136    fn clients(&self) -> &dyn ClientStore {
137        (**self).clients()
138    }
139
140    fn tokens(&self) -> &dyn AccessTokenStore {
141        (**self).tokens()
142    }
143
144    fn auth_codes(&self) -> &dyn AuthCodeStore {
145        (**self).auth_codes()
146    }
147
148    fn refresh_tokens(&self) -> &dyn RefreshTokenStore {
149        (**self).refresh_tokens()
150    }
151
152    fn device_codes(&self) -> &dyn DeviceCodeStore {
153        (**self).device_codes()
154    }
155
156    fn users(&self) -> &dyn UserProvider {
157        (**self).users()
158    }
159}