loco_rs/controller/middleware/
mod.rs1#[cfg(feature = "auth_session")]
10pub mod auth_session;
11pub mod catch_panic;
12pub mod compression;
13pub mod cors;
14pub mod etag;
15pub mod fallback;
16pub mod format;
17pub mod limit_payload;
18pub mod logger;
19pub mod powered_by;
20pub mod remote_ip;
21pub mod request_id;
22pub mod secure_headers;
23#[cfg(feature = "embedded_assets")]
24pub mod static_assets_embedded;
25#[cfg(feature = "embedded_assets")]
26pub use static_assets_embedded as static_assets;
27
28#[cfg(not(feature = "embedded_assets"))]
29pub mod static_assets;
30pub mod timeout;
31
32use axum::Router as AXRouter;
33use serde::{Deserialize, Serialize};
34
35use crate::{app::AppContext, environment::Environment, Result};
36
37pub trait MiddlewareLayer {
49 fn name(&self) -> &'static str;
53
54 fn is_enabled(&self) -> bool {
58 true
59 }
60
61 fn config(&self) -> serde_json::Result<serde_json::Value>;
66
67 fn apply(&self, app: AXRouter<AppContext>) -> Result<AXRouter<AppContext>>;
74}
75
76pub(crate) fn defaults<T: serde::de::DeserializeOwned>() -> T {
82 serde_yaml::from_value(serde_yaml::Value::Mapping(serde_yaml::Mapping::new()))
83 .expect("every middleware config field has a serde default")
84}
85
86#[allow(clippy::unnecessary_lazy_evaluations)]
87#[must_use]
88pub fn default_middleware_stack(ctx: &AppContext) -> Vec<Box<dyn MiddlewareLayer>> {
89 let middlewares = &ctx.config.server.middlewares;
91
92 #[allow(unused_mut)]
93 let mut stack: Vec<Box<dyn MiddlewareLayer>> =
94 vec![
95 Box::new(middlewares.limit_payload.clone().unwrap_or_default()),
97 Box::new(middlewares.cors.clone().unwrap_or_else(|| cors::Cors {
99 enable: false,
100 ..Default::default()
101 })),
102 Box::new(
104 middlewares
105 .catch_panic
106 .clone()
107 .unwrap_or_else(|| catch_panic::CatchPanic { enable: true }),
108 ),
109 Box::new(
111 middlewares
112 .etag
113 .clone()
114 .unwrap_or_else(|| etag::Etag { enable: true }),
115 ),
116 Box::new(middlewares.remote_ip.clone().unwrap_or_else(|| {
118 remote_ip::RemoteIpMiddleware {
119 enable: false,
120 ..Default::default()
121 }
122 })),
123 Box::new(
125 middlewares
126 .compression
127 .clone()
128 .unwrap_or_else(|| compression::Compression { enable: false }),
129 ),
130 Box::new(
132 middlewares
133 .timeout_request
134 .clone()
135 .unwrap_or_else(|| timeout::TimeOut {
136 enable: false,
137 ..Default::default()
138 }),
139 ),
140 Box::new(middlewares.static_assets.clone().unwrap_or_else(|| {
142 static_assets::StaticAssets {
143 enable: false,
144 ..Default::default()
145 }
146 })),
147 Box::new(middlewares.secure_headers.clone().unwrap_or_else(|| {
149 secure_headers::SecureHeader {
150 enable: false,
151 ..Default::default()
152 }
153 })),
154 Box::new(logger::new(
156 &middlewares
157 .logger
158 .clone()
159 .unwrap_or_else(|| logger::Config { enable: true }),
160 &ctx.environment,
161 )),
162 Box::new(
164 middlewares
165 .request_id
166 .clone()
167 .unwrap_or_else(|| request_id::RequestId { enable: true }),
168 ),
169 Box::new(
171 middlewares
172 .fallback
173 .clone()
174 .unwrap_or_else(|| fallback::Fallback {
175 enable: ctx.environment != Environment::Production,
176 ..Default::default()
177 }),
178 ),
179 Box::new(powered_by::new(ctx.config.server.ident.as_deref())),
181 ];
182 #[cfg(feature = "auth_session")]
185 stack.insert(1, Box::new(auth_session::AuthSession::new(ctx)));
186 stack
187}
188
189pub trait MiddlewareStackExt {
204 fn insert_before(&mut self, name: &str, middleware: Box<dyn MiddlewareLayer>) -> &mut Self;
206 fn insert_after(&mut self, name: &str, middleware: Box<dyn MiddlewareLayer>) -> &mut Self;
208 fn replace(&mut self, name: &str, middleware: Box<dyn MiddlewareLayer>) -> &mut Self;
210 fn delete(&mut self, name: &str) -> &mut Self;
212}
213
214impl MiddlewareStackExt for Vec<Box<dyn MiddlewareLayer>> {
215 fn insert_before(&mut self, name: &str, middleware: Box<dyn MiddlewareLayer>) -> &mut Self {
216 if let Some(idx) = self.iter().position(|m| m.name() == name) {
217 self.insert(idx, middleware);
218 } else {
219 tracing::warn!(
220 middleware = name,
221 "insert_before: no middleware named `{name}` in the stack; appending instead"
222 );
223 self.push(middleware);
224 }
225 self
226 }
227
228 fn insert_after(&mut self, name: &str, middleware: Box<dyn MiddlewareLayer>) -> &mut Self {
229 if let Some(idx) = self.iter().position(|m| m.name() == name) {
230 self.insert(idx + 1, middleware);
231 } else {
232 tracing::warn!(
233 middleware = name,
234 "insert_after: no middleware named `{name}` in the stack; appending instead"
235 );
236 self.push(middleware);
237 }
238 self
239 }
240
241 fn replace(&mut self, name: &str, middleware: Box<dyn MiddlewareLayer>) -> &mut Self {
242 if let Some(idx) = self.iter().position(|m| m.name() == name) {
243 self[idx] = middleware;
244 } else {
245 tracing::warn!(
246 middleware = name,
247 "replace: no middleware named `{name}` in the stack; leaving stack unchanged"
248 );
249 }
250 self
251 }
252
253 fn delete(&mut self, name: &str) -> &mut Self {
254 if let Some(idx) = self.iter().position(|m| m.name() == name) {
255 self.remove(idx);
256 } else {
257 tracing::warn!(
258 middleware = name,
259 "delete: no middleware named `{name}` in the stack; leaving stack unchanged"
260 );
261 }
262 self
263 }
264}
265
266#[derive(Default, Debug, Clone, Deserialize, Serialize)]
268pub struct Config {
269 pub compression: Option<compression::Compression>,
271
272 pub etag: Option<etag::Etag>,
274
275 pub limit_payload: Option<limit_payload::LimitPayload>,
277
278 pub logger: Option<logger::Config>,
280
281 pub catch_panic: Option<catch_panic::CatchPanic>,
283
284 pub timeout_request: Option<timeout::TimeOut>,
286
287 pub cors: Option<cors::Cors>,
289
290 #[serde(rename = "static")]
292 pub static_assets: Option<static_assets::StaticAssets>,
293
294 pub secure_headers: Option<secure_headers::SecureHeader>,
296
297 pub remote_ip: Option<remote_ip::RemoteIpMiddleware>,
301
302 pub fallback: Option<fallback::Fallback>,
304
305 pub request_id: Option<request_id::RequestId>,
307}
308
309#[cfg(test)]
310mod stack_ext_tests {
311 use super::{MiddlewareLayer, MiddlewareStackExt};
312
313 struct DummyMw(&'static str);
314 impl MiddlewareLayer for DummyMw {
315 fn name(&self) -> &'static str {
316 self.0
317 }
318 fn config(&self) -> serde_json::Result<serde_json::Value> {
319 Ok(serde_json::Value::Null)
320 }
321 fn apply(
322 &self,
323 app: axum::Router<crate::app::AppContext>,
324 ) -> crate::Result<axum::Router<crate::app::AppContext>> {
325 Ok(app)
326 }
327 }
328
329 fn stack(names: &[&'static str]) -> Vec<Box<dyn MiddlewareLayer>> {
330 names
331 .iter()
332 .map(|n| Box::new(DummyMw(n)) as Box<dyn MiddlewareLayer>)
333 .collect()
334 }
335
336 fn names(stack: &[Box<dyn MiddlewareLayer>]) -> Vec<&'static str> {
337 stack.iter().map(|m| m.name()).collect()
338 }
339
340 #[test]
341 fn insert_before_hit() {
342 let mut s = stack(&["a", "b", "c"]);
343 s.insert_before("b", Box::new(DummyMw("x")));
344 assert_eq!(names(&s), vec!["a", "x", "b", "c"]);
345 }
346
347 #[test]
348 fn insert_after_hit() {
349 let mut s = stack(&["a", "b", "c"]);
350 s.insert_after("b", Box::new(DummyMw("x")));
351 assert_eq!(names(&s), vec!["a", "b", "x", "c"]);
352 }
353
354 #[test]
355 fn insert_before_miss_appends() {
356 let mut s = stack(&["a", "b", "c"]);
357 s.insert_before("nope", Box::new(DummyMw("x")));
358 assert_eq!(names(&s), vec!["a", "b", "c", "x"]);
359 }
360
361 #[test]
362 fn insert_after_miss_appends() {
363 let mut s = stack(&["a", "b", "c"]);
364 s.insert_after("nope", Box::new(DummyMw("x")));
365 assert_eq!(names(&s), vec!["a", "b", "c", "x"]);
366 }
367
368 #[test]
369 fn replace_hit() {
370 let mut s = stack(&["a", "b", "c"]);
371 s.replace("b", Box::new(DummyMw("x")));
372 assert_eq!(names(&s), vec!["a", "x", "c"]);
373 assert_eq!(s.len(), 3);
374 }
375
376 #[test]
377 fn replace_miss_no_op() {
378 let mut s = stack(&["a", "b", "c"]);
379 s.replace("nope", Box::new(DummyMw("x")));
380 assert_eq!(names(&s), vec!["a", "b", "c"]);
381 }
382
383 #[test]
384 fn delete_hit() {
385 let mut s = stack(&["a", "b", "c"]);
386 s.delete("b");
387 assert_eq!(names(&s), vec!["a", "c"]);
388 assert_eq!(s.len(), 2);
389 }
390
391 #[test]
392 fn delete_miss_no_op() {
393 let mut s = stack(&["a", "b", "c"]);
394 s.delete("nope");
395 assert_eq!(names(&s), vec!["a", "b", "c"]);
396 assert_eq!(s.len(), 3);
397 }
398
399 #[test]
400 fn chaining_returns_mut_self() {
401 let mut s = stack(&["a", "b", "c"]);
402 s.insert_before("a", Box::new(DummyMw("x")))
403 .insert_after("c", Box::new(DummyMw("y")))
404 .replace("b", Box::new(DummyMw("z")))
405 .delete("a");
406 assert_eq!(names(&s), vec!["x", "z", "c", "y"]);
407 }
408}