rustyroad 1.3.0

Rusty Road is a framework written in Rust that is based on Ruby on Rails. It is designed to provide the familiar conventions and ease of use of Ruby on Rails, while also taking advantage of the performance and efficiency of Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//! `rustyroad migration start|complete|rollback-version|version-status`.
//!
//! The versioned lifecycle: `start` publishes a new schema version alongside the
//! current one, `complete` retires the old version, and `rollback-version` undoes
//! a started migration that has not yet been completed.

mod command;
mod context;
mod report;
mod status;
mod undo;

use crate::database::versions::lifecycle;
use clap::ArgMatches;

pub(crate) use command::{complete as complete_command, rollback as rollback_command};
pub(crate) use command::{start as start_command, status as status_command};

/// Schema whose versions are managed.
const SCHEMA: &str = "public";

pub(super) async fn start(matches: &ArgMatches) {
    super::print_config();

    let version = matches
        .get_one::<String>("name")
        .map(String::to_string)
        .unwrap_or_default();
    let migration = context::migration(&version);
    let connection = context::connect().await;

    match lifecycle::start(&connection, SCHEMA, &version, &migration).await {
        Ok(started) => report::started(&started, lifecycle::supports_versions(&connection)),
        Err(error) => report::fail(&error.to_string()),
    }
}

pub(super) async fn complete(_matches: &ArgMatches) {
    super::print_config();
    let connection = context::connect().await;

    match lifecycle::complete(&connection, SCHEMA).await {
        Ok(version) => report::completed(&version),
        Err(error) => report::fail(&error.to_string()),
    }
}

pub(super) async fn rollback(_matches: &ArgMatches) {
    super::print_config();
    undo::run().await;
}

pub(super) async fn status(_matches: &ArgMatches) {
    super::print_config();
    let connection = context::connect().await;

    match status::collect(&connection, SCHEMA).await {
        Ok(state) => report::status(&state),
        Err(error) => report::fail(&error.to_string()),
    }
}