use std::{fmt, time::Duration};
use serde::{Deserialize, Serialize};
use crate::{
secret::{ExposeSecret, SecretString},
settings::{SettingsIssues, SettingsValidationError, field_path},
};
#[derive(Clone)]
#[non_exhaustive]
pub struct PostgresConnectionConfig {
pub(super) database_url: SecretString,
pub(super) statement_timeout: Option<Duration>,
pub(super) idle_in_transaction_session_timeout: Option<Duration>,
}
impl fmt::Debug for PostgresConnectionConfig {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PostgresConnectionConfig")
.field("database_url", &self.database_url)
.field("statement_timeout", &self.statement_timeout)
.field(
"idle_in_transaction_session_timeout",
&self.idle_in_transaction_session_timeout,
)
.finish()
}
}
impl PostgresConnectionConfig {
#[must_use]
pub const fn database_url(&self) -> &SecretString {
&self.database_url
}
#[must_use]
pub const fn statement_timeout(&self) -> Option<Duration> {
self.statement_timeout
}
#[must_use]
pub const fn idle_in_transaction_session_timeout(&self) -> Option<Duration> {
self.idle_in_transaction_session_timeout
}
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct PostgresConnectionSettings<S = SecretString> {
#[cfg_attr(feature = "tier", tier(secret, leaf))]
pub database_url: S,
#[serde(default, with = "crate::settings::human_duration::option")]
pub statement_timeout: Option<Duration>,
#[serde(default, with = "crate::settings::human_duration::option")]
pub idle_in_transaction_session_timeout: Option<Duration>,
}
impl<S> fmt::Debug for PostgresConnectionSettings<S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PostgresConnectionSettings")
.field("database_url", &"[REDACTED]")
.field("statement_timeout", &self.statement_timeout)
.field(
"idle_in_transaction_session_timeout",
&self.idle_in_transaction_session_timeout,
)
.finish()
}
}
impl PostgresConnectionSettings {
#[must_use]
pub fn new(database_url: impl Into<String>) -> Self {
Self::from_secret(SecretString::new(database_url))
}
#[must_use]
pub fn with_database_url(mut self, database_url: impl Into<String>) -> Self {
self.database_url = SecretString::new(database_url);
self
}
}
impl<S> PostgresConnectionSettings<S> {
#[must_use]
pub const fn from_secret(database_url: S) -> Self {
Self {
database_url,
statement_timeout: None,
idle_in_transaction_session_timeout: None,
}
}
#[must_use]
pub fn map_database_url<T>(self, map: impl FnOnce(S) -> T) -> PostgresConnectionSettings<T> {
PostgresConnectionSettings {
database_url: map(self.database_url),
statement_timeout: self.statement_timeout,
idle_in_transaction_session_timeout: self.idle_in_transaction_session_timeout,
}
}
#[must_use]
pub const fn with_statement_timeout(mut self, timeout: Option<Duration>) -> Self {
self.statement_timeout = timeout;
self
}
#[must_use]
pub const fn with_idle_in_transaction_session_timeout(
mut self,
timeout: Option<Duration>,
) -> Self {
self.idle_in_transaction_session_timeout = timeout;
self
}
pub fn build(self) -> Result<PostgresConnectionConfig, SettingsValidationError>
where
S: Into<SecretString>,
{
let settings = self.map_database_url(Into::into);
settings.validate()?;
Ok(settings.into_config())
}
}
impl<S: ExposeSecret<str>> PostgresConnectionSettings<S> {
pub fn validate(&self) -> Result<(), SettingsValidationError> {
self.validate_at("postgres.connection")
}
pub fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
let mut issues = SettingsIssues::new();
let url = self.database_url.expose_secret();
issues.require_non_empty(field_path(path, "database_url"), url);
if !url.trim().is_empty() {
issues.require(
super::identity::connect_options(url).is_ok(),
field_path(path, "database_url"),
"must be a valid PostgreSQL URL",
);
}
for (field, timeout) in [
("statement_timeout", self.statement_timeout),
(
"idle_in_transaction_session_timeout",
self.idle_in_transaction_session_timeout,
),
] {
issues.require(
timeout.is_none_or(|value| {
value.subsec_nanos().is_multiple_of(1_000_000)
&& value.as_millis() <= i32::MAX as u128
}),
field_path(path, field),
"must be omitted or a whole number of milliseconds between 0 and 2147483647",
);
}
issues.into_result()
}
}
impl PostgresConnectionSettings {
pub(super) fn into_config(self) -> PostgresConnectionConfig {
PostgresConnectionConfig {
database_url: self.database_url,
statement_timeout: self.statement_timeout,
idle_in_transaction_session_timeout: self.idle_in_transaction_session_timeout,
}
}
}
impl From<PostgresConnectionConfig> for PostgresConnectionSettings {
fn from(config: PostgresConnectionConfig) -> Self {
Self {
database_url: config.database_url,
statement_timeout: config.statement_timeout,
idle_in_transaction_session_timeout: config.idle_in_transaction_session_timeout,
}
}
}