From 286b19361ca28494241f63a9908d59d509571ccb Mon Sep 17 00:00:00 2001
From: Owen Jacobson <owen@grimoire.ca>
Date: Sat, 5 Oct 2024 01:05:52 -0400
Subject: Improve ergonomics of `Backup`

---
 src/db/backup.rs | 43 ++++++++++++++++++++-----------------------
 src/db/mod.rs    | 10 +---------
 2 files changed, 21 insertions(+), 32 deletions(-)

(limited to 'src')

diff --git a/src/db/backup.rs b/src/db/backup.rs
index 027c233..a6fe917 100644
--- a/src/db/backup.rs
+++ b/src/db/backup.rs
@@ -8,41 +8,38 @@ use libsqlite3_sys::{
     sqlite3, sqlite3_backup, sqlite3_backup_finish, sqlite3_backup_init, sqlite3_backup_step,
     sqlite3_errmsg, sqlite3_extended_errcode, SQLITE_BUSY, SQLITE_LOCKED, SQLITE_OK,
 };
-use sqlx::{
-    pool::PoolConnection,
-    sqlite::{Sqlite, SqlitePool},
-};
+use sqlx::sqlite::SqlitePool;
 
-pub struct Builder {
-    from: PoolConnection<Sqlite>,
+pub struct Builder<'p> {
+    from: &'p SqlitePool,
 }
 
-impl Builder {
-    pub async fn to(self, to: &SqlitePool) -> sqlx::Result<Backup> {
-        Ok(Backup {
+impl<'p> Builder<'p> {
+    pub fn to(self, to: &'p SqlitePool) -> Backup<'p> {
+        Backup {
             from: self.from,
-            to: to.acquire().await?,
-        })
+            to,
+        }
     }
 }
 
-impl Backup {
-    pub async fn from(from: &SqlitePool) -> sqlx::Result<Builder> {
-        Ok(Builder {
-            from: from.acquire().await?,
-        })
-    }
+pub struct Backup<'p> {
+    from: &'p SqlitePool,
+    to: &'p SqlitePool,
 }
 
-pub struct Backup {
-    from: PoolConnection<Sqlite>,
-    to: PoolConnection<Sqlite>,
+impl<'p> Backup<'p> {
+    pub fn from(from: &'p SqlitePool) -> Builder<'p> {
+        Builder { from }
+    }
 }
 
-impl Backup {
+impl<'p> Backup<'p> {
     pub async fn backup(&mut self) -> Result<(), Error> {
-        let mut to = self.to.lock_handle().await?;
-        let mut from = self.from.lock_handle().await?;
+        let mut to = self.to.acquire().await?;
+        let mut to = to.lock_handle().await?;
+        let mut from = self.from.acquire().await?;
+        let mut from = from.lock_handle().await?;
 
         let handle = Self::start(to.as_raw_handle(), from.as_raw_handle())?;
         let step_result = Self::step(handle, -1);
diff --git a/src/db/mod.rs b/src/db/mod.rs
index 090fa38..bbaec7d 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -21,20 +21,12 @@ pub async fn prepare(url: &str, backup_url: &str) -> Result<SqlitePool, Error> {
 
     let backup_pool = create(backup_url).await?;
     backup::Backup::from(&pool)
-        .await?
         .to(&backup_pool)
-        .await?
         .backup()
         .await?;
 
     if let Err(migrate_error) = sqlx::migrate!().run(&pool).await {
-        if let Err(restore_error) = backup::Backup::from(&backup_pool)
-            .await?
-            .to(&pool)
-            .await?
-            .backup()
-            .await
-        {
+        if let Err(restore_error) = backup::Backup::from(&backup_pool).to(&pool).backup().await {
             Err(Error::Restore(restore_error, migrate_error))?;
         } else {
             Err(migrate_error)?;
-- 
cgit v1.2.3