runique 3.0.2

A Django-inspired web framework for Rust with ORM, templates, and comprehensive security middleware
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
96
97
98
99
100
101
102
103
104
105
106
107
108

//! CLI binary `runique` — `new`, `start`, `makemigration`, `migrate` commands via clap.
use anyhow::Result;
use clap::{Parser, Subcommand};
use runique::{
    cli::{create_new_project, create_superuser, makemigration, migrate, run_tests, runique_start},
    utils::{
        init_logging,
        trad::{Lang, set_lang},
    },
};

#[derive(Parser)]
#[command(name = "runique")]
#[command(about = "Runique framework CLI", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Create a new Runique project
    ///
    /// Generates the complete structure with routes, views, models and templates.
    New { name: String },

    /// Start Runique services (from the project root)
    ///
    /// Automatically detects the project configuration:
    ///   - If `.with_admin(...)` is present in src/main.rs → starts the `AdminPanel` daemon
    ///   - Otherwise → nothing to do
    Start {
        /// Path to src/main.rs (default: ./src/main.rs)
        #[arg(long, default_value = "src/main.rs")]
        main: String,

        /// Path to src/admin.rs (default: ./src/admin.rs)
        #[arg(long, default_value = "src/admin.rs")]
        admin: String,
    },
    /// Create an admin superuser
    CreateSuperuser,

    /// Run the project's runique tests (src/runique_test/)
    ///
    /// Each test runs against your database inside a transaction that always
    /// gets rolled back. `runique test` runs them all, `runique test user` only
    /// src/runique_test/user.rs, `runique test user add_email` a single test.
    Test {
        /// Test file in src/runique_test/, without the .rs
        file: Option<String>,
        /// Test function in that file
        test: Option<String>,
    },
    Migration {
        #[command(subcommand)]
        action: MigrateAction,
    },
    Makemigrations {
        #[arg(long, default_value = "src/entities")]
        entities: String,
        #[arg(long, default_value = "migration/src")]
        migrations: String,
        #[arg(long, default_value = "false")]
        force: bool,
    },
}

#[derive(Subcommand)]
enum MigrateAction {
    Up {
        #[arg(long, default_value = "migration/src")]
        migrations: String,
    },
}

#[tokio::main]
async fn main() -> Result<()> {
    let _log_guards = init_logging();
    dotenvy::dotenv_override().ok();

    if let Some(lang) = Lang::from_env() {
        set_lang(lang);
    }

    let cli = Cli::parse();

    match cli.command {
        Commands::New { name } => create_new_project(&name)?,
        Commands::Start { main, admin } => runique_start(&main, &admin)?,
        Commands::CreateSuperuser => create_superuser().await?,
        Commands::Test { file, test } => run_tests(file.as_deref(), test.as_deref())?,
        Commands::Migration { action } => match action {
            MigrateAction::Up { migrations } => {
                migrate::up(&migrations).await?;
            }
        },
        Commands::Makemigrations {
            entities,
            migrations,
            force,
        } => {
            makemigration::run(&entities, &migrations, force)?;
        }
    }

    Ok(())
}