1use http::StatusCode;
2use serde_json::Value;
3
4use crate::context::request_state::{run_with_request_state, set_current_request_path};
5use crate::context::AuthContext;
6use crate::error::OpenAuthError;
7use crate::plugin::{PluginBeforeHookAction, PluginRequestAction};
8use crate::rate_limit::{consume_rate_limit, on_request_rate_limit, on_response_rate_limit};
9use crate::utils::url::normalize_pathname;
10
11use super::endpoint::{
12 run_endpoint_middlewares, validate_async_endpoint_request, ApiRequest, ApiResponse,
13 AsyncAuthEndpoint, AuthEndpoint, EndpointInfo, EndpointKind,
14};
15use super::error::{api_error, rate_limit_response, response, ApiErrorCode};
16use super::openapi::build_openapi_schema;
17use super::path::{match_path_pattern, route_pathname, PathParams};
18use super::plugin_pipeline::{
19 endpoint_operation_id, plugin_async_endpoints, run_after_hooks, run_async_after_hooks,
20 run_async_before_hooks, run_before_hooks, run_matching_async_middlewares,
21 run_matching_middlewares, run_on_request_plugins, run_on_response_plugins,
22 validate_endpoint_conflicts,
23};
24use super::security::validate_request_security;
25
26#[derive(Clone)]
27pub struct AuthRouter {
28 context: AuthContext,
29 endpoints: Vec<AuthEndpoint>,
30 async_endpoints: Vec<AsyncAuthEndpoint>,
31}
32
33impl AuthRouter {
34 pub fn new(context: AuthContext, endpoints: Vec<AuthEndpoint>) -> Self {
35 let async_endpoints = plugin_async_endpoints(&context, Vec::new());
36 Self {
37 context,
38 endpoints,
39 async_endpoints,
40 }
41 }
42
43 pub fn try_new(
44 context: AuthContext,
45 endpoints: Vec<AuthEndpoint>,
46 ) -> Result<Self, OpenAuthError> {
47 let async_endpoints = plugin_async_endpoints(&context, Vec::new());
48 validate_endpoint_conflicts(&endpoints, &async_endpoints)?;
49 Ok(Self {
50 context,
51 endpoints,
52 async_endpoints,
53 })
54 }
55
56 pub fn with_async_endpoints(
57 context: AuthContext,
58 endpoints: Vec<AuthEndpoint>,
59 async_endpoints: Vec<AsyncAuthEndpoint>,
60 ) -> Result<Self, OpenAuthError> {
61 let async_endpoints = plugin_async_endpoints(&context, async_endpoints);
62 validate_endpoint_conflicts(&endpoints, &async_endpoints)?;
63 Ok(Self {
64 context,
65 endpoints,
66 async_endpoints,
67 })
68 }
69
70 pub fn endpoint_registry(&self) -> Vec<EndpointInfo> {
71 let sync_endpoints = self.endpoints.iter().map(|endpoint| EndpointInfo {
72 path: endpoint.path.clone(),
73 method: endpoint.method.clone(),
74 kind: EndpointKind::Sync,
75 operation_id: None,
76 allowed_media_types: Vec::new(),
77 });
78 let async_endpoints = self
79 .async_endpoints
80 .iter()
81 .filter(|endpoint| !endpoint.options.server_only)
82 .map(|endpoint| EndpointInfo {
83 path: endpoint.path.clone(),
84 method: endpoint.method.clone(),
85 kind: EndpointKind::Async,
86 operation_id: endpoint
87 .options
88 .operation_id
89 .clone()
90 .or_else(|| endpoint.options.openapi.as_ref()?.operation_id.clone()),
91 allowed_media_types: endpoint.options.allowed_media_types.clone(),
92 });
93 sync_endpoints.chain(async_endpoints).collect()
94 }
95
96 pub fn openapi_schema(&self) -> Value {
97 build_openapi_schema(&self.context, &self.async_endpoints)
98 }
99
100 pub fn handle(&self, mut request: ApiRequest) -> Result<ApiResponse, OpenAuthError> {
101 let normalized_path =
102 normalize_pathname(&request.uri().to_string(), &self.context.base_path);
103 if self
104 .context
105 .disabled_paths
106 .iter()
107 .any(|item| item == &normalized_path)
108 {
109 return api_error(StatusCode::NOT_FOUND, ApiErrorCode::NotFound);
110 }
111 request = match run_on_request_plugins(&self.context, request)? {
112 PluginRequestAction::Continue(request) => request,
113 PluginRequestAction::Respond(response) => return Ok(response),
114 };
115 if let Some(rejection) = validate_request_security(&self.context, &request, false)? {
116 return Ok(rejection);
117 }
118 let path = route_pathname(
119 &request.uri().to_string(),
120 &self.context.base_path,
121 self.context.options.advanced.skip_trailing_slashes,
122 );
123 let Some((endpoint, params)) = self.endpoints.iter().find_map(|endpoint| {
124 (endpoint.method == *request.method())
125 .then(|| match_path_pattern(&endpoint.path, &path).map(|params| (endpoint, params)))
126 .flatten()
127 }) else {
128 if self.async_endpoints.iter().any(|endpoint| {
129 endpoint.method == *request.method()
130 && !endpoint.options.server_only
131 && match_path_pattern(&endpoint.path, &path).is_some()
132 }) {
133 return Err(OpenAuthError::Api(
134 "async endpoint requires AuthRouter::handle_async".to_owned(),
135 ));
136 }
137 return api_error(StatusCode::NOT_FOUND, ApiErrorCode::NotFound);
138 };
139 request.extensions_mut().insert(PathParams::new(params));
140 if let Some(response) = run_matching_middlewares(&self.context, &request, &path)? {
141 return Ok(response);
142 }
143 if let Some(rejection) = on_request_rate_limit(&self.context, &request)? {
144 return rate_limit_response(rejection);
145 }
146 request = match run_before_hooks(&self.context, request, &endpoint.method, &path, None)? {
147 PluginBeforeHookAction::Continue(request) => request,
148 PluginBeforeHookAction::Respond(response) => return Ok(response),
149 };
150 let response = (endpoint.handler)(&self.context, request.clone())?;
151 let response = run_after_hooks(
152 &self.context,
153 &request,
154 response,
155 &endpoint.method,
156 &path,
157 None,
158 )?;
159 on_response_rate_limit(&self.context, &request)?;
160 run_on_response_plugins(&self.context, &request, response)
161 }
162
163 pub async fn handle_async(&self, request: ApiRequest) -> Result<ApiResponse, OpenAuthError> {
164 run_with_request_state(self.handle_async_scoped(request)).await
165 }
166
167 async fn handle_async_scoped(
168 &self,
169 mut request: ApiRequest,
170 ) -> Result<ApiResponse, OpenAuthError> {
171 let normalized_path =
172 normalize_pathname(&request.uri().to_string(), &self.context.base_path);
173 if self
174 .context
175 .disabled_paths
176 .iter()
177 .any(|item| item == &normalized_path)
178 {
179 return api_error(StatusCode::NOT_FOUND, ApiErrorCode::NotFound);
180 }
181 request = match run_on_request_plugins(&self.context, request)? {
182 PluginRequestAction::Continue(request) => request,
183 PluginRequestAction::Respond(response) => return Ok(response),
184 };
185 let path = route_pathname(
186 &request.uri().to_string(),
187 &self.context.base_path,
188 self.context.options.advanced.skip_trailing_slashes,
189 );
190 let async_endpoint = self.async_endpoints.iter().find_map(|endpoint| {
191 (endpoint.method == *request.method())
192 .then(|| match_path_pattern(&endpoint.path, &path).map(|params| (endpoint, params)))
193 .flatten()
194 });
195 let sync_endpoint = self.endpoints.iter().find_map(|endpoint| {
196 (endpoint.method == *request.method())
197 .then(|| match_path_pattern(&endpoint.path, &path).map(|params| (endpoint, params)))
198 .flatten()
199 });
200 let bypass_origin_security = async_endpoint.as_ref().is_some_and(|(endpoint, _)| {
201 !endpoint.options.server_only && endpoint.options.bypass_origin_security
202 });
203 if let Some(rejection) =
204 validate_request_security(&self.context, &request, bypass_origin_security)?
205 {
206 return Ok(rejection);
207 }
208 if async_endpoint.is_none() && sync_endpoint.is_none() {
209 return api_error(StatusCode::NOT_FOUND, ApiErrorCode::NotFound);
210 }
211 if let Some(response) = run_matching_middlewares(&self.context, &request, &path)? {
212 return Ok(response);
213 }
214 if let Some(response) =
215 run_matching_async_middlewares(&self.context, &request, &path).await?
216 {
217 return Ok(response);
218 }
219 if let Some(rejection) = consume_rate_limit(&self.context, &request).await? {
220 return rate_limit_response(rejection);
221 }
222 if let Some((endpoint, params)) = async_endpoint {
223 if endpoint.options.server_only {
224 return api_error(StatusCode::NOT_FOUND, ApiErrorCode::NotFound);
225 }
226 set_current_request_path(path.clone())?;
227 request.extensions_mut().insert(PathParams::new(params));
228 if let Some(response) = validate_async_endpoint_request(endpoint, &request)? {
229 return Ok(response);
230 }
231 if let Some(response) =
232 run_endpoint_middlewares(&self.context, endpoint, &request).await?
233 {
234 return Ok(response);
235 }
236 request = match run_before_hooks(
237 &self.context,
238 request,
239 &endpoint.method,
240 &path,
241 endpoint_operation_id(endpoint),
242 )? {
243 PluginBeforeHookAction::Continue(request) => request,
244 PluginBeforeHookAction::Respond(response) => return Ok(response),
245 };
246 request = match run_async_before_hooks(
247 &self.context,
248 request,
249 &endpoint.method,
250 &path,
251 endpoint_operation_id(endpoint),
252 )
253 .await?
254 {
255 PluginBeforeHookAction::Continue(request) => request,
256 PluginBeforeHookAction::Respond(response) => return Ok(response),
257 };
258 let response = (endpoint.handler)(&self.context, request.clone()).await?;
259 let response = run_after_hooks(
260 &self.context,
261 &request,
262 response,
263 &endpoint.method,
264 &path,
265 endpoint_operation_id(endpoint),
266 )?;
267 let response = run_async_after_hooks(
268 &self.context,
269 &request,
270 response,
271 &endpoint.method,
272 &path,
273 endpoint_operation_id(endpoint),
274 )
275 .await?;
276 return run_on_response_plugins(&self.context, &request, response);
277 }
278 if let Some((endpoint, params)) = sync_endpoint {
279 set_current_request_path(path.clone())?;
280 request.extensions_mut().insert(PathParams::new(params));
281 request = match run_before_hooks(&self.context, request, &endpoint.method, &path, None)?
282 {
283 PluginBeforeHookAction::Continue(request) => request,
284 PluginBeforeHookAction::Respond(response) => return Ok(response),
285 };
286 request =
287 match run_async_before_hooks(&self.context, request, &endpoint.method, &path, None)
288 .await?
289 {
290 PluginBeforeHookAction::Continue(request) => request,
291 PluginBeforeHookAction::Respond(response) => return Ok(response),
292 };
293 let response = (endpoint.handler)(&self.context, request.clone())?;
294 let response = run_after_hooks(
295 &self.context,
296 &request,
297 response,
298 &endpoint.method,
299 &path,
300 None,
301 )?;
302 let response = run_async_after_hooks(
303 &self.context,
304 &request,
305 response,
306 &endpoint.method,
307 &path,
308 None,
309 )
310 .await?;
311 return run_on_response_plugins(&self.context, &request, response);
312 }
313 api_error(StatusCode::NOT_FOUND, ApiErrorCode::NotFound)
314 }
315}
316
317pub fn ok_endpoint(
318 _context: &AuthContext,
319 _request: ApiRequest,
320) -> Result<ApiResponse, OpenAuthError> {
321 response(StatusCode::OK, b"OK".to_vec())
322}
323
324pub fn core_endpoints() -> Vec<AuthEndpoint> {
325 vec![AuthEndpoint {
326 path: "/ok".to_owned(),
327 method: http::Method::GET,
328 handler: ok_endpoint,
329 }]
330}