appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use crate::environment::ProjectEnvironment;
use appstruct_ir::{DatabaseDevMode, DatabaseMigrationPolicy};
use std::io;
use std::path::Path;
use std::process::{Command, ExitCode};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use std::time::Duration;

mod browser;
mod build_cache;
mod ports;
mod process;
mod watch;
use process::{DevProcesses, ManagedDatabase};
use watch::{ProjectChanges, ProjectWatcher};

pub(crate) const MANAGED_DATABASE_URL: &str =
    "postgresql://appstruct:appstruct-dev@127.0.0.1:5432/appstruct?sslmode=disable";

pub(crate) fn run(
    project: &Path,
    api_port: Option<u16>,
    web_port: Option<u16>,
    open_browser: bool,
) -> ExitCode {
    let (api_port, web_port) = match ports::resolve(project, api_port, web_port) {
        Ok(ports) => ports,
        Err(error) => {
            let exit = if error.kind() == io::ErrorKind::InvalidInput {
                crate::report::ExitClass::Usage
            } else {
                crate::report::ExitClass::Environment
            };
            return crate::report::fail(
                "AS6005",
                crate::report::ErrorCategory::Development,
                error.to_string(),
                exit,
            );
        }
    };
    let stopping = Arc::new(AtomicBool::new(false));
    let signal = Arc::clone(&stopping);
    if let Err(error) = ctrlc::set_handler(move || signal.store(true, Ordering::SeqCst)) {
        return crate::report::fail(
            "AS6005",
            crate::report::ErrorCategory::Development,
            format!("cannot install Ctrl-C handler: {error}"),
            crate::report::ExitClass::Environment,
        );
    }
    match DevSession::start(project, api_port, web_port, open_browser, stopping)
        .and_then(|mut session| session.run())
    {
        Ok(()) => ExitCode::SUCCESS,
        Err(error) if error.kind() == io::ErrorKind::Interrupted => ExitCode::SUCCESS,
        Err(error) => crate::report::fail(
            "AS6005",
            crate::report::ErrorCategory::Development,
            format!("development server failed: {error}"),
            crate::report::ExitClass::Environment,
        ),
    }
}

struct DevSession<'project> {
    project: &'project Path,
    environment: ProjectEnvironment,
    database_url: String,
    database_mode: DatabaseDevMode,
    migration_policy: DatabaseMigrationPolicy,
    database: ManagedDatabase,
    processes: DevProcesses,
    watcher: ProjectWatcher,
    api_port: u16,
    web_port: u16,
    stopping: Arc<AtomicBool>,
}

impl<'project> DevSession<'project> {
    fn start(
        project: &'project Path,
        api_port: u16,
        web_port: u16,
        open_browser: bool,
        stopping: Arc<AtomicBool>,
    ) -> io::Result<Self> {
        check_stopping(&stopping)?;
        let ir = compile(project)?;
        let environment = ProjectEnvironment::load(project)?;
        let database_mode = ir.database.dev_mode;
        let migration_policy = ir.database.dev_migration;
        let (database, database_url) = match database_mode {
            DatabaseDevMode::Managed => {
                let database = ManagedDatabase::start(project, &environment)?;
                let url = environment
                    .get("DATABASE_URL")
                    .unwrap_or_else(|| MANAGED_DATABASE_URL.to_owned());
                wait_for_database(&url, &stopping)?;
                (database, url)
            }
            DatabaseDevMode::External => {
                let url = environment.get("DATABASE_URL").ok_or_else(|| {
                    io::Error::new(
                        io::ErrorKind::NotFound,
                        "DATABASE_URL is required for external database mode",
                    )
                })?;
                (ManagedDatabase::external(), url)
            }
        };
        check_stopping(&stopping)?;
        prepare(
            project,
            &database_url,
            &environment,
            migration_policy,
            true,
            &stopping,
        )?;
        let mut processes =
            DevProcesses::spawn(project, &environment, &database_url, api_port, web_port)?;
        browser::wait_for_web(&mut processes, web_port, &stopping)?;
        check_stopping(&stopping)?;
        let watcher = ProjectWatcher::start(project)?;
        let web_url = format!("http://127.0.0.1:{web_port}");
        println!("AppStruct development environment is ready:");
        println!("- API: http://127.0.0.1:{api_port}");
        println!("- Web: {web_url}");
        if open_browser {
            match browser::launch(&web_url) {
                Ok(()) => println!("- Browser: opened"),
                Err(error) => eprintln!(
                    "[appstruct] could not open the default browser: {error}; open {web_url} manually"
                ),
            }
        }
        Ok(Self {
            project,
            environment,
            database_url,
            database_mode,
            migration_policy,
            database,
            processes,
            watcher,
            api_port,
            web_port,
            stopping,
        })
    }

    fn run(&mut self) -> io::Result<()> {
        while !self.stopping.load(Ordering::SeqCst) {
            if let Some(failure) = self.processes.failure()? {
                return Err(io::Error::other(failure));
            }
            if let Some(changes) = self.watcher.changes(Duration::from_millis(250))? {
                self.watcher.refresh()?;
                self.reload(changes);
            }
        }
        self.processes.stop();
        self.database.stop()
    }

    fn reload(&mut self, changes: ProjectChanges) {
        if changes.specification {
            self.reload_specification();
        } else if changes.backend {
            self.reload_backend();
        } else if changes.web {
            println!("[appstruct] web extension changed; Rsbuild will apply the update");
        }
    }

    fn reload_specification(&mut self) {
        println!("[appstruct] App Spec inputs changed; regenerating");
        let result = match self.refresh_environment() {
            Ok(()) => prepare(
                self.project,
                &self.database_url,
                &self.environment,
                self.migration_policy,
                false,
                &self.stopping,
            )
            .and_then(|()| {
                self.processes.restart(
                    self.project,
                    &self.environment,
                    &self.database_url,
                    self.api_port,
                    self.web_port,
                )
            }),
            Err(error) if error.kind() == io::ErrorKind::Unsupported => {
                crate::report::warning(
                    "AS6006",
                    crate::report::ErrorCategory::Development,
                    &error.to_string(),
                );
                return;
            }
            Err(error) => Err(error),
        };
        match result {
            Ok(()) => println!("[appstruct] generated services restarted"),
            Err(error) => {
                eprintln!("[appstruct] rebuild failed; services were not restarted: {error}");
            }
        }
    }

    fn reload_backend(&mut self) {
        println!("[appstruct] backend extension changed; rebuilding API");
        let result = (|| {
            if crate::generation::run(self.project, false) != ExitCode::SUCCESS {
                return Err(io::Error::other("generation failed"));
            }
            check_stopping(&self.stopping)?;
            build_backend(self.project, &self.environment)?;
            check_stopping(&self.stopping)?;
            self.processes.restart_api(
                self.project,
                &self.environment,
                &self.database_url,
                self.api_port,
                self.web_port,
            )
        })();
        match result {
            Ok(()) => println!("[appstruct] API restarted"),
            Err(error) => {
                eprintln!("[appstruct] API rebuild failed; the process was not restarted: {error}");
            }
        }
    }

    fn refresh_environment(&mut self) -> io::Result<()> {
        let ir = compile(self.project)?;
        if ir.database.dev_mode != self.database_mode {
            return Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "database development mode changed; restart `appstruct dev` to reconfigure it",
            ));
        }
        if ir.database.dev_migration != self.migration_policy {
            return Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "database migration policy changed; restart `appstruct dev` to apply it",
            ));
        }
        let environment = ProjectEnvironment::load(self.project)?;
        let database_url = match self.database_mode {
            DatabaseDevMode::Managed => environment
                .get("DATABASE_URL")
                .unwrap_or_else(|| MANAGED_DATABASE_URL.to_owned()),
            DatabaseDevMode::External => environment.get("DATABASE_URL").ok_or_else(|| {
                io::Error::new(
                    io::ErrorKind::NotFound,
                    "DATABASE_URL is required for external database mode",
                )
            })?,
        };
        if self.database_mode == DatabaseDevMode::Managed {
            wait_for_database(&database_url, &self.stopping)?;
        }
        self.database.update_environment(environment.clone());
        self.environment = environment;
        self.database_url = database_url;
        Ok(())
    }
}

impl Drop for DevSession<'_> {
    fn drop(&mut self) {
        self.processes.stop();
        let _ = self.database.stop();
    }
}

fn compile(project: &Path) -> io::Result<appstruct_ir::AppIr> {
    appstruct_compiler::compile_project(project).map_err(|diagnostics| {
        io::Error::new(
            io::ErrorKind::InvalidData,
            diagnostics
                .into_iter()
                .map(|diagnostic| format!("{}: {}", diagnostic.code, diagnostic.message))
                .collect::<Vec<_>>()
                .join("; "),
        )
    })
}

fn prepare(
    project: &Path,
    database_url: &str,
    environment: &ProjectEnvironment,
    migration_policy: DatabaseMigrationPolicy,
    announce_unmanaged: bool,
    stopping: &AtomicBool,
) -> io::Result<()> {
    check_stopping(stopping)?;
    crate::migration::prepare_development(
        project,
        database_url,
        migration_policy,
        announce_unmanaged,
    )?;
    check_stopping(stopping)?;
    if crate::generation::run(project, false) != ExitCode::SUCCESS {
        return Err(io::Error::other("generation failed"));
    }
    check_stopping(stopping)?;
    build_backend(project, environment)?;
    check_stopping(stopping)?;
    install_web(project, environment)
}

fn build_backend(project: &Path, environment: &ProjectEnvironment) -> io::Result<()> {
    if build_cache::backend_current(project, environment)? {
        println!("[appstruct] backend inputs unchanged; reusing debug build");
        return Ok(());
    }
    let backend = crate::build::backend_manifest(project)?;
    let target = project.join(".appstruct/cache/backend-target");
    let lock = backend
        .parent()
        .expect("backend manifest has a parent")
        .join("Cargo.lock");
    let mut command = Command::new("cargo");
    command.current_dir(project).env("CARGO_TARGET_DIR", target);
    if lock.is_file() {
        command.arg("build").arg("--locked");
    } else {
        command.arg("build");
    }
    command.args(["--manifest-path"]).arg(backend);
    environment.apply(&mut command);
    status(command, "build generated backend")?;
    build_cache::record_backend(project, environment)
}

fn install_web(project: &Path, environment: &ProjectEnvironment) -> io::Result<()> {
    if build_cache::web_dependencies_current(project, environment)? {
        println!("[appstruct] web dependencies unchanged; reusing installation");
        return Ok(());
    }
    let mut command = Command::new("pnpm");
    command
        .current_dir(project.join("generated/web"))
        .args(["install", "--frozen-lockfile"]);
    environment.apply(&mut command);
    status(command, "install generated web dependencies")?;
    build_cache::record_web_dependencies(project, environment)
}

fn wait_for_database(database_url: &str, stopping: &AtomicBool) -> io::Result<()> {
    for _ in 0..60 {
        check_stopping(stopping)?;
        match appstruct_migrate::connect_database(database_url) {
            Ok(_) => return Ok(()),
            Err(appstruct_migrate::MigrationError::Database(_)) => {}
            Err(error) => return Err(io::Error::other(error)),
        }
        thread::sleep(Duration::from_millis(500));
    }
    Err(io::Error::new(
        io::ErrorKind::TimedOut,
        "managed PostgreSQL did not become ready within 30 seconds",
    ))
}

fn check_stopping(stopping: &AtomicBool) -> io::Result<()> {
    if stopping.load(Ordering::SeqCst) {
        Err(io::Error::new(
            io::ErrorKind::Interrupted,
            "development server startup interrupted",
        ))
    } else {
        Ok(())
    }
}

fn status(mut command: Command, context: &str) -> io::Result<()> {
    let status = command.status()?;
    if status.success() {
        Ok(())
    } else {
        Err(io::Error::other(format!(
            "{context}: process exited with {status}"
        )))
    }
}

#[cfg(test)]
mod tests;