Database Migrations

kit make:migration <name>

kit make:migration create_users_table
kit make:migration add_email_to_users
kit make:migration create_posts_table

// migrations/YYYYMMDDHHMMSS_create_users_table.rs
use sea_orm_migration::prelude::*;

#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .create_table(
                Table::create()
                    .table(Users::Table)
                    .if_not_exists()
                    .col(
                        ColumnDef::new(Users::Id)
                            .integer()
                            .not_null()
                            .auto_increment()
                            .primary_key(),
                    )
                    .col(ColumnDef::new(Users::CreatedAt).timestamp().not_null())
                    .col(ColumnDef::new(Users::UpdatedAt).timestamp().not_null())
                    .to_owned(),
            )
            .await
    }

    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .drop_table(Table::drop().table(Users::Table).to_owned())
            .await
    }
}

#[derive(DeriveIden)]
enum Users {
    Table,
    Id,
    CreatedAt,
    UpdatedAt,
}

kit migrate

Running migrations...
Applying migration: 20240101120000_create_users_table
Applying migration: 20240101120001_create_posts_table
All migrations completed successfully!

kit migrate:status

Migration Status
----------------
[✓] 20240101120000_create_users_table (applied)
[✓] 20240101120001_create_posts_table (applied)
[ ] 20240101120002_add_email_to_users (pending)

kit migrate:rollback [options]

# Rollback the last migration
kit migrate:rollback

# Rollback the last 3 migrations
kit migrate:rollback --step 3

Rolling back migrations...
Rolling back: 20240101120002_add_email_to_users
Rollback completed successfully!

kit migrate:fresh

Dropping all tables...
Tables dropped.
Running migrations...
Applying migration: 20240101120000_create_users_table
Applying migration: 20240101120001_create_posts_table
Applying migration: 20240101120002_add_email_to_users
Fresh migration completed successfully!

kit db:sync [options]

# Run migrations and sync entities
kit db:sync

# Only sync entities (skip migrations)
kit db:sync --skip-migrations

# Regenerate all model files with the latest fluent API
kit db:sync --regenerate-models

# 1. Create a new migration
kit make:migration create_users_table

# 2. Edit the migration file to define your schema
# migrations/YYYYMMDDHHMMSS_create_users_table.rs

# 3. Run the migration
kit migrate

# 4. Sync entity files
kit db:sync

# 5. Use the generated model in your code
# src/models/users.rs is now available

async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
    manager
        .create_table(
            Table::create()
                .table(Posts::Table)
                .if_not_exists()
                .col(
                    ColumnDef::new(Posts::Id)
                        .integer()
                        .not_null()
                        .auto_increment()
                        .primary_key(),
                )
                .col(ColumnDef::new(Posts::Title).string().not_null())
                .col(ColumnDef::new(Posts::Content).text().not_null())
                .col(ColumnDef::new(Posts::UserId).integer().not_null())
                .foreign_key(
                    ForeignKey::create()
                        .from(Posts::Table, Posts::UserId)
                        .to(Users::Table, Users::Id)
                        .on_delete(ForeignKeyAction::Cascade),
                )
                .col(ColumnDef::new(Posts::CreatedAt).timestamp().not_null())
                .col(ColumnDef::new(Posts::UpdatedAt).timestamp().not_null())
                .to_owned(),
        )
        .await
}

async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
    manager
        .alter_table(
            Table::alter()
                .table(Users::Table)
                .add_column(ColumnDef::new(Users::Email).string().not_null())
                .to_owned(),
        )
        .await
}

async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
    manager
        .alter_table(
            Table::alter()
                .table(Users::Table)
                .drop_column(Users::Email)
                .to_owned(),
        )
        .await
}

async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
    manager
        .create_index(
            Index::create()
                .name("idx_users_email")
                .table(Users::Table)
                .col(Users::Email)
                .unique()
                .to_owned(),
        )
        .await
}