rustyroad 1.8.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

//! `rustyroad pull` — introspect the database into generated code.
//!
//! 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, and can emit Rust or TetherScript models from the same
//! introspection.

mod command;
mod filter;
#[cfg(test)]
mod filter_fixture;
#[cfg(test)]
mod filter_test;
mod help;
mod models;
mod notices;
mod report;
mod typescript;

use crate::database::introspection;
use crate::database::migrations::baseline;
use clap::ArgMatches;

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

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

pub async fn run(matches: &ArgMatches) {
    let schema_name = matches
        .get_one::<String>("schema")
        .map(String::as_str)
        .unwrap_or(DEFAULT_SCHEMA);

    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) => filter::apply(matches, schema),
        Err(error) => return report::fail(&error.to_string()),
    };

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

    // Models are skipped when the TypeScript write failed, rather than layered onto a
    // half-written output folder.
    if typescript::write(matches, &schema) {
        models::write(matches, &schema);
    }
}