Remove refinery for an inhouse migration tool

crates/cdk-sqlite/Cargo.toml

@@ -31,4 +31,3 @@ serde.workspace = true
 serde_json.workspace = true
 lightning-invoice.workspace = true
 uuid.workspace = true
-refinery = { version = "0.8.16", features = ["rusqlite", "rusqlite-bundled"] }

crates/cdk-sqlite/build.rs

@@ -0,0 +1,72 @@
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+fn main() {
+    // Step 1: Find `migrations/` folder recursively
+    let root = Path::new("src");
+
+    for migration_path in find_migrations_dirs(root) {
+        // Step 2: Collect all files inside the migrations dir
+        let mut files = Vec::new();
+        visit_dirs(&migration_path, &mut files).expect("Failed to read migrations directory");
+        files.sort();
+
+        // Step 3: Output file path (e.g., `src/db/migrations.rs`)
+        let parent = migration_path.parent().unwrap();
+        let skip_path = parent.to_str().unwrap_or_default().len();
+        let dest_path = parent.join("migrations.rs");
+        let mut out_file = File::create(&dest_path).expect("Failed to create migrations.rs");
+
+        writeln!(out_file, "// @generated").unwrap();
+        writeln!(out_file, "// Auto-generated by build.rs").unwrap();
+        writeln!(out_file, "pub static MIGRATIONS: &[(&str, &str)] = &[").unwrap();
+
+        for path in &files {
+            let name = path.file_name().unwrap().to_string_lossy();
+            let rel_path = &path.to_str().unwrap().replace("\\", "/")[skip_path..]; // for Windows
+            writeln!(
+                out_file,
+                "    (\"{name}\", include_str!(r#\".{rel_path}\"#)),"
+            )
+            .unwrap();
+        }
+
+        writeln!(out_file, "];").unwrap();
+
+        println!("cargo:rerun-if-changed={}", migration_path.display());
+    }
+}
+
+fn find_migrations_dirs(root: &Path) -> Vec<PathBuf> {
+    let mut found = Vec::new();
+    find_migrations_dirs_rec(root, &mut found);
+    found
+}
+
+fn find_migrations_dirs_rec(dir: &Path, found: &mut Vec<PathBuf>) {
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                if path.file_name().unwrap_or_default() == "migrations" {
+                    found.push(path.clone());
+                }
+                find_migrations_dirs_rec(&path, found);
+            }
+        }
+    }
+}
+
+fn visit_dirs(dir: &Path, files: &mut Vec<PathBuf>) -> std::io::Result<()> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            visit_dirs(&path, files)?;
+        } else if path.is_file() {
+            files.push(path);
+        }
+    }
+    Ok(())
+}

crates/cdk-sqlite/src/common.rs

@@ -1,4 +1,5 @@
-use r2d2::Pool;
+use r2d2::{Pool, PooledConnection};
+use r2d2_sqlite::rusqlite::params;
 use r2d2_sqlite::SqliteConnectionManager;
 
 /// Create a configured rusqlite connection to a SQLite database.
@@ -14,16 +15,18 @@ pub fn create_sqlite_pool(
     };
 
     let manager = manager.with_init(move |conn| {
-        // Apply pragmas
-        conn.pragma_update(None, "busy_timeout", 5000)?;
-        conn.pragma_update(None, "journal_mode", "wal")?;
-        conn.pragma_update(None, "synchronous", "normal")?;
-        conn.pragma_update(None, "temp_store", "memory")?;
-        conn.pragma_update(None, "mmap_size", 30000000000i64)?;
-        conn.pragma_update(None, "cache", "shared")?;
-
         #[cfg(feature = "sqlcipher")]
-        conn.pragma_update(None, "key", password.clone())?;
+        conn.execute_batch(&format!("pragma key = {};", password))?;
+
+        conn.execute_batch(
+            r#"
+            pragma journal_mode = WAL;
+            pragma synchronous = normal;
+            pragma temp_store = memory;
+            pragma mmap_size = 30000000000;
+            pragma cache = shared;
+            "#,
+        )?;
 
         Ok(())
     });
@@ -32,3 +35,38 @@ pub fn create_sqlite_pool(
         .max_size(if is_memory { 1 } else { 20 })
         .build(manager)
 }
+
+/// Migrates the migration generated by `build.rs`
+pub fn migrate(
+    mut conn: PooledConnection<SqliteConnectionManager>,
+    migrations: &[(&str, &str)],
+) -> Result<(), r2d2_sqlite::rusqlite::Error> {
+    let tx = conn.transaction()?;
+    tx.execute(
+        r#"
+           CREATE TABLE IF NOT EXISTS migrations (
+               name TEXT PRIMARY KEY,
+               applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+           )
+           "#,
+        [],
+    )?;
+
+    // Apply each migration if it hasn’t been applied yet
+    for (name, sql) in migrations {
+        let already_applied: bool = tx.query_row(
+            "SELECT EXISTS(SELECT 1 FROM migrations WHERE name = ?1)",
+            params![name],
+            |row| row.get(0),
+        )?;
+
+        if !already_applied {
+            tx.execute_batch(sql)?;
+            tx.execute("INSERT INTO migrations (name) VALUES (?1)", params![name])?;
+        }
+    }
+
+    tx.commit()?;
+
+    Ok(())
+}

crates/cdk-sqlite/src/mint/auth/migrations.rs

@@ -0,0 +1,5 @@
+// @generated
+// Auto-generated by build.rs
+pub static MIGRATIONS: &[(&str, &str)] = &[
+    ("20250109143347_init.sql", include_str!(r#"./migrations/20250109143347_init.sql"#)),
+];

crates/cdk-sqlite/src/mint/auth/mod.rs

@@ -14,7 +14,7 @@ use tracing::instrument;
 use super::async_rusqlite::AsyncRusqlite;
 use super::{sqlite_row_to_blind_signature, sqlite_row_to_keyset_info};
 use crate::column_as_string;
-use crate::common::create_sqlite_pool;
+use crate::common::{create_sqlite_pool, migrate};
 use crate::mint::async_rusqlite::query;
 use crate::mint::Error;
 
@@ -24,7 +24,8 @@ pub struct MintSqliteAuthDatabase {
     pool: AsyncRusqlite,
 }
 
-refinery::embed_migrations!("./src/mint/auth/migrations");
+#[rustfmt::skip]
+mod migrations;
 
 impl MintSqliteAuthDatabase {
     /// Create new [`MintSqliteAuthDatabase`]
@@ -36,10 +37,7 @@ impl MintSqliteAuthDatabase {
         )?;
         #[cfg(not(feature = "sqlcipher"))]
         let pool = create_sqlite_pool(path.as_ref().to_str().ok_or(Error::InvalidDbPath)?)?;
-        let mut conn = pool.get()?;
-
-        migrations::runner().run(&mut *conn)?;
-        drop(conn);
+        migrate(pool.get()?, migrations::MIGRATIONS)?;
 
         Ok(Self {
             pool: AsyncRusqlite::new(pool),

crates/cdk-sqlite/src/mint/error.rs

@@ -12,9 +12,6 @@ pub enum Error {
     /// Pool error
     #[error(transparent)]
     Pool(#[from] r2d2::Error),
-    /// Migration
-    #[error(transparent)]
-    Migration(#[from] refinery::Error),
     /// Invalid UUID
     #[error("Invalid UUID: {0}")]
     InvalidUuid(String),

crates/cdk-sqlite/src/mint/migrations.rs

@@ -0,0 +1,23 @@
+// @generated
+// Auto-generated by build.rs
+pub static MIGRATIONS: &[(&str, &str)] = &[
+    ("20240612124932_init.sql", include_str!(r#"./migrations/20240612124932_init.sql"#)),
+    ("20240618195700_quote_state.sql", include_str!(r#"./migrations/20240618195700_quote_state.sql"#)),
+    ("20240626092101_nut04_state.sql", include_str!(r#"./migrations/20240626092101_nut04_state.sql"#)),
+    ("20240703122347_request_lookup_id.sql", include_str!(r#"./migrations/20240703122347_request_lookup_id.sql"#)),
+    ("20240710145043_input_fee.sql", include_str!(r#"./migrations/20240710145043_input_fee.sql"#)),
+    ("20240711183109_derivation_path_index.sql", include_str!(r#"./migrations/20240711183109_derivation_path_index.sql"#)),
+    ("20240718203721_allow_unspent.sql", include_str!(r#"./migrations/20240718203721_allow_unspent.sql"#)),
+    ("20240811031111_update_mint_url.sql", include_str!(r#"./migrations/20240811031111_update_mint_url.sql"#)),
+    ("20240919103407_proofs_quote_id.sql", include_str!(r#"./migrations/20240919103407_proofs_quote_id.sql"#)),
+    ("20240923153640_melt_requests.sql", include_str!(r#"./migrations/20240923153640_melt_requests.sql"#)),
+    ("20240930101140_dleq_for_sigs.sql", include_str!(r#"./migrations/20240930101140_dleq_for_sigs.sql"#)),
+    ("20241108093102_mint_mint_quote_pubkey.sql", include_str!(r#"./migrations/20241108093102_mint_mint_quote_pubkey.sql"#)),
+    ("20250103201327_amount_to_pay_msats.sql", include_str!(r#"./migrations/20250103201327_amount_to_pay_msats.sql"#)),
+    ("20250129200912_remove_mint_url.sql", include_str!(r#"./migrations/20250129200912_remove_mint_url.sql"#)),
+    ("20250129230326_add_config_table.sql", include_str!(r#"./migrations/20250129230326_add_config_table.sql"#)),
+    ("20250307213652_keyset_id_as_foreign_key.sql", include_str!(r#"./migrations/20250307213652_keyset_id_as_foreign_key.sql"#)),
+    ("20250406091754_mint_time_of_quotes.sql", include_str!(r#"./migrations/20250406091754_mint_time_of_quotes.sql"#)),
+    ("20250406093755_mint_created_time_signature.sql", include_str!(r#"./migrations/20250406093755_mint_created_time_signature.sql"#)),
+    ("20250415093121_drop_keystore_foreign.sql", include_str!(r#"./migrations/20250415093121_drop_keystore_foreign.sql"#)),
+];

crates/cdk-sqlite/src/mint/mod.rs

@@ -26,7 +26,7 @@ use error::Error;
 use lightning_invoice::Bolt11Invoice;
 use uuid::Uuid;
 
-use crate::common::create_sqlite_pool;
+use crate::common::{create_sqlite_pool, migrate};
 use crate::stmt::Column;
 use crate::{
     column_as_nullable_number, column_as_nullable_string, column_as_number, column_as_string,
@@ -39,6 +39,9 @@ mod auth;
 pub mod error;
 pub mod memory;
 
+#[rustfmt::skip]
+mod migrations;
+
 #[cfg(feature = "auth")]
 pub use auth::MintSqliteAuthDatabase;
 
@@ -48,20 +51,12 @@ pub struct MintSqliteDatabase {
     pool: async_rusqlite::AsyncRusqlite,
 }
 
-#[allow(missing_docs)]
-mod migration {
-    refinery::embed_migrations!("./src/mint/migrations");
-}
-
 impl MintSqliteDatabase {
     /// Create new [`MintSqliteDatabase`]
     #[cfg(not(feature = "sqlcipher"))]
     pub async fn new<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
         let pool = create_sqlite_pool(path.as_ref().to_str().ok_or(Error::InvalidDbPath)?)?;
-        let mut conn = pool.get()?;
-
-        migration::migrations::runner().run(&mut *conn)?;
-        drop(conn);
+        migrate(pool.get()?, migrations::MIGRATIONS)?;
 
         Ok(Self {
             pool: async_rusqlite::AsyncRusqlite::new(pool),
@@ -75,10 +70,7 @@ impl MintSqliteDatabase {
             path.as_ref().to_str().ok_or(Error::InvalidDbPath)?,
             password,
         )?;
-        let mut conn = pool.get()?;
-
-        migration::migrations::runner().run(&mut *conn)?;
-        drop(conn);
+        migrate(pool.get()?, migrations::MIGRATIONS)?;
 
         Ok(Self {
             pool: async_rusqlite::AsyncRusqlite::new(pool),

crates/cdk-sqlite/src/wallet/error.rs

@@ -24,9 +24,6 @@ pub enum Error {
     #[error("Error converting {0} to {1}")]
     InvalidConversion(String, String),
 
-    /// Migration
-    #[error(transparent)]
-    Migration(#[from] refinery::Error),
     /// Serde Error
     #[error(transparent)]
     Serde(#[from] serde_json::Error),

crates/cdk-sqlite/src/wallet/migrations.rs

@@ -0,0 +1,19 @@
+// @generated
+// Auto-generated by build.rs
+pub static MIGRATIONS: &[(&str, &str)] = &[
+    ("20240612132920_init.sql", include_str!(r#"./migrations/20240612132920_init.sql"#)),
+    ("20240618200350_quote_state.sql", include_str!(r#"./migrations/20240618200350_quote_state.sql"#)),
+    ("20240626091921_nut04_state.sql", include_str!(r#"./migrations/20240626091921_nut04_state.sql"#)),
+    ("20240710144711_input_fee.sql", include_str!(r#"./migrations/20240710144711_input_fee.sql"#)),
+    ("20240810214105_mint_icon_url.sql", include_str!(r#"./migrations/20240810214105_mint_icon_url.sql"#)),
+    ("20240810233905_update_mint_url.sql", include_str!(r#"./migrations/20240810233905_update_mint_url.sql"#)),
+    ("20240902151515_icon_url.sql", include_str!(r#"./migrations/20240902151515_icon_url.sql"#)),
+    ("20240902210905_mint_time.sql", include_str!(r#"./migrations/20240902210905_mint_time.sql"#)),
+    ("20241011125207_mint_urls.sql", include_str!(r#"./migrations/20241011125207_mint_urls.sql"#)),
+    ("20241108092756_wallet_mint_quote_secretkey.sql", include_str!(r#"./migrations/20241108092756_wallet_mint_quote_secretkey.sql"#)),
+    ("20250214135017_mint_tos.sql", include_str!(r#"./migrations/20250214135017_mint_tos.sql"#)),
+    ("20250310111513_drop_nostr_last_checked.sql", include_str!(r#"./migrations/20250310111513_drop_nostr_last_checked.sql"#)),
+    ("20250314082116_allow_pending_spent.sql", include_str!(r#"./migrations/20250314082116_allow_pending_spent.sql"#)),
+    ("20250323152040_wallet_dleq_proofs.sql", include_str!(r#"./migrations/20250323152040_wallet_dleq_proofs.sql"#)),
+    ("20250401120000_add_transactions_table.sql", include_str!(r#"./migrations/20250401120000_add_transactions_table.sql"#)),
+];

crates/cdk-sqlite/src/wallet/mod.rs

@@ -20,7 +20,7 @@ use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
 use tracing::instrument;
 
-use crate::common::create_sqlite_pool;
+use crate::common::{create_sqlite_pool, migrate};
 use crate::stmt::{Column, Statement};
 use crate::{
     column_as_binary, column_as_nullable_binary, column_as_nullable_number,
@@ -30,17 +30,15 @@ use crate::{
 pub mod error;
 pub mod memory;
 
+#[rustfmt::skip]
+mod migrations;
+
 /// Wallet SQLite Database
 #[derive(Debug, Clone)]
 pub struct WalletSqliteDatabase {
     pool: Pool<SqliteConnectionManager>,
 }
 
-#[allow(missing_docs)]
-mod migration {
-    refinery::embed_migrations!("./src/wallet/migrations");
-}
-
 impl WalletSqliteDatabase {
     /// Create new [`WalletSqliteDatabase`]
     #[cfg(not(feature = "sqlcipher"))]
@@ -67,8 +65,7 @@ impl WalletSqliteDatabase {
 
     /// Migrate [`WalletSqliteDatabase`]
     fn migrate(&self) -> Result<(), Error> {
-        let mut conn = self.pool.get()?;
-        migration::migrations::runner().run(&mut *conn)?;
+        migrate(self.pool.get()?, migrations::MIGRATIONS)?;
         Ok(())
     }
 }
@@ -1108,8 +1105,6 @@ mod tests {
             .await
             .unwrap();
 
-        db.migrate().await.unwrap();
-
         let mint_info = MintInfo::new().description("test");
         let mint_url = MintUrl::from_str("https://mint.xyz").unwrap();