rustyroad 1.7.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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! `rustyroad pull` — introspect the database into a TypeScript folder.
//!
//! Mirrors `drizzle-kit pull`: read the live schema, then write a folder of
//! generated TypeScript. RustyRoad additionally emits a typed client and REST
//! routes, which Drizzle leaves to the application.

mod command;
mod help;
mod notices;
mod report;

use crate::database::introspection;
use crate::database::migrations::baseline;
use crate::generators::rust as rust_generator;
use crate::generators::typescript::{self, Casing, Outputs};
use clap::ArgMatches;
use std::path::PathBuf;

pub(crate) use command::pull as pull_command;

const TYPESCRIPT_OUT: &str = "./db";
const RUST_OUT: &str = "./src/db";

/// Schema introspected when none is given.
const DEFAULT_SCHEMA: &str = "public";

#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum Language {
    TypeScript,
    Rust,
}

pub async fn run(matches: &ArgMatches) {
    let language = match matches.get_one::<String>("language").map(String::as_str) {
        Some("rust") => Language::Rust,
        _ => Language::TypeScript,
    };
    let default_out = match language {
        Language::TypeScript => TYPESCRIPT_OUT,
        Language::Rust => RUST_OUT,
    };
    let out = PathBuf::from(
        matches
            .get_one::<String>("out")
            .map(String::as_str)
            .unwrap_or(default_out),
    );
    let schema_name = matches
        .get_one::<String>("schema")
        .map(String::as_str)
        .unwrap_or(DEFAULT_SCHEMA);
    let casing = Casing::parse(matches.get_one::<String>("casing").map(String::as_str));
    let connection = match baseline::connect().await {
        Ok(connection) => connection,
        Err(error) => return report::fail(&error.to_string()),
    };

    let schema = match introspection::read(&connection, schema_name).await {
        Ok(schema) => schema,
        Err(error) => return report::fail(&error.to_string()),
    };

    if schema.tables.is_empty() {
        return report::empty(schema_name);
    }

    let force = matches.get_flag("force");
    let result = match language {
        Language::TypeScript => {
            typescript::write(&out, &schema, casing, typescript_outputs(matches), force)
        }
        Language::Rust => rust_generator::write(&out, &schema, rust_outputs(matches), force),
    };
    match result {
        Ok(report_data) => report::written(&schema, &report_data, language),
        Err(error) => report::fail(&error.to_string()),
    }
}

/// Returns which artifacts to emit, honouring `--schema-only`.
fn typescript_outputs(matches: &ArgMatches) -> Outputs {
    if matches.get_flag("schema-only") {
        Outputs::schema_only()
    } else {
        Outputs::all()
    }
}

fn rust_outputs(matches: &ArgMatches) -> rust_generator::Outputs {
    if matches.get_flag("schema-only") {
        rust_generator::Outputs::schema_only()
    } else {
        rust_generator::Outputs::all()
    }
}