chore: get rid of direct DB init and use db_*

src/api/v1/account/delete.rs

@@ -36,7 +36,7 @@ pub async fn delete_account(
     let username = id.identity().unwrap();
 
     let hash = data
-        .dblib
+        .db
         .get_password(&db_core::Login::Username(&username))
         .await?;
 
@@ -54,7 +54,7 @@ pub mod runners {
     use super::*;
 
     pub async fn delete_user(name: &str, data: &AppData) -> ServiceResult<()> {
-        data.dblib.delete_user(name).await?;
+        data.db.delete_user(name).await?;
         Ok(())
     }
 }

src/api/v1/account/email.rs

@@ -33,7 +33,7 @@ pub async fn email_exists(
     payload: web::Json<AccountCheckPayload>,
     data: AppData,
 ) -> ServiceResult<impl Responder> {
-    let exists = data.dblib.email_exists(&payload.val).await?;
+    let exists = data.db.email_exists(&payload.val).await?;
 
     let resp = AccountCheckResp { exists };
 
@@ -59,7 +59,7 @@ async fn set_email(
         new_email: &payload.email,
     };
 
-    data.dblib.update_email(&update_email).await?;
+    data.db.update_email(&update_email).await?;
 
     Ok(HttpResponse::Ok())
 }

src/api/v1/account/password.rs

@@ -60,7 +60,7 @@ async fn update_password_runner(
         hash: new_hash,
     };
 
-    data.dblib.update_password(&p).await?;
+    data.db.update_password(&p).await?;
     Ok(())
 }
 
@@ -80,7 +80,7 @@ async fn update_user_password(
     let username = id.identity().unwrap();
 
     // TODO: verify behavior when account is not found
-    let res = data.dblib.get_password(&Login::Username(&username)).await?;
+    let res = data.db.get_password(&Login::Username(&username)).await?;
 
     if Config::verify(&res.hash, &payload.password)? {
         let update: UpdatePassword = payload.into_inner().into();

src/api/v1/account/secret.rs

@@ -28,7 +28,7 @@ use crate::AppData;
 )]
 async fn get_secret(id: Identity, data: AppData) -> ServiceResult<impl Responder> {
     let username = id.identity().unwrap();
-    let secret = data.dblib.get_secret(&username).await?;
+    let secret = data.db.get_secret(&username).await?;
     Ok(HttpResponse::Ok().json(secret))
 }
 
@@ -47,7 +47,7 @@ async fn update_user_secret(
     loop {
         secret = get_random(32);
 
-        match data.dblib.update_secret(&username, &secret).await {
+        match data.db.update_secret(&username, &secret).await {
             Ok(_) => break,
             Err(DBError::SecretTaken) => continue,
             Err(e) => return Err(e.into()),

src/api/v1/account/username.rs

@@ -38,7 +38,7 @@ pub mod runners {
         payload: &AccountCheckPayload,
         data: &AppData,
     ) -> ServiceResult<AccountCheckResp> {
-        let exists = data.dblib.username_exists(&payload.val).await?;
+        let exists = data.db.username_exists(&payload.val).await?;
 
         Ok(AccountCheckResp { exists })
     }
@@ -63,7 +63,7 @@ async fn set_username(
 
     let processed_uname = data.creds.username(&payload.username)?;
 
-    data.dblib
+    data.db
         .update_username(&username, &processed_uname)
         .await?;
 

src/api/v1/auth.rs

@@ -99,11 +99,11 @@ pub mod runners {
         };
 
         let s = if payload.login.contains('@') {
-            data.dblib
+            data.db
                 .get_password(&db_core::Login::Email(&payload.login))
                 .await?
         } else {
-            data.dblib
+            data.db
                 .get_password(&db_core::Login::Username(&payload.login))
                 .await?
         };
@@ -141,7 +141,7 @@ pub mod runners {
                 secret: &secret,
             };
 
-            match data.dblib.register(&p).await {
+            match data.db.register(&p).await {
                 Ok(_) => break,
                 Err(DBError::SecretTaken) => continue,
                 Err(e) => return Err(e.into()),

src/api/v1/mcaptcha/create.rs

@@ -81,13 +81,13 @@ pub mod runner {
                 duration,
             };
 
-            match data.dblib.create_captcha(username, &p).await {
+            match data.db.create_captcha(username, &p).await {
                 Ok(_) => break,
                 Err(DBError::SecretTaken) => continue,
                 Err(e) => return Err(e.into()),
             }
         }
-        data.dblib
+        data.db
             .add_captcha_levels(username, &key, &payload.levels)
             .await?;
         let mcaptcha_config = MCaptchaDetails {

src/api/v1/mcaptcha/delete.rs

@@ -43,13 +43,13 @@ async fn delete(
 
     let username = id.identity().unwrap();
 
-    let hash = data.dblib.get_password(&Login::Username(&username)).await?;
+    let hash = data.db.get_password(&Login::Username(&username)).await?;
 
     if !Config::verify(&hash.hash, &payload.password)? {
         return Err(ServiceError::WrongPassword);
     }
     let payload = payload.into_inner();
-    data.dblib.delete_captcha(&username, &payload.key).await?;
+    data.db.delete_captcha(&username, &payload.key).await?;
 
     if let Err(err) = data.captcha.remove(RemoveCaptcha(payload.key)).await {
         log::error!("Error while trying to remove captcha from cache {}", err);

src/api/v1/mcaptcha/easy.rs

@@ -130,7 +130,7 @@ async fn create(
     };
 
     let mcaptcha_config = create_runner(&msg, &data, &username).await?;
-    data.dblib
+    data.db
         .add_traffic_pattern(&username, &mcaptcha_config.key, &pattern)
         .await?;
     Ok(HttpResponse::Ok().json(mcaptcha_config))
@@ -166,11 +166,11 @@ async fn update(
 
     update_captcha_runner(&msg, &data, &username).await?;
 
-    data.dblib
+    data.db
         .delete_traffic_pattern(&username, &msg.key)
         .await?;
 
-    data.dblib
+    data.db
         .add_traffic_pattern(&username, &msg.key, &pattern)
         .await?;
 

src/api/v1/mcaptcha/get.rs

@@ -35,7 +35,7 @@ pub async fn get_captcha(
 ) -> ServiceResult<impl Responder> {
     let username = id.identity().unwrap();
     let levels = data
-        .dblib
+        .db
         .get_captcha_levels(Some(&username), &payload.key)
         .await?;
     Ok(HttpResponse::Ok().json(levels))

src/api/v1/mcaptcha/update.rs

@@ -44,7 +44,7 @@ pub async fn update_key(
         key = get_random(32);
 
         match data
-            .dblib
+            .db
             .update_captcha_key(&username, &payload.key, &key)
             .await
         {
@@ -113,7 +113,7 @@ pub mod runner {
         // still, needs to be benchmarked
         defense.build()?;
 
-        data.dblib
+        data.db
             .delete_captcha_levels(username, &payload.key)
             .await?;
 
@@ -123,9 +123,9 @@ pub mod runner {
             description: &payload.description,
         };
 
-        data.dblib.update_captcha_metadata(username, &m).await?;
+        data.db.update_captcha_metadata(username, &m).await?;
 
-        data.dblib
+        data.db
             .add_captcha_levels(username, &payload.key, &payload.levels)
             .await?;
         if let Err(ServiceError::CaptchaError(e)) = data

src/api/v1/meta.rs

@@ -75,7 +75,7 @@ impl Health {
 async fn health(data: AppData) -> impl Responder {
     let mut resp_builder = HealthBuilder::default();
 
-    resp_builder.db(data.dblib.ping().await);
+    resp_builder.db(data.db.ping().await);
 
     if let SystemGroup::Redis(_) = data.captcha {
         if let Ok(r) = Redis::new(RedisConfig::Single(

src/api/v1/notifications/add.rs

@@ -51,7 +51,7 @@ pub async fn add_notification(
         heading: &payload.heading,
     };
 
-    data.dblib.create_notification(&p).await?;
+    data.db.create_notification(&p).await?;
 
     Ok(HttpResponse::Ok())
 }

src/api/v1/notifications/get.rs

@@ -70,7 +70,7 @@ pub async fn get_notification(
     let receiver = id.identity().unwrap();
     // TODO handle error where payload.to doesnt exist
 
-    let notifications = data.dblib.get_all_unread_notifications(&receiver).await?;
+    let notifications = data.db.get_all_unread_notifications(&receiver).await?;
     let notifications = NotificationResp::from_notifications(notifications);
     Ok(HttpResponse::Ok().json(notifications))
 }

src/api/v1/notifications/mark_read.rs

@@ -41,7 +41,7 @@ pub async fn mark_read(
     // TODO handle error where payload.to doesnt exist
 
     // TODO get payload from path /api/v1/notifications/{id}/read"
-    data.dblib
+    data.db
         .mark_notification_read(&receiver, payload.id)
         .await?;
 

src/api/v1/pow/get_config.rs

@@ -42,7 +42,7 @@ pub async fn get_config(
     data: AppData,
 ) -> ServiceResult<impl Responder> {
     //if res.exists.is_none() {
-    if !data.dblib.captcha_exists(None, &payload.key).await? {
+    if !data.db.captcha_exists(None, &payload.key).await? {
         return Err(ServiceError::TokenNotFound);
     }
     let payload = payload.into_inner();
@@ -100,8 +100,8 @@ pub async fn get_config(
 /// creates [MCaptcha][libmcaptcha::MCaptcha] and adds it to [Master][libmcaptcha::Defense]
 async fn init_mcaptcha(data: &AppData, key: &str) -> ServiceResult<()> {
     // get levels
-    let levels = data.dblib.get_captcha_levels(None, key).await?;
+    let levels = data.db.get_captcha_levels(None, key).await?;
-    let duration = data.dblib.get_captcha_cooldown(&key).await?;
+    let duration = data.db.get_captcha_cooldown(&key).await?;
 
     // build defense
     let mut defense = DefenseBuilder::default();

src/data.rs

@@ -41,7 +41,6 @@ use libmcaptcha::{
     system::{System, SystemBuilder},
 };
 use sqlx::postgres::PgPoolOptions;
-use sqlx::PgPool;
 
 use db_core::MCDatabase;
 
@@ -150,7 +149,7 @@ impl SystemGroup {
 /// App data
 pub struct Data {
     /// database ops defined by db crates
-    pub dblib: Box<dyn MCDatabase>,
+    pub db: Box<dyn MCDatabase>,
     /// credential management configuration
     pub creds: Config,
     /// mCaptcha system: Redis cache, etc.
@@ -186,20 +185,14 @@ impl Data {
             log::info!("Initialized credential manager");
         });
 
-        //        let db = PgPoolOptions::new()
-        //            .max_connections(s.database.pool)
-        //            .connect(&s.database.url)
-        //            .await
-        //            .expect("Unable to form database pool");
-
          let pool = s.database.pool;
         let pool_options = PgPoolOptions::new().max_connections(pool);
         let connection_options = ConnectionOptions::Fresh(Fresh {
             pool_options,
             url: s.database.url.clone(),
         });
-        let dblib = connection_options.connect().await.unwrap();
+        let db = connection_options.connect().await.unwrap();
-        dblib.migrate().await.unwrap();
+        db.migrate().await.unwrap();
 
         let stats: Box<dyn Stats> = if s.captcha.enable_stats {
             Box::new(Real::default())
@@ -209,8 +202,7 @@ impl Data {
 
         let data = Data {
             creds,
-            //db,
+            db: Box::new(db),
-            dblib: Box::new(dblib),
             captcha: SystemGroup::new(s).await,
             mailer: Self::get_mailer(s),
             settings: s.clone(),

src/pages/panel/mod.rs

@@ -48,7 +48,7 @@ const PAGE: &str = "Dashboard";
 )]
 async fn panel(data: AppData, id: Identity) -> PageResult<impl Responder> {
     let username = id.identity().unwrap();
-    let sitekeys = data.dblib.get_all_user_captchas(&username).await?;
+    let sitekeys = data.db.get_all_user_captchas(&username).await?;
     let body = IndexPage::new(sitekeys).render_once().unwrap();
     Ok(HttpResponse::Ok()
         .content_type("text/html; charset=utf-8")

src/pages/panel/notifications.rs

@@ -74,7 +74,7 @@ pub async fn notifications(data: AppData, id: Identity) -> PageResult<impl Respo
     // TODO handle error where payload.to doesnt exist
 
     //    let mut notifications = runner::get_notification(&data, &receiver).await?;
-    let mut notifications = data.dblib.get_all_unread_notifications(&receiver).await?;
+    let mut notifications = data.db.get_all_unread_notifications(&receiver).await?;
     let notifications = notifications.drain(0..).map(|x| x.into()).collect();
 
     let body = IndexPage::new(notifications).render_once().unwrap();

src/pages/panel/settings.rs

@@ -69,9 +69,9 @@ pub struct IndexPage<'a> {
 async fn settings(data: AppData, id: Identity) -> PageResult<impl Responder> {
     let username = id.identity().unwrap();
 
-    let secret = data.dblib.get_secret(&username).await?;
+    let secret = data.db.get_secret(&username).await?;
     let secret = secret.secret;
-    let email = data.dblib.get_email(&username).await?;
+    let email = data.db.get_email(&username).await?;
 
     let data = IndexPage {
         email,

src/pages/panel/sitekey/edit.rs

@@ -61,8 +61,8 @@ pub async fn advance(
     let username = id.identity().unwrap();
     let key = path.into_inner();
 
-    let config = data.dblib.get_captcha_config(&username, &key).await?;
+    let config = data.db.get_captcha_config(&username, &key).await?;
-    let levels = data.dblib.get_captcha_levels(Some(&username), &key).await?;
+    let levels = data.db.get_captcha_levels(Some(&username), &key).await?;
 
     let body = AdvanceEditPage::new(config, levels, key)
         .render_once()
@@ -103,9 +103,9 @@ pub async fn easy(
     let username = id.identity().unwrap();
     let key = path.into_inner();
 
-    match data.dblib.get_traffic_pattern(&username, &key).await {
+    match data.db.get_traffic_pattern(&username, &key).await {
         Ok(c) => {
-            let config = data.dblib.get_captcha_config(&username, &key).await?;
+            let config = data.db.get_captcha_config(&username, &key).await?;
             let pattern = TrafficPatternRequest {
                 peak_sustainable_traffic: c.peak_sustainable_traffic as u32,
                 avg_traffic: c.avg_traffic as u32,

src/pages/panel/sitekey/list.rs

@@ -45,7 +45,7 @@ impl IndexPage {
 )]
 pub async fn list_sitekeys(data: AppData, id: Identity) -> PageResult<impl Responder> {
     let username = id.identity().unwrap();
-    let res = data.dblib.get_all_user_captchas(&username).await?;
+    let res = data.db.get_all_user_captchas(&username).await?;
     let body = IndexPage::new(res).render_once().unwrap();
     Ok(HttpResponse::Ok()
         .content_type("text/html; charset=utf-8")

src/pages/panel/sitekey/view.rs

@@ -67,8 +67,8 @@ pub async fn view_sitekey(
 ) -> PageResult<impl Responder> {
     let username = id.identity().unwrap();
     let key = path.into_inner();
-    let config = data.dblib.get_captcha_config(&username, &key).await?;
+    let config = data.db.get_captcha_config(&username, &key).await?;
-    let levels = data.dblib.get_captcha_levels(Some(&username), &key).await?;
+    let levels = data.db.get_captcha_levels(Some(&username), &key).await?;
     let stats = data.stats.fetch(&data, &username, &key).await?;
 
     let body = IndexPage::new(stats, config, levels, key)

src/stats.rs

@@ -71,24 +71,24 @@ pub struct Real;
 impl Stats for Real {
     /// record PoWConfig fetches
     async fn record_fetch(&self, d: &Data, key: &str) -> DBResult<()> {
-        d.dblib.record_fetch(key).await
+        d.db.record_fetch(key).await
     }
 
     /// record PoWConfig solves
     async fn record_solve(&self, d: &Data, key: &str) -> DBResult<()> {
-        d.dblib.record_solve(key).await
+        d.db.record_solve(key).await
     }
 
     /// record PoWConfig confirms
     async fn record_confirm(&self, d: &Data, key: &str) -> DBResult<()> {
-        d.dblib.record_confirm(key).await
+        d.db.record_confirm(key).await
     }
 
     /// fetch stats
     async fn fetch(&self, d: &Data, user: &str, key: &str) -> DBResult<CaptchaStats> {
-        let config_fetches_fut = d.dblib.fetch_config_fetched(user, key);
+        let config_fetches_fut = d.db.fetch_config_fetched(user, key);
-        let solves_fut = d.dblib.fetch_solve(user, key);
+        let solves_fut = d.db.fetch_solve(user, key);
-        let confirms_fut = d.dblib.fetch_confirm(user, key);
+        let confirms_fut = d.db.fetch_confirm(user, key);
 
         let (config_fetches, solves, confirms) =
             futures::try_join!(config_fetches_fut, solves_fut, confirms_fut)?;

src/tests/mod.rs

@@ -98,7 +98,7 @@ macro_rules! get_app {
 }
 
 pub async fn delete_user(data: &ArcData, name: &str) {
-    let x = data.dblib.delete_user(name).await;
+    let x = data.db.delete_user(name).await;
     println!();
     println!();
     println!();