rustbasic_passport/
store.rs1use 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 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 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}