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
135
136
137
138
139
140
141
142
143

use anyhow::Result;
use std::fmt;
use std::path::Path;
use std::process::Command;
use std::str::FromStr;

use super::frontend_codegen::{
    BindingGeneratorFn, BindingGeneratorInput, generate_dioxus_bindings, generate_svelte_bindings,
};

type DetectFn = fn(&Path) -> bool;
type PostGenerateFn = fn(&Path) -> Result<()>;
type ExtraFormatFn = fn(&Path) -> Result<bool>;

pub struct FrontendTargetSpec {
    pub id: &'static str,
    pub display_name: &'static str,
    pub default_output_dir: &'static str,
    detect: DetectFn,
    post_generate: PostGenerateFn,
    extra_format: ExtraFormatFn,
    generate_bindings: BindingGeneratorFn,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FrontendTarget {
    SvelteKit,
    Dioxus,
}

const SUPPORTED_FRONTENDS: [FrontendTarget; 2] =
    [FrontendTarget::Dioxus, FrontendTarget::SvelteKit];

const SVELTEKIT_SPEC: FrontendTargetSpec = FrontendTargetSpec {
    id: "sveltekit",
    display_name: "SvelteKit",
    default_output_dir: "frontend/src/lib/forge",
    detect: detect_sveltekit,
    post_generate: post_generate_sveltekit,
    extra_format: no_extra_format,
    generate_bindings: generate_svelte_bindings,
};

const DIOXUS_SPEC: FrontendTargetSpec = FrontendTargetSpec {
    id: "dioxus",
    display_name: "Dioxus",
    default_output_dir: "frontend/src/forge",
    detect: detect_dioxus,
    post_generate: no_post_generate,
    extra_format: format_dioxus_frontend,
    generate_bindings: generate_dioxus_bindings,
};

impl FrontendTarget {
    pub fn detect(frontend_dir: &Path) -> Option<Self> {
        SUPPORTED_FRONTENDS
            .into_iter()
            .find(|target| (target.spec().detect)(frontend_dir))
    }

    pub fn spec(self) -> &'static FrontendTargetSpec {
        match self {
            Self::SvelteKit => &SVELTEKIT_SPEC,
            Self::Dioxus => &DIOXUS_SPEC,
        }
    }

    pub fn default_output_dir(self) -> &'static str {
        self.spec().default_output_dir
    }

    pub fn display_name(self) -> &'static str {
        self.spec().display_name
    }

    pub fn post_generate(self, frontend_dir: &Path) -> Result<()> {
        (self.spec().post_generate)(frontend_dir)
    }

    pub fn extra_format(self, project_dir: &Path) -> Result<bool> {
        (self.spec().extra_format)(project_dir)
    }

    pub fn generate_bindings(self, input: &BindingGeneratorInput<'_>) -> Result<()> {
        (self.spec().generate_bindings)(input)
    }
}

impl fmt::Display for FrontendTarget {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.spec().id)
    }
}

impl FromStr for FrontendTarget {
    type Err = String;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value.trim().to_ascii_lowercase().as_str() {
            "svelte" | "sveltekit" => Ok(Self::SvelteKit),
            "dioxus" => Ok(Self::Dioxus),
            other => Err(format!(
                "unsupported frontend target '{other}' (expected 'sveltekit' or 'dioxus')"
            )),
        }
    }
}

fn detect_sveltekit(frontend_dir: &Path) -> bool {
    frontend_dir.join("svelte.config.js").exists()
        || frontend_dir.join("package.json").exists() && frontend_dir.join("src/routes").exists()
}

fn detect_dioxus(frontend_dir: &Path) -> bool {
    frontend_dir.join("Dioxus.toml").exists()
        || frontend_dir.join("dioxus.toml").exists()
        || frontend_dir.join("Cargo.toml").exists()
}

fn post_generate_sveltekit(frontend_dir: &Path) -> Result<()> {
    let _ = Command::new("bunx")
        .args(["svelte-kit", "sync"])
        .current_dir(frontend_dir)
        .output();
    Ok(())
}

fn no_post_generate(_frontend_dir: &Path) -> Result<()> {
    Ok(())
}

fn no_extra_format(_project_dir: &Path) -> Result<bool> {
    Ok(false)
}

fn format_dioxus_frontend(project_dir: &Path) -> Result<bool> {
    let output = Command::new("cargo")
        .args(["fmt", "--manifest-path", "frontend/Cargo.toml"])
        .current_dir(project_dir)
        .output()?;

    Ok(output.status.success())
}