mod seeds;
pub use seeds::{SeedContext, SeedFuture, Seeds};
use capy_core::{AppError, DatabaseSettings, Result};
use sea_orm::{ConnectOptions, Database};
use std::time::Duration;
pub use sea_orm::DatabaseConnection;
pub use sea_orm_migration::{MigrationTrait, MigratorTrait};
pub async fn connect(settings: &DatabaseSettings) -> Result<DatabaseConnection> {
settings.validate()?;
let in_memory = settings.url.starts_with("sqlite:") && settings.url.contains(":memory:");
let max = if in_memory {
1
} else {
settings.max_connections
};
let mut options = ConnectOptions::new(&settings.url);
options
.max_connections(max)
.min_connections(if in_memory {
1
} else {
settings.min_connections
})
.connect_timeout(Duration::from_secs(settings.connect_timeout_seconds))
.acquire_timeout(Duration::from_secs(settings.acquire_timeout_seconds))
.idle_timeout(Duration::from_secs(settings.idle_timeout_seconds))
.sqlx_logging(false);
let db = tokio::time::timeout(
Duration::from_secs(settings.connect_timeout_seconds),
Database::connect(options),
)
.await
.map_err(|_| {
AppError::DatabaseConnection(sea_orm::DbErr::ConnectionAcquire(
sea_orm::ConnAcquireErr::Timeout,
))
})?
.map_err(AppError::DatabaseConnection)?;
tracing::info!(
database = if settings.url.starts_with("sqlite:") {
"SQLite"
} else {
"PostgreSQL"
},
pool_max = max,
"database connected"
);
Ok(db)
}
pub struct NoMigrations;
#[sea_orm_migration::async_trait::async_trait]
impl MigratorTrait for NoMigrations {
fn migrations() -> Vec<Box<dyn MigrationTrait>> {
Vec::new()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MigrationStatus {
pub name: String,
pub applied: bool,
}
pub async fn status<M: MigratorTrait>(db: &DatabaseConnection) -> Result<Vec<MigrationStatus>> {
use sea_orm_migration::MigrationStatus as Status;
Ok(M::get_migration_with_status(db)
.await?
.into_iter()
.map(|migration| MigrationStatus {
name: migration.name().to_owned(),
applied: migration.status() == Status::Applied,
})
.collect())
}