gestalt/
authentication.rs1use crate::codec::authentication::{
6 from_wire_auth_session_settings, from_wire_authenticated_user, from_wire_begin_login_response,
7 to_wire_begin_login_request, to_wire_complete_login_request,
8 to_wire_validate_external_token_request,
9};
10use crate::generated::v1;
11use crate::rpc_support::GestaltError;
12
13#[derive(Clone, Debug, Default, PartialEq)]
17pub struct AuthSessionSettings {
18 pub session_ttl_seconds: i64,
20}
21
22#[derive(Clone, Debug, Default, PartialEq)]
27pub struct AuthenticatedUser {
28 pub subject: String,
30 pub email: String,
32 pub email_verified: bool,
34 pub display_name: String,
36 pub avatar_url: String,
38 pub claims: std::collections::BTreeMap<String, String>,
40}
41
42#[derive(Clone, Debug, Default, PartialEq)]
46pub struct BeginLoginRequest {
47 pub callback_url: String,
51 pub host_state: String,
56 pub scopes: Vec<String>,
60 pub options: std::collections::BTreeMap<String, String>,
64}
65
66#[derive(Clone, Debug, Default, PartialEq)]
71pub struct BeginLoginResponse {
72 pub authorization_url: String,
74 pub provider_state: Vec<u8>,
76}
77
78#[derive(Clone, Debug, Default, PartialEq)]
82pub struct CompleteLoginRequest {
83 pub query: std::collections::BTreeMap<String, String>,
88 pub provider_state: Vec<u8>,
92 pub callback_url: String,
96}
97
98#[derive(Clone, Debug, Default, PartialEq)]
103pub struct ValidateExternalTokenRequest {
104 pub token: String,
106}
107
108pub struct Authentication {
112 inner: v1::authentication_client::AuthenticationClient<tonic::transport::Channel>,
113 timeout: Option<std::time::Duration>,
114}
115
116impl Authentication {
117 pub fn new(channel: tonic::transport::Channel) -> Self {
119 Self {
120 inner: v1::authentication_client::AuthenticationClient::new(channel),
121 timeout: None,
122 }
123 }
124
125 pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
128 self.timeout = Some(timeout);
129 self
130 }
131
132 pub async fn begin_login(
134 &mut self,
135 callback_url: String,
136 host_state: String,
137 scopes: Vec<String>,
138 ) -> Result<BeginLoginResponse, GestaltError> {
139 let request = BeginLoginRequest {
140 callback_url,
141 host_state,
142 scopes,
143 ..Default::default()
144 };
145 let mut tonic_request = tonic::Request::new(to_wire_begin_login_request(request));
146 if let Some(timeout) = self.timeout {
147 tonic_request.set_timeout(timeout);
148 }
149 let response = self.inner.begin_login(tonic_request).await?;
150 Ok(from_wire_begin_login_response(response.into_inner()))
151 }
152
153 pub async fn begin_login_raw(
155 &mut self,
156 request: BeginLoginRequest,
157 ) -> Result<BeginLoginResponse, GestaltError> {
158 let mut tonic_request = tonic::Request::new(to_wire_begin_login_request(request));
159 if let Some(timeout) = self.timeout {
160 tonic_request.set_timeout(timeout);
161 }
162 let response = self.inner.begin_login(tonic_request).await?;
163 Ok(from_wire_begin_login_response(response.into_inner()))
164 }
165
166 pub async fn complete_login(
168 &mut self,
169 provider_state: Vec<u8>,
170 callback_url: String,
171 query: std::collections::BTreeMap<String, String>,
172 ) -> Result<AuthenticatedUser, GestaltError> {
173 let request = CompleteLoginRequest {
174 provider_state,
175 callback_url,
176 query,
177 };
178 let mut tonic_request = tonic::Request::new(to_wire_complete_login_request(request));
179 if let Some(timeout) = self.timeout {
180 tonic_request.set_timeout(timeout);
181 }
182 let response = self.inner.complete_login(tonic_request).await?;
183 Ok(from_wire_authenticated_user(response.into_inner()))
184 }
185
186 pub async fn complete_login_raw(
188 &mut self,
189 request: CompleteLoginRequest,
190 ) -> Result<AuthenticatedUser, GestaltError> {
191 let mut tonic_request = tonic::Request::new(to_wire_complete_login_request(request));
192 if let Some(timeout) = self.timeout {
193 tonic_request.set_timeout(timeout);
194 }
195 let response = self.inner.complete_login(tonic_request).await?;
196 Ok(from_wire_authenticated_user(response.into_inner()))
197 }
198
199 pub async fn validate_external_token(
201 &mut self,
202 token: String,
203 ) -> Result<AuthenticatedUser, GestaltError> {
204 let request = ValidateExternalTokenRequest { token };
205 let mut tonic_request =
206 tonic::Request::new(to_wire_validate_external_token_request(request));
207 if let Some(timeout) = self.timeout {
208 tonic_request.set_timeout(timeout);
209 }
210 let response = self.inner.validate_external_token(tonic_request).await?;
211 Ok(from_wire_authenticated_user(response.into_inner()))
212 }
213
214 pub async fn validate_external_token_raw(
216 &mut self,
217 request: ValidateExternalTokenRequest,
218 ) -> Result<AuthenticatedUser, GestaltError> {
219 let mut tonic_request =
220 tonic::Request::new(to_wire_validate_external_token_request(request));
221 if let Some(timeout) = self.timeout {
222 tonic_request.set_timeout(timeout);
223 }
224 let response = self.inner.validate_external_token(tonic_request).await?;
225 Ok(from_wire_authenticated_user(response.into_inner()))
226 }
227
228 pub async fn get_session_settings(&mut self) -> Result<AuthSessionSettings, GestaltError> {
230 let mut tonic_request = tonic::Request::new(());
231 if let Some(timeout) = self.timeout {
232 tonic_request.set_timeout(timeout);
233 }
234 let response = self.inner.get_session_settings(tonic_request).await?;
235 Ok(from_wire_auth_session_settings(response.into_inner()))
236 }
237}