chore: fun

Author: devdanco

Cargo.lock

@@ -27,6 +27,7 @@ rustflags = ["-C", "link-arg=-fuse-ld=/opt/homebrew/opt/llvm/bin/ld64.lld"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+serde-aux = "4"
 tracing-actix-web = "0.7"
 secrecy = { version = "0.8", features = ["serde"] }
 tracing-log = "0.1"

Cargo.toml

@@ -1,2 +1,4 @@
 application:
-  host: 127.0.0.1
+  host: 127.0.0.1
+database:
+  require_ssl: false

configuration/local.yml

@@ -1,2 +1,4 @@
 application:
-  host: 0.0.0.0
+  host: 0.0.0.0
+database:
+  require_ssl: true

configuration/production.yml

@@ -25,4 +25,27 @@ services:
     instance_size_slug: basic-xxs
     # All incoming requests should be routed to our app
     routes:
-      - path: /
+      - path: /
+    envs:
+      - key: APP_DATABASE__USERNAME
+        scope: RUN_TIME
+        value: ${newsletter.USERNAME}
+      - key: APP_DATABASE__PASSWORD
+        scope: RUN_TIME
+        value: ${newsletter.PASSWORD}
+      - key: APP_DATABASE__HOST
+        scope: RUN_TIME
+        value: ${newsletter.HOSTNAME}
+      - key: APP_DATABASE__PORT
+        scope: RUN_TIME
+        value: ${newsletter.PORT}
+      - key: APP_DATABASE__DATABASE_NAME
+        scope: RUN_TIME
+        value: ${newsletter.DATABASE}
+databases:
+  # PG = Postgres
+  - engine: PG
+    # Database name
+    name: newsletter
+    # Again, let's keep the bill lean
+    num_nodes: 1

migrations/20231203144603_create_subscriptions_table.sql

@@ -1,5 +1,7 @@
 use secrecy::ExposeSecret;
 use secrecy::Secret;
+use sqlx::postgres::{PgConnectOptions, PgSslMode};
+use serde_aux::field_attributes::deserialize_number_from_string;
 
 #[derive(serde::Deserialize)]
 pub struct Settings {
@@ -9,6 +11,7 @@ pub struct Settings {
 
 #[derive(serde::Deserialize)]
 pub struct ApplicationSettings {
+    #[serde(deserialize_with = "deserialize_number_from_string")]
     pub port: u16,
     pub host: String,
 }
@@ -17,9 +20,11 @@ pub struct ApplicationSettings {
 pub struct DatabaseSettings {
     pub username: String,
     pub password: Secret<String>,
+    #[serde(deserialize_with = "deserialize_number_from_string")]
     pub port: u16,
     pub host: String,
     pub database_name: String,
+    pub require_ssl: bool,
 }
 
 pub enum Environment {
@@ -51,25 +56,22 @@ impl TryFrom<String> for Environment {
     }
 }
 impl DatabaseSettings {
-    pub fn connection_string(&self) -> Secret<String> {
-        Secret::new(format!(
-            "postgres://{}:{}@{}:{}/{}",
-            self.username,
-            self.password.expose_secret(),
-            self.host,
-            self.port,
-            self.database_name
-        ))
+    pub fn without_db(&self) -> PgConnectOptions {
+        let ssl_mode = if self.require_ssl {
+            PgSslMode::Require
+        } else {
+            PgSslMode::Prefer
+        };
+        PgConnectOptions::new()
+            .host(&self.host)
+            .username(&self.username)
+            .password(self.password.expose_secret())
+            .port(self.port)
+            .ssl_mode(ssl_mode)
     }
 
-    pub fn connection_string_without_db(&self) -> Secret<String> {
-        Secret::new(format!(
-            "postgres://{}:{}@{}:{}",
-            self.username,
-            self.password.expose_secret(),
-            self.host,
-            self.port
-        ))
+    pub fn with_db(&self) -> PgConnectOptions {
+        self.without_db().database(&self.database_name)
     }
 }
 
@@ -84,12 +86,17 @@ pub fn get_configuration() -> Result<Settings, config::ConfigError> {
         .expect("Failed to parse APP_ENVIRONMENT.");
     let environment_filename = format!("{}.yml", environment.as_str());
     let settings = config::Config::builder()
-        .add_source(config::File::from(
-            configuration_directory.join("base.yml"),
-        ))
+        .add_source(config::File::from(configuration_directory.join("base.yml")))
         .add_source(config::File::from(
             configuration_directory.join(environment_filename),
         ))
+        // Add in settings from environment variables (with a prefix of APP and '__' as separator)
+        // E.g. `APP_APPLICATION__PORT=5001 would set `Settings.application.port`
+        .add_source(
+            config::Environment::with_prefix("APP")
+                .prefix_separator("_")
+                .separator("__"),
+        )
         .build()?;
     settings.try_deserialize::<Settings>()
 }

migrations/20231203202412_create_subscriptions_table.sql

@@ -1,17 +1,15 @@
 use rust_learn_api::configuration::get_configuration;
 use rust_learn_api::startup::run;
 use rust_learn_api::telemetry::{get_subscriber, init_subscriber};
-use secrecy::ExposeSecret;
-use sqlx::PgPool;
 use std::net::TcpListener;
+use sqlx::postgres::PgPoolOptions;
 
 #[tokio::main]
 async fn main() -> Result<(), std::io::Error> {
     let subscriber = get_subscriber("rust-learn-api".into(), "info".into(), std::io::stdout);
     init_subscriber(subscriber);
     let config = get_configuration().expect("Failed to read configuration.");
-    let db_pool = PgPool::connect_lazy(&config.database.connection_string().expose_secret())
-        .expect("Failed to connect to Postgres.");
+    let db_pool = PgPoolOptions::new().connect_lazy_with(config.database.with_db());
     let address = format!("{}:{}", config.application.host, config.application.port);
     let listener = TcpListener::bind(address)?;
     run(listener, db_pool).await?.await

spec.yaml

@@ -39,11 +39,11 @@ pub async fn insert_subscriber(pool: &PgPool, form: &FormData) -> Result<(), sql
         form.name,
         Utc::now()
     )
-    .execute(pool)
-    .await
-    .map_err(|e| {
-        tracing::error!("Failed to execute query: {:?}", e);
-        e
-    })?;
+        .execute(pool)
+        .await
+        .map_err(|e| {
+            tracing::error!("Failed to execute query: {:?}", e);
+            e
+        })?;
     Ok(())
 }

src/configuration.rs

@@ -115,21 +115,16 @@ async fn spawn_app() -> TestApp {
     }
 }
 
-pub async fn configure_database(config: &DatabaseSettings) -> PgPool {
-    // Create database
-    let mut connection =
-        PgConnection::connect(&config.connection_string_without_db().expose_secret())
-            .await
-            .expect("Failed to connect to Postgres");
-    connection
-        .execute(format!(r#"CREATE DATABASE "{}";"#, config.database_name).as_str())
+pub async fn configure_database(config: &DatabaseSettings) -> PgPool { // Create database
+    let mut connection = PgConnection::connect_with(&config.without_db())
         .await
+        .expect("Failed to connect to Postgres");
+    connection
+        .execute(format!(r#"CREATE DATABASE "{}";"#, config.database_name).as_str()) .await
         .expect("Failed to create database.");
     // Migrate database
-    let connection_pool = PgPool::connect(&config.connection_string().expose_secret())
-        .await
-        .expect("Failed to connect to Postgres.");
-    sqlx::migrate!("./migrations")
+    let connection_pool = PgPool::connect_with(config.with_db()) .await
+        .expect("Failed to connect to Postgres."); sqlx::migrate!("./migrations")
         .run(&connection_pool)
         .await
         .expect("Failed to migrate the database");