Load env vars from file

.env-sample

@@ -1,4 +1,5 @@
-MONGODB_URI=
-PORT=
-SECRET_KEY=
-RSA_KEY=
+MONGODB_URI=mongodb://localhost:27017
+DATABASE_NAME=base-api
+SERVER_PORT=8080
+SECRET_KEY=thisisasupersecretkey
+RSA_KEY=thisisanothersupersecretkey

.vscode/launch.json

@@ -42,4 +42,4 @@
             "cwd": "${workspaceFolder}"
         }
     ]
-}
+}

.vscode/settings.json

@@ -1,6 +1,8 @@
 {
-    "peacock.remoteColor": "#dc322f",
-    "rust-analyzer.linkedProjects": [
-        "./Cargo.toml"
-    ]
-}
+  "peacock.remoteColor": "#dc322f",
+  "rust-analyzer.linkedProjects": ["./Cargo.toml"],
+  "cSpell.words": [
+    "dotenv",
+    "thisisanothersupersecretkey"
+  ]
+}

Cargo.toml

@@ -38,6 +38,8 @@ sqlx = { version = "~0.7", features = [ "runtime-tokio", "tls-native-tls", "post
 stoppable_thread = "~0.2"
 thiserror = "~1.0"
 tokio = { version = "~1.35", features = ["full"] }
+dotenv = "0.15.0"
+lazy_static = "1.4.0"
 
 [dev-dependencies]
 env_logger = "~0.10"

Readme.md

@@ -2,10 +2,16 @@
 RS Base API is a boilerplate to quickstart your backend in Rust.
 As of today, it provides basic user management routes and communicates with MongoDB.
 
+# To run
+```shell
+cp .env-sample .env
+# Edit .env file according to your setup
+```
+
 # Roadmap
 
 * Implement Sentry
 * Send account management e-mails: AWS SES/Scaleway
 * Make a generic store
-* Handle another DB like SQL
+* Handle another DB like [PostgreSQL](https://github.com/launchbadge/sqlx/blob/main/examples/postgres/json/src/main.rs)
 * Develop a CLI to generate code interactively: clap

src/controllers/authentication.rs

@@ -1,6 +1,6 @@
 use crate::controllers::error::*;
 use crate::models::users::{self, User};
-use crate::{ProgramAppState, DB_NAME};
+use crate::{ProgramAppState, DATABASE_NAME};
 use actix_web::{
     dev::ServiceRequest,
     http::StatusCode,
@@ -36,15 +36,15 @@ pub(crate) async fn authentication(
     req_body: web::Json<users::AuthReq>,
 ) -> impl Responder {
     //println!("{} {}", req_body.email, req_body.password);
-    let secret_key = "supersecret"; //TODO: std::env::var("RSA_KEY");
+    let secret_key =
+        &std::env::var("RSA_KEY").unwrap_or_else(|_| "thisisanothersupersecretkey".into());
 
     let now = chrono::Utc::now();
     let iat = now.timestamp() as usize;
     let exp = (now + chrono::Duration::days(1)).timestamp() as usize;
-
     let collection: Collection<users::User> = app_state
         .mongo_db_client
-        .database(DB_NAME)
+        .database(&DATABASE_NAME)
         .collection(users::REPOSITORY_NAME);
     match collection
         .find_one(doc! { "email": &req_body.email.to_string() }, None)
@@ -92,7 +92,8 @@ pub struct ErrorResponse {
 }
 
 pub fn check_jwt(token: String) -> Result<TokenClaims, (StatusCode, Json<ErrorResponse>)> {
-    let secret_key = "supersecret"; //TODO: std::env::var("RSA_KEY");
+    let secret_key =
+        &std::env::var("RSA_KEY").unwrap_or_else(|_| "thisisanothersupersecretkey".into());
 
     let claims = decode::<TokenClaims>(
         &token,
@@ -269,7 +270,7 @@ impl AuthState {
     async fn get_user_info(&self, user_id: String) -> Result<User, Error> {
         let collection: Collection<users::User> = self
             .mongo_db
-            .database(DB_NAME)
+            .database(&DATABASE_NAME)
             .collection(users::REPOSITORY_NAME);
         let user_object_id = ObjectId::parse_str(user_id).unwrap();
         match collection

src/controllers/users.rs

@@ -3,7 +3,7 @@ use std::str::FromStr;
 use crate::{
     controllers::authentication::Authenticated,
     models::users::{self, User},
-    ProgramAppState, DB_NAME,
+    ProgramAppState, DATABASE_NAME,
 };
 use actix_web::{delete, get, post, put, web, HttpResponse};
 use json;
@@ -30,7 +30,7 @@ pub async fn create_user(
         Some(user) => {
             let collection: Collection<User> = app_state
                 .mongo_db_client
-                .database(DB_NAME)
+                .database(&DATABASE_NAME)
                 .collection(users::REPOSITORY_NAME);
             let result = collection.insert_one(user, None).await;
             match result {
@@ -42,7 +42,7 @@ pub async fn create_user(
                 }
             }
         }
-        None => HttpResponse::InternalServerError().body("Parsing error"),
+        None => HttpResponse::InternalServerError().body("Invalid input"),
     }
 }
 
@@ -61,7 +61,7 @@ pub async fn get_user_by_email(
     let email = email.into_inner();
     let collection: Collection<users::User> = app_state
         .mongo_db_client
-        .database(DB_NAME)
+        .database(&DATABASE_NAME)
         .collection(users::REPOSITORY_NAME);
     match collection.find_one(doc! { "email": &email }, None).await {
         Ok(Some(user)) => HttpResponse::Ok().json(user.sanitize()),
@@ -91,7 +91,7 @@ pub async fn update_user(
         Some(new_user) => {
             let collection: Collection<User> = app_state
                 .mongo_db_client
-                .database(DB_NAME)
+                .database(&DATABASE_NAME)
                 .collection(users::REPOSITORY_NAME);
 
             let user_obj_id = mongodb::bson::oid::ObjectId::from_str(&user_id).unwrap();
@@ -123,7 +123,7 @@ pub async fn update_user(
                 }
             }
         }
-        None => HttpResponse::InternalServerError().body("User from json error"),
+        None => HttpResponse::InternalServerError().body("Invalid input"),
     }
 }
 
@@ -137,7 +137,7 @@ pub async fn delete_user_by_id(
     let user_obj_id = mongodb::bson::oid::ObjectId::from_str(&id).unwrap();
     let collection: Collection<users::User> = app_state
         .mongo_db_client
-        .database(DB_NAME)
+        .database(&DATABASE_NAME)
         .collection(users::REPOSITORY_NAME);
     match collection
         .delete_one(doc! { "_id": &user_obj_id }, None)

src/drivers/mod.rs

@@ -1,16 +1,20 @@
 use crate::services::emails;
 use anyhow::bail;
 use async_trait::async_trait;
+use lazy_static::lazy_static;
 use mongodb::{error::ErrorKind, Client as mgoClient};
 // use sqlx::postgres::PgPool;
 
 use crate::models::users::{self, User};
 
-const DB_NAME: &str = "base-api";
-
 pub mod mongo;
 pub mod postgre;
 
+lazy_static! {
+    static ref DATABASE_NAME: String =
+        std::env::var("DATABASE_NAME").unwrap_or_else(|_| "base-api".into());
+}
+
 #[derive(Debug)]
 pub struct GenericDatabaseStatus {
     pub kind: String,
@@ -40,7 +44,9 @@ impl MongoDatabase {
     pub async fn seed_user(&self, user: User) -> anyhow::Result<&Self> {
         match &self.client {
             Some(client) => {
-                let collection = client.database(DB_NAME).collection(users::REPOSITORY_NAME);
+                let collection = client
+                    .database(&DATABASE_NAME)
+                    .collection(users::REPOSITORY_NAME);
                 match collection.insert_one(user.clone(), None).await {
                     Ok(_) => {
                         let _ = emails::send_email_with_aws_ses(&user.email, "Welcome", "Message")

src/main.rs

@@ -13,6 +13,8 @@ use actix_cors::Cors;
 use actix_identity::IdentityMiddleware;
 use actix_web::{http, middleware, web, App, HttpServer};
 use argon2::Config;
+use dotenv::dotenv;
+use lazy_static::lazy_static;
 use mongodb::{bson::oid::ObjectId, Client};
 use services::ntp::Ntp;
 use tokio::sync::broadcast;
@@ -26,7 +28,12 @@ use crate::{
     services::ntp,
 };
 
-const DB_NAME: &str = "base-api";
+lazy_static! {
+    static ref MONGODB_URI: String =
+        std::env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://localhost:27017".into());
+    static ref DATABASE_NAME: String =
+        std::env::var("DATABASE_NAME").unwrap_or_else(|_| "base-api".into());
+}
 
 /// The maximum size of a package the server will accept.
 pub const MAX_FRAME_SIZE: usize = 250_000_000; // 250Mb
@@ -44,6 +51,7 @@ pub struct ProgramAppState {
 
 #[actix_web::main]
 async fn main() -> anyhow::Result<()> {
+    dotenv().ok();
     env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
     // Start NTP and define the timestamp format
@@ -75,9 +83,9 @@ async fn main() -> anyhow::Result<()> {
             anyhow::bail!("Failed to connect mongo with drivers: {:?}", error)
         }
     }
-    models::users::create_email_index(&mongo_db_client, DB_NAME).await;
+    models::users::create_email_index(&mongo_db_client, &DATABASE_NAME).await;
 
-    let salt = std::env::var("SECRET_KEY").unwrap_or_else(|_| "0123".repeat(16));
+    let salt = &std::env::var("SECRET_KEY").unwrap_or_else(|_| "thisisasupersecretkey".into());
 
     let hashed_password =
         argon2::hash_encoded("password".as_bytes(), salt.as_bytes(), &Config::original()).unwrap();
@@ -115,7 +123,7 @@ async fn main() -> anyhow::Result<()> {
 
     let time_thread = app_state.ntp.start_time_thread(app_state.clone());
 
-    let port: u16 = std::env::var("PORT")
+    let port: u16 = std::env::var("SERVER_PORT")
         .unwrap_or_else(|_| "8080".into())
         .parse()
         .unwrap();

src/models/users.rs

@@ -84,10 +84,13 @@ impl User {
                     }
                 }
             }
-            None => log::warn!("No organization id for: {email}"),
+            None => {
+                log::warn!("No organization id for: {email}");
+                return None;
+            }
         }
 
-        let salt = std::env::var("SECRET_KEY").unwrap_or_else(|_| "0123".repeat(16));
+        let salt = &std::env::var("SECRET_KEY").unwrap_or_else(|_| "thisisasupersecretkey".into());
         let config = Config::default();
         let hashed_password =
             argon2::hash_encoded(password.as_bytes(), salt.as_bytes(), &config).unwrap();

src/test.rs

@@ -20,7 +20,7 @@ async fn test() {
 
     // Clear any data currently in the users collection.
     client
-        .database(DB_NAME)
+        .database(&DATABASE_NAME)
         .collection::<User>(users::REPOSITORY_NAME)
         .drop(None)
         .await