Migrations¶

//! Creates the `post` table.

use turso_orm_migration::prelude::*;

/// The migration.
#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager<'_>) -> Result<(), DbErr> {
        manager
            .create_table(
                Table::create()
                    .table("post")
                    .if_not_exists()
                    .col(ColumnDef::integer("id").primary_key().auto_increment())
                    .col(ColumnDef::text("title").not_null())
                    .col(ColumnDef::text("text").not_null()),
            )
            .await
    }

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

//! Seeds two posts so that the API has something to list on first start.

use entity::post;
use entity::prelude::Post;
use turso_orm::prelude::*;
use turso_orm_migration::prelude::*;

/// The migration.
#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager<'_>) -> Result<(), DbErr> {
        // The connection is the migration's own transaction, so the seed is
        // rolled back together with the schema change if anything fails.
        Post::insert_many([
            post::ActiveModel {
                title: Set("Hello, Turso".to_owned()),
                text: Set("The first post, inserted by a migration.".to_owned()),
                ..Default::default()
            },
            post::ActiveModel {
                title: Set("Second post".to_owned()),
                text: Set("Also seeded.".to_owned()),
                ..Default::default()
            },
        ])
        .exec(manager.get_connection())
        .await?;
        Ok(())
    }

    async fn down(&self, manager: &SchemaManager<'_>) -> Result<(), DbErr> {
        Post::delete_many()
            .filter(post::Column::Title.is_in(["Hello, Turso", "Second post"]))
            .exec(manager.get_connection())
            .await?;
        Ok(())
    }
}

//! The migrator of the axum example and its migrations, oldest first.
//!
//! Each migration lives in a module named `m<date>_<seq>_<what>`; the
//! `DeriveMigrationName` derive takes the migration name from that module,
//! so every struct is simply called `Migration`.

pub use turso_orm_migration::prelude::*;

mod m20240101_000001_create_post_table;
mod m20240101_000002_seed_posts;

/// The migrator; `migrations` is the only method to implement.
pub struct Migrator;

#[async_trait]
impl MigratorTrait for Migrator {
    fn migrations() -> Vec<Box<dyn MigrationTrait>> {
        vec![
            Box::new(m20240101_000001_create_post_table::Migration),
            Box::new(m20240101_000002_seed_posts::Migration),
        ]
    }
}

//! A minimal migration CLI: `up`, `down`, `status`, `fresh`, `refresh`, `reset`.
//!
//! The database path comes from `DATABASE_URL` in the environment or in the
//! `.env` file next to the workspace root, like the server.
//!
//! ```text
//! cargo run -p migration -- status
//! ```

#![allow(clippy::print_stdout, reason = "a CLI reports on stdout")]

use migration::{Migrator, MigratorTrait};
use turso_orm_migration::prelude::*;

/// Parses the single command argument and runs it against the database.
#[tokio::main]
async fn main() -> Result<(), DbErr> {
    dotenvy::dotenv().ok();
    let url = std::env::var("DATABASE_URL").unwrap_or_else(|_| "axum_example.db".to_owned());
    let db = Database::connect(ConnectOptions::new(url)).await?;
    let command = std::env::args().nth(1).unwrap_or_else(|| "up".to_owned());
    match command.as_str() {
        "up" => Migrator::up(&db, None).await?,
        "down" => Migrator::down(&db, Some(1)).await?,
        "fresh" => Migrator::fresh(&db).await?,
        "refresh" => Migrator::refresh(&db).await?,
        "reset" => Migrator::reset(&db).await?,
        "status" => {}
        other => {
            eprintln!(
                "unknown command `{other}`; expected up, down, fresh, refresh, reset or status"
            );
            std::process::exit(2);
        }
    }
    for status in Migrator::status(&db).await? {
        let mark = if status.applied { "applied" } else { "pending" };
        println!("{mark:8} {}", status.name);
    }
    Ok(())
}

/// Creates the three tables and the index declared on `cake`, in dependency order.
///
/// Foreign keys are derived from the `belongs_to` relations and the DDL is
/// `STRICT`-compatible, so the generated statements are what a migration
/// would contain.
async fn create_schema(db: &Database) -> Result<(), DbErr> {
    let schema = Schema::new();
    for stmt in [
        schema.create_table_from_entity(Bakery).to_statement(),
        schema.create_table_from_entity(Cake).to_statement(),
        schema.create_table_from_entity(Fruit).to_statement(),
    ] {
        println!("{}", stmt.sql);
        db.execute(stmt).await?;
    }
    for idx in schema.create_index_from_entity(Cake) {
        let stmt = idx.to_statement();
        println!("{}", stmt.sql);
        db.execute(stmt).await?;
    }
    println!();
    Ok(())
}