Upgrade deps

Cargo.toml

@@ -4,7 +4,7 @@
 edition.workspace = true
 publish.workspace = true
 license-file.workspace = true
-rust-version = "1.74"
+rust-version = "1.76"
 default-run = "matverseny-backend"
 
 [lints]
@@ -17,13 +17,13 @@
 license-file = "LICENSE"
 
 [workspace.lints.rust]
 rust_2018_idioms = "warn"
 future_incompatible = "warn"
 nonstandard_style = "warn"
 elided_lifetimes_in_paths = "allow"
 
 [workspace.lints.clippy]
 all = "warn"
 dbg_macro = "warn"
 todo = "warn"
 empty_enum = "warn"
@@ -61,25 +61,25 @@
 default-members = [".", "migration", "cmds"]
 
 [dependencies]
-axum = { version = "0.6.20", features = ["ws", "http2", "headers"] }
+axum = { version = "0.7.5", features = ["ws", "http2"] }
 serde = { version = "1.0.193", features = ["derive"] }
 tokio = { version = "1.33.0", features = ["macros", "rt-multi-thread", "signal", "parking_lot", "sync"] }
 tower = "0.4.13"
-tower-http = { version = "0.4.4", features = ["cors", "compression-full", "decompression-full", "catch-panic", "sensitive-headers", "request-id", "util", "normalize-path"] }
+tower-http = { version = "0.5.2", features = ["cors", "compression-full", "decompression-full", "catch-panic", "sensitive-headers", "request-id", "util", "normalize-path"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 entity = { path = "./entity" }
 sea-orm = { version = "0.12.7", default-features = false, features = ["runtime-tokio-rustls", "sqlx-postgres", "with-uuid", "with-chrono"] }
 serde_json = "1.0.108"
-validator = { version = "0.16.1", features = ["derive"] }
+validator = { version = "0.18.1", features = ["derive"] }
 pin-project = "1.1.3"
 jsonwebtoken = "9.1.0"
 once_cell = { version = "1.18.0", features = ["parking_lot"] }
 rand = "0.8.5"
 futures = "0.3.29"
 rand_chacha = "0.3.1"
 serde_with = "3.4.0"
-tokio-tungstenite = "0.20.1"
+tokio-tungstenite = "0.23.1"
 sqlx = { version = "0.7.2", default-features = false, features = ["postgres"] }
 uuid.workspace = true
 bytes = "1.5.0"
@@ -88,17 +88,19 @@
 smallvec = "1.11.1"
 const_format = "0.2.32"
 pin-project-lite = "0.2.13"
-reqwest = { version = "0.11.22", default-features = false, features = ["json", "rustls-tls"] }
+reqwest = { version = "0.12.5", default-features = false, features = ["json", "rustls-tls"] }
 libiam = { git = "https://github.com/Verseghy/iam", package = "libiam" }
 chrono = { version = "0.4.31", features = ["serde"] }
 async-nats = "0.35.1"
+headers = "0.4.0"
+anyhow = "1.0.86"
 
 [workspace.dependencies]
 uuid = { version = "1.5.0", features = ["v4", "fast-rng", "serde"] }
 
 [dev-dependencies]
 dotenvy = "0.15.7"
-http = "0.2.9"
+http = "1.1.0"
 migration = { path = "./migration" }
 assert-json-diff = "2.0.2"
 serial_test = "2.0.0"

src/error/mod.rs

@@ -153,7 +153,7 @@ mod tests {
     fn error_response_has_json_content_type() {
         let error = Error::new(Some(StatusCode::OK), "", "");
         let response = error.into_response();
-        let content_type = response.headers().get(http::header::CONTENT_TYPE);
+        let content_type = response.headers().get(header::CONTENT_TYPE);
 
         assert!(content_type.is_some(), "response");
         assert_eq!(content_type.unwrap(), "application/json");

src/iam.rs

@@ -9,20 +9,10 @@ use serde::Deserialize;
 use std::env;
 use uuid::Uuid;
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct Claims {
-    #[serde(rename = "iss")]
-    pub issuer: String,
     #[serde(rename = "sub", deserialize_with = "deserialize_subject")]
     pub subject: Uuid,
-    #[serde(rename = "aud")]
-    pub audience: Vec<String>,
-    #[serde(rename = "exp")]
-    pub expires_at: i64,
-    #[serde(rename = "nbf")]
-    pub not_before: i64,
-    #[serde(rename = "iat")]
-    pub issued_at: i64,
 }
 
 #[async_trait]

src/json.rs

@@ -1,29 +1,23 @@
 use crate::{error, Error};
 use axum::{
     async_trait,
-    body::HttpBody,
-    extract::{rejection::JsonRejection, FromRequest},
-    http::Request,
+    extract::{rejection::JsonRejection, FromRequest, Request},
     response::{IntoResponse, Response},
-    BoxError,
 };
 use serde::{de::DeserializeOwned, Serialize};
 use validator::Validate;
 
 pub struct Json<T>(pub T);
 
 #[async_trait]
-impl<T, S, B> FromRequest<S, B> for Json<T>
+impl<T, S> FromRequest<S> for Json<T>
 where
     T: DeserializeOwned,
-    B: HttpBody + Send + 'static,
-    B::Data: Send,
-    B::Error: Into<BoxError>,
     S: Send + Sync,
 {
     type Rejection = Error<'static>;
 
-    async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
         match axum::Json::<T>::from_request(req, state).await {
             Ok(value) => Ok(Self(value.0)),
             Err(rejection) => match rejection {
@@ -49,17 +43,14 @@ where
 pub struct ValidatedJson<T>(pub T);
 
 #[async_trait]
-impl<T, S, B> FromRequest<S, B> for ValidatedJson<T>
+impl<T, S> FromRequest<S> for ValidatedJson<T>
 where
     T: DeserializeOwned + Validate,
-    B: HttpBody + Send + 'static,
-    B::Data: Send,
-    B::Error: Into<BoxError>,
     S: Send + Sync,
 {
     type Rejection = Error<'static>;
 
-    async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
         let Json(json) = Json::<T>::from_request(req, state).await?;
 
         json.validate().map_err(|_| error::JSON_VALIDATE_INVALID)?;

src/lib.rs

@@ -10,15 +10,15 @@ mod state;
 mod utils;
 
 use crate::{middlewares::middlewares, utils::SignalHandler};
-use axum::ServiceExt;
+use axum::{extract::Request, ServiceExt};
 use error::{Error, Result};
 use json::*;
 pub use state::*;
-use std::net::TcpListener;
+use tokio::net::TcpListener;
 use tower_http::normalize_path::NormalizePath;
 pub use utils::panic;
 
-pub async fn run<S: StateTrait>(listener: TcpListener, state: S) {
+pub async fn run<S: StateTrait>(listener: TcpListener, state: S) -> anyhow::Result<()> {
     info!(
         "listening on port {}",
         listener.local_addr().unwrap().port()
@@ -28,10 +28,9 @@ pub async fn run<S: StateTrait>(listener: TcpListener, state: S) {
     let app = middlewares(state, app);
     let app = NormalizePath::trim_trailing_slash(app);
 
-    axum::Server::from_tcp(listener)
-        .expect("failed to start server")
-        .serve(app.into_make_service())
-        .with_graceful_shutdown(SignalHandler::new())
-        .await
-        .unwrap()
+    Ok(
+        axum::serve(listener, ServiceExt::<Request>::into_make_service(app))
+            .with_graceful_shutdown(SignalHandler::new())
+            .await?,
+    )
 }

src/main.rs

@@ -2,29 +2,27 @@ use libiam::{App, Iam};
 use matverseny_backend::State;
 use std::{
     env,
-    net::{Ipv4Addr, SocketAddr, TcpListener},
+    net::{Ipv4Addr, SocketAddr},
+    process::ExitCode,
 };
-use tracing::level_filters::LevelFilter;
+use tokio::net::TcpListener;
+use tracing::{error, level_filters::LevelFilter};
 use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Layer};
 
-pub async fn login() -> App {
-    let Ok(iam_url) = env::var("IAM_URL") else {
-        panic!("IAM_URL is not set");
-    };
+pub async fn login() -> anyhow::Result<App> {
+    let iam_url = env::var("IAM_URL").inspect_err(|_| error!("IAM_URL is not set"))?;
+    let app_secret =
+        env::var("IAM_APP_SECRET").inspect_err(|_| error!("IAM_APP_SECRET is not set"))?;
 
     let iam = Iam::new(&iam_url);
 
-    let Ok(app_secret) = env::var("IAM_APP_SECRET") else {
-        panic!("IAM_APP_SECRET is not set");
-    };
-
-    App::login(&iam, &app_secret)
+    Ok(App::login(&iam, &app_secret)
         .await
-        .expect("failed to login into the iam")
+        .inspect_err(|_| error!("failed to login into the iam"))?)
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> ExitCode {
     let env_filter = EnvFilter::builder()
         .with_default_directive(LevelFilter::INFO.into())
         .from_env_lossy();
@@ -35,12 +33,20 @@ async fn main() {
 
     matverseny_backend::panic::set_hook();
 
-    let iam_app = login().await;
+    if run().await.is_err() {
+        ExitCode::FAILURE
+    } else {
+        ExitCode::SUCCESS
+    }
+}
+
+async fn run() -> anyhow::Result<()> {
+    let iam_app = login().await?;
 
     let addr = SocketAddr::from((Ipv4Addr::UNSPECIFIED, 3002));
 
-    let listener = TcpListener::bind(addr).expect("failed to bind tcp listener");
+    let listener = TcpListener::bind(addr).await?;
     let state = State::new(iam_app).await;
 
-    matverseny_backend::run(listener, state).await;
+    matverseny_backend::run(listener, state).await
 }

src/middlewares/claims.rs

@@ -1,10 +1,8 @@
 use crate::{iam::IamTrait, StateTrait};
-use axum::{
-    headers::{
-        authorization::{Authorization, Bearer},
-        HeaderMapExt,
-    },
-    http::Request,
+use axum::http::Request;
+use headers::{
+    authorization::{Authorization, Bearer},
+    HeaderMapExt,
 };
 use std::{
     future::Future,

tests/utils/mod.rs

@@ -16,14 +16,17 @@ use request::*;
 use reqwest::Client;
 use serde_json::{json, Value};
 use std::{
-    net::{Ipv4Addr, SocketAddr, TcpListener},
+    net::{Ipv4Addr, SocketAddr},
     sync::{
         atomic::{AtomicU64, Ordering},
         Arc,
     },
 };
 use team::Team;
-use tokio::sync::{oneshot, OnceCell};
+use tokio::{
+    net::TcpListener,
+    sync::{oneshot, OnceCell},
+};
 use tokio_tungstenite::tungstenite::Message;
 use user::*;
 use uuid::Uuid;
@@ -76,7 +79,9 @@ impl App {
                 tracing::trace!("binding socket");
 
                 let addr = SocketAddr::from((Ipv4Addr::LOCALHOST, 0));
-                let listener = TcpListener::bind(addr).expect("failed to bind tcp listener");
+                let listener = TcpListener::bind(addr)
+                    .await
+                    .expect("failed to bind tcp listener");
                 let state = State::with_database(iam_app, conn.conn()).await;
 
                 let inner = Arc::new(AppInner {
@@ -88,7 +93,7 @@ impl App {
 
                 tracing::trace!("starting app");
 
-                matverseny_backend::run(listener, state).await;
+                matverseny_backend::run(listener, state).await.unwrap();
             });
         });