glacier-web-cli 0.1.0

//! The `glacier` command-line tool.

mod auth;
mod diagnostics;
mod dialect;
mod generate;
mod lsp;
mod scaffold;
mod server;

use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command as Process, ExitCode};

use clap::{Parser, Subcommand, ValueEnum};

#[derive(Parser)]
#[command(name = "glacier", version, about = "The Glacier web framework")]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Create a new Glacier application
    New {
        /// Name of the application (also its directory)
        name: String,
        /// Path to a local `glacier` crate (crates/glacier in a checkout),
        /// instead of the published `glacier-web`
        #[arg(long)]
        glacier_path: Option<PathBuf>,
        /// The language for generated controllers
        #[arg(long, value_enum, default_value_t = Dialect::Glacier)]
        dialect: Dialect,
        /// A JSON API: no views, assets or CSRF, errors as JSON; the
        /// generators then make JSON controllers
        #[arg(long)]
        api: bool,
    },
    /// Run the app, rebuilding and restarting it when files change
    #[command(alias = "s")]
    Server {
        /// Run once without watching for changes
        #[arg(long)]
        no_watch: bool,
        /// Extra arguments for cargo, e.g. --release
        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
        args: Vec<String>,
    },
    /// Print the application's routes
    Routes,
    /// Compile .glacier files, then build (errors point at .glacier lines)
    #[command(alias = "b")]
    Build {
        /// Extra arguments for cargo, e.g. --release
        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
        args: Vec<String>,
    },
    /// Run the app's tests (failures point at .glacier lines)
    #[command(alias = "t")]
    Test {
        /// Extra arguments for cargo test, e.g. a name filter
        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
        args: Vec<String>,
    },
    /// Compile .glacier files into the hidden .glacier/ folder (build.rs does this too)
    Compile,
    /// Language server for .glacier files (proxies rust-analyzer)
    Lsp,
    /// Format .glacier files (all of them under src/, or the paths given)
    Fmt {
        /// Report unformatted files and fail instead of rewriting them
        #[arg(long)]
        check: bool,
        /// Files to format; defaults to every .glacier file under src/
        paths: Vec<PathBuf>,
    },
    /// Manage the database
    #[command(subcommand)]
    Db(DbCommand),
    /// Generate code
    #[command(subcommand, alias = "g")]
    Generate(GenerateCommand),
    /// Print a new random value for `secret_key_base`
    Secret,
}

#[derive(Subcommand)]
enum DbCommand {
    /// Apply pending migrations
    Migrate,
    /// Revert the most recent migrations
    Rollback {
        /// How many migrations to revert
        #[arg(long, default_value_t = 1)]
        steps: usize,
    },
    /// List migrations and whether each is applied
    Status,
}

#[derive(Subcommand)]
enum GenerateCommand {
    /// A migration in src/migrations; `create_<table>` names start a table
    Migration {
        /// snake_case description, e.g. create_posts or add_slug_to_posts
        name: String,
    },
    /// A model and its migration, with tests (and a factory)
    Model {
        /// The model name, e.g. Post or BlogPost
        name: String,
        /// Fields as name:type, as for `scaffold`
        #[arg(required = true)]
        fields: Vec<String>,
        /// The language for the tests
        #[arg(long, value_enum, default_value_t = Dialect::Glacier)]
        dialect: Dialect,
    },
    /// A controller with actions, their views and routes, and tests
    Controller {
        /// The controller name, e.g. Pages or Reports
        name: String,
        /// Action names, e.g. about contact
        #[arg(required = true)]
        actions: Vec<String>,
        /// The language for the controller and its tests
        #[arg(long, value_enum, default_value_t = Dialect::Glacier)]
        dialect: Dialect,
    },
    /// A policy: who may do what with a model, for `authorize`
    Policy {
        /// The model name, e.g. Post
        name: String,
    },
    /// A background job, run by the app's workers
    Job {
        /// The job name, e.g. SendReport
        name: String,
        /// Its arguments as name:type, as for `scaffold`
        fields: Vec<String>,
    },
    /// Sign up, sign in and sign out: User and Session models, controllers,
    /// views and tests, as code in the app
    Authentication {
        /// JSON endpoints and bearer tokens instead of pages and cookies
        #[arg(long)]
        api: bool,
    },
    /// A model, migration, CRUD controller, views and routes, with tests
    Scaffold {
        /// The model name, e.g. Post or BlogPost
        name: String,
        /// Fields as name:type, e.g. title:string body:text:optional published:boolean
        /// (types: string, text, integer, bigint, float, boolean, references;
        /// `:optional` makes string/text nullable)
        #[arg(required = true)]
        fields: Vec<String>,
        /// The language for the controller
        #[arg(long, value_enum, default_value_t = Dialect::Glacier)]
        dialect: Dialect,
    },
}

/// The language generated controllers are written in.
#[derive(Clone, Copy, PartialEq, Eq, ValueEnum)]
pub enum Dialect {
    /// `.glacier`, compiled to Rust at build time
    Glacier,
    /// Plain Rust
    Rust,
}

/// Files of every new application: (path, template).
const APP_TEMPLATE: &[(&str, &str)] = &[
    ("Cargo.toml", include_str!("../templates/Cargo.toml.tmpl")),
    (".gitignore", include_str!("../templates/gitignore.tmpl")),
    ("build.rs", include_str!("../templates/build.rs.tmpl")),
    ("src/main.rs", include_str!("../templates/main.rs.tmpl")),
    (
        "src/migrations/mod.rs",
        include_str!("../templates/migrations_mod.rs.tmpl"),
    ),
    (
        "config/default.toml",
        include_str!("../templates/config_default.toml.tmpl"),
    ),
    (
        "config/development.toml",
        include_str!("../templates/config_development.toml.tmpl"),
    ),
    (
        "config/test.toml",
        include_str!("../templates/config_test.toml.tmpl"),
    ),
    (
        "config/production.toml",
        include_str!("../templates/config_production.toml.tmpl"),
    ),
];

/// Files of an app with pages: views, a stylesheet, CSRF protection.
const BROWSER_TEMPLATE: &[(&str, &str)] = &[
    ("src/lib.rs", include_str!("../templates/lib.rs.tmpl")),
    ("src/routes.rs", include_str!("../templates/routes.rs.tmpl")),
    ("src/views.rs", include_str!("../templates/views.rs.tmpl")),
    (
        "src/views/layouts/app.html",
        include_str!("../templates/layout.html.tmpl"),
    ),
    (
        "src/views/pages/home.html",
        include_str!("../templates/home.html.tmpl"),
    ),
    ("public/app.css", include_str!("../templates/app.css.tmpl")),
];

/// Files of a JSON API (`glacier new --api`).
const API_TEMPLATE: &[(&str, &str)] = &[
    ("src/lib.rs", include_str!("../templates/api/lib.rs.tmpl")),
    (
        "src/routes.rs",
        include_str!("../templates/api/routes.rs.tmpl"),
    ),
];

fn main() -> ExitCode {
    let result = match Cli::parse().command {
        Command::New {
            name,
            glacier_path,
            dialect,
            api,
        } => new_app(&name, glacier_path, dialect, api),
        Command::Server { no_watch, args } => server::run(&args, !no_watch),
        Command::Routes => task("routes", &[]),
        Command::Build { args } => {
            if dialect::cargo("build", &args) {
                Ok(())
            } else {
                Err("build failed".into())
            }
        }
        Command::Test { args } => {
            if dialect::cargo("test", &args) {
                Ok(())
            } else {
                Err("tests failed".into())
            }
        }
        Command::Lsp => lsp::run(),
        Command::Fmt { check, paths } => dialect::format(&paths, check),
        Command::Compile => dialect::compile_all().map(|written| {
            let total = dialect::sources().len();
            println!("compiled {total} .glacier file(s), {written} changed");
        }),
        Command::Db(DbCommand::Migrate) => task("db:migrate", &[]),
        Command::Db(DbCommand::Rollback { steps }) => {
            task("db:rollback", &[("GLACIER_STEPS", &steps.to_string())])
        }
        Command::Db(DbCommand::Status) => task("db:status", &[]),
        Command::Generate(GenerateCommand::Migration { name }) => generate::migration(&name),
        Command::Generate(GenerateCommand::Job { name, fields }) => scaffold::job(&name, &fields),
        Command::Generate(GenerateCommand::Policy { name }) => scaffold::policy(&name),
        Command::Generate(GenerateCommand::Authentication { api }) => auth::authentication(api),
        Command::Generate(GenerateCommand::Scaffold {
            name,
            fields,
            dialect,
        }) => scaffold::scaffold(&name, &fields, dialect),
        Command::Generate(GenerateCommand::Model {
            name,
            fields,
            dialect,
        }) => scaffold::model_only(&name, &fields, dialect),
        Command::Generate(GenerateCommand::Controller {
            name,
            actions,
            dialect,
        }) => scaffold::controller_only(&name, &actions, dialect),
        Command::Secret => {
            println!("{}", secret());
            Ok(())
        }
    };
    match result {
        Ok(()) => ExitCode::SUCCESS,
        Err(message) => {
            eprintln!("error: {message}");
            ExitCode::FAILURE
        }
    }
}

/// The app's starter controller and models module (and, in `.glacier`, its
/// test), in the chosen language.
fn controller_files(dialect: Dialect, api: bool) -> Vec<(&'static str, &'static str)> {
    match (dialect, api) {
        (Dialect::Glacier, true) => vec![
            (
                "src/models/mod.rs",
                include_str!("../templates/models_mod_glacier.rs.tmpl"),
            ),
            (
                "src/controllers/mod.rs",
                include_str!("../templates/api/controllers_mod_glacier.rs.tmpl"),
            ),
            (
                "src/controllers/home_controller.glacier",
                include_str!("../templates/api/home_controller.glacier.tmpl"),
            ),
            (
                "tests/glacier.rs",
                include_str!("../templates/api/tests_glacier.rs.tmpl"),
            ),
            (
                "tests/controllers/home_controller.test.glacier",
                include_str!("../templates/api/home_controller.test.glacier.tmpl"),
            ),
        ],
        (Dialect::Rust, true) => vec![
            (
                "src/models/mod.rs",
                include_str!("../templates/models_mod.rs.tmpl"),
            ),
            (
                "src/controllers/mod.rs",
                include_str!("../templates/api/controllers_mod.rs.tmpl"),
            ),
            (
                "src/controllers/home_controller.rs",
                include_str!("../templates/api/home_controller.rs.tmpl"),
            ),
        ],
        (Dialect::Glacier, false) => vec![
            (
                "src/models/mod.rs",
                include_str!("../templates/models_mod_glacier.rs.tmpl"),
            ),
            (
                "src/controllers/mod.rs",
                include_str!("../templates/controllers_mod_glacier.rs.tmpl"),
            ),
            (
                "src/controllers/pages_controller.glacier",
                include_str!("../templates/pages_controller.glacier.tmpl"),
            ),
            ("tests/glacier.rs", scaffold::TESTS_RS),
            (
                "tests/controllers/pages_controller.test.glacier",
                include_str!("../templates/pages_controller.test.glacier.tmpl"),
            ),
        ],
        (Dialect::Rust, false) => vec![
            (
                "src/models/mod.rs",
                include_str!("../templates/models_mod.rs.tmpl"),
            ),
            (
                "src/controllers/mod.rs",
                include_str!("../templates/controllers_mod.rs.tmpl"),
            ),
            (
                "src/controllers/pages_controller.rs",
                include_str!("../templates/pages_controller.rs.tmpl"),
            ),
        ],
    }
}

fn new_app(
    name: &str,
    glacier_path: Option<PathBuf>,
    dialect: Dialect,
    api: bool,
) -> Result<(), String> {
    validate_name(name)?;
    let root = Path::new(name);
    if root.exists() {
        return Err(format!("`{name}` already exists"));
    }

    let (glacier_dependency, dialect_dependency) = dependencies(glacier_path)?;
    let flavour = if api { API_TEMPLATE } else { BROWSER_TEMPLATE };
    let controllers = controller_files(dialect, api);
    for (path, template) in APP_TEMPLATE.iter().chain(flavour).chain(&controllers) {
        let target = root.join(path);
        if let Some(dir) = target.parent() {
            fs::create_dir_all(dir).map_err(|e| format!("creating {}: {e}", dir.display()))?;
        }
        let contents = template
            .replace("{{name}}", name)
            .replace("{{crate_name}}", &name.replace('-', "_"))
            .replace("{{glacier_dependency}}", &glacier_dependency)
            .replace("{{dialect_dependency}}", &dialect_dependency)
            .replace("{{secret}}", &secret());
        fs::write(&target, contents).map_err(|e| format!("writing {}: {e}", target.display()))?;
        println!("      create  {name}/{path}");
    }

    println!("\nDone! Next:\n\n    cd {name}\n    glacier server\n");
    Ok(())
}

/// The new app's `glacier-web` and `glacier-dialect` dependency lines: the
/// crates at `--glacier-path`, else those in the Glacier checkout this CLI
/// was built from, else (installed from crates.io) this CLI's version.
fn dependencies(glacier_path: Option<PathBuf>) -> Result<(String, String), String> {
    let checkout = Path::new(env!("CARGO_MANIFEST_DIR")).join("../glacier");
    let path = match glacier_path {
        Some(path) => Some(
            path.canonicalize()
                .map_err(|_| format!("can't find the glacier crate at {}", path.display()))?,
        ),
        None => is_glacier_crate(&checkout)
            .then(|| checkout.canonicalize().ok())
            .flatten(),
    };
    Ok(match path {
        Some(path) => {
            let glacier = path.display().to_string().replace('\\', "\\\\");
            let dialect = path
                .join("../glacier-dialect")
                .display()
                .to_string()
                .replace('\\', "\\\\");
            (
                format!("glacier-web = {{ path = \"{glacier}\" }}"),
                format!("glacier-dialect = {{ path = \"{dialect}\" }}"),
            )
        }
        None => {
            let version = env!("CARGO_PKG_VERSION");
            (
                format!("glacier-web = \"{version}\""),
                format!("glacier-dialect = \"{version}\""),
            )
        }
    })
}

/// Whether `dir` holds the `glacier-web` crate.
fn is_glacier_crate(dir: &Path) -> bool {
    fs::read_to_string(dir.join("Cargo.toml"))
        .is_ok_and(|manifest| manifest.contains("name = \"glacier-web\""))
}

fn validate_name(name: &str) -> Result<(), String> {
    let starts_with_letter = name.chars().next().is_some_and(|c| c.is_ascii_alphabetic());
    let valid_chars = name
        .chars()
        .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-');
    if starts_with_letter && valid_chars {
        Ok(())
    } else {
        Err(format!(
            "invalid app name `{name}`: use letters, digits, `_` or `-`, starting with a letter"
        ))
    }
}

/// 64 random bytes, hex-encoded: comfortably above the 32-byte minimum.
fn secret() -> String {
    let mut bytes = [0u8; 64];
    getrandom::fill(&mut bytes).expect("the OS random number generator failed");
    bytes.iter().map(|b| format!("{b:02x}")).collect()
}

/// Runs the app with `GLACIER_TASK` set, so it performs `name` and exits.
fn task(name: &str, envs: &[(&str, &str)]) -> Result<(), String> {
    let mut envs = envs.to_vec();
    envs.push(("GLACIER_TASK", name));
    cargo_run(&["-q".into()], &envs)
}

pub(crate) fn cargo_run(args: &[String], envs: &[(&str, &str)]) -> Result<(), String> {
    if !Path::new("Cargo.toml").exists() {
        return Err("no Cargo.toml here; run this from your app's directory".into());
    }
    let status = Process::new("cargo")
        .arg("run")
        .args(args)
        .envs(envs.iter().copied())
        .status()
        .map_err(|e| format!("failed to run cargo: {e}"))?;
    if status.success() {
        Ok(())
    } else {
        Err(format!("cargo run exited with {status}"))
    }
}

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

    #[test]
    fn validates_names() {
        assert!(validate_name("blog").is_ok());
        assert!(validate_name("my-app_2").is_ok());
        assert!(validate_name("2fast").is_err());
        assert!(validate_name("").is_err());
        assert!(validate_name("../etc").is_err());
    }
}