Struct MigrationManager 

pub struct MigrationManager { /* private fields */ }

Central migration system manager that orchestrates schema evolution.

The MigrationManager maintains the complete registry of available migrations and provides the logic for applying them in the correct order. It ensures that migrations are applied atomically and tracks their completion status.

Architecture

• Migration Registry: Stores all available migrations in version order
• Version Control: Tracks current schema version and pending changes
• Transaction Management: Ensures each migration is atomic
• Error Recovery: Provides rollback on migration failures

Thread Safety

The migration manager is designed for single-threaded use during application startup. Multiple concurrent migration attempts should be avoided.

Implementations

impl MigrationManager

pub fn new() -> Self

Creates a new migration manager with all registered migrations.

This constructor automatically registers all available migrations in the correct order. The registration process is deterministic and ensures consistent schema evolution across all environments.

Returns

Returns a fully initialized migration manager ready to apply pending schema changes.

Example

use kasl::db::migrations::MigrationManager;

let manager = MigrationManager::new();
// Manager is ready to apply migrations

pub fn run_migrations(&self, conn: &mut Connection) -> Result<()>

Executes all pending migrations in the correct order.

This method performs the complete migration process:

1. Creates the migrations tracking table if needed
2. Determines current database version
3. Identifies pending migrations
4. Applies each migration within a transaction
5. Records successful migrations in the tracking table

Transaction Safety

Each migration runs in its own transaction, ensuring that partial failures don’t leave the database in an inconsistent state. If any migration fails, all changes are rolled back automatically.

Arguments

• conn - Mutable database connection for applying migrations

Returns

Returns Ok(()) if all migrations succeed, or an error if any migration fails during application.

Example

use kasl::db::migrations::MigrationManager;
use rusqlite::Connection;

let manager = MigrationManager::new();
let mut conn = Connection::open(":memory:")?;
manager.run_migrations(&mut conn)?;

pub fn is_migration_applied( &self, conn: &Connection, version: u32, ) -> Result<bool>

Checks if a specific migration version has been applied.

This utility method allows callers to verify whether a particular migration has been successfully applied to the database. Useful for conditional logic based on schema capabilities.

Arguments

• conn - Database connection for querying migration status
• version - Migration version number to check

Returns

Returns true if the migration has been applied, false otherwise.

Example

use kasl::db::migrations::MigrationManager;
use rusqlite::Connection;

let manager = MigrationManager::new();
let mut conn = Connection::open(":memory:")?;
manager.run_migrations(&mut conn)?;
if manager.is_migration_applied(&conn, 3)? {
    // Tags system is available
}

pub fn get_migration_history( &self, conn: &Connection, ) -> Result<Vec<(u32, String, String)>>

Retrieves the complete migration history with timestamps.

This method returns a chronological list of all applied migrations, including their version numbers, names, and application timestamps. Useful for auditing and debugging schema evolution.

Arguments

• conn - Database connection for querying migration history

Returns

Returns a vector of tuples containing (version, name, applied_at) for each applied migration, ordered by version number.

Example

use kasl::db::migrations::MigrationManager;
use rusqlite::Connection;

let manager = MigrationManager::new();
let mut conn = Connection::open(":memory:")?;
manager.run_migrations(&mut conn)?;
let history = manager.get_migration_history(&conn)?;
for (version, name, applied_at) in history {
    println!("v{}: {} ({})", version, name, applied_at);
}

pub fn rollback_to( &self, conn: &mut Connection, target_version: u32, ) -> Result<()>

Rolls back migrations to a specific target version (debug builds only).

This development utility allows rolling back migrations to a previous schema version by removing migration records from the tracking table.

⚠️ Important Notes

• Only available in debug builds for safety
• This is a simplified rollback that removes migration records
• Does not actually reverse schema changes (no down() functions)
• Primarily useful for development and testing scenarios

Arguments

• conn - Mutable database connection for rollback operations
• target_version - Target version to roll back to

Returns

Returns Ok(()) if rollback succeeds, or an error if the operation fails.

Example

use kasl::db::migrations::MigrationManager;
use rusqlite::Connection;

#[cfg(debug_assertions)]
{
    let manager = MigrationManager::new();
    let mut conn = Connection::open(":memory:")?;
    manager.run_migrations(&mut conn)?;
    manager.rollback_to(&mut conn, 2)?; // Roll back to version 2
}

Trait Implementations

impl Default for MigrationManager

fn default() -> Self

Returns the “default value” for a type.