chore: rustfmt

Author: bitfl0wer

.sqlx/query-e237af1073cf4a9e21833deccc5acdced42ba4c96d4fa79f92727faab7cb3210.json

@@ -3,8 +3,8 @@
 use vergen::{BuildBuilder, Emitter};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-	println!("cargo::rustc-check-cfg=cfg(coverage_nightly)");
-	let build = BuildBuilder::all_build()?;
-	Emitter::default().add_instructions(&build)?.emit()?;
-	Ok(())
+    println!("cargo::rustc-check-cfg=cfg(coverage_nightly)");
+    let build = BuildBuilder::all_build()?;
+    Emitter::default().add_instructions(&build)?.emit()?;
+    Ok(())
 }

build.rs

@@ -6,28 +6,28 @@ use rand::{Rng, distr::Alphanumeric};
 use sqlx::{query_as, types::Uuid};
 
 use crate::{
-	database::{Database, Invite},
-	errors::Error,
+    database::{Database, Invite},
+    errors::Error,
 };
 
 /// Create an invite.
 #[cfg_attr(coverage_nightly, coverage(off))]
 pub(super) async fn create_invite(
-	owner: Option<&Uuid>,
-	code: Option<&str>,
-	uses_max: i32,
-	db: &Database,
+    owner: Option<&Uuid>,
+    code: Option<&str>,
+    uses_max: i32,
+    db: &Database,
 ) -> Result<Invite, Error> {
-	let code = {
-		if let Some(code) = code {
-			code
-		} else {
-			&rand::rng().sample_iter(&Alphanumeric).take(16).map(char::from).collect::<String>()
-		}
-	};
-	Ok(query_as!(
-		Invite,
-		"INSERT INTO invite_links
+    let code = {
+        if let Some(code) = code {
+            code
+        } else {
+            &rand::rng().sample_iter(&Alphanumeric).take(16).map(char::from).collect::<String>()
+        }
+    };
+    Ok(query_as!(
+        Invite,
+        "INSERT INTO invite_links
         (
             invite_link_owner,
             usages_current, usages_maximum,
@@ -41,11 +41,11 @@ pub(super) async fn create_invite(
             usages_maximum,
             invite AS invite_code,
             invalid",
-		owner,
-		uses_max,
-		code,
-		false
-	)
-	.fetch_one(&db.pool)
-	.await?)
+        owner,
+        uses_max,
+        code,
+        false
+    )
+    .fetch_one(&db.pool)
+    .await?)
 }

src/api/admin/db/mod.rs

@@ -1,59 +1,59 @@
 use argon2::{Argon2, PasswordHash, PasswordVerifier};
 use log::error;
 use poem::{
-	IntoResponse, Response, handler,
-	http::StatusCode,
-	web::{Data, Json},
+    IntoResponse, Response, handler,
+    http::StatusCode,
+    web::{Data, Json},
 };
 use serde_json::json;
 
 use crate::{
-	MAX_PERMITTED_PASSWORD_LEN,
-	api::auth::models::LoginSchema,
-	database::{Database, LocalActor, tokens::TokenStore},
-	errors::{Context, Errcode, Error},
+    MAX_PERMITTED_PASSWORD_LEN,
+    api::auth::models::LoginSchema,
+    database::{Database, LocalActor, tokens::TokenStore},
+    errors::{Context, Errcode, Error},
 };
 
 #[handler]
 #[cfg_attr(coverage_nightly, coverage(off))]
 pub(super) async fn login(
-	Json(payload): Json<LoginSchema>,
-	Data(db): Data<&Database>,
-	Data(token_store): Data<&TokenStore>,
+    Json(payload): Json<LoginSchema>,
+    Data(db): Data<&Database>,
+    Data(token_store): Data<&TokenStore>,
 ) -> Result<impl IntoResponse, Error> {
-	if payload.password.len() > MAX_PERMITTED_PASSWORD_LEN {
-		return Err(Error::new(
-			Errcode::IllegalInput,
-			Some(Context::new(
-				Some("password"),
-				Some(&format!("{} characters", payload.password.len())),
-				Some(&format!("Not more than {MAX_PERMITTED_PASSWORD_LEN} characters")),
-				None,
-			)),
-		));
-	}
-	let local_actor = match LocalActor::by_local_name(db, &payload.local_name).await? {
-		Some(actor) => actor,
-		None => return Err(Error::new_invalid_login()),
-	};
-	let actor_password_hashstring =
-		match LocalActor::get_password_hash(db, &payload.local_name).await? {
-			Some(hash_string) => hash_string,
-			None => {
-				return Err(Error::new_invalid_login());
-			}
-		};
-	let actor_password_hash = PasswordHash::new(&actor_password_hashstring).map_err(|e| {
-		error!(
-			"Password hash for user {} is not in PHC string format? Got error: {e}",
-			payload.password
-		);
-		Error::new(Errcode::Internal, None)
-	})?;
-	Argon2::default()
-		.verify_password(payload.password.as_bytes(), &actor_password_hash)
-		.map_err(|_| Error::new_invalid_login())?;
-	let token =
-		token_store.generate_upsert_token(&local_actor.unique_actor_identifier, None).await?;
-	Ok(Response::builder().status(StatusCode::OK).body(json!({"token": token}).to_string()))
+    if payload.password.len() > MAX_PERMITTED_PASSWORD_LEN {
+        return Err(Error::new(
+            Errcode::IllegalInput,
+            Some(Context::new(
+                Some("password"),
+                Some(&format!("{} characters", payload.password.len())),
+                Some(&format!("Not more than {MAX_PERMITTED_PASSWORD_LEN} characters")),
+                None,
+            )),
+        ));
+    }
+    let local_actor = match LocalActor::by_local_name(db, &payload.local_name).await? {
+        Some(actor) => actor,
+        None => return Err(Error::new_invalid_login()),
+    };
+    let actor_password_hashstring =
+        match LocalActor::get_password_hash(db, &payload.local_name).await? {
+            Some(hash_string) => hash_string,
+            None => {
+                return Err(Error::new_invalid_login());
+            }
+        };
+    let actor_password_hash = PasswordHash::new(&actor_password_hashstring).map_err(|e| {
+        error!(
+            "Password hash for user {} is not in PHC string format? Got error: {e}",
+            payload.password
+        );
+        Error::new(Errcode::Internal, None)
+    })?;
+    Argon2::default()
+        .verify_password(payload.password.as_bytes(), &actor_password_hash)
+        .map_err(|_| Error::new_invalid_login())?;
+    let token =
+        token_store.generate_upsert_token(&local_actor.unique_actor_identifier, None).await?;
+    Ok(Response::builder().status(StatusCode::OK).body(json!({"token": token}).to_string()))
 }

src/api/auth/login.rs

@@ -10,5 +10,5 @@ mod register;
 #[cfg_attr(coverage_nightly, coverage(off))]
 /// Route handler for the auth module
 pub(super) fn setup_routes() -> Route {
-	Route::new().at("/register", post(register::register)).at("/login", post(login::login))
+    Route::new().at("/register", post(register::register)).at("/login", post(login::login))
 }

src/api/auth/mod.rs

@@ -13,16 +13,16 @@ use serde::{Deserialize, Serialize};
 /// subject to a lot of change. If you build clients around sonata, expect
 /// things to break in future versions.
 pub struct RegisterSchema {
-	/// Whether the client has agreed to the terms of service offered by the
-	/// instance.
-	pub tos_consent: bool,
-	/// The local name the client would like to choose
-	pub local_name: String,
-	/// A password for the clients' new account
-	pub password: String,
-	/// Optional: An invite code, which the client got referred to this instance
-	/// with.
-	pub invite: Option<String>,
+    /// Whether the client has agreed to the terms of service offered by the
+    /// instance.
+    pub tos_consent: bool,
+    /// The local name the client would like to choose
+    pub local_name: String,
+    /// A password for the clients' new account
+    pub password: String,
+    /// Optional: An invite code, which the client got referred to this instance
+    /// with.
+    pub invite: Option<String>,
 }
 
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]
@@ -36,47 +36,47 @@ pub struct RegisterSchema {
 /// subject to a lot of change. If you build clients around sonata, expect
 /// things to break in future versions.
 pub struct LoginSchema {
-	/// The name of the account the client wants to login to
-	pub local_name: String,
-	/// The password of the account the client wants to login to
-	pub password: String,
+    /// The name of the account the client wants to login to
+    pub local_name: String,
+    /// The password of the account the client wants to login to
+    pub password: String,
 }
 
 #[cfg(test)]
 #[allow(
-	clippy::unwrap_used,
-	clippy::str_to_string,
-	clippy::indexing_slicing,
-	clippy::bool_assert_comparison
+    clippy::unwrap_used,
+    clippy::str_to_string,
+    clippy::indexing_slicing,
+    clippy::bool_assert_comparison
 )]
 mod test {
-	use super::*;
-	#[test]
-	fn test_register_schema_serialization() {
-		let schema = RegisterSchema {
-			tos_consent: true,
-			local_name: "testuser".to_string(),
-			password: "testpassword123".to_string(),
-			invite: Some("invite123".to_string()),
-		};
+    use super::*;
+    #[test]
+    fn test_register_schema_serialization() {
+        let schema = RegisterSchema {
+            tos_consent: true,
+            local_name: "testuser".to_string(),
+            password: "testpassword123".to_string(),
+            invite: Some("invite123".to_string()),
+        };
 
-		let serialized = serde_json::to_string(&schema).unwrap();
-		let parsed: serde_json::Value = serde_json::from_str(&serialized).unwrap();
+        let serialized = serde_json::to_string(&schema).unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&serialized).unwrap();
 
-		assert_eq!(parsed["tosConsent"], true);
-		assert_eq!(parsed["localName"], "testuser");
-		assert_eq!(parsed["password"], "testpassword123");
-		assert_eq!(parsed["invite"], "invite123");
-	}
+        assert_eq!(parsed["tosConsent"], true);
+        assert_eq!(parsed["localName"], "testuser");
+        assert_eq!(parsed["password"], "testpassword123");
+        assert_eq!(parsed["invite"], "invite123");
+    }
 
-	#[test]
-	fn test_register_schema_deserialization() {
-		let json_str = r#"{"tosConsent":true,"localName":"testuser","password":"testpassword123","invite":"invite123"}"#;
-		let schema: RegisterSchema = serde_json::from_str(json_str).unwrap();
+    #[test]
+    fn test_register_schema_deserialization() {
+        let json_str = r#"{"tosConsent":true,"localName":"testuser","password":"testpassword123","invite":"invite123"}"#;
+        let schema: RegisterSchema = serde_json::from_str(json_str).unwrap();
 
-		assert_eq!(schema.tos_consent, true);
-		assert_eq!(schema.local_name, "testuser");
-		assert_eq!(schema.password, "testpassword123");
-		assert_eq!(schema.invite, Some("invite123".to_string()));
-	}
+        assert_eq!(schema.tos_consent, true);
+        assert_eq!(schema.local_name, "testuser");
+        assert_eq!(schema.password, "testpassword123");
+        assert_eq!(schema.invite, Some("invite123".to_string()));
+    }
 }