use std::{fmt, str::FromStr, time::Duration};
use serde::{Deserialize, Serialize};
use sqlx::sqlite::SqliteConnectOptions;
use crate::settings::{SettingsIssues, SettingsValidationError};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct SqlitePoolConfig {
pub(super) max_connections: u32,
pub(super) min_connections: u32,
pub(super) acquire_timeout: Duration,
pub(super) idle_timeout: Option<Duration>,
pub(super) max_lifetime: Option<Duration>,
pub(super) test_before_acquire: bool,
}
impl Default for SqlitePoolConfig {
fn default() -> Self {
Self {
max_connections: 5,
min_connections: 0,
acquire_timeout: Duration::from_secs(5),
idle_timeout: Some(Duration::from_secs(10 * 60)),
max_lifetime: Some(Duration::from_secs(30 * 60)),
test_before_acquire: true,
}
}
}
impl SqlitePoolConfig {
#[must_use]
pub const fn max_connections(&self) -> u32 {
self.max_connections
}
#[must_use]
pub const fn min_connections(&self) -> u32 {
self.min_connections
}
#[must_use]
pub const fn acquire_timeout(&self) -> Duration {
self.acquire_timeout
}
#[must_use]
pub const fn idle_timeout(&self) -> Option<Duration> {
self.idle_timeout
}
#[must_use]
pub const fn max_lifetime(&self) -> Option<Duration> {
self.max_lifetime
}
#[must_use]
pub const fn test_before_acquire(&self) -> bool {
self.test_before_acquire
}
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
#[non_exhaustive]
pub struct SqlitePoolSettings {
pub max_connections: u32,
pub min_connections: u32,
#[serde(with = "crate::settings::human_duration")]
pub acquire_timeout: Duration,
#[serde(with = "crate::settings::human_duration::option")]
pub idle_timeout: Option<Duration>,
#[serde(with = "crate::settings::human_duration::option")]
pub max_lifetime: Option<Duration>,
pub test_before_acquire: bool,
}
impl Default for SqlitePoolSettings {
fn default() -> Self {
Self::from(SqlitePoolConfig::default())
}
}
impl From<SqlitePoolConfig> for SqlitePoolSettings {
fn from(value: SqlitePoolConfig) -> Self {
Self {
max_connections: value.max_connections,
min_connections: value.min_connections,
acquire_timeout: value.acquire_timeout,
idle_timeout: value.idle_timeout,
max_lifetime: value.max_lifetime,
test_before_acquire: value.test_before_acquire,
}
}
}
impl SqlitePoolSettings {
#[must_use]
pub const fn with_max_connections(mut self, max_connections: u32) -> Self {
self.max_connections = max_connections;
self
}
#[must_use]
pub const fn with_min_connections(mut self, min_connections: u32) -> Self {
self.min_connections = min_connections;
self
}
#[must_use]
pub const fn with_acquire_timeout(mut self, acquire_timeout: Duration) -> Self {
self.acquire_timeout = acquire_timeout;
self
}
#[must_use]
pub const fn with_idle_timeout(mut self, idle_timeout: Option<Duration>) -> Self {
self.idle_timeout = idle_timeout;
self
}
#[must_use]
pub const fn with_max_lifetime(mut self, max_lifetime: Option<Duration>) -> Self {
self.max_lifetime = max_lifetime;
self
}
#[must_use]
pub const fn with_test_before_acquire(mut self, test_before_acquire: bool) -> Self {
self.test_before_acquire = test_before_acquire;
self
}
pub fn build(self) -> Result<SqlitePoolConfig, SettingsValidationError> {
self.validate()?;
Ok(self.into_config())
}
fn into_config(self) -> SqlitePoolConfig {
SqlitePoolConfig {
max_connections: self.max_connections,
min_connections: self.min_connections,
acquire_timeout: self.acquire_timeout,
idle_timeout: self.idle_timeout,
max_lifetime: self.max_lifetime,
test_before_acquire: self.test_before_acquire,
}
}
pub fn validate(&self) -> Result<(), SettingsValidationError> {
self.validate_at("sqlite.pool")
}
pub(crate) fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
let mut issues = SettingsIssues::new();
issues.require(
self.max_connections > 0,
format!("{path}.max_connections"),
"must be greater than zero",
);
issues.require(
!self.acquire_timeout.is_zero()
&& std::time::Instant::now()
.checked_add(self.acquire_timeout)
.is_some(),
format!("{path}.acquire_timeout"),
"must be greater than zero and fit the runtime timer range",
);
issues.require(
self.min_connections <= self.max_connections,
format!("{path}.min_connections"),
"must be less than or equal to max_connections",
);
issues.into_result()
}
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum SqliteJournalMode {
Delete,
Truncate,
Persist,
Memory,
Wal,
Off,
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum SqliteSynchronousMode {
Off,
Normal,
Full,
Extra,
}
#[derive(Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SqliteConnectionConfig {
pub(super) database_url: String,
pub(super) create_if_missing: bool,
pub(super) read_only: bool,
pub(super) foreign_keys: bool,
pub(super) busy_timeout: Duration,
pub(super) journal_mode: Option<SqliteJournalMode>,
pub(super) synchronous: Option<SqliteSynchronousMode>,
pub(super) statement_cache_capacity: usize,
}
impl fmt::Debug for SqliteConnectionConfig {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("SqliteConnectionConfig")
.field("database_url", &"[REDACTED]")
.field("create_if_missing", &self.create_if_missing)
.field("read_only", &self.read_only)
.field("foreign_keys", &self.foreign_keys)
.field("busy_timeout", &self.busy_timeout)
.field("journal_mode", &self.journal_mode)
.field("synchronous", &self.synchronous)
.field("statement_cache_capacity", &self.statement_cache_capacity)
.finish()
}
}
impl SqliteConnectionConfig {
#[must_use]
pub fn database_url(&self) -> &str {
&self.database_url
}
#[must_use]
pub const fn create_if_missing(&self) -> bool {
self.create_if_missing
}
#[must_use]
pub const fn read_only(&self) -> bool {
self.read_only
}
#[must_use]
pub const fn foreign_keys(&self) -> bool {
self.foreign_keys
}
#[must_use]
pub const fn busy_timeout(&self) -> Duration {
self.busy_timeout
}
#[must_use]
pub const fn journal_mode(&self) -> Option<SqliteJournalMode> {
self.journal_mode
}
#[must_use]
pub const fn synchronous(&self) -> Option<SqliteSynchronousMode> {
self.synchronous
}
#[must_use]
pub const fn statement_cache_capacity(&self) -> usize {
self.statement_cache_capacity
}
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct SqliteConnectionSettings {
pub database_url: String,
#[serde(default)]
pub create_if_missing: bool,
#[serde(default)]
pub read_only: bool,
#[serde(default = "default_true")]
pub foreign_keys: bool,
#[serde(
default = "default_busy_timeout",
with = "crate::settings::human_duration"
)]
pub busy_timeout: Duration,
#[serde(default)]
pub journal_mode: Option<SqliteJournalMode>,
#[serde(default)]
pub synchronous: Option<SqliteSynchronousMode>,
#[serde(default = "default_statement_cache_capacity")]
pub statement_cache_capacity: usize,
}
impl fmt::Debug for SqliteConnectionSettings {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("SqliteConnectionSettings")
.field("database_url", &"[REDACTED]")
.field("create_if_missing", &self.create_if_missing)
.field("read_only", &self.read_only)
.field("foreign_keys", &self.foreign_keys)
.field("busy_timeout", &self.busy_timeout)
.field("journal_mode", &self.journal_mode)
.field("synchronous", &self.synchronous)
.field("statement_cache_capacity", &self.statement_cache_capacity)
.finish()
}
}
impl SqliteConnectionSettings {
#[must_use]
pub fn new(database_url: impl Into<String>) -> Self {
Self {
database_url: database_url.into(),
create_if_missing: false,
read_only: false,
foreign_keys: true,
busy_timeout: default_busy_timeout(),
journal_mode: None,
synchronous: None,
statement_cache_capacity: default_statement_cache_capacity(),
}
}
#[must_use]
pub const fn with_create_if_missing(mut self, create_if_missing: bool) -> Self {
self.create_if_missing = create_if_missing;
self
}
#[must_use]
pub const fn with_read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self
}
#[must_use]
pub const fn with_foreign_keys(mut self, foreign_keys: bool) -> Self {
self.foreign_keys = foreign_keys;
self
}
#[must_use]
pub const fn with_busy_timeout(mut self, busy_timeout: Duration) -> Self {
self.busy_timeout = busy_timeout;
self
}
#[must_use]
pub const fn with_journal_mode(mut self, journal_mode: Option<SqliteJournalMode>) -> Self {
self.journal_mode = journal_mode;
self
}
#[must_use]
pub const fn with_synchronous(mut self, synchronous: Option<SqliteSynchronousMode>) -> Self {
self.synchronous = synchronous;
self
}
#[must_use]
pub const fn with_statement_cache_capacity(mut self, capacity: usize) -> Self {
self.statement_cache_capacity = capacity;
self
}
pub fn validate(&self) -> Result<(), SettingsValidationError> {
self.validate_at("sqlite.connection")
}
pub(crate) fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
let mut issues = SettingsIssues::new();
issues.require_non_empty(format!("{path}.database_url"), &self.database_url);
issues.require(
self.busy_timeout.as_millis() <= i32::MAX as u128,
format!("{path}.busy_timeout"),
"must not exceed 2147483647 milliseconds",
);
if !self.database_url.trim().is_empty() {
issues.require(
self.database_url.starts_with("sqlite:")
&& SqliteConnectOptions::from_str(&self.database_url).is_ok(),
format!("{path}.database_url"),
"must be a valid SQLite connection URL beginning with 'sqlite:'",
);
issues.require(
!self.database_url.contains('?'),
format!("{path}.database_url"),
"must not contain connection parameters; use explicit settings instead",
);
}
issues.require(
!(self.read_only && self.create_if_missing),
format!("{path}.create_if_missing"),
"must be false when read_only is true",
);
issues.require(
!(self.read_only && self.journal_mode.is_some()),
format!("{path}.journal_mode"),
"must be omitted when read_only is true",
);
issues.into_result()
}
pub fn build(self) -> Result<SqliteConnectionConfig, SettingsValidationError> {
self.validate()?;
Ok(self.into_config())
}
fn into_config(self) -> SqliteConnectionConfig {
SqliteConnectionConfig {
database_url: self.database_url,
create_if_missing: self.create_if_missing,
read_only: self.read_only,
foreign_keys: self.foreign_keys,
busy_timeout: self.busy_timeout,
journal_mode: self.journal_mode,
synchronous: self.synchronous,
statement_cache_capacity: self.statement_cache_capacity,
}
}
}
impl From<SqliteConnectionConfig> for SqliteConnectionSettings {
fn from(value: SqliteConnectionConfig) -> Self {
Self {
database_url: value.database_url,
create_if_missing: value.create_if_missing,
read_only: value.read_only,
foreign_keys: value.foreign_keys,
busy_timeout: value.busy_timeout,
journal_mode: value.journal_mode,
synchronous: value.synchronous,
statement_cache_capacity: value.statement_cache_capacity,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SqliteBootstrapConfig {
pub(super) connection_config: SqliteConnectionConfig,
pub(super) pool_config: SqlitePoolConfig,
pub(super) migrate_on_startup: bool,
}
impl SqliteBootstrapConfig {
#[must_use]
pub const fn connection_config(&self) -> &SqliteConnectionConfig {
&self.connection_config
}
#[must_use]
pub const fn pool_config(&self) -> SqlitePoolConfig {
self.pool_config
}
#[must_use]
pub const fn migrate_on_startup(&self) -> bool {
self.migrate_on_startup
}
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct SqliteBootstrapSettings {
pub connection: SqliteConnectionSettings,
#[serde(default)]
pub pool: SqlitePoolSettings,
#[serde(default)]
pub migrate_on_startup: bool,
}
impl SqliteBootstrapSettings {
#[must_use]
pub fn new(database_url: impl Into<String>) -> Self {
Self::from_connection(SqliteConnectionSettings::new(database_url))
}
#[must_use]
pub fn from_connection(connection: SqliteConnectionSettings) -> Self {
Self {
connection,
pool: SqlitePoolSettings::default(),
migrate_on_startup: false,
}
}
#[must_use]
pub fn with_connection(mut self, connection: SqliteConnectionSettings) -> Self {
self.connection = connection;
self
}
#[must_use]
pub fn with_pool(mut self, pool: SqlitePoolSettings) -> Self {
self.pool = pool;
self
}
#[must_use]
pub const fn with_migrate_on_startup(mut self, migrate_on_startup: bool) -> Self {
self.migrate_on_startup = migrate_on_startup;
self
}
pub fn validate(&self) -> Result<(), SettingsValidationError> {
self.validate_at("sqlite")
}
pub(crate) fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
let mut issues = SettingsIssues::new();
issues.extend_result(self.connection.validate_at(&format!("{path}.connection")));
issues.extend_result(self.pool.validate_at(&format!("{path}.pool")));
issues.require(
!(self.connection.read_only && self.migrate_on_startup),
format!("{path}.migrate_on_startup"),
"must be false when connection.read_only is true",
);
issues.into_result()
}
pub fn build(self) -> Result<SqliteBootstrapConfig, SettingsValidationError> {
self.validate()?;
Ok(SqliteBootstrapConfig {
connection_config: self.connection.into_config(),
pool_config: self.pool.into_config(),
migrate_on_startup: self.migrate_on_startup,
})
}
}
impl From<SqliteBootstrapConfig> for SqliteBootstrapSettings {
fn from(value: SqliteBootstrapConfig) -> Self {
Self {
connection: SqliteConnectionSettings::from(value.connection_config),
pool: SqlitePoolSettings::from(value.pool_config),
migrate_on_startup: value.migrate_on_startup,
}
}
}
const fn default_busy_timeout() -> Duration {
Duration::from_secs(5)
}
const fn default_statement_cache_capacity() -> usize {
100
}
const fn default_true() -> bool {
true
}