server/

config.rs

use crate::db::get_connection;
use derive_more::From;
use rust_i18n::t;
use sqlx::Error::RowNotFound;
use std::env::var;
use std::fmt;
use std::ops::Deref;
use std::sync::LazyLock;
use thiserror::Error;

/// Represents an error that can occur while accessing the configuration.
///
/// # Variants
///
/// - `NoConfig(String)`: Returned when a specific configuration field is not found.
/// - `DB`: Indicates a database access error.
/// - `Sqlx`: An error propagated from the `SQLx` crate.
///
/// # Example
///
/// ```rust
/// use thiserror::Error;
///
/// #[derive(Debug, Error)]
/// pub enum ConfigError {
///     #[error("No such config field: {0}")]
///     NoConfig(String),
///     #[error("Can't access db")]
///     DB,
///     #[error("Sqlx")]
///     Sqlx(#[from] sqlx::Error),
/// }
/// ```
#[derive(Debug, Error)]
pub enum ConfigError {
    #[error("No such config field: {0}")]
    NoConfig(String),
    #[error("Can't access db")]
    DB,
    #[error("Sqlx")]
    Sqlx(#[from] sqlx::Error),
}

/// Represents a configuration value stored in the system.
///
/// # Variants
///
/// - `String`: Stores the configuration as a string.
/// - `Blob`: Stores the configuration as a binary blob.
///
/// # Example
///
/// ```rust
/// use server::config::ConfigOption;
/// let config_str = ConfigOption::String("example".to_string());
/// let config_blob = ConfigOption::Blob(vec![1, 2, 3, 4]);
/// ```
///
/// You can also convert `String` and `Vec<u8>` directly into `ConfigOption`
/// using the `From` trait:
///
/// ```rust
/// use server::config::ConfigOption;
/// let config: ConfigOption = "example".to_string().into();
/// let blob: ConfigOption = vec![1, 2, 3, 4].into();
/// ```
#[derive(Debug, From, PartialEq, Clone)]
pub enum ConfigOption {
    String(#[from] String),
    Blob(#[from] Vec<u8>),
}

impl fmt::Display for ConfigOption {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ConfigOption::String(s) => write!(f, "{s}"),
            ConfigOption::Blob(b) => write!(f, "ConfigOption<Blob>: \"{}\" bytes", b.len()),
        }
    }
}

/// Convert `ConfigOption` into a `&str` reference when the variant is a `String`.
///
/// # Panics
///
/// This will panic if the `ConfigOption` is of type `Blob`, as it cannot be
/// converted to a `&str`.
///
/// # Example
///
/// ```rust,should_panic
/// use server::config::ConfigOption;
/// let config = ConfigOption::Blob(vec![1, 2, 3]);
/// let str_ref: &str = config.as_ref(); // Will panic
/// ```
impl AsRef<str> for ConfigOption {
    fn as_ref(&self) -> &str {
        match self {
            ConfigOption::String(s) => s.as_str(),
            ConfigOption::Blob(_) => panic!("ConfigOption::Blob cannot be converted to &str"),
        }
    }
}

/// Dereference `ConfigOption::String` to `&str`.
///
/// This allows you to use `ConfigOption` directly in contexts where a `&str`
/// is expected, without having to manually call `.as_ref()`.
///
/// # Panics
///
/// This will panic if the `ConfigOption` is of type `Blob`.
///
/// # Example
///
/// ```rust,should_panic
/// use server::config::ConfigOption;
/// let config = ConfigOption::Blob(vec![1, 2, 3]);
/// let str_ref: &str = &*config; // Will panic
/// ```
impl Deref for ConfigOption {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        match self {
            ConfigOption::String(s) => s.as_str(),
            ConfigOption::Blob(_) => panic!("ConfigOption::Blob cannot be dereferenced as &str"),
        }
    }
}

/// Allows for the conversion from a `&str` to `ConfigOption`.
///
/// This is useful for passing string literals or string slices directly as `ConfigOption`.
/// The conversion will wrap the `&str` in the `ConfigOption::String` variant.
///
/// # Example
///
/// ```rust
/// use server::config::ConfigOption;
/// let config_option: ConfigOption = "example text".into();
/// assert_eq!(config_option, ConfigOption::String("example text".to_string()));
/// ```
impl From<&str> for ConfigOption {
    fn from(value: &str) -> Self {
        ConfigOption::String(value.to_string())
    }
}

/// Convert `ConfigOption` into a `&[u8]` reference when the variant is a `Blob`.
///
/// # Example
///
/// ```rust
/// use server::config::ConfigOption;
/// let config = ConfigOption::Blob(vec![1, 2, 3]);
/// let byte_ref: &[u8] = config.as_ref(); // Works
/// ```
impl AsRef<[u8]> for ConfigOption {
    fn as_ref(&self) -> &[u8] {
        match self {
            ConfigOption::String(s) => s.as_bytes(),
            ConfigOption::Blob(b) => b.as_slice(),
        }
    }
}

/// Fetches the `contents` of a field from the configdata.
///
/// This function attempts to retrieve the configuration stored in the
/// `configdata` table.  If the field is not found, it returns a
/// `ConfigError::NoConfig`.
///
/// # Arguments
///
/// - `field`: The name of the field to retrieve.
///
/// # Returns
///
/// - `Ok(Some(ConfigOption))` if the field exists.
/// - `Ok(None)` if the field doesn't exist.
/// - `Err(ConfigError)` if there is an error during retrieval.
///
/// # Example
///
/// ```rust,ignore
/// let config = system_configdata("example_field").await?;
/// if let Some(option) = config {
///     println!("Config value: {}", option);
/// }
/// ```
///
/// # Errors
///
/// Returns a `ConfigError::DB` if there is an issue with the database connection.
// The config read/write logic is identical for the system (admin DB) and
// per-user surfaces — only the connection differs. The `*_on` helpers take an
// explicit connection so both surfaces share one implementation; `User::config`
// / `User::set_config` (see `user.rs`) pass a per-user connection, while the
// `system_*` wrappers below pass the global admin connection.

async fn configdata_on(
    conn: &mut sqlx::PgConnection,
    field: &str,
) -> Result<Option<ConfigOption>, ConfigError> {
    let value = sqlx::query_file_scalar!("../server/sql/select/config/data.sql", field)
        .fetch_one(&mut *conn)
        .await
        .map_err(|err| {
            if let RowNotFound = err {
                ConfigError::NoConfig(String::from(field))
            } else {
                log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
                ConfigError::DB
            }
        })?;

    Ok(Some(ConfigOption::Blob(value)))
}

/// Reads a config field on the given connection: the `config` (string) table
/// first, falling back to `configdata` (blob).
///
/// # Errors
/// `ConfigError::DB` on a database error.
pub async fn config_on(
    conn: &mut sqlx::PgConnection,
    field: &str,
) -> Result<Option<ConfigOption>, ConfigError> {
    let value = sqlx::query_file_scalar!("../server/sql/select/config/string.sql", field)
        .fetch_one(&mut *conn)
        .await;
    match value {
        Ok(l) => Ok(Some(ConfigOption::String(l))),
        Err(RowNotFound) => configdata_on(conn, field).await,
        Err(err) => {
            log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
            Err(ConfigError::DB)
        }
    }
}

/// Upserts a config field on the given connection (string → `config`, blob →
/// `configdata`). The upsert keys on `lower(field)` (see the SQL), so it is
/// idempotent and case-insensitive.
///
/// # Errors
/// `ConfigError::DB` on a database error, `ConfigError::NoConfig` if the row is
/// missing for an update.
pub async fn set_config_on(
    conn: &mut sqlx::PgConnection,
    field: &str,
    contents: ConfigOption,
) -> Result<(), ConfigError> {
    let id = uuid::Uuid::new_v4();
    match contents {
        ConfigOption::String(s) => {
            sqlx::query_file!("../server/sql/set/config/string.sql", &id, field, s)
        }
        ConfigOption::Blob(b) => {
            sqlx::query_file!("../server/sql/set/config/blob.sql", &id, field, b)
        }
    }
    .execute(&mut *conn)
    .await
    .map_err(|err| {
        if let RowNotFound = err {
            ConfigError::NoConfig(String::from(field))
        } else {
            log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
            ConfigError::DB
        }
    })?;

    Ok(())
}

/// Reads a SYSTEM (server-wide) config field from the global admin database.
/// For server-wide keys (infra URLs, locale) and the bootstrap reads that run
/// before any user is resolved. Per-user config goes through `User::config`.
///
/// # Errors
/// `ConfigError::DB` on a database error.
pub async fn system_config(field: &str) -> Result<Option<ConfigOption>, ConfigError> {
    let mut conn = get_connection().await.map_err(|err| {
        log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
        ConfigError::DB
    })?;
    config_on(&mut conn, field).await
}

/// Reads a SYSTEM config blob field from the global admin database.
///
/// # Errors
/// `ConfigError::DB` on a database error.
pub async fn system_configdata(field: &str) -> Result<Option<ConfigOption>, ConfigError> {
    let mut conn = get_connection().await.map_err(|err| {
        log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
        ConfigError::DB
    })?;
    configdata_on(&mut conn, field).await
}

/// Writes a SYSTEM config field to the global admin database.
///
/// # Errors
/// `ConfigError::DB` on a database error.
pub async fn set_system_config(field: &str, contents: ConfigOption) -> Result<(), ConfigError> {
    let mut conn = get_connection().await.map_err(|err| {
        log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
        ConfigError::DB
    })?;
    set_config_on(&mut conn, field, contents).await
}

static LOCALE_NAME: LazyLock<String> = LazyLock::new(|| var("LANG").unwrap_or(String::from("en")));

pub async fn load_config() -> Result<(), ConfigError> {
    if let Ok(Some(locale)) = system_config("locale").await {
        rust_i18n::set_locale(&locale);
        log::info!(
            "{}",
            t!(
                "Loaded the %{loc} locale from config, setting as main",
                loc = &locale
            )
        );
    } else {
        rust_i18n::set_locale(&LOCALE_NAME);
    }
    Ok(())
}

#[cfg(test)]
mod config_tests {
    use super::*;
    use crate::db::DB_POOL;
    use sqlx::PgPool;
    use supp_macro::local_db_sqlx_test;
    use tokio::sync::OnceCell;

    /// Context for keeping environment intact
    static CONTEXT: OnceCell<()> = OnceCell::const_new();

    async fn setup() {
        CONTEXT
            .get_or_init(|| async {
                #[cfg(feature = "testlog")]
                let _ = env_logger::builder()
                    .is_test(true)
                    .filter_level(log::LevelFilter::Trace)
                    .try_init();
            })
            .await;
    }

    #[local_db_sqlx_test]
    async fn test_config_string(pool: PgPool) {
        let opt = ConfigOption::String("testval".to_string());
        set_system_config("testfield", opt.clone()).await.unwrap();
        let val = system_config("testfield").await.unwrap().unwrap();
        assert_eq!(val, opt);
    }

    #[local_db_sqlx_test]
    async fn test_config_configdata(pool: PgPool) {
        let opt = ConfigOption::Blob(vec![0, 1, 2, 3]);
        set_system_config("testblob", opt.clone()).await.unwrap();
        let val = system_config("testblob").await.unwrap().unwrap();
        assert_eq!(val, opt);
    }
}