refactor(core): pull in actix::web into root http module

Author: ncrmro

src/core/auth/routes.rs

@@ -3,9 +3,9 @@ use anyhow::Result;
 use super::User;
 use crate::core::auth::ViewerModel;
 use crate::core::db::PgPool;
+use crate::core::http;
 use crate::core::http::api_v2_operation;
 use crate::core::http::errors::*;
-use crate::core::http::web;
 use crate::core::http::Apiv2Schema;
 
 use crate::core::db::model::DatabaseModel;
@@ -18,14 +18,14 @@ pub struct AuthenticationResponse {
 
 #[api_v2_operation]
 async fn viewer(
-    _req: web::HttpRequest,
+    _req: http::HttpRequest,
     viewer: super::Viewer,
-    db_pool: web::Data<PgPool>,
-) -> Result<web::Json<User>, Error> {
+    db_pool: http::Data<PgPool>,
+) -> Result<http::Json<User>, Error> {
     if let Some(id) = viewer.id {
         let viewer = User::get(id, &db_pool).await;
         match viewer {
-            Ok(user) => Ok(web::Json(user)),
+            Ok(user) => Ok(http::Json(user)),
             Err(_err) => Err(ErrorBadRequest("Not Authenticated")),
         }
     } else {
@@ -35,27 +35,27 @@ async fn viewer(
 
 #[api_v2_operation]
 async fn create(
-    user: web::Json<super::NewUser>,
-    db_pool: web::Data<PgPool>,
-) -> Result<web::Json<AuthenticationResponse>, Error> {
+    user: http::Json<super::NewUser>,
+    db_pool: http::Data<PgPool>,
+) -> Result<http::Json<AuthenticationResponse>, Error> {
     let res = super::User::create_user(user.into_inner(), db_pool.get_ref()).await;
     match res {
         Ok(user) => {
             let res = AuthenticationResponse {
                 user: user.clone(),
                 token: super::utils::jwt_get(user.id),
             };
-            Ok(web::Json(res))
+            Ok(http::Json(res))
         }
         Err(_e) => Err(ErrorConflict("user-exists")),
     }
 }
 
 #[api_v2_operation]
 async fn authenticate(
-    user: web::Json<super::LoginUser>,
-    db_pool: web::Data<PgPool>,
-) -> Result<web::Json<AuthenticationResponse>, Error> {
+    user: http::Json<super::LoginUser>,
+    db_pool: http::Data<PgPool>,
+) -> Result<http::Json<AuthenticationResponse>, Error> {
     let row = super::User::find_user_by_credentials(
         user.email.clone(),
         user.password.clone(),
@@ -69,15 +69,15 @@ async fn authenticate(
             token: super::utils::jwt_get(user.id),
             user,
         };
-        Ok(web::Json(res))
+        Ok(http::Json(res))
     } else {
         Err(ErrorBadRequest("Not Authenticated"))
     }
 }
 
 // function that will be called on new Application to configure routes for this module
-pub fn init(cfg: &mut web::ServiceConfig) {
-    cfg.route("/viewer", web::get().to(viewer))
-        .route("/viewer/create", web::post().to(create))
-        .route("/viewer/authenticate", web::post().to(authenticate));
+pub fn init(cfg: &mut http::ServiceConfig) {
+    cfg.route("/viewer", http::get().to(viewer))
+        .route("/viewer/create", http::post().to(create))
+        .route("/viewer/authenticate", http::post().to(authenticate));
 }

src/core/auth/viewer.rs

@@ -4,8 +4,8 @@ use actix_web::dev::Payload;
 use actix_web::dev::PayloadStream;
 
 use crate::core::db::model::fields;
+use crate::core::http;
 use crate::core::http::errors;
-use crate::core::http::web;
 use crate::core::http::Apiv2Schema;
 use crate::core::http::FromRequest;
 
@@ -21,7 +21,10 @@ impl FromRequest for Viewer {
     type Future = Ready<Result<Self, Self::Error>>;
     type Config = ();
 
-    fn from_request(req: &web::HttpRequest, _payload: &mut Payload<PayloadStream>) -> Self::Future {
+    fn from_request(
+        req: &http::HttpRequest,
+        _payload: &mut Payload<PayloadStream>,
+    ) -> Self::Future {
         let ext = req.extensions();
         let viewer = ext.get::<Viewer>();
         if let Some(viewer) = viewer {

src/core/http/mod.rs

@@ -3,9 +3,10 @@ pub mod server;
 
 pub use actix_web::guard;
 pub use actix_web::FromRequest;
+pub use actix_web::Responder;
 
 pub use paperclip::actix::api_v2_operation;
-pub use paperclip::actix::web;
+pub use paperclip::actix::web::*;
 pub use paperclip::actix::Apiv2Schema;
 
 pub use server::server;

src/core/http/server.rs

@@ -11,14 +11,13 @@ use crate::core::settings::Settings;
 use super::api_v2_operation;
 use super::guard;
 use super::middlewares;
-use super::web;
 
 #[api_v2_operation]
 async fn p404() -> Result<String, ()> {
     Ok("404".to_string())
 }
 
-pub async fn server(settings: Settings, routes: fn(&mut web::ServiceConfig)) -> Result<()> {
+pub async fn server(settings: Settings, routes: fn(&mut super::ServiceConfig)) -> Result<()> {
     info!("Initializing server");
 
     // this will enable us to keep application running during recompile: systemfd --no-pid -s http::5000 -- cargo watch -x run
@@ -39,10 +38,10 @@ pub async fn server(settings: Settings, routes: fn(&mut web::ServiceConfig)) ->
             .build()
             .default_service(
                 // 404 for GET request
-                web::resource("")
-                    .route(web::get().to(p404))
+                super::resource("")
+                    .route(super::get().to(p404))
                     // all requests that are not `GET`
-                    .route(web::Route::new().guard(guard::Not(guard::Get()))),
+                    .route(super::Route::new().guard(guard::Not(guard::Get()))),
             )
     });
 

src/lib.rs

@@ -11,20 +11,20 @@ pub mod user;
 use anyhow::Result;
 use env_logger::Env;
 
+use crate::core::http;
 use crate::core::http::api_v2_operation;
-use crate::core::http::web;
 
 #[api_v2_operation]
 async fn index() -> Result<String, ()> {
     Ok("Hello World".to_string())
 }
 
-pub fn routes(cfg: &mut web::ServiceConfig) {
-    let v1 = web::scope("/v1")
+pub fn routes(cfg: &mut http::ServiceConfig) {
+    let v1 = http::scope("/v1")
         .configure(todo::init)
         .configure(core::auth::init);
 
-    cfg.route("/", web::get().to(index)).service(v1);
+    cfg.route("/", http::get().to(index)).service(v1);
 }
 
 #[actix_rt::main]