Skip to main content

openauth_core/api/
router.rs

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}