fix: cargo fmt

Author: abonander

examples/postgres/multi-database/accounts/src/lib.rs

@@ -5,8 +5,8 @@ use sqlx::{Acquire, Executor, PgPool, PgTransaction, Postgres};
 use std::sync::Arc;
 use uuid::Uuid;
 
-use tokio::sync::Semaphore;
 use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
+use tokio::sync::Semaphore;
 
 #[derive(sqlx::Type, Copy, Clone, Debug, serde::Deserialize, serde::Serialize)]
 #[sqlx(transparent)]
@@ -118,7 +118,7 @@ impl AccountsManager {
             .max_connections(5)
             .connect_with(opts)
             .await?;
-        
+
         sqlx::migrate!()
             .run(&pool)
             .await

examples/postgres/multi-database/payments/src/lib.rs

@@ -1,8 +1,8 @@
 use accounts::{AccountId, AccountsManager};
+use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
 use sqlx::{Acquire, PgConnection, PgPool, Postgres};
 use time::OffsetDateTime;
 use uuid::Uuid;
-use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
 
 #[derive(sqlx::Type, Copy, Clone, Debug)]
 #[sqlx(transparent)]
@@ -41,17 +41,13 @@ pub struct PaymentsManager {
 }
 
 impl PaymentsManager {
-    pub async fn setup(
-        opts: PgConnectOptions,
-    ) -> sqlx::Result<Self> {
+    pub async fn setup(opts: PgConnectOptions) -> sqlx::Result<Self> {
         let pool = PgPoolOptions::new()
             .max_connections(5)
             .connect_with(opts)
             .await?;
 
-        sqlx::migrate!()
-            .run(&pool)
-            .await?;
+        sqlx::migrate!().run(&pool).await?;
 
         Ok(Self { pool })
     }
@@ -61,8 +57,8 @@ impl PaymentsManager {
     pub async fn create(
         &self,
         account_id: AccountId,
-                            currency: &str,
-                            amount: rust_decimal::Decimal,
+        currency: &str,
+        amount: rust_decimal::Decimal,
     ) -> sqlx::Result<Payment> {
         // Check-out a connection to avoid paying the overhead of acquiring one for each call.
         let mut conn = self.pool.acquire().await?;
@@ -91,8 +87,8 @@ impl PaymentsManager {
             currency,
             amount,
         )
-            .fetch_one(&mut *conn)
-            .await?;
+        .fetch_one(&mut *conn)
+        .await?;
 
         // We then create the record with the payment vendor...
         let external_payment_id = "foobar1234";
@@ -103,17 +99,17 @@ impl PaymentsManager {
         // the order of columns gets baked into the binary, so if it changes between compile time and
         // run-time, you may run into errors.
         let payment = sqlx::query_as!(
-        Payment,
-        "update payment \
+            Payment,
+            "update payment \
          set status = $1, external_payment_id = $2 \
          where payment_id = $3 \
          returning *",
-        PaymentStatus::Created,
-        external_payment_id,
-        payment_id.0,
-    )
-            .fetch_one(&mut *conn)
-            .await?;
+            PaymentStatus::Created,
+            external_payment_id,
+            payment_id.0,
+        )
+        .fetch_one(&mut *conn)
+        .await?;
 
         Ok(payment)
     }
@@ -125,9 +121,7 @@ impl PaymentsManager {
             "select * from payment where payment_id = $1",
             payment_id.0
         )
-            .fetch_optional(&self.pool)
-            .await
+        .fetch_optional(&self.pool)
+        .await
     }
 }
-
-

examples/postgres/multi-database/src/main.rs

@@ -1,8 +1,8 @@
 use accounts::AccountsManager;
 use color_eyre::eyre;
 use color_eyre::eyre::{Context, OptionExt};
-use rand::distributions::{Alphanumeric, DistString};
 use payments::PaymentsManager;
+use rand::distributions::{Alphanumeric, DistString};
 use sqlx::Connection;
 
 #[tokio::main]
@@ -18,23 +18,24 @@ async fn main() -> eyre::Result<()> {
     .await
     .wrap_err("could not connect to database")?;
 
-    let accounts = AccountsManager::setup( 
+    let accounts = AccountsManager::setup(
         dotenvy::var("ACCOUNTS_DATABASE_URL")
             .wrap_err("ACCOUNTS_DATABASE_URL must be set")?
             .parse()
             .wrap_err("error parsing ACCOUNTS_DATABASE_URL")?,
-        1)
-        .await
-        .wrap_err("error initializing AccountsManager")?;
-    
+        1,
+    )
+    .await
+    .wrap_err("error initializing AccountsManager")?;
+
     let payments = PaymentsManager::setup(
         dotenvy::var("PAYMENTS_DATABASE_URL")
             .wrap_err("PAYMENTS_DATABASE_URL must be set")?
             .parse()
             .wrap_err("error parsing PAYMENTS_DATABASE_URL")?,
     )
-        .await
-        .wrap_err("error initializing PaymentsManager")?;
+    .await
+    .wrap_err("error initializing PaymentsManager")?;
 
     // For simplicity's sake, imagine each of these might be invoked by different request routes
     // in a web application.
@@ -94,7 +95,8 @@ async fn main() -> eyre::Result<()> {
     let purchase_amount: rust_decimal::Decimal = "12.34".parse().unwrap();
 
     // Then, because the user is making a purchase, we record a payment.
-    let payment = payments.create(account_id, "USD", purchase_amount)
+    let payment = payments
+        .create(account_id, "USD", purchase_amount)
         .await
         .wrap_err("error creating payment")?;