Update dependencies (#17)

Reviewed-on: phoenix/textsender_auth#17

.gitea/workflows/pr.yml

@@ -5,6 +5,10 @@ on:
     branches:
       - main
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   check:
     name: Check

.gitea/workflows/workflow.yml

@@ -5,6 +5,10 @@ on:
     branches:
       - main
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   check:
     name: Check

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "textsender_auth"
-version = "0.1.23"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.96"
 
@@ -13,7 +13,7 @@ tracing-subscriber = { version = "0.3.23" }
 tower = { version = "0.5.3", features = ["full"] }
 tower-http = { version = "0.6.11", features = ["cors"] }
 hyper = { version = "1.10.1" }
-sqlx = { version = "0.8.6", features = ["postgres", "runtime-tokio-native-tls", "time", "uuid"] }
+sqlx = { version = "0.9.0", features = ["runtime-tokio", "tls-native-tls", "postgres", "time", "uuid"] }
 uuid = { version = "1.23.3", features = ["v4", "serde"] }
 argon2 = { version = "0.5.3", features = ["std"] } # Use the latest 0.5.x version
 rand = { version = "0.10.1" }
@@ -21,7 +21,7 @@ time = { version = "0.3.49", features = ["macros", "serde"] }
 josekit = { version = "0.10.3" }
 utoipa = { version = "5.5.0", features = ["axum_extras"] }
 utoipa-swagger-ui = { version = "9.0.2", features = ["axum"] }
-textsender_models = { git = "ssh://git@git.kundeng.us/phoenix/textsender_models.git", tag = "v0.4.0", features = ["config", "user"] }
+textsender_models = { git = "ssh://git@git.kundeng.us/phoenix/textsender_models.git", tag = "v0.4.10", features = ["config", "user"] }
 
 [dev-dependencies]
 http-body-util = { version = "0.1.3" }

src/callers/login.rs

@@ -189,10 +189,9 @@ pub async fn user_login(
                                 let key = textsender_models::envy::environment::get_secret_key()
                                     .await
                                     .value;
-                                let (token_literal, duration) =
+                                let cst = token_stuff::create_token(&key, &user.id).unwrap();
-                                    token_stuff::create_token(&key, &user.id).unwrap();
 
-                                if token_stuff::verify_token(&key, &token_literal) {
+                                if token_stuff::verify_token(&key, &cst.access_token) {
                                     let current_time = time::OffsetDateTime::now_utc();
                                     let _ =
                                         repo::user::update_last_login(&pool, &user, &current_time)
@@ -204,12 +203,12 @@ pub async fn user_login(
                                             message: String::from("Successful"),
                                             data: vec![textsender_models::token::LoginResult {
                                                 user_id: user.id,
-                                                access_token: token_literal,
+                                                access_token: cst.access_token,
                                                 token_type: String::from(
                                                     textsender_models::token::TOKEN_TYPE,
                                                 ),
-                                                issued_at: duration,
+                                                issued_at: cst.issued,
-                                                ..Default::default()
+                                                expires_in: cst.expires_in,
                                             }],
                                         }),
                                     )
@@ -330,10 +329,10 @@ pub async fn service_user_login(
                                 let key = textsender_models::envy::environment::get_secret_key()
                                     .await
                                     .value;
-                                let (token_literal, duration) =
+                                let cst =
                                     token_stuff::create_token(&key, &service_user.id).unwrap();
 
-                                if token_stuff::verify_token(&key, &token_literal) {
+                                if token_stuff::verify_token(&key, &cst.access_token) {
                                     let current_time = time::OffsetDateTime::now_utc();
                                     let _ = repo::service::update_last_login(
                                         &pool,
@@ -350,12 +349,12 @@ pub async fn service_user_login(
                                             ),
                                             data: vec![textsender_models::token::LoginResult {
                                                 user_id: service_user.id,
-                                                access_token: token_literal,
+                                                access_token: cst.access_token,
                                                 token_type: String::from(
                                                     textsender_models::token::TOKEN_TYPE,
                                                 ),
-                                                issued_at: duration,
+                                                issued_at: cst.issued,
-                                                ..Default::default()
+                                                expires_in: cst.expires_in,
                                             }],
                                         }),
                                     )
@@ -440,11 +439,9 @@ pub async fn refresh_token(
         if token_stuff::verify_token(&key, &payload.access_token) {
             match token_stuff::extract_id_from_token(&key, &payload.access_token) {
                 Ok(id) => {
-                    let generate_service_token = |id, key| -> (Option<String>, Option<i64>) {
+                    let generate_service_token =
-                        match token_stuff::create_service_refresh_token(key, id) {
+                        |id, key| -> Option<textsender_models::token::CreateTokenResult> {
-                            Ok((token, issued)) => (Some(token), Some(issued)),
+                            token_stuff::create_service_refresh_token(key, id).ok()
-                            Err(_err) => (None, None),
-                        }
                         };
 
                     let mut response = response::RefreshTokenResponse {
@@ -453,33 +450,20 @@ pub async fn refresh_token(
                     };
 
                     match repo::user::get_with_id(&pool, &id).await {
-                        Ok(_user) => {
+                        Ok(_user) => match generate_service_token(&id, &key) {
-                            let (refresh_token, issued) = generate_service_token(&id, &key);
+                            Some(cst) => {
-                            match refresh_token {
-                                Some(token) => match issued {
-                                    Some(issued_at) => {
                                 response.message =
                                     String::from(super::messages::SUCCESSFUL_MESSAGE);
                                 let lr = textsender_models::token::LoginResult {
                                     user_id: id,
-                                            access_token: token,
+                                    access_token: cst.access_token,
-                                            issued_at,
+                                    issued_at: cst.issued,
-                                            token_type: String::from(
+                                    expires_in: cst.expires_in,
-                                                textsender_models::token::TOKEN_TYPE,
+                                    token_type: String::from(textsender_models::token::TOKEN_TYPE),
-                                            ),
-                                            ..Default::default()
                                 };
                                 response.data.push(lr);
                                 (axum::http::StatusCode::OK, axum::Json(response))
                             }
-                                    None => (
-                                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-                                        axum::Json(response::RefreshTokenResponse {
-                                            message: String::from("Issued at not returned"),
-                                            data: Vec::new(),
-                                        }),
-                                    ),
-                                },
                             None => (
                                 axum::http::StatusCode::INTERNAL_SERVER_ERROR,
                                 axum::Json(response::RefreshTokenResponse {
@@ -487,27 +471,22 @@ pub async fn refresh_token(
                                     data: Vec::new(),
                                 }),
                             ),
-                            }
+                        },
-                        }
                         Err(err) => {
                             println!("Unable to find user, checking service user: {err:?}");
                             match repo::service::get(&pool, &id).await {
-                                Ok(_service_user) => {
+                                Ok(_service_user) => match generate_service_token(&id, &key) {
-                                    let (refresh_token, issued) = generate_service_token(&id, &key);
+                                    Some(cst) => {
-                                    match refresh_token {
+                                        response.message =
-                                        Some(token) => match issued {
+                                            String::from(super::messages::SUCCESSFUL_MESSAGE);
-                                            Some(issued_at) => {
-                                                response.message = String::from(
-                                                    super::messages::SUCCESSFUL_MESSAGE,
-                                                );
                                         let lr = textsender_models::token::LoginResult {
                                             user_id: id,
-                                                    access_token: token,
+                                            access_token: cst.access_token,
-                                                    issued_at,
+                                            issued_at: cst.issued,
+                                            expires_in: cst.expires_in,
                                             token_type: String::from(
                                                 textsender_models::token::TOKEN_TYPE,
                                             ),
-                                                    ..Default::default()
                                         };
                                         response.data.push(lr);
                                         (axum::http::StatusCode::OK, axum::Json(response))
@@ -520,17 +499,6 @@ pub async fn refresh_token(
                                         }),
                                     ),
                                 },
-                                        None => (
-                                            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-                                            axum::Json(response::RefreshTokenResponse {
-                                                message: String::from(
-                                                    "Refresh token not generated",
-                                                ),
-                                                data: Vec::new(),
-                                            }),
-                                        ),
-                                    }
-                                }
                                 Err(err) => (
                                     axum::http::StatusCode::INTERNAL_SERVER_ERROR,
                                     axum::Json(response::RefreshTokenResponse {

src/token_stuff/mod.rs

@@ -19,7 +19,7 @@ pub fn get_expiration(issued: &time::OffsetDateTime) -> Result<time::OffsetDateT
 pub fn create_token(
     provided_key: &String,
     id: &uuid::Uuid,
-) -> Result<(String, i64), josekit::JoseError> {
+) -> Result<textsender_models::token::CreateTokenResult, josekit::JoseError> {
     let resource = textsender_models::token::TokenResource {
         message: String::from(MESSAGE),
         issuer: String::from(ISSUER),
@@ -32,7 +32,7 @@ pub fn create_token(
 pub fn create_service_token(
     provided: &String,
     id: &uuid::Uuid,
-) -> Result<(String, i64), josekit::JoseError> {
+) -> Result<textsender_models::token::CreateTokenResult, josekit::JoseError> {
     let resource = textsender_models::token::TokenResource {
         message: String::from(SERVICE_SUBJECT),
         issuer: String::from(ISSUER),
@@ -45,7 +45,7 @@ pub fn create_service_token(
 pub fn create_service_refresh_token(
     key: &String,
     id: &uuid::Uuid,
-) -> Result<(String, i64), josekit::JoseError> {
+) -> Result<textsender_models::token::CreateTokenResult, josekit::JoseError> {
     let resource = textsender_models::token::TokenResource {
         message: String::from(SERVICE_SUBJECT),
         issuer: String::from(ISSUER),
@@ -125,8 +125,8 @@ mod tests {
             .value;
         let id = uuid::Uuid::new_v4();
         match create_token(&special_key, &id) {
-            Ok((token, _duration)) => {
+            Ok(cst) => {
-                let result = verify_token(&special_key, &token);
+                let result = verify_token(&special_key, &cst.access_token);
                 assert!(result, "Token not verified");
             }
             Err(err) => {