Ignore unknown facet search query parameters

meilisearch-types/src/deserr/mod.rs

@@ -151,6 +151,10 @@ make_missing_field_convenience_builder!(MissingApiKeyExpiresAt, missing_api_key_
 make_missing_field_convenience_builder!(MissingApiKeyIndexes, missing_api_key_indexes);
 make_missing_field_convenience_builder!(MissingSwapIndexes, missing_swap_indexes);
 make_missing_field_convenience_builder!(MissingDocumentFilter, missing_document_filter);
+make_missing_field_convenience_builder!(
+    MissingFacetSearchFacetName,
+    missing_facet_search_facet_name
+);
 
 // Integrate a sub-error into a [`DeserrError`] by taking its error message but using
 // the default error code (C) from `Self`

meilisearch-types/src/error.rs

@@ -230,6 +230,7 @@ InvalidSearchAttributesToRetrieve     , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchCropLength               , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchCropMarker               , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchFacets                   , InvalidRequest       , BAD_REQUEST ;
+InvalidFacetSearchFacetName           , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchFilter                   , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchHighlightPostTag         , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchHighlightPreTag          , InvalidRequest       , BAD_REQUEST ;
@@ -243,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 ;
@@ -280,6 +280,7 @@ MissingApiKeyIndexes                  , InvalidRequest       , BAD_REQUEST ;
 MissingAuthorizationHeader            , Auth                 , UNAUTHORIZED ;
 MissingContentType                    , InvalidRequest       , UNSUPPORTED_MEDIA_TYPE ;
 MissingDocumentId                     , InvalidRequest       , BAD_REQUEST ;
+MissingFacetSearchFacetName           , InvalidRequest       , BAD_REQUEST ;
 MissingIndexUid                       , InvalidRequest       , BAD_REQUEST ;
 MissingMasterKey                      , Auth                 , UNAUTHORIZED ;
 MissingPayload                        , InvalidRequest       , BAD_REQUEST ;
@@ -333,7 +334,9 @@ impl ErrorCode for milli::Error {
                     UserError::SortRankingRuleMissing => Code::InvalidSearchSort,
                     UserError::InvalidFacetsDistribution { .. } => Code::InvalidSearchFacets,
                     UserError::InvalidSortableAttribute { .. } => Code::InvalidSearchSort,
-                    UserError::InvalidSearchFacet { .. } => Code::InvalidSearchFacet,
+                    UserError::InvalidFacetSearchFacetName { .. } => {
+                        Code::InvalidFacetSearchFacetName
+                    }
                     UserError::CriterionError(_) => Code::InvalidSettingsRankingRules,
                     UserError::InvalidGeoField { .. } => Code::InvalidDocumentGeoField,
                     UserError::SortError(_) => Code::InvalidSearchSort,

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,44 +24,16 @@ 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>,
-    #[deserr(error = DeserrJsonError<InvalidFacetSearchName>)]
+    #[deserr(error = DeserrJsonError<MissingFacetSearchFacetName>, missing_field_error = DeserrJsonError::missing_facet_search_facet_name)]
     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,
         }
     }
 }

meilisearch/src/search.rs

@@ -246,8 +246,8 @@ pub struct FacetStats {
 #[derive(Serialize, Debug, Clone, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct FacetSearchResult {
-    pub hits: Vec<FacetValueHit>,
-    pub query: Option<String>,
+    pub facet_hits: Vec<FacetValueHit>,
+    pub facet_query: Option<String>,
     pub processing_time_ms: u128,
 }
 
@@ -509,11 +509,9 @@ pub fn perform_facet_search(
         facet_search.query(facet_query);
     }
 
-    let hits = facet_search.execute()?;
-
     Ok(FacetSearchResult {
-        hits,
-        query: facet_query,
+        facet_hits: facet_search.execute()?,
+        facet_query,
         processing_time_ms: before_search.elapsed().as_millis(),
     })
 }

milli/src/error.rs

@@ -124,16 +124,16 @@ 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(", ")
                 ),
         }
     )]
-    InvalidSearchFacet { field: String, valid_fields: BTreeSet<String> },
+    InvalidFacetSearchFacetName { field: String, valid_fields: BTreeSet<String> },
     #[error("{}", HeedError::BadOpenOptions)]
     InvalidLmdbOpenOptions,
     #[error("You must specify where `sort` is listed in the rankingRules setting to use the sort parameter at search time.")]

milli/src/search/mod.rs

@@ -13,7 +13,7 @@ use self::new::PartialSearchResult;
 use crate::error::UserError;
 use crate::heed_codec::facet::{FacetGroupKey, FacetGroupValue};
 use crate::{
-    execute_search, AscDesc, DefaultSearchLogger, DocumentId, FieldIdMapMissingEntry, Index,
+    execute_search, normalize_facet, AscDesc, DefaultSearchLogger, DocumentId, FieldId, Index,
     Result, SearchContext, BEU16,
 };
 
@@ -224,13 +224,25 @@ 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;
 
         let filterable_fields = index.filterable_fields(rtxn)?;
         if !filterable_fields.contains(&self.facet) {
-            return Err(UserError::InvalidSearchFacet {
+            return Err(UserError::InvalidFacetSearchFacetName {
                 field: self.facet.clone(),
                 valid_fields: filterable_fields.into_iter().collect(),
             }
@@ -240,13 +252,9 @@ impl<'a> SearchForFacetValues<'a> {
         let fields_ids_map = index.fields_ids_map(rtxn)?;
         let fid = match fields_ids_map.id(&self.facet) {
             Some(fid) => fid,
-            None => {
-                return Err(FieldIdMapMissingEntry::FieldName {
-                    field_name: self.facet.clone(),
-                    process: "search for facet values",
-                }
-                .into());
-            }
+            // we return an empty list of results when the attribute has been
+            // set as filterable but no document contains this field (yet).
+            None => return Ok(Vec::new()),
         };
 
         let fst = match self.search_query.index.facet_id_string_fst.get(rtxn, &BEU16::new(fid))? {
@@ -258,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);
@@ -267,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 {
@@ -306,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 {
@@ -335,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 {
@@ -355,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 {

milli/src/update/facet/mod.rs

@@ -169,7 +169,7 @@ impl<'i> FacetsUpdate<'i> {
                 current_fst = match current_fst.take() {
                     Some((fid, fst_builder)) if fid != field_id => {
                         let fst = fst_builder.into_set();
-                        text_fsts.push((field_id, fst));
+                        text_fsts.push((fid, fst));
                         Some((field_id, fst::SetBuilder::memory()))
                     }
                     Some((field_id, fst_builder)) => Some((field_id, fst_builder)),