use crate::{AppConfig, AppContext, AppError, Result, Routes};
use capy_db::{MigratorTrait, NoMigrations};
use std::{marker::PhantomData, path::PathBuf, sync::Arc};
use tracing_subscriber::EnvFilter;
pub struct App<M = NoMigrations> {
routes: Routes,
api_routes: Option<Routes>,
frontend: Option<PathBuf>,
config: Option<AppConfig>,
migrations: PhantomData<M>,
}
impl Default for App {
fn default() -> Self {
Self::new()
}
}
impl App {
pub fn new() -> Self {
Self {
routes: Routes::new(),
api_routes: None,
frontend: None,
config: None,
migrations: PhantomData,
}
}
}
impl<M: MigratorTrait> App<M> {
pub fn api_routes(mut self, routes: Routes) -> Self {
self.api_routes = Some(routes);
self
}
pub fn frontend(mut self, directory: impl Into<PathBuf>) -> Self {
self.frontend = Some(directory.into());
self
}
pub fn routes(mut self, routes: Routes) -> Self {
self.routes = routes;
self
}
pub fn config(mut self, config: AppConfig) -> Self {
self.config = Some(config);
self
}
pub fn migrations<N: MigratorTrait>(self, _migrator: N) -> App<N> {
App {
routes: self.routes,
api_routes: self.api_routes,
frontend: self.frontend,
config: self.config,
migrations: PhantomData,
}
}
pub fn into_router(self, context: AppContext) -> axum::Router {
let mut router = self.routes.into_router();
if let Some(api) = self.api_routes {
router = router.nest("/api", api.into_router());
}
if let Some(directory) = self.frontend {
router =
router.fallback(move |request| crate::frontend::serve(directory.clone(), request));
}
router
.with_state(context)
.layer(axum::middleware::from_fn(crate::diagnostics::request))
}
pub async fn run(self) -> Result<()> {
let mut args = std::env::args().skip(1);
let command = args.next().unwrap_or_else(|| "serve".into());
if args.next().is_some() {
return Err(AppError::Configuration(
"Unexpected arguments. Use the capy CLI for application commands.".into(),
));
}
self.run_command(&command).await
}
pub async fn run_command(self, command: &str) -> Result<()> {
if command == "routes" {
for route in self.routes.inventory() {
println!("{:<7} {}", route.method, route.path);
}
if let Some(api) = &self.api_routes {
for route in api.inventory() {
println!("{:<7} /api{}", route.method, route.path);
}
}
return Ok(());
}
if !matches!(
command,
"serve" | "migrate" | "migrate:rollback" | "migrate:status"
) {
return Err(AppError::Configuration(format!(
"Unknown application command: {command}"
)));
}
let config = match &self.config {
Some(config) => config.clone(),
None => AppConfig::load()?,
};
config.validate()?;
if command == "serve" && config.app.environment == "production" {
if let Some(directory) = &self.frontend {
crate::frontend::validate(directory)?;
}
}
init_logging(&config);
let db = capy_db::connect(&config.database).await?;
match command {
"migrate" => {
M::up(&db, None).await?;
println!("Migrations applied.");
}
"migrate:rollback" => {
M::down(&db, Some(1)).await?;
println!("Rolled back the latest migration.");
}
"migrate:status" => {
let statuses = capy_db::status::<M>(&db).await?;
if statuses.is_empty() {
println!("No migrations registered.");
}
for status in statuses {
println!(
"{:<8} {}",
if status.applied { "Applied" } else { "Pending" },
status.name
);
}
}
_ => {
let listener =
tokio::net::TcpListener::bind((config.app.host.as_str(), config.app.port))
.await?;
let address = listener.local_addr()?;
if config.app.environment == "production" {
tracing::info!(%address, environment = %config.app.environment, "Capy ready");
} else if std::env::var_os("CAPY_DEV").is_some() {
println!(
"✓ Database connected\n✓ Backend ready\nServer running on http://{address}"
);
} else {
println!("Capy v{}\n\nA calmer way to build web apps in Rust.\n\nApplication\n http://{address}\n\nEnvironment\n {}\n\nDatabase\n {}\n\nReady.",
env!("CARGO_PKG_VERSION"), config.app.environment,
if config.database.url.starts_with("sqlite:") { "SQLite" } else { "PostgreSQL" });
}
let context = AppContext {
config: Arc::new(config),
db,
};
axum::serve(listener, self.into_router(context))
.with_graceful_shutdown(shutdown_signal())
.await?;
}
}
Ok(())
}
}
fn init_logging(config: &AppConfig) {
let filter = EnvFilter::try_from_default_env()
.unwrap_or_else(|_| EnvFilter::new(crate::diagnostics::DEFAULT_FILTER));
if config.app.environment != "production"
&& std::env::var("CAPY_DEV_LOG").is_ok_and(|value| value == "1")
{
let _ = tracing_subscriber::fmt()
.with_env_filter(filter)
.with_ansi(false)
.json()
.with_writer(crate::dev_logging::writer)
.try_init();
} else if config.app.environment == "production" {
let _ = tracing_subscriber::fmt()
.with_env_filter(filter)
.json()
.try_init();
} else {
let _ = tracing_subscriber::fmt()
.with_env_filter(filter)
.compact()
.try_init();
}
}
async fn shutdown_signal() {
let ctrl_c = async {
let _ = tokio::signal::ctrl_c().await;
};
#[cfg(unix)]
let terminate = async {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) {
Ok(mut stream) => {
stream.recv().await;
}
Err(_) => std::future::pending::<()>().await,
}
};
#[cfg(not(unix))]
let terminate = std::future::pending::<()>();
tokio::select! { () = ctrl_c => {}, () = terminate => {} }
}