Ignore unknown facet search query parameters

meilisearch-types/src/error.rs

@@ -244,7 +244,6 @@ InvalidFacetSearchQuery               , InvalidRequest       , BAD_REQUEST ;
 InvalidFacetSearchName                , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchShowMatchesPosition      , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchSort                     , InvalidRequest       , BAD_REQUEST ;
-InvalidSearchFacet                    , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsDisplayedAttributes    , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsDistinctAttribute      , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsFaceting               , InvalidRequest       , BAD_REQUEST ;

meilisearch/src/analytics/segment_analytics.rs

@@ -36,7 +36,7 @@ use crate::routes::{create_all_stats, Stats};
 use crate::search::{
     FacetSearchResult, MatchingStrategy, SearchQuery, SearchQueryWithIndex, SearchResult,
     DEFAULT_CROP_LENGTH, DEFAULT_CROP_MARKER, DEFAULT_HIGHLIGHT_POST_TAG,
-    DEFAULT_HIGHLIGHT_PRE_TAG, DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_OFFSET,
+    DEFAULT_HIGHLIGHT_PRE_TAG, DEFAULT_SEARCH_LIMIT,
 };
 use crate::Opt;
 
@@ -527,11 +527,13 @@ impl Segment {
             let _ = self.batcher.push(update_documents).await;
         }
         if let Some(get_fetch_documents) =
-            take(get_fetch_documents_aggregator).into_event(&user, "Documents Fetched GET") {
+            take(get_fetch_documents_aggregator).into_event(&user, "Documents Fetched GET")
+        {
             let _ = self.batcher.push(get_fetch_documents).await;
         }
         if let Some(post_fetch_documents) =
-            take(post_fetch_documents_aggregator).into_event(&user, "Documents Fetched POST") {
+            take(post_fetch_documents_aggregator).into_event(&user, "Documents Fetched POST")
+        {
             let _ = self.batcher.push(post_fetch_documents).await;
         }
         if let Some(get_tasks) = take(get_tasks_aggregator).into_event(&user, "Tasks Seen") {
@@ -935,27 +937,7 @@ pub struct FacetSearchAggregator {
 
 impl FacetSearchAggregator {
     pub fn from_query(query: &FacetSearchQuery, request: &HttpRequest) -> Self {
-        let FacetSearchQuery {
-            facet_query: _,
-            facet_name,
-            q,
-            offset,
-            limit,
-            page,
-            hits_per_page,
-            attributes_to_retrieve,
-            attributes_to_crop,
-            crop_length,
-            attributes_to_highlight,
-            show_matches_position,
-            filter,
-            sort,
-            facets,
-            highlight_pre_tag,
-            highlight_post_tag,
-            crop_marker,
-            matching_strategy,
-        } = query;
+        let FacetSearchQuery { facet_query: _, facet_name, q, filter, matching_strategy } = query;
 
         let mut ret = Self::default();
         ret.timestamp = Some(OffsetDateTime::now_utc());
@@ -964,23 +946,8 @@ impl FacetSearchAggregator {
         ret.user_agents = extract_user_agents(request).into_iter().collect();
         ret.facet_names = Some(facet_name.clone()).into_iter().collect();
 
-        ret.additional_search_parameters_provided = q.is_some()
-            || *offset != DEFAULT_SEARCH_OFFSET()
-            || *limit != DEFAULT_SEARCH_LIMIT()
-            || page.is_some()
-            || hits_per_page.is_some()
-            || attributes_to_retrieve.is_some()
-            || attributes_to_crop.is_some()
-            || *crop_length != DEFAULT_CROP_LENGTH()
-            || attributes_to_highlight.is_some()
-            || *show_matches_position
-            || filter.is_some()
-            || sort.is_some()
-            || facets.is_some()
-            || *highlight_pre_tag != DEFAULT_HIGHLIGHT_PRE_TAG()
-            || *highlight_post_tag != DEFAULT_HIGHLIGHT_POST_TAG()
-            || *crop_marker != DEFAULT_CROP_MARKER()
-            || *matching_strategy != MatchingStrategy::default();
+        ret.additional_search_parameters_provided =
+            q.is_some() || filter.is_some() || *matching_strategy != MatchingStrategy::default();
 
         ret
     }

meilisearch/src/routes/indexes/facet_search.rs

@@ -1,5 +1,3 @@
-use std::collections::{BTreeSet, HashSet};
-
 use actix_web::web::Data;
 use actix_web::{web, HttpRequest, HttpResponse};
 use deserr::actix_web::AwebJson;
@@ -26,7 +24,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
 
 // TODO improve the error messages
 #[derive(Debug, Clone, Default, PartialEq, Eq, deserr::Deserr)]
-#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase)]
 pub struct FacetSearchQuery {
     #[deserr(default, error = DeserrJsonError<InvalidFacetSearchQuery>)]
     pub facet_query: Option<String>,
@@ -34,36 +32,8 @@ pub struct FacetSearchQuery {
     pub facet_name: String,
     #[deserr(default, error = DeserrJsonError<InvalidSearchQ>)]
     pub q: Option<String>,
-    #[deserr(default = DEFAULT_SEARCH_OFFSET(), error = DeserrJsonError<InvalidSearchOffset>)]
-    pub offset: usize,
-    #[deserr(default = DEFAULT_SEARCH_LIMIT(), error = DeserrJsonError<InvalidSearchLimit>)]
-    pub limit: usize,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchPage>)]
-    pub page: Option<usize>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchHitsPerPage>)]
-    pub hits_per_page: Option<usize>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchAttributesToRetrieve>)]
-    pub attributes_to_retrieve: Option<BTreeSet<String>>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchAttributesToCrop>)]
-    pub attributes_to_crop: Option<Vec<String>>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchCropLength>, default = DEFAULT_CROP_LENGTH())]
-    pub crop_length: usize,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchAttributesToHighlight>)]
-    pub attributes_to_highlight: Option<HashSet<String>>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchShowMatchesPosition>, default)]
-    pub show_matches_position: bool,
     #[deserr(default, error = DeserrJsonError<InvalidSearchFilter>)]
     pub filter: Option<Value>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchSort>)]
-    pub sort: Option<Vec<String>>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchFacets>)]
-    pub facets: Option<Vec<String>>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchHighlightPreTag>, default = DEFAULT_HIGHLIGHT_PRE_TAG())]
-    pub highlight_pre_tag: String,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchHighlightPostTag>, default = DEFAULT_HIGHLIGHT_POST_TAG())]
-    pub highlight_post_tag: String,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchCropMarker>, default = DEFAULT_CROP_MARKER())]
-    pub crop_marker: String,
     #[deserr(default, error = DeserrJsonError<InvalidSearchMatchingStrategy>, default)]
     pub matching_strategy: MatchingStrategy,
 }
@@ -110,24 +80,27 @@ pub async fn search(
 
 impl From<FacetSearchQuery> for SearchQuery {
     fn from(value: FacetSearchQuery) -> Self {
+        let FacetSearchQuery { facet_query: _, facet_name: _, q, filter, matching_strategy } =
+            value;
+
         SearchQuery {
-            q: value.q,
-            offset: value.offset,
-            limit: value.limit,
-            page: value.page,
-            hits_per_page: value.hits_per_page,
-            attributes_to_retrieve: value.attributes_to_retrieve,
-            attributes_to_crop: value.attributes_to_crop,
-            crop_length: value.crop_length,
-            attributes_to_highlight: value.attributes_to_highlight,
-            show_matches_position: value.show_matches_position,
-            filter: value.filter,
-            sort: value.sort,
-            facets: value.facets,
-            highlight_pre_tag: value.highlight_pre_tag,
-            highlight_post_tag: value.highlight_post_tag,
-            crop_marker: value.crop_marker,
-            matching_strategy: value.matching_strategy,
+            q,
+            offset: DEFAULT_SEARCH_OFFSET(),
+            limit: DEFAULT_SEARCH_LIMIT(),
+            page: None,
+            hits_per_page: None,
+            attributes_to_retrieve: None,
+            attributes_to_crop: None,
+            crop_length: DEFAULT_CROP_LENGTH(),
+            attributes_to_highlight: None,
+            show_matches_position: false,
+            filter,
+            sort: None,
+            facets: None,
+            highlight_pre_tag: DEFAULT_HIGHLIGHT_PRE_TAG(),
+            highlight_post_tag: DEFAULT_HIGHLIGHT_POST_TAG(),
+            crop_marker: DEFAULT_CROP_MARKER(),
+            matching_strategy,
         }
     }
 }

milli/src/error.rs

@@ -124,11 +124,11 @@ only composed of alphanumeric characters (a-z A-Z 0-9), hyphens (-) and undersco
         }
     )]
     InvalidSortableAttribute { field: String, valid_fields: BTreeSet<String> },
-    #[error("Attribute `{}` is not filterable. {}",
+    #[error("Attribute `{}` is not facet-searchable. {}",
         .field,
         match .valid_fields.is_empty() {
-            true => "This index does not have configured filterable attributes.".to_string(),
-            false => format!("Available filterable attributes are: `{}`.",
+            true => "This index does not have configured facet-searchable attributes. To make it facet-searchable add it to the `filterableAttributes` index settings.".to_string(),
+            false => format!("Available facet-searchable attributes are: `{}`. To make it facet-searchable add it to the `filterableAttributes` index settings.",
                     valid_fields.iter().map(AsRef::as_ref).collect::<Vec<&str>>().join(", ")
                 ),
         }

milli/src/search/mod.rs

@@ -13,7 +13,8 @@ use self::new::PartialSearchResult;
 use crate::error::UserError;
 use crate::heed_codec::facet::{FacetGroupKey, FacetGroupValue};
 use crate::{
-    execute_search, AscDesc, DefaultSearchLogger, DocumentId, Index, Result, SearchContext, BEU16,
+    execute_search, normalize_facet, AscDesc, DefaultSearchLogger, DocumentId, FieldId, Index,
+    Result, SearchContext, BEU16,
 };
 
 // Building these factories is not free.
@@ -223,6 +224,18 @@ impl<'a> SearchForFacetValues<'a> {
         self
     }
 
+    fn one_original_value_of(
+        &self,
+        field_id: FieldId,
+        facet_str: &str,
+        any_docid: DocumentId,
+    ) -> Result<Option<String>> {
+        let index = self.search_query.index;
+        let rtxn = self.search_query.rtxn;
+        let key: (FieldId, _, &str) = (field_id, any_docid, facet_str);
+        Ok(index.field_id_docid_facet_strings.get(rtxn, &key)?.map(|v| v.to_owned()))
+    }
+
     pub fn execute(&self) -> Result<Vec<FacetValueHit>> {
         let index = self.search_query.index;
         let rtxn = self.search_query.rtxn;
@@ -253,6 +266,8 @@ impl<'a> SearchForFacetValues<'a> {
 
         match self.query.as_ref() {
             Some(query) => {
+                let query = normalize_facet(query);
+                let query = query.as_str();
                 let authorize_typos = self.search_query.index.authorize_typos(rtxn)?;
                 let field_authorizes_typos =
                     !self.search_query.index.exact_attributes_ids(rtxn)?.contains(&fid);
@@ -262,14 +277,16 @@ impl<'a> SearchForFacetValues<'a> {
 
                     let exact_words_fst = self.search_query.index.exact_words(rtxn)?;
                     if exact_words_fst.map_or(false, |fst| fst.contains(query)) {
-                        let key =
-                            FacetGroupKey { field_id: fid, level: 0, left_bound: query.as_ref() };
+                        let key = FacetGroupKey { field_id: fid, level: 0, left_bound: query };
                         if let Some(FacetGroupValue { bitmap, .. }) =
                             index.facet_id_string_docids.get(rtxn, &key)?
                         {
                             let count = search_candidates.intersection_len(&bitmap);
                             if count != 0 {
-                                results.push(FacetValueHit { value: query.to_string(), count });
+                                let value = self
+                                    .one_original_value_of(fid, query, bitmap.min().unwrap())?
+                                    .unwrap_or_else(|| query.to_string());
+                                results.push(FacetValueHit { value, count });
                             }
                         }
                     } else {
@@ -301,7 +318,10 @@ impl<'a> SearchForFacetValues<'a> {
                             };
                             let count = search_candidates.intersection_len(&docids);
                             if count != 0 {
-                                results.push(FacetValueHit { value: value.to_string(), count });
+                                let value = self
+                                    .one_original_value_of(fid, value, docids.min().unwrap())?
+                                    .unwrap_or_else(|| query.to_string());
+                                results.push(FacetValueHit { value, count });
                                 length += 1;
                             }
                             if length >= MAX_NUMBER_OF_FACETS {
@@ -330,7 +350,10 @@ impl<'a> SearchForFacetValues<'a> {
                         };
                         let count = search_candidates.intersection_len(&docids);
                         if count != 0 {
-                            results.push(FacetValueHit { value: value.to_string(), count });
+                            let value = self
+                                .one_original_value_of(fid, value, docids.min().unwrap())?
+                                .unwrap_or_else(|| query.to_string());
+                            results.push(FacetValueHit { value, count });
                             length += 1;
                         }
                         if length >= MAX_NUMBER_OF_FACETS {
@@ -350,7 +373,10 @@ impl<'a> SearchForFacetValues<'a> {
                         result?;
                     let count = search_candidates.intersection_len(&bitmap);
                     if count != 0 {
-                        results.push(FacetValueHit { value: left_bound.to_string(), count });
+                        let value = self
+                            .one_original_value_of(fid, left_bound, bitmap.min().unwrap())?
+                            .unwrap_or_else(|| left_bound.to_string());
+                        results.push(FacetValueHit { value, count });
                         length += 1;
                     }
                     if length >= MAX_NUMBER_OF_FACETS {