refactor create_app macro

meilisearch-http/src/lib.rs

@@ -13,73 +13,83 @@ pub mod analytics;
 pub use self::data::Data;
 pub use option::Opt;
 
+use actix_web::{HttpResponse, web};
+
+pub fn configure_data(config: &mut web::ServiceConfig, data: Data) {
+    let http_payload_size_limit = data.http_payload_size_limit();
+    config
+        .data(data)
+        .app_data(
+            web::JsonConfig::default()
+                .limit(dbg!(http_payload_size_limit))
+                .content_type(|_mime| true) // Accept all mime types
+                .error_handler(|err, _req| error::payload_error_handler(err).into()),
+        )
+        .app_data(web::PayloadConfig::new(http_payload_size_limit))
+        .app_data(
+            web::QueryConfig::default()
+                .error_handler(|err, _req| error::payload_error_handler(err).into()),
+        );
+}
+
+#[cfg(feature = "mini-dashboard")]
+pub fn dashboard(config: &mut web::ServiceConfig, enable_frontend: bool) {
+    use actix_web_static_files::Resource;
+
+    mod dashboard {
+        include!(concat!(env!("OUT_DIR"), "/generated.rs"));
+    }
+
+    if enable_frontend {
+        let generated = dashboard::generate();
+            let mut scope = web::scope("/");
+            // Generate routes for mini-dashboard assets
+            for (path, resource) in generated.into_iter() {
+                let Resource {mime_type, data, ..} = resource;
+                // Redirect index.html to /
+                if path == "index.html" {
+                    config.service(web::resource("/").route(web::get().to(move || {
+                        HttpResponse::Ok().content_type(mime_type).body(data)
+                    })));
+                } else {
+                    scope = scope.service(web::resource(path).route(web::get().to(move || {
+                        HttpResponse::Ok().content_type(mime_type).body(data)
+                    })));
+                }
+            }
+            config.service(scope);
+    } else {
+        config.service(routes::running);
+    }
+}
+
+#[cfg(not(feature = "mini-dashboard"))]
+pub fn dashboard(config: &mut web::ServiceConfig, _enable_frontend: bool) {
+    config.service(routes::running);
+}
+
 #[macro_export]
 macro_rules! create_app {
-    ($data:expr, $enable_frontend:expr) => {
+    ($data:expr, $enable_frontend:expr) => {{
-        {
+        use actix_cors::Cors;
-            use actix_cors::Cors;
+        use actix_web::middleware::TrailingSlash;
-            use actix_web::middleware::TrailingSlash;
+        use actix_web::App;
-            use actix_web::{App, HttpResponse};
+        use actix_web::{middleware, web};
-            use actix_web::{middleware, web};
+        use meilisearch_http::routes::*;
-            use meilisearch_http::error::payload_error_handler;
+        use meilisearch_http::{dashboard, configure_data};
-            use meilisearch_http::routes::*;
 
-            #[cfg(feature = "mini-dashboard")]
+        App::new()
-            use actix_web_static_files::Resource;
+            .configure(|s| configure_data(s, $data.clone()))
-
+            .configure(document::services)
-            #[cfg(feature = "mini-dashboard")]
+            .configure(index::services)
-            mod dashboard {
+            .configure(search::services)
-                include!(concat!(env!("OUT_DIR"), "/generated.rs"));
+            .configure(settings::services)
-            }
+            .configure(health::services)
-
+            .configure(stats::services)
-            let app = App::new()
+            .configure(key::services)
-                .data($data.clone())
+            .configure(dump::services)
-                .app_data(
+            .configure(|s| dashboard(s, $enable_frontend))
-                    web::JsonConfig::default()
+            .wrap(
-                    .limit($data.http_payload_size_limit())
-                    .content_type(|_mime| true) // Accept all mime types
-                    .error_handler(|err, _req| payload_error_handler(err).into()),
-                )
-                .app_data(
-                    web::QueryConfig::default()
-                    .error_handler(|err, _req| payload_error_handler(err).into()),
-                )
-                .configure(document::services)
-                .configure(index::services)
-                .configure(search::services)
-                .configure(settings::services)
-                .configure(health::services)
-                .configure(stats::services)
-                .configure(key::services)
-                .configure(dump::services);
-            #[cfg(feature = "mini-dashboard")]
-            let app = if $enable_frontend {
-                let mut app = app;
-                let generated = dashboard::generate();
-                let mut scope = web::scope("/");
-                // Generate routes for mini-dashboard assets
-                for (path, resource) in generated.into_iter() {
-                    let Resource {mime_type, data, ..} = resource;
-                    // Redirect index.html to /
-                    if path == "index.html" {
-                        app = app.service(web::resource("/").route(web::get().to(move || {
-                            HttpResponse::Ok().content_type(mime_type).body(data)
-                        })));
-                    } else {
-                        scope = scope.service(web::resource(path).route(web::get().to(move || {
-                            HttpResponse::Ok().content_type(mime_type).body(data)
-                        })));
-                    }
-                }
-                app.service(scope)
-            } else {
-                app.service(running)
-            };
-
-            #[cfg(not(feature = "mini-dashboard"))]
-            let app = app.service(running);
-
-            app.wrap(
                 Cors::default()
                 .send_wildcard()
                 .allowed_headers(vec!["content-type", "x-meili-api-key"])
@@ -87,11 +97,8 @@ macro_rules! create_app {
                 .allow_any_method()
                 .max_age(86_400), // 24h
             )
-                .wrap(middleware::Logger::default())
+            .wrap(middleware::Logger::default())
-                .wrap(middleware::Compress::default())
+            .wrap(middleware::Compress::default())
-                .wrap(middleware::NormalizePath::new(TrailingSlash::Trim))
+            .wrap(middleware::NormalizePath::new(middleware::TrailingSlash::Trim))
-                .default_service(
+    }};
-                    web::route().to(|| HttpResponse::NotFound()))
-        }
-    };
 }

meilisearch-http/src/main.rs

@@ -2,7 +2,7 @@ use std::env;
 
 use actix_web::HttpServer;
 use main_error::MainError;
-use meilisearch_http::{create_app, Data, Opt};
+use meilisearch_http::{Data, Opt, create_app};
 use structopt::StructOpt;
 
 #[cfg(all(not(debug_assertions), feature = "analytics"))]
@@ -74,7 +74,7 @@ async fn main() -> Result<(), MainError> {
 
 async fn run_http(data: Data, opt: Opt) -> Result<(), Box<dyn std::error::Error>> {
     let _enable_dashboard = &opt.env == "development";
-    let http_server = HttpServer::new(move || create_app!(&data, _enable_dashboard))
+    let http_server = HttpServer::new(move || create_app!(data, _enable_dashboard))
         // Disable signals allows the server to terminate immediately when a user enter CTRL-C
         .disable_signals();
 
@@ -83,8 +83,8 @@ async fn run_http(data: Data, opt: Opt) -> Result<(), Box<dyn std::error::Error>
             .bind_rustls(opt.http_addr, config)?
             .run()
             .await?;
-    } else {
+        } else {
-        http_server.bind(opt.http_addr)?.run().await?;
+            http_server.bind(opt.http_addr)?.run().await?;
     }
     Ok(())
 }

meilisearch-http/src/routes/document.rs

@@ -1,4 +1,3 @@
-use actix_web::web::Payload;
 use actix_web::{delete, get, post, put};
 use actix_web::{web, HttpResponse};
 use indexmap::IndexMap;
@@ -130,7 +129,7 @@ async fn add_documents(
     data: web::Data<Data>,
     path: web::Path<IndexParam>,
     params: web::Query<UpdateDocumentsQuery>,
-    body: Payload,
+    body: web::Payload,
 ) -> Result<HttpResponse, ResponseError> {
     let update_status = data
         .add_documents(