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 build_cache;
mod process;
mod watch;
use process::{DevProcesses, ManagedDatabase};
use watch::SourceFingerprint;
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: u16, web_port: u16) -> ExitCode {
if api_port == 0 || web_port == 0 || api_port == web_port {
return crate::report::fail(
"AS6005",
crate::report::ErrorCategory::Development,
"API and web ports must be non-zero and different",
crate::report::ExitClass::Usage,
);
}
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, 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,
fingerprint: SourceFingerprint,
api_port: u16,
web_port: u16,
stopping: Arc<AtomicBool>,
}
impl<'project> DevSession<'project> {
fn start(
project: &'project Path,
api_port: u16,
web_port: u16,
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 processes =
DevProcesses::spawn(project, &environment, &database_url, api_port, web_port)?;
check_stopping(&stopping)?;
let fingerprint = SourceFingerprint::read(project)?;
println!("AppStruct development environment is ready:");
println!("- API: http://127.0.0.1:{api_port}");
println!("- Web: http://127.0.0.1:{web_port}");
Ok(Self {
project,
environment,
database_url,
database_mode,
migration_policy,
database,
processes,
fingerprint,
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));
}
let next = SourceFingerprint::read(self.project)?;
if next != self.fingerprint {
self.fingerprint = next;
self.reload();
}
thread::sleep(Duration::from_millis(400));
}
self.processes.stop();
self.database.stop()
}
fn reload(&mut self) {
println!("[appstruct] project inputs changed; rebuilding");
let result = self
.refresh_environment()
.and_then(|()| {
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,
)
});
match result {
Ok(()) => println!("[appstruct] services restarted"),
Err(error) => {
eprintln!("[appstruct] rebuild failed; services were 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::other(
"database development mode changed; restart `appstruct dev` to reconfigure it",
));
}
if ir.database.dev_migration != self.migration_policy {
return Err(io::Error::other(
"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 {
use super::*;
#[test]
fn rejects_invalid_ports_before_project_access() {
let missing = Path::new("/path/that/does/not/exist");
assert_eq!(run(missing, 0, 5173), ExitCode::from(2));
assert_eq!(run(missing, 3000, 3000), ExitCode::from(2));
}
}