appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use super::{CapabilityMode, DatabaseMode, ProjectTemplate, name, run_with_command};
use clap::Args;
use std::fmt::Write as _;
use std::fs;
use std::io::{self, IsTerminal, Write};
use std::path::Path;
use std::process::ExitCode;

#[derive(Debug, Args)]
pub(crate) struct InitArgs {
    pub name: Option<String>,
    #[arg(long, value_enum)]
    pub template: Option<ProjectTemplate>,
    #[arg(long, value_enum)]
    pub database_mode: Option<DatabaseMode>,
    #[arg(long)]
    pub api_port: Option<u16>,
    #[arg(long)]
    pub web_port: Option<u16>,
    #[arg(long, value_enum)]
    pub auth: Option<CapabilityMode>,
    #[arg(long, value_enum)]
    pub tenant: Option<CapabilityMode>,
}

#[derive(Clone, Copy)]
pub(super) struct InitSettings {
    pub(super) database_mode: DatabaseMode,
    pub(super) api_port: u16,
    pub(super) web_port: u16,
    pub(super) auth: CapabilityMode,
    pub(super) tenant: CapabilityMode,
}

impl InitSettings {
    pub(super) fn apply(
        self,
        root: &Path,
        name: &str,
        template: ProjectTemplate,
    ) -> io::Result<()> {
        let appstruct_path = root.join("appstruct.yaml");
        let source = fs::read_to_string(&appstruct_path)?;
        let source = render_capabilities(source, template, self.auth, self.tenant)?;
        fs::write(appstruct_path, source)?;
        match (template, self.database_mode) {
            (ProjectTemplate::Minimal, DatabaseMode::Managed) => {
                fs::write(
                    root.join("compose.yaml"),
                    include_str!("../../templates/dashboard/compose.yaml"),
                )?;
            }
            (ProjectTemplate::Dashboard | ProjectTemplate::Saas, DatabaseMode::External) => {
                fs::remove_file(root.join("compose.yaml"))?;
            }
            _ => {}
        }
        let database_url = match self.database_mode {
            DatabaseMode::Managed => {
                "postgresql://appstruct:appstruct-dev@127.0.0.1:5432/appstruct?sslmode=disable"
                    .to_owned()
            }
            DatabaseMode::External => {
                format!("postgresql://postgres@127.0.0.1:5432/{name}?sslmode=disable")
            }
        };
        let mut example = format!("DATABASE_URL={database_url}\n");
        if !matches!(template, ProjectTemplate::Minimal) {
            let _ = writeln!(
                example,
                "APPSTRUCT_ALLOWED_ORIGIN=http://127.0.0.1:{}",
                self.web_port
            );
            match template {
                ProjectTemplate::Dashboard => example.push_str("APPSTRUCT_AUTH_MAIL_MODE=dev\n"),
                ProjectTemplate::Saas => example.push_str(
                    "APPSTRUCT_AUTH_MAIL_MODE=capture\nAPPSTRUCT_ENV=development\nAPPSTRUCT_FILE_ROOT=.appstruct/files\n",
                ),
                ProjectTemplate::Minimal => unreachable!(),
            }
        }
        fs::write(root.join(".env.example"), example)?;
        fs::write(
            root.join(".env"),
            format!(
                "APPSTRUCT_API_PORT={}\nAPPSTRUCT_WEB_PORT={}\n",
                self.api_port, self.web_port
            ),
        )
    }
}

fn render_capabilities(
    source: String,
    template: ProjectTemplate,
    auth: CapabilityMode,
    tenant: CapabilityMode,
) -> io::Result<String> {
    let valid = match template {
        ProjectTemplate::Minimal => {
            auth == CapabilityMode::Disabled && tenant == CapabilityMode::Disabled
        }
        ProjectTemplate::Dashboard => auth == CapabilityMode::Enabled,
        ProjectTemplate::Saas => {
            auth == CapabilityMode::Enabled && tenant == CapabilityMode::Enabled
        }
    };
    if !valid {
        return Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            format!(
                "template `{}` does not support auth={} and tenant={}",
                template.name(),
                auth.name(),
                tenant.name()
            ),
        ));
    }
    let mut output = source;
    if template == ProjectTemplate::Dashboard {
        output = output.replace(
            "    enabled: true\n",
            &format!("    enabled: {}\n", auth == CapabilityMode::Enabled),
        );
        if tenant == CapabilityMode::Enabled {
            output = output.replace(
                "    default_role: member\n",
                "    default_role: member\n  tenant:\n    enabled: true\n",
            );
        }
    }
    if template == ProjectTemplate::Saas {
        output.push_str("\nmodules:\n  auth:\n    enabled: true\n  tenant:\n    enabled: true\n");
    }
    Ok(output)
}

pub(crate) fn run(parent: &Path, args: &InitArgs) -> ExitCode {
    let name = args.name.as_deref();
    let template = args.template;
    let database_mode = args.database_mode;
    let api_port = args.api_port;
    let web_port = args.web_port;
    let auth = args.auth;
    let tenant = args.tenant;
    let needs_prompt = name.is_none() || template.is_none();
    let interactive = io::stdin().is_terminal() && !crate::report::is_json();
    if needs_prompt && (crate::report::is_json() || !io::stdin().is_terminal()) {
        return crate::report::fail(
            "AS6003",
            crate::report::ErrorCategory::Project,
            "appstruct init needs a terminal and text output when name or template is omitted; pass a project name and --template for non-interactive use",
            crate::report::ExitClass::Usage,
        );
    }

    let name = match name {
        Some(name) => name.to_owned(),
        None => match prompt_name() {
            Ok(name) => name,
            Err(error) => {
                return crate::report::fail(
                    "AS6004",
                    crate::report::ErrorCategory::Project,
                    format!("cannot read project name: {error}"),
                    crate::report::ExitClass::Usage,
                );
            }
        },
    };
    let template = match template {
        Some(template) => template,
        None => match prompt_template() {
            Ok(template) => template,
            Err(error) => {
                return crate::report::fail(
                    "AS6005",
                    crate::report::ErrorCategory::Project,
                    format!("cannot read project template: {error}"),
                    crate::report::ExitClass::Usage,
                );
            }
        },
    };

    if api_port == Some(0) || web_port == Some(0) || api_port.is_some() && api_port == web_port {
        return invalid_ports();
    }
    let database_mode = match database_mode {
        Some(mode) => mode,
        None if interactive => match prompt_database_mode(template.database_mode()) {
            Ok(mode) => mode,
            Err(error) => return prompt_error("database mode", &error),
        },
        None => template.database_mode(),
    };
    let api_port = match api_port {
        Some(port) => port,
        None if interactive => match prompt_port("API port [3000]: ", 3000, None) {
            Ok(port) => port,
            Err(error) => return prompt_error("API port", &error),
        },
        None => 3000,
    };
    let web_port = match web_port {
        Some(port) => port,
        None if interactive => match prompt_port("Web port [5173]: ", 5173, Some(api_port)) {
            Ok(port) => port,
            Err(error) => return prompt_error("web port", &error),
        },
        None => 5173,
    };
    if api_port == web_port {
        return invalid_ports();
    }
    let auth = match auth {
        Some(value) => value,
        None if interactive => match prompt_capability("Auth", template.auth_mode()) {
            Ok(value) => value,
            Err(error) => return prompt_error("auth capability", &error),
        },
        None => template.auth_mode(),
    };
    let tenant = match tenant {
        Some(value) => value,
        None if interactive => match prompt_capability("Tenant", template.tenant_mode()) {
            Ok(value) => value,
            Err(error) => return prompt_error("tenant capability", &error),
        },
        None => template.tenant_mode(),
    };
    let settings = InitSettings {
        database_mode,
        api_port,
        web_port,
        auth,
        tenant,
    };
    run_with_command(parent, &name, template, "init", Some(settings))
}

fn invalid_ports() -> ExitCode {
    crate::report::fail(
        "AS6006",
        crate::report::ErrorCategory::Project,
        "API and web ports must be non-zero and different",
        crate::report::ExitClass::Usage,
    )
}

fn prompt_error(field: &str, error: &io::Error) -> ExitCode {
    crate::report::fail(
        "AS6007",
        crate::report::ErrorCategory::Project,
        format!("cannot read {field}: {error}"),
        crate::report::ExitClass::Usage,
    )
}

fn prompt_line(prompt: &str, default: Option<&str>) -> io::Result<String> {
    print!("{prompt}");
    io::stdout().flush()?;
    let mut input = String::new();
    if io::stdin().read_line(&mut input)? == 0 {
        return Err(io::Error::new(
            io::ErrorKind::UnexpectedEof,
            "input ended before a choice was entered",
        ));
    }
    let value = input.lines().next().unwrap_or_default().trim();
    if value.is_empty() {
        Ok(default.unwrap_or_default().to_owned())
    } else {
        Ok(value.to_owned())
    }
}

fn prompt_name() -> io::Result<String> {
    loop {
        let name = prompt_line("Project name: ", None)?;
        match name::validate_name(&name) {
            Ok(()) => return Ok(name),
            Err(error) => eprintln!("{error}"),
        }
    }
}

fn prompt_template() -> io::Result<ProjectTemplate> {
    println!("Choose a template:");
    println!("  1) minimal   Public Note app with external PostgreSQL");
    println!("  2) dashboard Auth, RBAC, owner scope, and managed PostgreSQL");
    println!("  3) saas      Tenant, Audit, Mail, Jobs, and File modules");
    loop {
        let choice = prompt_line("Template [2]: ", Some("2"))?;
        if let Some(template) = ProjectTemplate::from_choice(&choice) {
            return Ok(template);
        }
        eprintln!("template must be 1 (minimal), 2 (dashboard), or 3 (saas)");
    }
}

fn prompt_database_mode(default: DatabaseMode) -> io::Result<DatabaseMode> {
    println!("Database: 1) external PostgreSQL  2) managed PostgreSQL (Docker)");
    let label = match default {
        DatabaseMode::External => "1",
        DatabaseMode::Managed => "2",
    };
    loop {
        let choice = prompt_line(&format!("Database mode [{label}]: "), Some(label))?;
        match choice.as_str() {
            "1" | "external" => return Ok(DatabaseMode::External),
            "2" | "managed" => return Ok(DatabaseMode::Managed),
            _ => eprintln!("database mode must be 1 (external) or 2 (managed)"),
        }
    }
}

fn prompt_capability(label: &str, default: CapabilityMode) -> io::Result<CapabilityMode> {
    let fallback = default.name();
    loop {
        let input = prompt_line(
            &format!("{label} capability [{fallback}]: "),
            Some(fallback),
        )?;
        match input.as_str() {
            "enabled" | "on" | "true" => return Ok(CapabilityMode::Enabled),
            "disabled" | "off" | "false" => return Ok(CapabilityMode::Disabled),
            _ => eprintln!("{label} must be enabled or disabled"),
        }
    }
}

fn prompt_port(label: &str, default: u16, other: Option<u16>) -> io::Result<u16> {
    let fallback = default.to_string();
    loop {
        let input = prompt_line(label, Some(&fallback))?;
        match input.parse::<u16>() {
            Ok(port) if port != 0 && Some(port) != other => return Ok(port),
            _ => eprintln!("port must be 1-65535 and different from the other port"),
        }
    }
}

impl ProjectTemplate {
    fn from_choice(choice: &str) -> Option<Self> {
        match choice {
            "1" | "minimal" => Some(Self::Minimal),
            "2" | "dashboard" => Some(Self::Dashboard),
            "3" | "saas" => Some(Self::Saas),
            _ => None,
        }
    }

    fn auth_mode(self) -> CapabilityMode {
        match self {
            Self::Minimal => CapabilityMode::Disabled,
            Self::Dashboard | Self::Saas => CapabilityMode::Enabled,
        }
    }

    fn tenant_mode(self) -> CapabilityMode {
        match self {
            Self::Saas => CapabilityMode::Enabled,
            Self::Minimal | Self::Dashboard => CapabilityMode::Disabled,
        }
    }
}