use crate::{AppConfig, AppContext, AppError, Result, Routes, Services};
use capy_db::{MigratorTrait, NoMigrations};
use std::{collections::BTreeMap, marker::PhantomData, path::PathBuf, sync::Arc, time::Duration};
use tracing_subscriber::EnvFilter;
type OpenApiCustomizer = Arc<dyn Fn(&mut crate::ApiDocument) + Send + Sync>;
#[cfg(feature = "testing")]
impl<M: MigratorTrait + Send> capy_testing::TestApplication for App<M> {
fn test_config(&self) -> Result<AppConfig> {
self.config
.clone()
.map(Ok)
.unwrap_or_else(|| AppConfig::load_for_tests("."))
}
async fn boot_test(self, context: AppContext, migrate: bool) -> Result<capy_testing::TestApp> {
context.config.validate()?;
let contracts = self.api_document(&context.config)?.as_value().clone();
if migrate {
M::up(&context.db, None).await?;
}
#[cfg(feature = "auth")]
let csrf = self.auth_delivery.is_some();
#[cfg(not(feature = "auth"))]
let csrf = false;
#[cfg(feature = "jobs")]
let jobs = self.jobs.clone();
let services = self.resolved_services(&context.config)?;
#[cfg(all(feature = "jobs", feature = "mail"))]
let jobs = if let Some(mailer) = self.configured_mailer(&context.config)? {
Some(capy_mail::register_jobs(jobs.unwrap_or_default(), mailer))
} else {
jobs
};
#[cfg(feature = "jobs")]
let queue = jobs
.map(|jobs| {
capy_testing::TestQueue::new(context.clone(), jobs)
.map(|queue| queue.with_services(services.clone()))
})
.transpose()?;
let seeds = self.seeds.clone();
let app = capy_testing::TestApp::new(
self.into_router_with_services(context.clone(), Ok(services.clone())),
)
.with_context(context)
.with_services(services)
.with_csrf(csrf)
.with_seeds(seeds)
.with_contracts(contracts);
#[cfg(feature = "jobs")]
let app = if let Some(queue) = queue {
app.with_jobs(queue)
} else {
app
};
Ok(app)
}
#[cfg(feature = "mail")]
fn capture_test_mail(self, config: &AppConfig) -> Result<(Self, capy_testing::TestMailer)> {
let (mailer, capture) = capy_mail::Mailer::capture(config)?;
Ok((self.with_mail(mailer), capture))
}
}
pub struct App<M = NoMigrations> {
services: Services,
seeds: Option<capy_db::Seeds>,
events: capy_core::Events,
routes: Routes,
api_routes: Option<Routes>,
frontend: Option<PathBuf>,
config: Option<AppConfig>,
request_timeouts: BTreeMap<String, Option<Duration>>,
observer: crate::diagnostics::Observer,
openapi_customizer: Option<OpenApiCustomizer>,
#[cfg(feature = "auth")]
auth_delivery: Option<Arc<dyn capy_auth::ResetDelivery>>,
#[cfg(feature = "auth")]
verification_delivery: Option<Arc<dyn capy_auth::VerificationDelivery>>,
#[cfg(feature = "jobs")]
jobs: Option<capy_jobs::Jobs>,
#[cfg(feature = "scheduler")]
schedules: capy_jobs::scheduler::Schedules,
#[cfg(feature = "scheduler")]
tasks: capy_jobs::scheduler::Tasks,
#[cfg(feature = "mail")]
mail_enabled: bool,
#[cfg(feature = "mail")]
mailer: Option<capy_mail::Mailer>,
migrations: PhantomData<M>,
}
impl Default for App {
fn default() -> Self {
Self::new()
}
}
impl App {
pub fn new() -> Self {
Self {
services: Services::new(),
seeds: None,
events: capy_core::Events::new(),
routes: Routes::new(),
api_routes: None,
frontend: None,
config: None,
request_timeouts: BTreeMap::new(),
observer: None,
openapi_customizer: None,
#[cfg(feature = "auth")]
auth_delivery: None,
#[cfg(feature = "auth")]
verification_delivery: None,
#[cfg(feature = "jobs")]
jobs: None,
#[cfg(feature = "scheduler")]
schedules: capy_jobs::scheduler::Schedules::new(),
#[cfg(feature = "scheduler")]
tasks: capy_jobs::scheduler::Tasks::new(),
#[cfg(feature = "mail")]
mail_enabled: false,
#[cfg(feature = "mail")]
mailer: None,
migrations: PhantomData,
}
}
}
impl<M: MigratorTrait> App<M> {
pub fn service<T: Send + Sync + 'static>(mut self, service: T) -> Self {
self.services.insert(service);
self
}
#[cfg(feature = "storage")]
pub fn storage(self, storage: capy_storage::Storage) -> Self {
self.service(storage)
}
fn resolved_services(&self, config: &AppConfig) -> Result<Services> {
#[cfg(feature = "mail")]
let mut services = self.services.clone();
#[cfg(all(not(feature = "mail"), feature = "storage"))]
let mut services = self.services.clone();
#[cfg(all(not(feature = "mail"), not(feature = "storage")))]
let services = self.services.clone();
#[cfg(feature = "mail")]
if let Some(mailer) = self.configured_mailer(config)? {
services.insert(mailer);
}
#[cfg(feature = "storage")]
if services.find::<capy_storage::Storage>().is_none() {
if let Some(storage) = capy_storage::Storage::from_config(&config.storage)
.map_err(|error| AppError::Configuration(error.to_string()))?
{
services.insert(storage);
}
}
#[cfg(not(feature = "mail"))]
let _ = config;
Ok(services)
}
#[cfg(feature = "auth")]
pub fn email_verification(mut self, delivery: impl capy_auth::VerificationDelivery) -> Self {
self.verification_delivery = Some(Arc::new(delivery));
self
}
#[cfg(feature = "auth")]
fn auth_routes(&self) -> Routes {
let routes = capy_auth::routes();
if self.verification_delivery.is_some() {
routes.merge(capy_auth::verification_routes())
} else {
routes
}
}
pub fn seeds(
mut self,
seed: impl for<'a> Fn(capy_db::SeedContext<'a>) -> capy_db::SeedFuture<'a>
+ Send
+ Sync
+ 'static,
) -> Self {
self.seeds = Some(capy_db::Seeds::new(seed));
self
}
pub fn on<E: capy_core::Event>(
mut self,
listener: impl for<'a> Fn(&'a E, capy_core::EventContext<'a>) -> capy_core::EventFuture<'a>
+ Send
+ Sync
+ 'static,
) -> Self {
self.events = self.events.on::<E>(listener);
self
}
#[cfg(feature = "mail")]
pub fn mail(mut self) -> Self {
self.mail_enabled = true;
self
}
#[cfg(feature = "mail")]
pub fn with_mail(mut self, mailer: capy_mail::Mailer) -> Self {
self.mail_enabled = true;
self.mailer = Some(mailer);
self
}
#[cfg(feature = "mail")]
fn validate_mail(&self, config: &AppConfig) -> Result<()> {
if self.mail_enabled {
if let Some(mailer) = &self.mailer {
mailer.validate_environment(config.app.environment == "production")?;
} else if let Some(mailer) = self.services.find::<capy_mail::Mailer>() {
mailer.validate_environment(config.app.environment == "production")?;
} else {
capy_mail::Mailer::validate(config)?;
}
#[cfg(feature = "jobs")]
capy_mail::validate_jobs(self.jobs.clone().unwrap_or_default())?;
}
Ok(())
}
#[cfg(feature = "mail")]
fn configured_mailer(&self, config: &AppConfig) -> Result<Option<capy_mail::Mailer>> {
self.validate_mail(config)?;
if !self.mail_enabled {
return Ok(None);
}
self.mailer
.clone()
.or_else(|| {
self.services
.find::<capy_mail::Mailer>()
.map(|mailer| (*mailer).clone())
})
.map(Ok)
.unwrap_or_else(|| capy_mail::Mailer::from_config(config))
.map(Some)
}
#[cfg(feature = "auth")]
pub fn auth(mut self, delivery: impl capy_auth::ResetDelivery) -> Self {
self.auth_delivery = Some(Arc::new(delivery));
self
}
#[cfg(feature = "jobs")]
pub fn jobs(mut self, jobs: capy_jobs::Jobs) -> Self {
self.jobs = Some(jobs);
self
}
#[cfg(feature = "scheduler")]
pub fn tasks(mut self, tasks: capy_jobs::scheduler::Tasks) -> Self {
self.tasks = tasks;
self
}
#[cfg(feature = "scheduler")]
pub fn schedules(mut self, schedules: capy_jobs::scheduler::Schedules) -> Self {
self.schedules = schedules;
self
}
pub fn openapi_with(
mut self,
customize: impl Fn(&mut crate::ApiDocument) + Send + Sync + 'static,
) -> Self {
self.openapi_customizer = Some(Arc::new(customize));
self
}
pub fn openapi(&self) -> Result<crate::ApiDocument> {
let config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load_for_contracts)?;
self.api_document(&config)
}
pub fn openapi_strict(&self) -> Result<crate::ApiDocument> {
let mut config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load_for_contracts)?;
config.api.require_documented_routes = true;
self.api_document(&config)
}
fn api_document(&self, config: &AppConfig) -> Result<crate::ApiDocument> {
#[cfg(feature = "mail")]
self.validate_mail(config)?;
#[cfg(feature = "jobs")]
if let Some(jobs) = &self.jobs {
jobs.validate()?;
}
let mut routes = vec![("", &self.routes)];
if let Some(api) = &self.api_routes {
routes.push(("/api", api));
}
if config.api.require_documented_routes {
for (prefix, routes) in &routes {
routes.require_documented(prefix)?;
}
}
#[cfg(feature = "auth")]
let auth_routes = self.auth_routes();
#[cfg(feature = "auth")]
if let Some(delivery) = &self.verification_delivery {
if self.auth_delivery.is_none() {
return Err(AppError::Configuration(
"Enable App::auth before email verification.".into(),
));
}
if config.app.environment == "production" && delivery.development_only() {
return Err(AppError::Configuration(
"Install a production email verification delivery adapter.".into(),
));
}
}
#[cfg(feature = "auth")]
if let Some(delivery) = &self.auth_delivery {
let production = config.app.environment == "production";
config.auth.validate(production)?;
config.http.client_ip.validate()?;
if production && delivery.development_only() {
return Err(AppError::Configuration("Install an application-owned password reset delivery adapter before enabling auth in production.".into()));
}
routes.push(("/api/auth", &auth_routes));
}
let mut document = crate::ApiDocument::from_routes(
config.api.title.as_deref().unwrap_or(&config.app.name),
&config.api.version,
routes,
)?;
#[cfg(feature = "auth")]
if self.auth_delivery.is_some() {
document.as_value_mut()["components"]["securitySchemes"]["session"] = crate::serde_json::json!({
"type": "apiKey", "in": "cookie",
"name": config.auth.cookie_name(config.app.environment == "production")
});
if let Some(paths) = document.as_value_mut()["paths"].as_object_mut() {
for (path, methods) in paths {
if let Some(methods) = methods.as_object_mut() {
for (method, operation) in methods {
let mutation =
matches!(method.as_str(), "post" | "put" | "patch" | "delete");
let bootstrap = path == "/api/auth/csrf" && method == "get";
if mutation || bootstrap {
if operation.get("parameters").is_none() {
operation["parameters"] = crate::serde_json::json!([]);
}
operation["parameters"].as_array_mut().expect("generated parameter array").push(crate::serde_json::json!({
"name": if bootstrap { "X-Capy-CSRF" } else { "X-CSRF-Token" },
"in": "header", "required": true,
"description": if bootstrap { "Send 1 to bootstrap a same-origin CSRF session." } else { "Synchronizer token from GET /api/auth/csrf; never a session secret." },
"schema": {"type": "string"}
}));
operation["responses"]["403"] = crate::serde_json::json!({"description": "CSRF or policy rejection", "content": {"application/json": {"schema": {"$ref": "#/components/schemas/ApiErrorResponse"}}}});
}
}
}
}
}
}
if let Some(customize) = &self.openapi_customizer {
customize(&mut document);
}
Ok(document)
}
pub fn observe_requests(mut self, observer: impl crate::RequestObserver) -> Self {
self.observer = Some(Arc::new(observer));
self
}
pub fn request_timeout_for(
mut self,
route: impl Into<String>,
timeout: Option<Duration>,
) -> Self {
self.request_timeouts.insert(route.into(), timeout);
self
}
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 {
services: self.services,
seeds: self.seeds,
events: self.events,
routes: self.routes,
api_routes: self.api_routes,
frontend: self.frontend,
config: self.config,
request_timeouts: self.request_timeouts,
observer: self.observer,
openapi_customizer: self.openapi_customizer,
#[cfg(feature = "auth")]
auth_delivery: self.auth_delivery,
#[cfg(feature = "auth")]
verification_delivery: self.verification_delivery,
#[cfg(feature = "jobs")]
jobs: self.jobs,
#[cfg(feature = "scheduler")]
schedules: self.schedules,
#[cfg(feature = "scheduler")]
tasks: self.tasks,
#[cfg(feature = "mail")]
mail_enabled: self.mail_enabled,
#[cfg(feature = "mail")]
mailer: self.mailer,
migrations: PhantomData,
}
}
pub fn into_router(self, context: AppContext) -> axum::Router {
let services = self.resolved_services(&context.config);
self.into_router_with_services(context, services)
}
fn into_router_with_services(
self,
context: AppContext,
services: Result<Services>,
) -> axum::Router {
#[cfg(feature = "auth")]
let auth_routes = self.auth_routes();
#[cfg(feature = "mail")]
let mailer = self.configured_mailer(&context.config);
let events = self
.events
.clone()
.with_services(services.as_ref().cloned().unwrap_or_default());
let docs_enabled =
context.config.api.docs && context.config.app.environment != "production";
let schema = (context.config.api.openapi || docs_enabled).then(|| {
self.api_document(&context.config)
.map(|doc| doc.as_value().clone())
});
let http = context.config.http.clone();
let policy = crate::http_policy::HttpPolicy {
default_timeout: (http.request_timeout_seconds != 0)
.then(|| Duration::from_secs(http.request_timeout_seconds)),
overrides: self.request_timeouts,
};
let mut router = self.routes.into_router();
if let Some(api) = self.api_routes {
router = router.nest("/api", api.into_router());
}
#[cfg(feature = "auth")]
let auth = self.auth_delivery.map(|delivery| {
capy_auth::AuthService::new(context.clone(), delivery).and_then(|service| {
let service = service.with_events(events.clone());
match self.verification_delivery {
Some(delivery) => service.with_email_verification(delivery),
None => Ok(service),
}
})
});
#[cfg(feature = "auth")]
if auth.is_some() {
router = router.nest("/api/auth", auth_routes.into_router());
}
if let Some(schema) = schema {
let schema = Arc::new(schema.map_err(|error| error.to_string()));
router = router.route(
"/openapi.json",
axum::routing::get(move || {
let schema = schema.clone();
async move {
match schema.as_ref() {
Ok(document) => Ok(axum::Json(document.clone())),
Err(_) => Err(AppError::Configuration(
"Invalid API contract. Run capy openapi to inspect the error."
.into(),
)),
}
}
}),
);
}
if docs_enabled {
router = router.route(
"/docs/api",
axum::routing::get(|| async {
axum::response::Html(include_str!("api_docs.html"))
}),
);
}
if let Some(directory) = self.frontend {
router =
router.fallback(move |request| crate::frontend::serve(directory.clone(), request));
}
let mut router = router.with_state(context).layer(axum::Extension(events));
match services {
Ok(services) => router = router.layer(axum::Extension(services)),
Err(_) => {
router = axum::Router::new().fallback(|| async {
AppError::Configuration("Invalid application services. Run capy check.".into())
})
}
}
#[cfg(feature = "mail")]
match mailer {
Ok(Some(mailer)) => router = router.layer(axum::Extension(mailer)),
Ok(None) => {}
Err(_) => {
router = axum::Router::new().fallback(|| async {
AppError::Configuration("Invalid mail configuration. Run capy check.".into())
})
}
}
#[cfg(feature = "auth")]
if let Some(service) = auth {
router = match service {
Ok(service) => service.protect(router),
Err(_) => axum::Router::new().fallback(|| async {
AppError::Configuration("Invalid auth configuration. Run capy check.".into())
}),
};
}
router = router
.layer(axum::extract::DefaultBodyLimit::max(http.max_body_bytes))
.layer(axum::middleware::from_fn_with_state(
policy,
crate::http_policy::deadline,
));
if http.compression {
router = router.layer(tower_http::compression::CompressionLayer::new());
}
router
.layer(axum::middleware::from_fn_with_state(
self.observer,
crate::diagnostics::request,
))
.layer(
tower_http::sensitive_headers::SetSensitiveRequestHeadersLayer::new([
axum::http::header::AUTHORIZATION,
axum::http::header::COOKIE,
axum::http::HeaderName::from_static("x-csrf-token"),
]),
)
.layer(
tower_http::sensitive_headers::SetSensitiveResponseHeadersLayer::new([
axum::http::header::SET_COOKIE,
]),
)
}
pub async fn run(self) -> Result<()> {
let mut args = std::env::args().skip(1);
let command = args.next().unwrap_or_else(|| "serve".into());
#[cfg(feature = "jobs")]
if command.starts_with("queue:") {
return self
.run_queue_command(&command, &args.collect::<Vec<_>>())
.await;
}
#[cfg(feature = "scheduler")]
if command == "task:run" {
let name = args.next().ok_or_else(|| {
AppError::Configuration("task:run requires a registered task name.".into())
})?;
if args.next().is_some() {
return Err(AppError::Configuration(
"task:run accepts exactly one task name.".into(),
));
}
return self.run_task(&name).await;
}
#[cfg(feature = "mail")]
if matches!(command.as_str(), "mail:list" | "mail:show" | "mail:clear") {
let config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load_for_contracts)?;
return crate::mail_commands::run(&config, &command, &args.collect::<Vec<_>>());
}
if args.next().is_some() {
return Err(AppError::Configuration(
"Unexpected arguments. Use the capy CLI for application commands.".into(),
));
}
self.run_command(&command).await
}
#[cfg(feature = "jobs")]
async fn run_queue_command(self, command: &str, args: &[String]) -> Result<()> {
let config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load)?;
#[cfg(feature = "mail")]
let mailer = self.configured_mailer(&config)?;
let services = self.resolved_services(&config)?;
let jobs = self.jobs;
#[cfg(feature = "mail")]
let jobs = if let Some(mailer) = mailer {
Some(capy_mail::register_jobs(jobs.unwrap_or_default(), mailer))
} else {
jobs
};
let jobs = jobs.ok_or_else(|| {
AppError::Configuration(
"Register jobs with App::jobs (capy make:job installs the conventional registry)."
.into(),
)
})?;
crate::job_commands::run(command, args, config, jobs, services).await
}
#[cfg(feature = "scheduler")]
async fn run_task(self, name: &str) -> Result<()> {
let config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load)?;
config.validate()?;
let services = self.resolved_services(&config)?;
let db = capy_db::connect(&config.database).await?;
self.tasks
.run(
name,
AppContext {
db,
config: Arc::new(config),
},
services,
)
.await
}
#[cfg(feature = "scheduler")]
async fn run_scheduler(self) -> Result<()> {
let config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load)?;
config.validate()?;
config.jobs.validate_database(&config.database)?;
let jobs = self.jobs.as_ref().ok_or_else(|| {
AppError::Configuration(
"Register scheduled jobs with App::jobs before running the scheduler.".into(),
)
})?;
self.schedules.validate_jobs(jobs)?;
let db = capy_db::connect(&config.database).await?;
let context = AppContext {
db,
config: Arc::new(config),
};
capy_jobs::scheduler::Scheduler::new(context, self.schedules)
.run(async {
let _ = tokio::signal::ctrl_c().await;
})
.await
}
pub async fn run_command(self, command: &str) -> Result<()> {
let command = match command {
"db:migrate" => "migrate",
"db:rollback" => "migrate:rollback",
"db:status" => "migrate:status",
command => command,
};
#[cfg(feature = "jobs")]
if command.starts_with("queue:") {
return self.run_queue_command(command, &[]).await;
}
#[cfg(feature = "scheduler")]
if command == "scheduler:run" {
return self.run_scheduler().await;
}
#[cfg(feature = "scheduler")]
if command == "task:list" {
for name in self.tasks.names() {
println!("{name}");
}
return Ok(());
}
#[cfg(feature = "mail")]
if command == "mail:check" {
let config = self
.config
.clone()
.map(Ok)
.unwrap_or_else(AppConfig::load_for_contracts)?;
if !self.mail_enabled {
return Err(AppError::Configuration(
"Enable mail with App::mail.".into(),
));
}
self.validate_mail(&config)?;
println!("Mail: configuration and compiled templates valid. No DNS, authentication or delivery attempted.");
return Ok(());
}
if matches!(command, "__capy_contract" | "__capy_contract_strict") {
let document = if command == "__capy_contract_strict" {
self.openapi_strict()?
} else {
self.openapi()?
};
print!("{}", document.to_json()?);
return Ok(());
}
if command == "routes:api" {
self.openapi()?;
for (prefix, routes) in std::iter::once(("", &self.routes))
.chain(self.api_routes.as_ref().map(|r| ("/api", r)))
{
for route in routes.api_inventory() {
println!(
"{:<7} {:<28} {:<22} {}",
route.method,
format!("{prefix}{}", route.path),
route.operation_id.unwrap_or_default(),
route.response.unwrap_or_default()
);
}
}
#[cfg(feature = "auth")]
if self.auth_delivery.is_some() {
for route in self.auth_routes().api_inventory() {
println!(
"{:<7} {:<28} {:<22} {}",
route.method,
format!("/api/auth{}", route.path),
route.operation_id.unwrap_or_default(),
route.response.unwrap_or_default()
);
}
}
return Ok(());
}
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);
}
}
#[cfg(feature = "auth")]
if self.auth_delivery.is_some() {
for route in self.auth_routes().inventory() {
println!("{:<7} /api/auth{}", route.method, route.path);
}
}
return Ok(());
}
if !matches!(
command,
"serve"
| "check"
| "migrate"
| "migrate:rollback"
| "migrate:status"
| "auth:prune"
| "db:seed"
) {
return Err(AppError::Configuration(format!(
"Unknown application command: {command}"
)));
}
let config = match &self.config {
Some(config) => config.clone(),
None => AppConfig::load()?,
};
config.validate()?;
if matches!(command, "serve" | "check") {
#[cfg(feature = "storage")]
if command == "serve" {
self.resolved_services(&config)?;
}
#[cfg(not(feature = "storage"))]
if config.storage.driver != "none" {
return Err(AppError::Configuration(
"Storage is configured but the capy storage feature is disabled.".into(),
));
}
#[cfg(all(feature = "storage", not(feature = "storage-s3")))]
if config.storage.driver == "s3" {
return Err(AppError::Configuration(
"S3 storage requires the capy storage-s3 feature.".into(),
));
}
}
if command == "db:seed" {
capy_db::Seeds::validate_environment(&config)?;
let seeds = self.seeds.ok_or_else(|| {
AppError::Configuration(
"Register application-owned seeds with App::seeds before running db:seed."
.into(),
)
})?;
let db = capy_db::connect(&config.database).await?;
let context = AppContext {
db,
config: Arc::new(config),
};
seeds.run(&context).await?;
println!("Development seeds committed. Migrations were not run automatically.");
return Ok(());
}
if matches!(command, "serve" | "check") {
self.api_document(&config)?;
}
if command == "check" || (command == "serve" && config.app.environment == "production") {
if let Some(directory) = &self.frontend {
crate::frontend::validate(directory)?;
}
}
if command == "check" {
#[cfg(feature = "auth")]
if self.auth_delivery.is_some()
&& config.app.environment == "production"
&& !config.auth.throttle.enabled
{
eprintln!("Warning [auth.throttle.disabled]: built-in auth abuse limits are disabled; enforce equivalent deployment-level protection.");
}
#[cfg(feature = "jobs")]
{
let jobs_enabled = self.jobs.is_some();
#[cfg(feature = "mail")]
let jobs_enabled = jobs_enabled || self.mail_enabled;
if jobs_enabled {
config.jobs.validate_database(&config.database)?;
}
}
#[cfg(feature = "scheduler")]
if self.schedules.names().next().is_some() {
let jobs = self.jobs.as_ref().ok_or_else(|| {
AppError::Configuration("Registered schedules require App::jobs.".into())
})?;
self.schedules.validate_jobs(jobs)?;
}
let migrations = M::migrations();
let mut names = std::collections::BTreeSet::new();
for migration in &migrations {
if !names.insert(migration.name()) {
return Err(AppError::Configuration(
"Duplicate registered migration name.".into(),
));
}
}
println!(
"Configuration valid; {} migrations registered. No database connection opened.",
migrations.len()
);
return Ok(());
}
if command == "auth:prune" {
#[cfg(feature = "auth")]
if self.auth_delivery.is_some() {
let db = capy_db::connect(&config.database).await?;
let mut count = capy_auth::prune(&db).await?;
if self.verification_delivery.is_some() {
count += capy_auth::verification::prune(&db).await?;
}
println!("Pruned {count} expired auth records.");
return Ok(());
}
return Err(AppError::Configuration(
"Install auth with capy make:auth before pruning.".into(),
));
}
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.host(), config.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 shutdown_timeout = Duration::from_secs(config.server.shutdown_timeout_seconds);
let context = AppContext {
config: Arc::new(config),
db,
};
serve(
listener,
self.into_router(context),
shutdown_timeout,
shutdown_signal(),
)
.await?;
}
}
Ok(())
}
}
pub(crate) async fn serve(
listener: tokio::net::TcpListener,
router: axum::Router,
timeout: Duration,
signal: impl std::future::Future<Output = ()>,
) -> Result<()> {
let handle = axum_server::Handle::new();
let server = axum_server::from_tcp(listener.into_std()?)?
.handle(handle.clone())
.serve(router.into_make_service_with_connect_info::<std::net::SocketAddr>());
tokio::pin!(server);
tokio::select! {
result = &mut server => { result?; }
() = signal => {
tracing::info!("shutdown requested");
handle.graceful_shutdown(None);
tracing::info!("waiting for active requests");
match tokio::time::timeout(timeout, &mut server).await {
Ok(result) => result?,
Err(_) => {
tracing::warn!("shutdown deadline reached");
handle.shutdown();
server.await?;
}
}
}
}
tracing::info!("server stopped");
Ok(())
}
pub(crate) 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();
}
}
pub(crate) 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 => {} }
}