appstruct-cli 0.1.0

Command-line compiler and development workflow for AppStruct applications
use crate::environment::ProjectEnvironment;
use std::io;
use std::path::{Path, PathBuf};
use std::process::{Command, ExitCode, Stdio};

pub(crate) fn run(project: &Path) -> ExitCode {
    let backend = match backend_manifest(project) {
        Ok(backend) => backend,
        Err(error) => {
            return crate::report::fail(
                "AS6004",
                crate::report::ErrorCategory::Build,
                format!("cannot resolve project layout: {error}"),
                crate::report::ExitClass::Validation,
            );
        }
    };
    let binary = match backend_binary_name(project) {
        Ok(binary) => binary,
        Err(error) => {
            return crate::report::fail(
                "AS6004",
                crate::report::ErrorCategory::Build,
                format!("cannot resolve project layout: {error}"),
                crate::report::ExitClass::Validation,
            );
        }
    };
    let generation = if crate::report::is_json() {
        super::generation::run_quiet(project, false)
    } else {
        super::generation::run(project, false)
    };
    if generation != ExitCode::SUCCESS {
        return ExitCode::from(1);
    }
    let environment = match ProjectEnvironment::load(project) {
        Ok(environment) => environment,
        Err(error) => {
            return crate::report::fail(
                "AS6003",
                crate::report::ErrorCategory::Configuration,
                error.to_string(),
                crate::report::ExitClass::Environment,
            );
        }
    };
    let web = project.join("generated/web");
    let target = project.join(".appstruct/cache/backend-target");
    if let Err(error) = build_steps(project, &backend, &web, &target, &environment) {
        let exit = if error.kind() == io::ErrorKind::NotFound {
            crate::report::ExitClass::Environment
        } else {
            crate::report::ExitClass::Validation
        };
        return crate::report::fail(
            "AS6004",
            crate::report::ErrorCategory::Build,
            format!("production build failed: {error}"),
            exit,
        );
    }
    let backend = format!(".appstruct/cache/backend-target/release/{binary}");
    if crate::report::is_json() {
        crate::report::success(&serde_json::json!({
            "command": "build",
            "backend": backend,
            "web": "generated/web/dist",
        }));
    } else {
        println!("Production build completed:");
        println!("- backend: {backend}");
        println!("- web: generated/web/dist");
    }
    ExitCode::SUCCESS
}

pub(crate) fn verify_update(project: &Path) -> io::Result<()> {
    let environment = ProjectEnvironment::load(project)?;
    let backend = backend_manifest(project)?;
    let web = project.join("generated/web");
    let target = project.join(".appstruct/cache/backend-target");
    build_steps(project, &backend, &web, &target, &environment)?;
    run_cargo(
        &environment,
        project,
        &target,
        &["test", "--release", "--locked", "--manifest-path"],
        Some(&backend),
        &["--all-targets"],
    )
}

pub(crate) fn backend_manifest(project: &Path) -> io::Result<PathBuf> {
    match project_layout(project)? {
        appstruct_compiler::ProjectLayout::LegacyGeneratedBackend => {
            Ok(project.join("generated/backend/Cargo.toml"))
        }
        appstruct_compiler::ProjectLayout::CompositionRoot => {
            Ok(project.join("generated/server/Cargo.toml"))
        }
    }
}

pub(crate) fn backend_binary_name(project: &Path) -> io::Result<&'static str> {
    match project_layout(project)? {
        appstruct_compiler::ProjectLayout::LegacyGeneratedBackend => {
            Ok("appstruct-generated-backend")
        }
        appstruct_compiler::ProjectLayout::CompositionRoot => Ok("appstruct-generated-server"),
    }
}

fn project_layout(project: &Path) -> io::Result<appstruct_compiler::ProjectLayout> {
    appstruct_compiler::project_layout(project).map_err(|diagnostic| {
        io::Error::new(
            io::ErrorKind::InvalidData,
            format!("{}: {}", diagnostic.code, diagnostic.message),
        )
    })
}

fn build_steps(
    project: &Path,
    backend: &Path,
    web: &Path,
    target: &Path,
    environment: &ProjectEnvironment,
) -> io::Result<()> {
    if !backend
        .parent()
        .expect("backend manifest has a parent")
        .join("Cargo.lock")
        .is_file()
    {
        run_cargo(
            environment,
            project,
            target,
            &["generate-lockfile", "--manifest-path"],
            Some(backend),
            &[],
        )?;
    }
    run_cargo(
        environment,
        project,
        target,
        &["fmt", "--manifest-path"],
        Some(backend),
        &["--", "--check"],
    )?;
    run_cargo(
        environment,
        project,
        target,
        &["clippy", "--release", "--locked", "--manifest-path"],
        Some(backend),
        &["--all-targets", "--", "-D", "warnings"],
    )?;
    run_cargo(
        environment,
        project,
        target,
        &["build", "--release", "--locked", "--manifest-path"],
        Some(backend),
        &[],
    )?;
    run_command(
        environment,
        web,
        "pnpm",
        &["install", "--frozen-lockfile"],
        None,
        &[],
    )?;
    run_command(
        environment,
        web,
        "pnpm",
        &["run", "format:check"],
        None,
        &[],
    )?;
    run_command(environment, web, "pnpm", &["run", "build"], None, &[])
}

fn run_cargo(
    environment: &ProjectEnvironment,
    directory: &Path,
    target: &Path,
    leading: &[&str],
    path_argument: Option<&Path>,
    trailing: &[&str],
) -> io::Result<()> {
    let mut command = Command::new("cargo");
    command
        .current_dir(directory)
        .env("CARGO_TARGET_DIR", target)
        .args(leading);
    if let Some(path) = path_argument {
        command.arg(path);
    }
    command.args(trailing);
    environment.apply(&mut command);
    isolate_stdout_for_json(&mut command);
    check_status(command.status()?, "cargo")
}

fn run_command(
    environment: &ProjectEnvironment,
    directory: &Path,
    program: &str,
    leading: &[&str],
    path_argument: Option<&Path>,
    trailing: &[&str],
) -> io::Result<()> {
    let mut command = Command::new(program);
    command.current_dir(directory).args(leading);
    if let Some(path) = path_argument {
        command.arg(path);
    }
    command.args(trailing);
    environment.apply(&mut command);
    isolate_stdout_for_json(&mut command);
    check_status(command.status()?, program)
}

fn isolate_stdout_for_json(command: &mut Command) {
    if crate::report::is_json() {
        command.stdout(Stdio::null());
    }
}

fn check_status(status: std::process::ExitStatus, program: &str) -> io::Result<()> {
    if status.success() {
        Ok(())
    } else {
        Err(io::Error::other(format!(
            "`{program}` exited with {status}"
        )))
    }
}

#[cfg(test)]
mod tests {
    use super::{backend_binary_name, backend_manifest};
    use std::fs;
    use std::path::Path;

    #[test]
    fn backend_target_is_selected_by_lock_protocol_not_directory_presence() {
        let project = tempfile::tempdir().unwrap();
        fs::create_dir_all(project.path().join("app/backend")).unwrap();
        fs::write(
            project.path().join("appstruct.lock"),
            "lock_version = 1\nproject_layout_version = 1\nappstruct = \"0.1.0\"\n",
        )
        .unwrap();
        assert!(
            backend_manifest(project.path())
                .unwrap()
                .ends_with(Path::new("generated/backend/Cargo.toml"))
        );
        assert_eq!(
            backend_binary_name(project.path()).unwrap(),
            "appstruct-generated-backend"
        );

        fs::write(
            project.path().join("appstruct.lock"),
            "lock_version = 1\nproject_layout_version = 2\nappstruct = \"0.1.0\"\n",
        )
        .unwrap();
        assert!(
            backend_manifest(project.path())
                .unwrap()
                .ends_with(Path::new("generated/server/Cargo.toml"))
        );
        assert_eq!(
            backend_binary_name(project.path()).unwrap(),
            "appstruct-generated-server"
        );
    }

    #[test]
    fn unversioned_lock_requires_explicit_update() {
        let project = tempfile::tempdir().unwrap();
        fs::write(
            project.path().join("appstruct.lock"),
            "lock_version = 1\nappstruct = \"0.1.0\"\n",
        )
        .unwrap();
        assert!(backend_manifest(project.path()).is_err());
    }
}