refactor routes

meilisearch-http/src/routes/indexes/documents.rs

@@ -0,0 +1,214 @@
+use actix_web::{web, HttpResponse};
+use log::debug;
+use milli::update::{IndexDocumentsMethod, UpdateFormat};
+use serde::Deserialize;
+use serde_json::Value;
+
+use crate::error::ResponseError;
+use crate::extractors::authentication::{policies::*, GuardedData};
+use crate::extractors::payload::Payload;
+use crate::routes::IndexParam;
+use crate::Data;
+
+const DEFAULT_RETRIEVE_DOCUMENTS_OFFSET: usize = 0;
+const DEFAULT_RETRIEVE_DOCUMENTS_LIMIT: usize = 20;
+
+/*
+macro_rules! guard_content_type {
+    ($fn_name:ident, $guard_value:literal) => {
+        fn $fn_name(head: &actix_web::dev::RequestHead) -> bool {
+            if let Some(content_type) = head.headers.get("Content-Type") {
+                content_type
+                    .to_str()
+                    .map(|v| v.contains($guard_value))
+                    .unwrap_or(false)
+            } else {
+                false
+            }
+        }
+    };
+}
+
+guard_content_type!(guard_json, "application/json");
+*/
+
+fn guard_json(head: &actix_web::dev::RequestHead) -> bool {
+    if let Some(_content_type) = head.headers.get("Content-Type") {
+        // CURRENTLY AND FOR THIS RELEASE ONLY WE DECIDED TO INTERPRET ALL CONTENT-TYPES AS JSON
+        true
+        /*
+        content_type
+            .to_str()
+            .map(|v| v.contains("application/json"))
+            .unwrap_or(false)
+        */
+    } else {
+        // if no content-type is specified we still accept the data as json!
+        true
+    }
+}
+
+#[derive(Deserialize)]
+struct DocumentParam {
+    index_uid: String,
+    document_id: String,
+}
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::resource("")
+            .route(web::get().to(get_all_documents))
+            .route(web::post().guard(guard_json).to(add_documents))
+            .route(web::put().guard(guard_json).to(update_documents))
+            .route(web::delete().to(clear_all_documents)),
+    )
+    // this route needs to be before the /documents/{document_id} to match properly
+    .service(web::resource("/delete-batch").route(web::post().to(delete_documents)))
+    .service(
+        web::resource("/{document_id}")
+            .route(web::get().to(get_document))
+            .route(web::delete().to(delete_document)),
+    );
+}
+
+async fn get_document(
+    data: GuardedData<Public, Data>,
+    path: web::Path<DocumentParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let index = path.index_uid.clone();
+    let id = path.document_id.clone();
+    let document = data
+        .retrieve_document(index, id, None as Option<Vec<String>>)
+        .await?;
+    debug!("returns: {:?}", document);
+    Ok(HttpResponse::Ok().json(document))
+}
+
+async fn delete_document(
+    data: GuardedData<Private, Data>,
+    path: web::Path<DocumentParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let update_status = data
+        .delete_documents(path.index_uid.clone(), vec![path.document_id.clone()])
+        .await?;
+    debug!("returns: {:?}", update_status);
+    Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct BrowseQuery {
+    offset: Option<usize>,
+    limit: Option<usize>,
+    attributes_to_retrieve: Option<String>,
+}
+
+async fn get_all_documents(
+    data: GuardedData<Public, Data>,
+    path: web::Path<IndexParam>,
+    params: web::Query<BrowseQuery>,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("called with params: {:?}", params);
+    let attributes_to_retrieve = params.attributes_to_retrieve.as_ref().and_then(|attrs| {
+        let mut names = Vec::new();
+        for name in attrs.split(',').map(String::from) {
+            if name == "*" {
+                return None;
+            }
+            names.push(name);
+        }
+        Some(names)
+    });
+
+    let documents = data
+        .retrieve_documents(
+            path.index_uid.clone(),
+            params.offset.unwrap_or(DEFAULT_RETRIEVE_DOCUMENTS_OFFSET),
+            params.limit.unwrap_or(DEFAULT_RETRIEVE_DOCUMENTS_LIMIT),
+            attributes_to_retrieve,
+        )
+        .await?;
+    debug!("returns: {:?}", documents);
+    Ok(HttpResponse::Ok().json(documents))
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct UpdateDocumentsQuery {
+    primary_key: Option<String>,
+}
+
+/// Route used when the payload type is "application/json"
+/// Used to add or replace documents
+async fn add_documents(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+    params: web::Query<UpdateDocumentsQuery>,
+    body: Payload,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("called with params: {:?}", params);
+    let update_status = data
+        .add_documents(
+            path.into_inner().index_uid,
+            IndexDocumentsMethod::ReplaceDocuments,
+            UpdateFormat::Json,
+            body,
+            params.primary_key.clone(),
+        )
+        .await?;
+
+    debug!("returns: {:?}", update_status);
+    Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
+}
+
+/// Route used when the payload type is "application/json"
+/// Used to add or replace documents
+async fn update_documents(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+    params: web::Query<UpdateDocumentsQuery>,
+    body: Payload,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("called with params: {:?}", params);
+    let update = data
+        .add_documents(
+            path.into_inner().index_uid,
+            IndexDocumentsMethod::UpdateDocuments,
+            UpdateFormat::Json,
+            body,
+            params.primary_key.clone(),
+        )
+        .await?;
+
+    debug!("returns: {:?}", update);
+    Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update.id() })))
+}
+
+async fn delete_documents(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+    body: web::Json<Vec<Value>>,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("called with params: {:?}", body);
+    let ids = body
+        .iter()
+        .map(|v| {
+            v.as_str()
+                .map(String::from)
+                .unwrap_or_else(|| v.to_string())
+        })
+        .collect();
+
+    let update_status = data.delete_documents(path.index_uid.clone(), ids).await?;
+    debug!("returns: {:?}", update_status);
+    Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
+}
+
+async fn clear_all_documents(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let update_status = data.clear_documents(path.index_uid.clone()).await?;
+    debug!("returns: {:?}", update_status);
+    Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
+}

meilisearch-http/src/routes/indexes/mod.rs

@@ -0,0 +1,115 @@
+use actix_web::{web, HttpResponse};
+use chrono::{DateTime, Utc};
+use log::debug;
+use serde::{Deserialize, Serialize};
+
+use crate::error::ResponseError;
+use crate::extractors::authentication::{policies::*, GuardedData};
+use crate::routes::IndexParam;
+use crate::Data;
+
+mod documents;
+mod search;
+mod settings;
+mod updates;
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::resource("")
+            .route(web::get().to(list_indexes))
+            .route(web::post().to(create_index)),
+    )
+    .service(
+        web::scope("/{index_uid}")
+            .service(
+                web::resource("")
+                    .route(web::get().to(get_index))
+                    .route(web::put().to(update_index))
+                    .route(web::delete().to(delete_index)),
+            )
+            .service(web::resource("/stats").route(web::get().to(get_index_stats)))
+            .service(web::scope("/documents").configure(documents::configure))
+            .service(web::scope("/search").configure(search::configure))
+            .service(web::scope("/updates").configure(updates::configure))
+            .service(web::scope("/settings").configure(settings::configure)),
+    );
+}
+
+async fn list_indexes(data: GuardedData<Private, Data>) -> Result<HttpResponse, ResponseError> {
+    let indexes = data.list_indexes().await?;
+    debug!("returns: {:?}", indexes);
+    Ok(HttpResponse::Ok().json(indexes))
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct IndexCreateRequest {
+    uid: String,
+    primary_key: Option<String>,
+}
+
+async fn create_index(
+    data: GuardedData<Private, Data>,
+    body: web::Json<IndexCreateRequest>,
+) -> Result<HttpResponse, ResponseError> {
+    let body = body.into_inner();
+    let meta = data.create_index(body.uid, body.primary_key).await?;
+    Ok(HttpResponse::Ok().json(meta))
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct UpdateIndexRequest {
+    uid: Option<String>,
+    primary_key: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateIndexResponse {
+    name: String,
+    uid: String,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+    primary_key: Option<String>,
+}
+async fn get_index(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let meta = data.index(path.index_uid.clone()).await?;
+    debug!("returns: {:?}", meta);
+    Ok(HttpResponse::Ok().json(meta))
+}
+
+async fn update_index(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+    body: web::Json<UpdateIndexRequest>,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("called with params: {:?}", body);
+    let body = body.into_inner();
+    let meta = data
+        .update_index(path.into_inner().index_uid, body.primary_key, body.uid)
+        .await?;
+    debug!("returns: {:?}", meta);
+    Ok(HttpResponse::Ok().json(meta))
+}
+
+async fn delete_index(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+) -> Result<HttpResponse, ResponseError> {
+    data.delete_index(path.index_uid.clone()).await?;
+    Ok(HttpResponse::NoContent().finish())
+}
+
+async fn get_index_stats(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let response = data.get_index_stats(path.index_uid.clone()).await?;
+
+    debug!("returns: {:?}", response);
+    Ok(HttpResponse::Ok().json(response))
+}

meilisearch-http/src/routes/indexes/search.rs

@@ -0,0 +1,103 @@
+use std::collections::{BTreeSet, HashSet};
+
+use actix_web::{web, HttpResponse};
+use log::debug;
+use serde::Deserialize;
+use serde_json::Value;
+
+use crate::error::ResponseError;
+use crate::extractors::authentication::{policies::*, GuardedData};
+use crate::index::{default_crop_length, SearchQuery, DEFAULT_SEARCH_LIMIT};
+use crate::routes::IndexParam;
+use crate::Data;
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::resource("")
+            .route(web::get().to(search_with_url_query))
+            .route(web::post().to(search_with_post)),
+    );
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct SearchQueryGet {
+    q: Option<String>,
+    offset: Option<usize>,
+    limit: Option<usize>,
+    attributes_to_retrieve: Option<String>,
+    attributes_to_crop: Option<String>,
+    #[serde(default = "default_crop_length")]
+    crop_length: usize,
+    attributes_to_highlight: Option<String>,
+    filter: Option<String>,
+    #[serde(default = "Default::default")]
+    matches: bool,
+    facets_distribution: Option<String>,
+}
+
+impl From<SearchQueryGet> for SearchQuery {
+    fn from(other: SearchQueryGet) -> Self {
+        let attributes_to_retrieve = other
+            .attributes_to_retrieve
+            .map(|attrs| attrs.split(',').map(String::from).collect::<BTreeSet<_>>());
+
+        let attributes_to_crop = other
+            .attributes_to_crop
+            .map(|attrs| attrs.split(',').map(String::from).collect::<Vec<_>>());
+
+        let attributes_to_highlight = other
+            .attributes_to_highlight
+            .map(|attrs| attrs.split(',').map(String::from).collect::<HashSet<_>>());
+
+        let facets_distribution = other
+            .facets_distribution
+            .map(|attrs| attrs.split(',').map(String::from).collect::<Vec<_>>());
+
+        let filter = match other.filter {
+            Some(f) => match serde_json::from_str(&f) {
+                Ok(v) => Some(v),
+                _ => Some(Value::String(f)),
+            },
+            None => None,
+        };
+
+        Self {
+            q: other.q,
+            offset: other.offset,
+            limit: other.limit.unwrap_or(DEFAULT_SEARCH_LIMIT),
+            attributes_to_retrieve,
+            attributes_to_crop,
+            crop_length: other.crop_length,
+            attributes_to_highlight,
+            filter,
+            matches: other.matches,
+            facets_distribution,
+        }
+    }
+}
+
+async fn search_with_url_query(
+    data: GuardedData<Admin, Data>,
+    path: web::Path<IndexParam>,
+    params: web::Query<SearchQueryGet>,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("called with params: {:?}", params);
+    let query = params.into_inner().into();
+    let search_result = data.search(path.into_inner().index_uid, query).await?;
+    debug!("returns: {:?}", search_result);
+    Ok(HttpResponse::Ok().json(search_result))
+}
+
+async fn search_with_post(
+    data: GuardedData<Public, Data>,
+    path: web::Path<IndexParam>,
+    params: web::Json<SearchQuery>,
+) -> Result<HttpResponse, ResponseError> {
+    debug!("search called with params: {:?}", params);
+    let search_result = data
+        .search(path.into_inner().index_uid, params.into_inner())
+        .await?;
+    debug!("returns: {:?}", search_result);
+    Ok(HttpResponse::Ok().json(search_result))
+}

meilisearch-http/src/routes/indexes/settings.rs

@@ -0,0 +1,172 @@
+use actix_web::{web, HttpResponse};
+use log::debug;
+
+use crate::extractors::authentication::{policies::*, GuardedData};
+use crate::index::Settings;
+use crate::Data;
+use crate::{error::ResponseError, index::Unchecked};
+
+#[macro_export]
+macro_rules! make_setting_route {
+    ($route:literal, $type:ty, $attr:ident, $camelcase_attr:literal) => {
+        mod $attr {
+            use log::debug;
+            use actix_web::{web, HttpResponse, Resource};
+
+            use crate::data;
+            use crate::error::ResponseError;
+            use crate::index::Settings;
+            use crate::extractors::authentication::{GuardedData, policies::*};
+
+            async fn delete(
+                data: GuardedData<Private, data::Data>,
+                index_uid: web::Path<String>,
+            ) -> Result<HttpResponse, ResponseError> {
+                use crate::index::Settings;
+                let settings = Settings {
+                    $attr: Some(None),
+                    ..Default::default()
+                };
+                let update_status = data.update_settings(index_uid.into_inner(), settings, false).await?;
+                debug!("returns: {:?}", update_status);
+                Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
+            }
+
+            async fn update(
+                data: GuardedData<Private, data::Data>,
+                index_uid: actix_web::web::Path<String>,
+                body: actix_web::web::Json<Option<$type>>,
+            ) -> std::result::Result<HttpResponse, ResponseError> {
+                let settings = Settings {
+                    $attr: Some(body.into_inner()),
+                    ..Default::default()
+                };
+
+                let update_status = data.update_settings(index_uid.into_inner(), settings, true).await?;
+                debug!("returns: {:?}", update_status);
+                Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
+            }
+
+            async fn get(
+                data: GuardedData<Private, data::Data>,
+                index_uid: actix_web::web::Path<String>,
+            ) -> std::result::Result<HttpResponse, ResponseError> {
+                let settings = data.settings(index_uid.into_inner()).await?;
+                debug!("returns: {:?}", settings);
+                let mut json = serde_json::json!(&settings);
+                let val = json[$camelcase_attr].take();
+                Ok(HttpResponse::Ok().json(val))
+            }
+
+            pub fn resources() -> Resource {
+                Resource::new($route)
+                    .route(web::get().to(get))
+                    .route(web::post().to(update))
+                    .route(web::delete().to(delete))
+            }
+        }
+    };
+}
+
+make_setting_route!(
+    "/filterable-attributes",
+    std::collections::HashSet<String>,
+    filterable_attributes,
+    "filterableAttributes"
+);
+
+make_setting_route!(
+    "/displayed-attributes",
+    Vec<String>,
+    displayed_attributes,
+    "displayedAttributes"
+);
+
+make_setting_route!(
+    "/searchable-attributes",
+    Vec<String>,
+    searchable_attributes,
+    "searchableAttributes"
+);
+
+make_setting_route!(
+    "/stop-words",
+    std::collections::BTreeSet<String>,
+    stop_words,
+    "stopWords"
+);
+
+make_setting_route!(
+    "/synonyms",
+    std::collections::BTreeMap<String, Vec<String>>,
+    synonyms,
+    "synonyms"
+);
+
+make_setting_route!(
+    "/distinct-attribute",
+    String,
+    distinct_attribute,
+    "distinctAttribute"
+);
+
+make_setting_route!("/ranking-rules", Vec<String>, ranking_rules, "rankingRules");
+
+macro_rules! generate_configure {
+    ($($mod:ident),*) => {
+        pub fn configure(cfg: &mut web::ServiceConfig) {
+            cfg.service(
+                web::resource("")
+                .route(web::post().to(update_all))
+                .route(web::get().to(get_all))
+                .route(web::delete().to(delete_all)))
+                $(.service($mod::resources()))*;
+        }
+    };
+}
+
+generate_configure!(
+    filterable_attributes,
+    displayed_attributes,
+    searchable_attributes,
+    distinct_attribute,
+    stop_words,
+    synonyms,
+    ranking_rules
+);
+
+async fn update_all(
+    data: GuardedData<Private, Data>,
+    index_uid: web::Path<String>,
+    body: web::Json<Settings<Unchecked>>,
+) -> Result<HttpResponse, ResponseError> {
+    let settings = body.into_inner().check();
+    let update_result = data
+        .update_settings(index_uid.into_inner(), settings, true)
+        .await?;
+    let json = serde_json::json!({ "updateId": update_result.id() });
+    debug!("returns: {:?}", json);
+    Ok(HttpResponse::Accepted().json(json))
+}
+
+async fn get_all(
+    data: GuardedData<Private, Data>,
+    index_uid: web::Path<String>,
+) -> Result<HttpResponse, ResponseError> {
+    let settings = data.settings(index_uid.into_inner()).await?;
+    debug!("returns: {:?}", settings);
+    Ok(HttpResponse::Ok().json(settings))
+}
+
+async fn delete_all(
+    data: GuardedData<Private, Data>,
+    index_uid: web::Path<String>,
+) -> Result<HttpResponse, ResponseError> {
+    let settings = Settings::cleared();
+    let update_result = data
+        .update_settings(index_uid.into_inner(), settings, false)
+        .await?;
+    let json = serde_json::json!({ "updateId": update_result.id() });
+    debug!("returns: {:?}", json);
+    Ok(HttpResponse::Accepted().json(json))
+}

meilisearch-http/src/routes/indexes/updates.rs

@@ -0,0 +1,64 @@
+use actix_web::{web, HttpResponse};
+use chrono::{DateTime, Utc};
+use log::debug;
+use serde::{Deserialize, Serialize};
+
+use crate::error::ResponseError;
+use crate::extractors::authentication::{policies::*, GuardedData};
+use crate::routes::{IndexParam, UpdateStatusResponse};
+use crate::Data;
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(web::resource("").route(web::get().to(get_all_updates_status)))
+        .service(web::resource("{update_id}").route(web::get().to(get_update_status)));
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct UpdateIndexRequest {
+    uid: Option<String>,
+    primary_key: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateIndexResponse {
+    name: String,
+    uid: String,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+    primary_key: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct UpdateParam {
+    index_uid: String,
+    update_id: u64,
+}
+
+async fn get_update_status(
+    data: GuardedData<Private, Data>,
+    path: web::Path<UpdateParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let params = path.into_inner();
+    let meta = data
+        .get_update_status(params.index_uid, params.update_id)
+        .await?;
+    let meta = UpdateStatusResponse::from(meta);
+    debug!("returns: {:?}", meta);
+    Ok(HttpResponse::Ok().json(meta))
+}
+
+async fn get_all_updates_status(
+    data: GuardedData<Private, Data>,
+    path: web::Path<IndexParam>,
+) -> Result<HttpResponse, ResponseError> {
+    let metas = data.get_updates_status(path.into_inner().index_uid).await?;
+    let metas = metas
+        .into_iter()
+        .map(UpdateStatusResponse::from)
+        .collect::<Vec<_>>();
+
+    debug!("returns: {:?}", metas);
+    Ok(HttpResponse::Ok().json(metas))
+}