forgex 0.9.0

CLI and runtime for the Forge full-stack framework
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

mod check;
mod frontend_codegen;
mod frontend_target;
mod generate;
mod migrate;
mod new;
mod template;
mod template_catalog;
mod test;
mod ui;

pub use check::CheckCommand;
pub use generate::GenerateCommand;
pub use migrate::MigrateCommand;
pub use new::NewCommand;
pub use test::TestCommand;

use anyhow::Result;
use clap::{Parser, Subcommand};

const ABOUT: &str = r#"FORGE - The Full-Stack Framework for the Impatient

Everything you need in one binary. No Redis, no Kafka, just PostgreSQL.

Quick Start:
  forge new my-app --template with-svelte/minimal
  cd my-app
  docker compose up --build      Start development

Learn more: https://tryforge.dev/docs"#;

const AFTER_HELP: &str = r#"Examples:
  forge new my-app --template with-svelte/minimal
  forge new my-app --template with-dioxus/realtime-todo-list
  docker compose up --build      Start development (requires Docker)
  docker compose down            Stop the development environment
  docker compose down -v         Stop and remove volumes
  forge test                     Run all tests (backend + frontend)
  forge test --skip-frontend     Run backend unit tests only
  forge test --skip-backend      Run frontend Playwright tests only
  forge test --skip-backend --ui Run frontend tests in Playwright UI mode
  forge check                    Validate project configuration
  forge generate                 Generate frontend bindings from backend code
  forge migrate status           Check migration status
"#;

/// FORGE - The Full-Stack Framework for the Impatient
#[derive(Parser)]
#[command(name = "forge")]
#[command(author, version)]
#[command(about = ABOUT, long_about = None, after_help = AFTER_HELP)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,
}

/// CLI commands.
#[derive(Subcommand)]
pub enum Commands {
    /// Create a new FORGE project
    New(NewCommand),

    /// Validate project configuration and dependencies
    Check(CheckCommand),

    /// Generate frontend bindings from backend source
    Generate(GenerateCommand),

    /// Run project tests (backend + frontend)
    Test(TestCommand),

    /// Manage database migrations
    Migrate(MigrateCommand),
}

impl Cli {
    /// Execute the CLI command.
    pub async fn execute(self) -> Result<()> {
        match self.command {
            Commands::New(cmd) => cmd.execute().await,
            Commands::Check(cmd) => cmd.execute().await,
            Commands::Test(cmd) => cmd.execute().await,
            Commands::Generate(cmd) => cmd.execute().await,
            Commands::Migrate(cmd) => cmd.execute().await,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cli_parse_new_template() {
        let cli = Cli::try_parse_from([
            "forge",
            "new",
            "my-app",
            "--template",
            "with-svelte/minimal",
        ]);
        assert!(cli.is_ok());
    }

    #[test]
    fn test_cli_requires_template_for_new() {
        let cli = Cli::try_parse_from(["forge", "new", "my-app"]);
        assert!(cli.is_err());
    }

    #[test]
    fn test_cli_parse_generate() {
        let cli = Cli::try_parse_from(["forge", "generate"]);
        assert!(cli.is_ok());
    }

    #[test]
    fn test_cli_parse_test() {
        let cli = Cli::try_parse_from(["forge", "test"]);
        assert!(cli.is_ok());
    }

    #[test]
    fn test_cli_parse_test_ui() {
        let cli = Cli::try_parse_from(["forge", "test", "--ui"]);
        assert!(cli.is_ok());
    }

    #[test]
    fn test_cli_parse_test_with_args() {
        let cli = Cli::try_parse_from(["forge", "test", "tests/home.spec.ts", "--headed"]);
        assert!(cli.is_ok());
    }
}