rws-proxy 18.36.2

//! `rws gen …`: the command line of the generators.

use std::io::Write;
use std::path::PathBuf;

use super::names::parse_fields;
use super::{plan, Db, GenError, Generate, RouteAction};

/// Written (or nothing to write: every file already as generated).
pub const EXIT_OK: i32 = 0;
/// A conflict (a file exists with other content) or the project refused
/// (no `app()`, no route module, …): nothing written.
pub const EXIT_CONFLICT: i32 = 1;
/// Bad arguments.
pub const EXIT_USAGE: i32 = 2;

const USAGE: &str = "\
Usage: rws gen <generator> <name> [args] [--dir <project>] [--dry-run] [--json]

Generators:
  model <Name> field:type...      src/models/<name>.rs (#[derive(Model)], id auto-increment)
        [--db sqlite|postgres|mysql]  and migrations/NNNN_create_<table>.sql + .down.sql
        [--timestamps] [--soft-delete]  created_at/updated_at, deleted_at kept by save/delete
  route <resource> [field:type...]  src/routes/<resource>.rs: typed handlers and register(app)
        [--methods list,show,create,update,remove] [--prefix /api]
  migration <name>                migrations/NNNN_<name>.sql + .down.sql to fill in
        [--from-models [--database-url <url>] [--db …]]  written from the models: CREATE TABLE /
                                  ADD COLUMN for what the database (DATABASE_URL / RWS_DB_*) lacks
  test <resource> [--app-expr 'app(...)']  tests/<resource>.rs: TestClient against app()
  deploy --image <image> [--port 7878] [--replicas 2] [--max-replicas 10] [--out deploy/k8s]
                                  Kubernetes manifests: Deployment (probes, graceful shutdown),
                                  Service, PodDisruptionBudget, HPA, ServiceAccount, kustomization

Field types: i64, i32, f64, bool, String, Option<T> (T one of those).
Paths come from rws.app.toml (the conventional layout without one). --db
defaults to the model-* feature in Cargo.toml, else sqlite.

Nothing is overwritten: a file that exists with other content is a conflict,
shown as a diff, and nothing is written. Running a generator twice changes
nothing the second time. --dry-run prints the plan and the diffs without
writing; --json prints it for agents.
Exit codes: 0 written (or already as generated), 1 conflict or refused, 2 usage.
";

/// Run `rws gen <args>` (the arguments after `gen`), writing to `out` and
/// `err`; answers the exit code ([`EXIT_OK`], [`EXIT_CONFLICT`],
/// [`EXIT_USAGE`]).
pub fn run(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> i32 {
    let parsed = match parse(args) {
        Ok(Parsed::Help) => {
            let _ = write!(out, "{USAGE}");
            return EXIT_OK;
        }
        Ok(Parsed::Run(cli)) => cli,
        Err(e) => return fail(&e, args.iter().any(|a| a == "--json"), out, err),
    };
    let planned = match (&parsed.request, &parsed.from_models) {
        (Request::Deploy(spec), _) => super::plan_deploy(&parsed.dir, spec),
        (Request::Generate(request), from_models) => match from_models {
        Some((url, db)) => match (request, existing_columns(url.clone())) {
            (Generate::Migration { name }, Ok(existing)) => super::plan_model_migration(&parsed.dir, name, &existing, *db),
            (_, Err(e)) => Err(GenError::refused(e)),
            _ => Err(GenError::usage("--from-models applies to rws gen migration only")),
        },
        None => plan(&parsed.dir, request),
        },
    };
    let plan = match planned {
        Ok(plan) => plan,
        Err(e) => return fail(&e, parsed.json, out, err),
    };
    if parsed.from_models.is_some() && plan.changes.is_empty() {
        if parsed.json {
            let _ = writeln!(out, "{}", plan.to_json(false));
        } else {
            let _ = write!(out, "{}", plan.render(false));
        }
        return EXIT_OK;
    }
    if plan.has_conflicts() || parsed.dry_run || plan.is_unchanged() {
        if parsed.json {
            let _ = writeln!(out, "{}", plan.to_json(false));
        } else {
            let _ = write!(out, "{}", plan.render(parsed.dry_run));
            if plan.has_conflicts() {
                let _ = writeln!(err, "rws gen: not written — a file above exists with other content (the diff is what the generator would write). Move it aside or merge by hand.");
            } else if plan.is_unchanged() {
                let _ = writeln!(out, "nothing to do: every file is already as generated");
            }
        }
        return if plan.has_conflicts() { EXIT_CONFLICT } else { EXIT_OK };
    }
    match plan.apply(&parsed.dir) {
        Ok(_) => {
            if parsed.json {
                let _ = writeln!(out, "{}", plan.to_json(true));
            } else {
                let _ = write!(out, "{}", plan.render(false));
            }
            EXIT_OK
        }
        Err(e) => fail(&e, parsed.json, out, err),
    }
}

fn fail(e: &GenError, json: bool, out: &mut dyn Write, err: &mut dyn Write) -> i32 {
    if json {
        let _ = writeln!(out, "{}", e.to_json());
    } else if e.usage {
        let _ = writeln!(err, "rws gen: {}\n(rws gen --help lists the generators and their arguments)", e.message);
    } else {
        let _ = writeln!(err, "rws gen: {}", e.message);
    }
    if e.usage {
        EXIT_USAGE
    } else {
        EXIT_CONFLICT
    }
}

enum Request {
    Generate(Generate),
    /// `rws gen deploy`: not a [`Generate`] variant (adding one would break
    /// exhaustive matches on it).
    Deploy(super::DeploySpec),
}

struct Cli {
    request: Request,
    dir: PathBuf,
    dry_run: bool,
    json: bool,
    /// `--from-models`: the database URL (`--database-url`) and `--db`.
    from_models: Option<(Option<String>, Option<Db>)>,
}

/// The database's tables and columns, for `--from-models`: `url`, else
/// `DATABASE_URL`, else the `RWS_DB_*` variables (as `rws db`).
#[cfg(any(feature = "model-sqlite", feature = "model-postgres", feature = "model-mysql"))]
fn existing_columns(url: Option<String>) -> Result<super::ExistingColumns, String> {
    use crate::model::DbPool;
    let url = url.or_else(|| std::env::var("DATABASE_URL").ok().filter(|u| !u.trim().is_empty()));
    crate::dev_mcp::db::run(async move {
        let pool = match &url {
            Some(url) => DbPool::connect(url).await?,
            None => DbPool::from_env().await.map_err(|e| crate::model::DbError::new(format!("{} (or give --database-url / DATABASE_URL)", e.0)))?,
        };
        let schema = pool.schema().await;
        pool.close().await;
        Ok(schema?.tables.into_iter().map(|t| (t.name, t.columns.into_iter().map(|c| c.name).collect())).collect())
    })
}

#[cfg(not(any(feature = "model-sqlite", feature = "model-postgres", feature = "model-mysql")))]
fn existing_columns(_url: Option<String>) -> Result<super::ExistingColumns, String> {
    Err("--from-models reads the database: this rws was built without a database driver (cargo install rust-web-server --features model-sqlite,model-postgres,model-mysql)".into())
}

enum Parsed {
    Help,
    Run(Cli),
}

fn parse(args: &[String]) -> Result<Parsed, GenError> {
    let mut positional: Vec<String> = Vec::new();
    let mut dir = PathBuf::from(".");
    let (mut dry_run, mut json) = (false, false);
    let (mut db, mut methods, mut prefix, mut app_expr) = (None, None, None, None);
    let (mut timestamps, mut soft_delete) = (false, false);
    let (mut from_models, mut database_url) = (false, None);
    let (mut image, mut port, mut replicas, mut max_replicas, mut out_dir) = (None, None, None, None, None);
    let mut i = 0;
    while i < args.len() {
        let arg = args[i].as_str();
        i += 1;
        if arg == "-h" || arg == "--help" || (arg == "help" && positional.is_empty()) {
            return Ok(Parsed::Help);
        }
        if !arg.starts_with("--") {
            positional.push(arg.to_string());
            continue;
        }
        let (flag, inline) = match arg.split_once('=') {
            Some((f, v)) => (f, Some(v.to_string())),
            None => (arg, None),
        };
        let mut value = |name: &str| -> Result<String, GenError> {
            if let Some(v) = inline.clone() {
                return Ok(v);
            }
            let v = args.get(i).cloned().ok_or_else(|| GenError::usage(format!("{name} needs a value")))?;
            i += 1;
            Ok(v)
        };
        match flag {
            "--dry-run" => dry_run = true,
            "--timestamps" => timestamps = true,
            "--soft-delete" => soft_delete = true,
            "--json" => json = true,
            "--dir" => dir = PathBuf::from(value("--dir")?),
            "--db" => {
                let v = value("--db")?;
                db = Some(Db::parse(&v).ok_or_else(|| GenError::usage(format!("--db {v}: use sqlite, postgres or mysql")))?);
            }
            "--methods" => methods = Some(value("--methods")?),
            "--prefix" => prefix = Some(value("--prefix")?),
            "--app-expr" => app_expr = Some(value("--app-expr")?),
            "--from-models" => from_models = true,
            "--image" => image = Some(value("--image")?),
            "--port" => port = Some(value("--port")?),
            "--replicas" => replicas = Some(value("--replicas")?),
            "--max-replicas" => max_replicas = Some(value("--max-replicas")?),
            "--out" => out_dir = Some(value("--out")?),
            "--database-url" => database_url = Some(value("--database-url")?),
            other => return Err(GenError::usage(format!("unknown option {other}"))),
        }
    }
    let Some(kind) = positional.first().cloned() else {
        return Err(GenError::usage("name a generator: model, route, migration, test or deploy"));
    };
    let deploy_flags = image.is_some() || port.is_some() || replicas.is_some() || max_replicas.is_some() || out_dir.is_some();
    if kind == "deploy" {
        if let Some(extra) = positional.get(1) {
            return Err(GenError::usage(format!("rws gen deploy takes no name; `{extra}` is extra")));
        }
        let image = image.ok_or_else(|| GenError::usage("rws gen deploy: give the container image with --image"))?;
        let mut spec = super::DeploySpec::new(&image);
        let number = |flag: &str, v: &str| v.parse::<u32>().map_err(|_| GenError::usage(format!("{flag} {v}: a number")));
        if let Some(p) = &port {
            spec.port = u16::try_from(number("--port", p)?).map_err(|_| GenError::usage(format!("--port {p}: 1 to 65535")))?;
        }
        if let Some(r) = &replicas {
            spec.replicas = number("--replicas", r)?;
        }
        if let Some(m) = &max_replicas {
            spec.max_replicas = number("--max-replicas", m)?;
        }
        if let Some(o) = out_dir {
            spec.dir = o;
        }
        return Ok(Parsed::Run(Cli { request: Request::Deploy(spec), dir, dry_run, json, from_models: None }));
    }
    if deploy_flags {
        return Err(GenError::usage("--image, --port, --replicas, --max-replicas and --out apply to rws gen deploy only"));
    }
    let name = positional.get(1).cloned();
    let rest = positional.get(2..).unwrap_or(&[]);
    let only = |flag: &str, set: bool, kinds: &str| -> Result<(), GenError> {
        if set {
            Err(GenError::usage(format!("{flag} applies to rws gen {kinds} only")))
        } else {
            Ok(())
        }
    };
    let need_name = |what: &str| name.clone().ok_or_else(|| GenError::usage(format!("rws gen {kind}: give the {what}")));
    let request = match kind.as_str() {
        "model" => {
            only("--methods", methods.is_some(), "route")?;
            only("--prefix", prefix.is_some(), "route")?;
            only("--app-expr", app_expr.is_some(), "test")?;
            Generate::Model { name: need_name("model's name (e.g. Post)")?, fields: parse_fields(rest)?, db, timestamps, soft_delete }
        }
        "route" => {
            only("--db", db.is_some(), "model")?;
            only("--timestamps", timestamps, "model")?;
            only("--soft-delete", soft_delete, "model")?;
            only("--app-expr", app_expr.is_some(), "test")?;
            let actions = match &methods {
                Some(m) => RouteAction::parse_list(m)?,
                None => RouteAction::ALL.to_vec(),
            };
            Generate::Route { resource: need_name("resource (e.g. posts)")?, fields: parse_fields(rest)?, actions, prefix: prefix.unwrap_or_default() }
        }
        "migration" | "test" => {
            only("--db", db.is_some() && !(kind == "migration" && from_models), "model (and migration --from-models)")?;
            only("--timestamps", timestamps, "model")?;
            only("--soft-delete", soft_delete, "model")?;
            only("--methods", methods.is_some(), "route")?;
            only("--prefix", prefix.is_some(), "route")?;
            if let Some(extra) = rest.first() {
                return Err(GenError::usage(format!("rws gen {kind} takes one name; `{extra}` is extra")));
            }
            if kind == "migration" {
                only("--app-expr", app_expr.is_some(), "test")?;
                Generate::Migration { name: need_name("migration's name (e.g. add_index_to_posts)")? }
            } else {
                Generate::Test { resource: need_name("resource (e.g. posts)")?, app_expr }
            }
        }
        other => return Err(GenError::usage(format!("unknown generator `{other}`: use model, route, migration, test or deploy"))),
    };
    only("--from-models", from_models && kind != "migration", "migration")?;
    only("--database-url", database_url.is_some() && !from_models, "migration --from-models")?;
    let from_models = from_models.then_some((database_url, db));
    Ok(Parsed::Run(Cli { request: Request::Generate(request), dir, dry_run, json, from_models }))
}

/// `rws gen …` asked for: the arguments after `gen`.
pub fn requested(args: &[String]) -> Option<&[String]> {
    (args.get(1).map(String::as_str) == Some("gen")).then(|| &args[2..])
}