Move config to its own file

Author: OverHash

.env.example

@@ -1,6 +1,9 @@
-# The database URL
+# The database URL to use when compiling.
+# WARNING: This value is only used at compile time. To configure the runtime
+# behavior of database connection, see the below parameters.
 DATABASE_URL = "postgres://postgres:password@localhost/supermarket_tracker"
 
 DATABASE_USER = "postgres"
 DATABASE_PASSWORD = "password"
+DATABASE_HOST = "localhost"
 DATABASE_NAME = "supermarket_tracker"

Cargo.lock

@@ -34,6 +34,7 @@ tracing-subscriber = { version = "0.3.18", default-features = false, features =
 	"fmt",
 	"env-filter",
 ] }
+secrecy = "0.8.0"
 
 [lints.clippy]
 cargo = "deny"

Cargo.toml

@@ -0,0 +1,143 @@
+use std::{
+    collections::HashSet,
+    env,
+    ffi::OsStr,
+    fmt::{Debug, Display},
+};
+
+use error_stack::{Context, Result, ResultExt};
+use secrecy::{ExposeSecret, Secret};
+use sqlx::postgres::PgConnectOptions;
+
+use crate::supermarket::{get_supermarket_type, Supermarket};
+
+pub struct Config {
+    pub(crate) application: ApplicationConfig,
+    pub(crate) database: DatabaseConfig,
+}
+
+#[allow(clippy::module_name_repetitions)]
+pub struct ApplicationConfig {
+    /// The supermarket we are targeting to get price information for.
+    pub(crate) supermarket: Supermarket,
+}
+
+#[allow(clippy::module_name_repetitions)]
+pub struct DatabaseConfig {
+    /// If we should insert information into the Postgres database, or if we
+    /// are in read-only mode.
+    pub(crate) should_insert: bool,
+    /// The username to use when connect to the Postgres database.
+    ///
+    /// Common values include `postgres`.
+    username: String,
+    /// The password to use when connecting to the Postgres database.
+    password: Secret<String>,
+    /// The host to use to connect to the database. Commonly `localhost`.
+    host: String,
+    /// The name of the database to use. Commonly `supermarket_tracker`.
+    name: String,
+}
+
+#[derive(Debug)]
+#[allow(clippy::module_name_repetitions)]
+pub enum ConfigError {
+    /// The variable that was missing when trying to load it.
+    LoadVariable { variable: String },
+    InvalidOption {
+        /// The invalid option the user passed.
+        option: String,
+    },
+}
+
+impl Display for ConfigError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::LoadVariable { variable } => {
+                write!(f, "Failed to load environment variable '{variable}'")
+            }
+            Self::InvalidOption { option } => write!(f, "Invalid option '{option}'"),
+        }
+    }
+}
+impl Context for ConfigError {}
+
+impl Config {
+    /// Reads configuration values from environment and arguments passed to the application.
+    ///
+    /// # Errors
+    /// - If unable to load a section of the config.
+    pub fn read_from_env() -> Result<Self, ConfigError> {
+        dotenvy::dotenv().ok();
+        let args = env::args().skip(1).collect::<Vec<_>>();
+
+        Ok(Self {
+            application: ApplicationConfig::read_from_env(&args)
+                .attach_printable("When loading application configuration")?,
+            database: DatabaseConfig::read_from_env(&args)
+                .attach_printable("When loading database configuration")?,
+        })
+    }
+}
+
+impl ApplicationConfig {
+    /// Reads the application configuration from environment variables passed
+    /// as the primary argument.
+    ///
+    /// # Errors
+    /// Errors if the user provides an invalid `--supermarket` option.
+    fn read_from_env(args: &[String]) -> Result<Self, ConfigError> {
+        let supermarket =
+            get_supermarket_type(args).change_context(ConfigError::InvalidOption {
+                option: "--supermarket".to_string(),
+            })?;
+
+        Ok(Self { supermarket })
+    }
+}
+
+fn load_env<U>(variable: U) -> Result<String, ConfigError>
+where
+    U: AsRef<OsStr> + Into<String> + Clone,
+{
+    env::var(variable.clone()).change_context(ConfigError::LoadVariable {
+        variable: variable.into(),
+    })
+}
+
+impl DatabaseConfig {
+    /// Reads the database configuration from environment variables passed as
+    /// the primary argument.
+    fn read_from_env(args: &[String]) -> Result<Self, ConfigError> {
+        let user = load_env("DATABASE_USER")?;
+        let password = load_env("DATABASE_PASSWORD").map(Secret::new)?;
+        let host = load_env("DATABASE_HOST")?;
+        let name = load_env("DATABASE_NAME")?;
+
+        let hashed_args = args.iter().collect::<HashSet<_>>();
+        let no_insert = hashed_args.contains(&"--no-insert".to_string());
+
+        Ok(Self {
+            should_insert: !no_insert,
+
+            username: user,
+            password,
+            host,
+            name,
+        })
+    }
+
+    /// Generates the Postgres connection string to use to connect to the
+    /// database.
+    ///
+    /// Because this string contains the database password, it is wrapped with
+    /// the [`Secret`] type.
+    pub fn connection_string(&self) -> PgConnectOptions {
+        PgConnectOptions::new()
+            .application_name("supermarket-tracker")
+            .database(&self.name)
+            .host(&self.host)
+            .password(self.password.expose_secret())
+            .username(&self.username)
+    }
+}

src/config.rs

@@ -5,11 +5,8 @@ use error_stack::Context;
 #[derive(Debug)]
 #[allow(clippy::module_name_repetitions)]
 pub enum ApplicationError {
-    /// Invalid user option provided to the binary
-    InvalidOption {
-        /// The option which was invalid
-        option: String,
-    },
+    /// Failed to load configuration data
+    Config,
     /// Failed to connect to the database
     DatabaseConnectError,
     /// Failed to initialize the database with the initial tables
@@ -31,7 +28,7 @@ pub enum ApplicationError {
 impl fmt::Display for ApplicationError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ApplicationError::InvalidOption { option } => write!(f, "Invalid option '{option}'"),
+            ApplicationError::Config => write!(f, "Failed to load configuration"),
             ApplicationError::DatabaseConnectError => write!(f, "Failed to connect to database"),
             ApplicationError::DatabaseInitializeError => {
                 write!(f, "Failed to initialize database")

src/error.rs

@@ -5,6 +5,7 @@ use sqlx::{Pool, Postgres};
 ///
 /// # Errors
 /// If unable to migrate the database.
+#[tracing::instrument(name = "initialize database", level = "debug", skip_all)]
 pub async fn initialize_database(conn: &Pool<Postgres>) -> Result<(), sqlx::migrate::MigrateError> {
     sqlx::migrate!().run(conn).await?;
 

src/initialize_database.rs

@@ -1,14 +1,13 @@
-use std::collections::HashSet;
-use std::env;
 use std::time::Duration;
 
 use dotenvy::dotenv;
 use error_stack::{Result, ResultExt};
 use sqlx::postgres::PgPoolOptions;
 
+use crate::config::Config;
 use crate::error::ApplicationError;
 use crate::initialize_database::initialize_database;
-use crate::supermarket::{get_supermarket_type, Supermarket};
+use crate::supermarket::Supermarket;
 use crate::telemetry::init_subscriber;
 
 pub const CACHE_PATH: &str = "cache.json";
@@ -17,6 +16,7 @@ const PAGE_ITERATION_INTERVAL: Duration = Duration::from_millis(500);
 /// The amount of requests to perform in parallel.
 const CONCURRENT_REQUESTS: i64 = 12;
 
+mod config;
 mod countdown;
 mod error;
 mod initialize_database;
@@ -32,32 +32,23 @@ async fn main() -> Result<(), ApplicationError> {
     // ignore any error attempting to load .env file
     dotenv().ok();
 
-    let args: Vec<_> = env::args().skip(1).collect();
-    let hashed_args: HashSet<String> = args.iter().cloned().collect();
-
-    let no_insert = hashed_args.contains("--no-insert");
-
-    let supermarket_type =
-        get_supermarket_type(&args).change_context(ApplicationError::InvalidOption {
-            option: String::from("--supermarket"),
-        })?;
+    let config = Config::read_from_env().change_context(ApplicationError::Config)?;
 
     // connect to database
-    let database_url =
-        env::var("DATABASE_URL").change_context(ApplicationError::DatabaseConnectError)?;
+    tracing::debug!("Connecting to database");
     let connection = PgPoolOptions::new()
         .max_connections(5)
-        .connect(&database_url)
+        .connect_with(config.database.connection_string())
         .await
         .change_context(ApplicationError::DatabaseConnectError)?;
-
     tracing::debug!("Connected to database");
+
     initialize_database(&connection)
         .await
         .change_context(ApplicationError::DatabaseInitializeError)?;
 
-    match supermarket_type {
-        Supermarket::Countdown => countdown::run(connection, no_insert).await,
+    match config.application.supermarket {
+        Supermarket::Countdown => countdown::run(connection, config.database.should_insert).await,
         Supermarket::NewWorld => new_world::run().await,
     }
 }