Add database migration CLI tool

Cargo.toml

@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "crates/toasty",
+    "crates/toasty-cli",
     "crates/toasty-codegen",
     "crates/toasty-core",
     "crates/toasty-macros",
@@ -23,6 +24,7 @@ members = [
     # Examples
     "examples/composite-key",
     "examples/hello-toasty",
+    "examples/todo-with-cli",
     "examples/user-has-one-profile",
 
     # Tests
@@ -35,6 +37,7 @@ members = [
 [workspace.dependencies]
 # Toasty crates
 toasty = { path = "crates/toasty" }
+toasty-cli = { path = "crates/toasty-cli" }
 toasty-codegen = { path = "crates/toasty-codegen" }
 toasty-core = { path = "crates/toasty-core" }
 toasty-macros = { path = "crates/toasty-macros" }
@@ -62,7 +65,9 @@ bit-set = "0.8.0"
 by_address = "1.2.1"
 cfg-if = "1.0.0"
 clap = { version = "4.5.20", features = ["derive"] }
+console = "0.16"
 deadpool = { version = "0.12.3", features = ["rt_tokio_1"] }
+dialoguer = "0.12"
 heck = "0.5.0"
 indexmap = "2.6.0"
 index_vec = "0.1.4"
@@ -85,6 +90,8 @@ rusqlite = { version = "0.32", features = ["bundled"] }
 serde = { version = "1.0.214", features = ["derive"] }
 serde_json = "1.0.132"
 syn = { version = "2.0.86", features = ["full", "extra-traits", "visit-mut"] }
+toml = "0.9.11"
+toml_edit = "0.24.0"
 tempfile = "3.8"
 tokio = { version = "1.18", features = ["full"] }
 tokio-postgres = "0.7.13"

crates/toasty-cli/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "toasty-cli"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[dependencies]
+toasty.workspace = true
+toasty-core = { workspace = true, features = ["serde"] }
+toasty-sql.workspace = true
+
+anyhow = "1.0.100"
+clap.workspace = true
+console.workspace = true
+dialoguer.workspace = true
+rand.workspace = true
+serde.workspace = true
+toml.workspace = true
+toml_edit = { workspace = true, features = ["serde"] }

crates/toasty-cli/src/config.rs

@@ -0,0 +1,33 @@
+use crate::migration::MigrationConfig;
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+
+/// Configuration for Toasty CLI operations
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct Config {
+    /// Migration-related configuration
+    pub migration: MigrationConfig,
+}
+
+impl Config {
+    /// Create a new Config with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load configuration from Toasty.toml in the project root
+    pub fn load() -> Result<Self> {
+        let path = Path::new("Toasty.toml");
+        let contents = fs::read_to_string(path)?;
+        let config: Config = toml::from_str(&contents)?;
+        Ok(config)
+    }
+
+    /// Set the migration configuration
+    pub fn migration(mut self, migration: MigrationConfig) -> Self {
+        self.migration = migration;
+        self
+    }
+}

crates/toasty-cli/src/lib.rs

@@ -0,0 +1,73 @@
+mod config;
+mod migration;
+mod theme;
+
+pub use config::*;
+pub use migration::*;
+
+use anyhow::Result;
+use clap::Parser;
+use toasty::Db;
+
+/// Toasty CLI library for building custom command-line tools
+pub struct ToastyCli {
+    db: Db,
+    config: Config,
+}
+
+impl ToastyCli {
+    /// Create a new ToastyCli instance with the given database connection
+    pub fn new(db: Db) -> Self {
+        Self {
+            db,
+            config: Config::default(),
+        }
+    }
+
+    /// Create a new ToastyCli instance with a custom configuration
+    pub fn with_config(db: Db, config: Config) -> Self {
+        Self { db, config }
+    }
+
+    /// Get a reference to the configuration
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Parse and execute CLI commands from command-line arguments
+    pub async fn parse_and_run(&self) -> Result<()> {
+        let cli = Cli::parse();
+        self.run(cli).await
+    }
+
+    /// Parse and execute CLI commands from an iterator of arguments
+    pub async fn parse_from<I, T>(&self, args: I) -> Result<()>
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<std::ffi::OsString> + Clone,
+    {
+        let cli = Cli::parse_from(args);
+        self.run(cli).await
+    }
+
+    async fn run(&self, cli: Cli) -> Result<()> {
+        match cli.command {
+            Command::Migration(cmd) => cmd.run(&self.db, &self.config).await,
+        }
+    }
+}
+
+#[derive(Parser, Debug)]
+#[command(name = "toasty")]
+#[command(about = "Toasty CLI - Database migration and management tool")]
+#[command(version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Parser, Debug)]
+enum Command {
+    /// Database migration commands
+    Migration(migration::MigrationCommand),
+}

crates/toasty-cli/src/migration.rs

@@ -0,0 +1,58 @@
+mod apply;
+mod config;
+mod drop;
+mod generate;
+mod history_file;
+mod snapshot;
+mod snapshot_file;
+
+pub use apply::*;
+pub use config::*;
+pub use drop::*;
+pub use generate::*;
+pub use history_file::*;
+pub use snapshot::*;
+pub use snapshot_file::*;
+
+use crate::Config;
+use anyhow::Result;
+use clap::Parser;
+use toasty::Db;
+
+#[derive(Parser, Debug)]
+pub struct MigrationCommand {
+    #[command(subcommand)]
+    subcommand: MigrationSubcommand,
+}
+
+#[derive(Parser, Debug)]
+enum MigrationSubcommand {
+    /// Apply pending migrations to the database
+    Apply(ApplyCommand),
+
+    /// Generate a new migration based on schema changes
+    Generate(GenerateCommand),
+
+    /// Print the current schema snapshot file
+    Snapshot(SnapshotCommand),
+
+    /// Drop a migration from the history
+    Drop(DropCommand),
+}
+
+impl MigrationCommand {
+    pub(crate) async fn run(self, db: &Db, config: &Config) -> Result<()> {
+        self.subcommand.run(db, config).await
+    }
+}
+
+impl MigrationSubcommand {
+    async fn run(self, db: &Db, config: &Config) -> Result<()> {
+        match self {
+            Self::Apply(cmd) => cmd.run(db, config).await,
+            Self::Generate(cmd) => cmd.run(db, config),
+            Self::Snapshot(cmd) => cmd.run(db, config),
+            Self::Drop(cmd) => cmd.run(db, config),
+        }
+    }
+}

crates/toasty-cli/src/migration/apply.rs

@@ -0,0 +1,111 @@
+use super::HistoryFile;
+use crate::Config;
+use anyhow::Result;
+use clap::Parser;
+use console::style;
+use std::collections::HashSet;
+use std::fs;
+use toasty::Db;
+use toasty::schema::db::Migration;
+
+#[derive(Parser, Debug)]
+pub struct ApplyCommand {}
+
+impl ApplyCommand {
+    pub(crate) async fn run(self, db: &Db, config: &Config) -> Result<()> {
+        println!();
+        println!("  {}", style("Apply Migrations").cyan().bold().underlined());
+        println!();
+
+        let history_path = config.migration.get_history_file_path();
+
+        // Load migration history
+        let history = HistoryFile::load_or_default(&history_path)?;
+
+        if history.migrations().is_empty() {
+            println!(
+                "  {}",
+                style("No migrations found in history file.")
+                    .magenta()
+                    .dim()
+            );
+            println!();
+            return Ok(());
+        }
+
+        // Get a connection to check which migrations have been applied
+        let mut conn = db.driver().connect().await?;
+
+        // Get list of already applied migrations
+        let applied_migrations = conn.applied_migrations().await?;
+        let applied_ids: HashSet<u64> = applied_migrations.iter().map(|m| m.id()).collect();
+
+        // Find migrations that haven't been applied yet
+        let pending_migrations: Vec<_> = history
+            .migrations()
+            .iter()
+            .filter(|m| !applied_ids.contains(&m.id))
+            .collect();
+
+        if pending_migrations.is_empty() {
+            println!(
+                "  {}",
+                style("All migrations are already applied. Database is up to date.")
+                    .green()
+                    .dim()
+            );
+            println!();
+            return Ok(());
+        }
+
+        let pending_count = pending_migrations.len();
+        println!(
+            "  {} Found {} pending migration(s) to apply",
+            style("→").cyan(),
+            pending_count
+        );
+        println!();
+
+        // Apply each pending migration
+        for migration_entry in &pending_migrations {
+            let migration_path = config
+                .migration
+                .get_migrations_dir()
+                .join(&migration_entry.name);
+
+            println!(
+                "  {} Applying migration: {}",
+                style("→").cyan(),
+                style(&migration_entry.name).bold()
+            );
+
+            // Load the migration SQL file
+            let sql = fs::read_to_string(&migration_path)?;
+            let migration = Migration::new_sql(sql);
+
+            // Apply the migration
+            conn.apply_migration(migration_entry.id, migration_entry.name.clone(), &migration)
+                .await?;
+
+            println!(
+                "  {} {}",
+                style("✓").green().bold(),
+                style(format!("Applied: {}", migration_entry.name)).dim()
+            );
+        }
+
+        println!();
+        println!(
+            "  {}",
+            style(format!(
+                "Successfully applied {} migration(s)",
+                pending_count
+            ))
+            .green()
+            .bold()
+        );
+        println!();
+
+        Ok(())
+    }
+}