Move crates under a sub folder to clean up the code

crates/meilisearch-types/Cargo.toml

@@ -0,0 +1,70 @@
+[package]
+name = "meilisearch-types"
+publish = false
+
+version.workspace = true
+authors.workspace = true
+description.workspace = true
+homepage.workspace = true
+readme.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+actix-web = { version = "4.8.0", default-features = false }
+anyhow = "1.0.86"
+convert_case = "0.6.0"
+csv = "1.3.0"
+deserr = { version = "0.6.2", features = ["actix-web"] }
+either = { version = "1.13.0", features = ["serde"] }
+enum-iterator = "2.1.0"
+file-store = { path = "../file-store" }
+flate2 = "1.0.30"
+fst = "0.4.7"
+memmap2 = "0.9.4"
+milli = { path = "../milli" }
+roaring = { version = "0.10.6", features = ["serde"] }
+serde = { version = "1.0.204", features = ["derive"] }
+serde-cs = "0.2.4"
+serde_json = "1.0.120"
+tar = "0.4.41"
+tempfile = "3.10.1"
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = [
+    "serde-well-known",
+    "formatting",
+    "parsing",
+    "macros",
+] }
+tokio = "1.38"
+uuid = { version = "1.10.0", features = ["serde", "v4"] }
+
+[dev-dependencies]
+insta = "1.39.0"
+meili-snap = { path = "../meili-snap" }
+
+[features]
+# all specialized tokenizations
+all-tokenizations = ["milli/all-tokenizations"]
+
+# chinese specialized tokenization
+chinese = ["milli/chinese"]
+chinese-pinyin = ["milli/chinese-pinyin"]
+# hebrew specialized tokenization
+hebrew = ["milli/hebrew"]
+# japanese specialized tokenization
+japanese = ["milli/japanese"]
+# korean specialized tokenization
+korean = ["milli/korean"]
+# thai specialized tokenization
+thai = ["milli/thai"]
+# allow greek specialized tokenization
+greek = ["milli/greek"]
+# allow khmer specialized tokenization
+khmer = ["milli/khmer"]
+# allow vietnamese specialized tokenization
+vietnamese = ["milli/vietnamese"]
+# force swedish character recomposition
+swedish-recomposition = ["milli/swedish-recomposition"]
+# force german character recomposition
+german = ["milli/german"]

crates/meilisearch-types/src/compression.rs

@@ -0,0 +1,28 @@
+use std::fs::{create_dir_all, File};
+use std::io::Write;
+use std::path::Path;
+
+use flate2::read::GzDecoder;
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use tar::{Archive, Builder};
+
+pub fn to_tar_gz(src: impl AsRef<Path>, dest: impl AsRef<Path>) -> anyhow::Result<()> {
+    let mut f = File::create(dest)?;
+    let gz_encoder = GzEncoder::new(&mut f, Compression::default());
+    let mut tar_encoder = Builder::new(gz_encoder);
+    tar_encoder.append_dir_all(".", src)?;
+    let gz_encoder = tar_encoder.into_inner()?;
+    gz_encoder.finish()?;
+    f.flush()?;
+    Ok(())
+}
+
+pub fn from_tar_gz(src: impl AsRef<Path>, dest: impl AsRef<Path>) -> anyhow::Result<()> {
+    let f = File::open(&src)?;
+    let gz = GzDecoder::new(f);
+    let mut ar = Archive::new(gz);
+    create_dir_all(&dest)?;
+    ar.unpack(&dest)?;
+    Ok(())
+}

crates/meilisearch-types/src/deserr/mod.rs

@@ -0,0 +1,199 @@
+use std::convert::Infallible;
+use std::fmt;
+use std::marker::PhantomData;
+use std::ops::ControlFlow;
+
+use deserr::errors::{JsonError, QueryParamError};
+use deserr::{take_cf_content, DeserializeError, IntoValue, MergeWithError, ValuePointerRef};
+
+use crate::error::deserr_codes::*;
+use crate::error::{
+    Code, DeserrParseBoolError, DeserrParseIntError, ErrorCode, InvalidTaskDateError,
+    ParseOffsetDateTimeError,
+};
+use crate::index_uid::IndexUidFormatError;
+use crate::tasks::{ParseTaskKindError, ParseTaskStatusError};
+
+pub mod query_params;
+
+/// Marker type for the Json format
+pub struct DeserrJson;
+/// Marker type for the Query Parameter format
+pub struct DeserrQueryParam;
+
+pub type DeserrJsonError<C = BadRequest> = DeserrError<DeserrJson, C>;
+pub type DeserrQueryParamError<C = BadRequest> = DeserrError<DeserrQueryParam, C>;
+
+/// A request deserialization error.
+///
+/// The first generic parameter is a marker type describing the format of the request: either json (e.g. [`DeserrJson`] or [`DeserrQueryParam`]).
+/// The second generic parameter is the default error code for the deserialization error, in case it is not given.
+pub struct DeserrError<Format, C: Default + ErrorCode> {
+    pub msg: String,
+    pub code: Code,
+    _phantom: PhantomData<(Format, C)>,
+}
+impl<Format, C: Default + ErrorCode> DeserrError<Format, C> {
+    pub fn new(msg: String, code: Code) -> Self {
+        Self { msg, code, _phantom: PhantomData }
+    }
+}
+
+impl<Format, C: Default + ErrorCode> std::fmt::Debug for DeserrError<Format, C> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("DeserrError").field("msg", &self.msg).field("code", &self.code).finish()
+    }
+}
+
+impl<Format, C: Default + ErrorCode> std::fmt::Display for DeserrError<Format, C> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
+
+impl<F, C: Default + ErrorCode> actix_web::ResponseError for DeserrError<F, C> {
+    fn status_code(&self) -> actix_web::http::StatusCode {
+        self.code.http()
+    }
+
+    fn error_response(&self) -> actix_web::HttpResponse<actix_web::body::BoxBody> {
+        crate::error::ResponseError::from_msg(self.msg.to_string(), self.code).error_response()
+    }
+}
+
+impl<Format, C: Default + ErrorCode> std::error::Error for DeserrError<Format, C> {}
+impl<Format, C: Default + ErrorCode> ErrorCode for DeserrError<Format, C> {
+    fn error_code(&self) -> Code {
+        self.code
+    }
+}
+
+// For now, we don't accumulate errors. Only one deserialisation error is ever returned at a time.
+impl<Format, C1: Default + ErrorCode, C2: Default + ErrorCode>
+    MergeWithError<DeserrError<Format, C2>> for DeserrError<Format, C1>
+{
+    fn merge(
+        _self_: Option<Self>,
+        other: DeserrError<Format, C2>,
+        _merge_location: ValuePointerRef,
+    ) -> ControlFlow<Self, Self> {
+        ControlFlow::Break(DeserrError { msg: other.msg, code: other.code, _phantom: PhantomData })
+    }
+}
+
+impl<Format, C: Default + ErrorCode> MergeWithError<Infallible> for DeserrError<Format, C> {
+    fn merge(
+        _self_: Option<Self>,
+        _other: Infallible,
+        _merge_location: ValuePointerRef,
+    ) -> ControlFlow<Self, Self> {
+        unreachable!()
+    }
+}
+
+impl<C: Default + ErrorCode> DeserializeError for DeserrJsonError<C> {
+    fn error<V: IntoValue>(
+        _self_: Option<Self>,
+        error: deserr::ErrorKind<V>,
+        location: ValuePointerRef,
+    ) -> ControlFlow<Self, Self> {
+        ControlFlow::Break(DeserrJsonError::new(
+            take_cf_content(JsonError::error(None, error, location)).to_string(),
+            C::default().error_code(),
+        ))
+    }
+}
+
+impl<C: Default + ErrorCode> DeserializeError for DeserrQueryParamError<C> {
+    fn error<V: IntoValue>(
+        _self_: Option<Self>,
+        error: deserr::ErrorKind<V>,
+        location: ValuePointerRef,
+    ) -> ControlFlow<Self, Self> {
+        ControlFlow::Break(DeserrQueryParamError::new(
+            take_cf_content(QueryParamError::error(None, error, location)).to_string(),
+            C::default().error_code(),
+        ))
+    }
+}
+
+pub fn immutable_field_error(field: &str, accepted: &[&str], code: Code) -> DeserrJsonError {
+    let msg = format!(
+        "Immutable field `{field}`: expected one of {}",
+        accepted
+            .iter()
+            .map(|accepted| format!("`{}`", accepted))
+            .collect::<Vec<String>>()
+            .join(", ")
+    );
+
+    DeserrJsonError::new(msg, code)
+}
+
+// Implement a convenience function to build a `missing_field` error
+macro_rules! make_missing_field_convenience_builder {
+    ($err_code:ident, $fn_name:ident) => {
+        impl DeserrJsonError<$err_code> {
+            pub fn $fn_name(field: &str, location: ValuePointerRef) -> Self {
+                let x = deserr::take_cf_content(Self::error::<Infallible>(
+                    None,
+                    deserr::ErrorKind::MissingField { field },
+                    location,
+                ));
+                Self { msg: x.msg, code: $err_code.error_code(), _phantom: PhantomData }
+            }
+        }
+    };
+}
+make_missing_field_convenience_builder!(MissingIndexUid, missing_index_uid);
+make_missing_field_convenience_builder!(MissingApiKeyActions, missing_api_key_actions);
+make_missing_field_convenience_builder!(MissingApiKeyExpiresAt, missing_api_key_expires_at);
+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
+);
+make_missing_field_convenience_builder!(
+    MissingDocumentEditionFunction,
+    missing_document_edition_function
+);
+
+// Integrate a sub-error into a [`DeserrError`] by taking its error message but using
+// the default error code (C) from `Self`
+macro_rules! merge_with_error_impl_take_error_message {
+    ($err_type:ty) => {
+        impl<Format, C: Default + ErrorCode> MergeWithError<$err_type> for DeserrError<Format, C>
+        where
+            DeserrError<Format, C>: deserr::DeserializeError,
+        {
+            fn merge(
+                _self_: Option<Self>,
+                other: $err_type,
+                merge_location: ValuePointerRef,
+            ) -> ControlFlow<Self, Self> {
+                DeserrError::<Format, C>::error::<Infallible>(
+                    None,
+                    deserr::ErrorKind::Unexpected { msg: other.to_string() },
+                    merge_location,
+                )
+            }
+        }
+    };
+}
+
+// All these errors can be merged into a `DeserrError`
+merge_with_error_impl_take_error_message!(DeserrParseIntError);
+merge_with_error_impl_take_error_message!(DeserrParseBoolError);
+merge_with_error_impl_take_error_message!(uuid::Error);
+merge_with_error_impl_take_error_message!(InvalidTaskDateError);
+merge_with_error_impl_take_error_message!(ParseOffsetDateTimeError);
+merge_with_error_impl_take_error_message!(ParseTaskKindError);
+merge_with_error_impl_take_error_message!(ParseTaskStatusError);
+merge_with_error_impl_take_error_message!(IndexUidFormatError);
+merge_with_error_impl_take_error_message!(InvalidMultiSearchWeight);
+merge_with_error_impl_take_error_message!(InvalidSearchSemanticRatio);
+merge_with_error_impl_take_error_message!(InvalidSearchRankingScoreThreshold);
+merge_with_error_impl_take_error_message!(InvalidSimilarRankingScoreThreshold);
+merge_with_error_impl_take_error_message!(InvalidSimilarId);

crates/meilisearch-types/src/deserr/query_params.rs

@@ -0,0 +1,114 @@
+/*!
+This module provides helper traits, types, and functions to deserialize query parameters.
+
+The source of the problem is that query parameters only give us a string to work with.
+This means `deserr` is never given a sequence or numbers, and thus the default deserialization
+code for common types such as `usize` or `Vec<T>` does not work. To work around it, we create a
+wrapper type called `Param<T>`, which is deserialised using the `from_query_param` method of the trait
+`FromQueryParameter`.
+
+We also use other helper types such as `CS` (i.e. comma-separated) from `serde_cs` as well as
+`StarOr`, `OptionStarOr`, and `OptionStarOrList`.
+*/
+
+use std::convert::Infallible;
+use std::ops::Deref;
+use std::str::FromStr;
+
+use deserr::{DeserializeError, Deserr, MergeWithError, ValueKind};
+
+use super::{DeserrParseBoolError, DeserrParseIntError};
+use crate::index_uid::IndexUid;
+use crate::tasks::{Kind, Status};
+
+/// A wrapper type indicating that the inner value should be
+/// deserialised from a query parameter string.
+///
+/// Note that if the field is optional, it is better to use
+/// `Option<Param<T>>` instead of `Param<Option<T>>`.
+#[derive(Default, Debug, Clone, Copy)]
+pub struct Param<T>(pub T);
+
+impl<T> Deref for Param<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T, E> Deserr<E> for Param<T>
+where
+    E: DeserializeError + MergeWithError<T::Err>,
+    T: FromQueryParameter,
+{
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        value: deserr::Value<V>,
+        location: deserr::ValuePointerRef,
+    ) -> Result<Self, E> {
+        match value {
+            deserr::Value::String(s) => match T::from_query_param(&s) {
+                Ok(x) => Ok(Param(x)),
+                Err(e) => Err(deserr::take_cf_content(E::merge(None, e, location))),
+            },
+            _ => Err(deserr::take_cf_content(E::error(
+                None,
+                deserr::ErrorKind::IncorrectValueKind {
+                    actual: value,
+                    accepted: &[ValueKind::String],
+                },
+                location,
+            ))),
+        }
+    }
+}
+
+/// Parse a value from a query parameter string.
+///
+/// This trait is functionally equivalent to `FromStr`.
+/// Having a separate trait trait allows us to return better
+/// deserializatio error messages.
+pub trait FromQueryParameter: Sized {
+    type Err;
+    fn from_query_param(p: &str) -> Result<Self, Self::Err>;
+}
+
+/// Implement `FromQueryParameter` for the given type using its `FromStr`
+/// trait implementation.
+macro_rules! impl_from_query_param_from_str {
+    ($type:ty) => {
+        impl FromQueryParameter for $type {
+            type Err = <$type as FromStr>::Err;
+            fn from_query_param(p: &str) -> Result<Self, Self::Err> {
+                p.parse()
+            }
+        }
+    };
+}
+impl_from_query_param_from_str!(Kind);
+impl_from_query_param_from_str!(Status);
+impl_from_query_param_from_str!(IndexUid);
+
+/// Implement `FromQueryParameter` for the given type using its `FromStr`
+/// trait implementation, replacing the returned error with a struct
+/// that wraps the original query parameter.
+macro_rules! impl_from_query_param_wrap_original_value_in_error {
+    ($type:ty, $err_type:path) => {
+        impl FromQueryParameter for $type {
+            type Err = $err_type;
+            fn from_query_param(p: &str) -> Result<Self, Self::Err> {
+                p.parse().map_err(|_| $err_type(p.to_owned()))
+            }
+        }
+    };
+}
+impl_from_query_param_wrap_original_value_in_error!(usize, DeserrParseIntError);
+impl_from_query_param_wrap_original_value_in_error!(u32, DeserrParseIntError);
+impl_from_query_param_wrap_original_value_in_error!(bool, DeserrParseBoolError);
+
+impl FromQueryParameter for String {
+    type Err = Infallible;
+    fn from_query_param(p: &str) -> Result<Self, Infallible> {
+        Ok(p.to_owned())
+    }
+}

crates/meilisearch-types/src/document_formats.rs

@@ -0,0 +1,213 @@
+use std::fmt::{self, Debug, Display};
+use std::fs::File;
+use std::io::{self, BufWriter, Write};
+use std::marker::PhantomData;
+
+use memmap2::MmapOptions;
+use milli::documents::{DocumentsBatchBuilder, Error};
+use milli::Object;
+use serde::de::{SeqAccess, Visitor};
+use serde::{Deserialize, Deserializer};
+use serde_json::error::Category;
+
+use crate::error::{Code, ErrorCode};
+
+type Result<T> = std::result::Result<T, DocumentFormatError>;
+
+#[derive(Debug)]
+pub enum PayloadType {
+    Ndjson,
+    Json,
+    Csv { delimiter: u8 },
+}
+
+impl fmt::Display for PayloadType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PayloadType::Ndjson => f.write_str("ndjson"),
+            PayloadType::Json => f.write_str("json"),
+            PayloadType::Csv { .. } => f.write_str("csv"),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum DocumentFormatError {
+    Io(io::Error),
+    MalformedPayload(Error, PayloadType),
+}
+
+impl Display for DocumentFormatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Io(e) => write!(f, "{e}"),
+            Self::MalformedPayload(me, b) => match me {
+                Error::Json(se) => {
+                    let mut message = match se.classify() {
+                        Category::Data => {
+                            "data are neither an object nor a list of objects".to_string()
+                        }
+                        _ => se.to_string(),
+                    };
+
+                    // https://github.com/meilisearch/meilisearch/issues/2107
+                    // The user input maybe insanely long. We need to truncate it.
+                    let ellipsis = "...";
+                    let trim_input_prefix_len = 50;
+                    let trim_input_suffix_len = 85;
+
+                    if message.len()
+                        > trim_input_prefix_len + trim_input_suffix_len + ellipsis.len()
+                    {
+                        message.replace_range(
+                            trim_input_prefix_len..message.len() - trim_input_suffix_len,
+                            ellipsis,
+                        );
+                    }
+
+                    write!(
+                        f,
+                        "The `{}` payload provided is malformed. `Couldn't serialize document value: {}`.",
+                        b, message
+                    )
+                }
+                _ => write!(f, "The `{}` payload provided is malformed: `{}`.", b, me),
+            },
+        }
+    }
+}
+
+impl std::error::Error for DocumentFormatError {}
+
+impl From<(PayloadType, Error)> for DocumentFormatError {
+    fn from((ty, error): (PayloadType, Error)) -> Self {
+        match error {
+            Error::Io(e) => Self::Io(e),
+            e => Self::MalformedPayload(e, ty),
+        }
+    }
+}
+
+impl From<io::Error> for DocumentFormatError {
+    fn from(error: io::Error) -> Self {
+        Self::Io(error)
+    }
+}
+
+impl ErrorCode for DocumentFormatError {
+    fn error_code(&self) -> Code {
+        match self {
+            DocumentFormatError::Io(e) => e.error_code(),
+            DocumentFormatError::MalformedPayload(_, _) => Code::MalformedPayload,
+        }
+    }
+}
+
+/// Reads CSV from input and write an obkv batch to writer.
+pub fn read_csv(file: &File, writer: impl Write, delimiter: u8) -> Result<u64> {
+    let mut builder = DocumentsBatchBuilder::new(BufWriter::new(writer));
+    let mmap = unsafe { MmapOptions::new().map(file)? };
+    let csv = csv::ReaderBuilder::new().delimiter(delimiter).from_reader(mmap.as_ref());
+    builder.append_csv(csv).map_err(|e| (PayloadType::Csv { delimiter }, e))?;
+
+    let count = builder.documents_count();
+    let _ = builder.into_inner().map_err(DocumentFormatError::Io)?;
+
+    Ok(count as u64)
+}
+
+/// Reads JSON from temporary file and write an obkv batch to writer.
+pub fn read_json(file: &File, writer: impl Write) -> Result<u64> {
+    let mut builder = DocumentsBatchBuilder::new(BufWriter::new(writer));
+    let mmap = unsafe { MmapOptions::new().map(file)? };
+    let mut deserializer = serde_json::Deserializer::from_slice(&mmap);
+
+    match array_each(&mut deserializer, |obj| builder.append_json_object(&obj)) {
+        // The json data has been deserialized and does not need to be processed again.
+        // The data has been transferred to the writer during the deserialization process.
+        Ok(Ok(_)) => (),
+        Ok(Err(e)) => return Err(DocumentFormatError::Io(e)),
+        Err(e) => {
+            // Attempt to deserialize a single json string when the cause of the exception is not Category.data
+            // Other types of deserialisation exceptions are returned directly to the front-end
+            if e.classify() != serde_json::error::Category::Data {
+                return Err(DocumentFormatError::MalformedPayload(
+                    Error::Json(e),
+                    PayloadType::Json,
+                ));
+            }
+
+            let content: Object = serde_json::from_slice(&mmap)
+                .map_err(Error::Json)
+                .map_err(|e| (PayloadType::Json, e))?;
+            builder.append_json_object(&content).map_err(DocumentFormatError::Io)?;
+        }
+    }
+
+    let count = builder.documents_count();
+    let _ = builder.into_inner().map_err(DocumentFormatError::Io)?;
+
+    Ok(count as u64)
+}
+
+/// Reads JSON from temporary file  and write an obkv batch to writer.
+pub fn read_ndjson(file: &File, writer: impl Write) -> Result<u64> {
+    let mut builder = DocumentsBatchBuilder::new(BufWriter::new(writer));
+    let mmap = unsafe { MmapOptions::new().map(file)? };
+
+    for result in serde_json::Deserializer::from_slice(&mmap).into_iter() {
+        let object = result.map_err(Error::Json).map_err(|e| (PayloadType::Ndjson, e))?;
+        builder.append_json_object(&object).map_err(Into::into).map_err(DocumentFormatError::Io)?;
+    }
+
+    let count = builder.documents_count();
+    let _ = builder.into_inner().map_err(Into::into).map_err(DocumentFormatError::Io)?;
+
+    Ok(count as u64)
+}
+
+/// The actual handling of the deserialization process in serde
+/// avoids storing the deserialized object in memory.
+///
+/// ## References
+/// <https://serde.rs/stream-array.html>
+/// <https://github.com/serde-rs/json/issues/160>
+fn array_each<'de, D, T, F>(deserializer: D, f: F) -> std::result::Result<io::Result<u64>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+    F: FnMut(T) -> io::Result<()>,
+{
+    struct SeqVisitor<T, F>(F, PhantomData<T>);
+
+    impl<'de, T, F> Visitor<'de> for SeqVisitor<T, F>
+    where
+        T: Deserialize<'de>,
+        F: FnMut(T) -> io::Result<()>,
+    {
+        type Value = io::Result<u64>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a nonempty sequence")
+        }
+
+        fn visit_seq<A>(
+            mut self,
+            mut seq: A,
+        ) -> std::result::Result<io::Result<u64>, <A as SeqAccess<'de>>::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let mut max: u64 = 0;
+            while let Some(value) = seq.next_element::<T>()? {
+                match self.0(value) {
+                    Ok(()) => max += 1,
+                    Err(e) => return Ok(Err(e)),
+                };
+            }
+            Ok(Ok(max))
+        }
+    }
+    let visitor = SeqVisitor(f, PhantomData);
+    deserializer.deserialize_seq(visitor)
+}

crates/meilisearch-types/src/error.rs

@@ -0,0 +1,578 @@
+use std::{fmt, io};
+
+use actix_web::http::StatusCode;
+use actix_web::{self as aweb, HttpResponseBuilder};
+use aweb::http::header;
+use aweb::rt::task::JoinError;
+use convert_case::Casing;
+use milli::heed::{Error as HeedError, MdbError};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ResponseError {
+    #[serde(skip)]
+    pub code: StatusCode,
+    pub message: String,
+    #[serde(rename = "code")]
+    error_code: String,
+    #[serde(rename = "type")]
+    error_type: String,
+    #[serde(rename = "link")]
+    error_link: String,
+}
+
+impl ResponseError {
+    pub fn from_msg(mut message: String, code: Code) -> Self {
+        if code == Code::IoError {
+            message.push_str(". This error generally happens when you have no space left on device or when your database doesn't have read or write right.");
+        }
+        Self {
+            code: code.http(),
+            message,
+            error_code: code.name(),
+            error_type: code.type_(),
+            error_link: code.url(),
+        }
+    }
+}
+
+impl fmt::Display for ResponseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.message.fmt(f)
+    }
+}
+
+impl std::error::Error for ResponseError {}
+
+impl<T> From<T> for ResponseError
+where
+    T: std::error::Error + ErrorCode,
+{
+    fn from(other: T) -> Self {
+        Self::from_msg(other.to_string(), other.error_code())
+    }
+}
+
+impl aweb::error::ResponseError for ResponseError {
+    fn error_response(&self) -> aweb::HttpResponse {
+        let json = serde_json::to_vec(self).unwrap();
+        let mut builder = HttpResponseBuilder::new(self.status_code());
+        builder.content_type("application/json");
+
+        if self.code == StatusCode::SERVICE_UNAVAILABLE {
+            builder.insert_header((header::RETRY_AFTER, "10"));
+        }
+
+        builder.body(json)
+    }
+
+    fn status_code(&self) -> StatusCode {
+        self.code
+    }
+}
+
+pub trait ErrorCode {
+    fn error_code(&self) -> Code;
+
+    /// returns the HTTP status code associated with the error
+    fn http_status(&self) -> StatusCode {
+        self.error_code().http()
+    }
+
+    /// returns the doc url associated with the error
+    fn error_url(&self) -> String {
+        self.error_code().url()
+    }
+
+    /// returns error name, used as error code
+    fn error_name(&self) -> String {
+        self.error_code().name()
+    }
+
+    /// return the error type
+    fn error_type(&self) -> String {
+        self.error_code().type_()
+    }
+}
+
+#[allow(clippy::enum_variant_names)]
+enum ErrorType {
+    Internal,
+    InvalidRequest,
+    Auth,
+    System,
+}
+
+impl fmt::Display for ErrorType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use ErrorType::*;
+
+        match self {
+            Internal => write!(f, "internal"),
+            InvalidRequest => write!(f, "invalid_request"),
+            Auth => write!(f, "auth"),
+            System => write!(f, "system"),
+        }
+    }
+}
+
+/// Implement all the error codes.
+///
+/// 1. Make an enum `Code` where each error code is a variant
+/// 2. Implement the `http`, `name`, and `type_` method on the enum
+/// 3. Make a unit type for each error code in the module `deserr_codes`.
+///
+/// The unit type's purpose is to be used as a marker type parameter, e.g.
+/// `DeserrJsonError<MyErrorCode>`. It implements `Default` and `ErrorCode`,
+/// so we can get a value of the `Code` enum with the correct variant by calling
+/// `MyErrorCode::default().error_code()`.
+macro_rules! make_error_codes {
+    ($($code_ident:ident, $err_type:ident, $status:ident);*) => {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub enum Code {
+            $($code_ident),*
+        }
+        impl Code {
+            /// return the HTTP status code associated with the `Code`
+            pub fn http(&self) -> StatusCode {
+                match self {
+                    $(
+                        Code::$code_ident => StatusCode::$status
+                    ),*
+                }
+            }
+
+            /// return error name, used as error code
+            fn name(&self) -> String {
+                match self {
+                    $(
+                        Code::$code_ident => stringify!($code_ident).to_case(convert_case::Case::Snake)
+                    ),*
+                }
+            }
+
+            /// return the error type
+            fn type_(&self) -> String {
+                match self {
+                    $(
+                        Code::$code_ident => ErrorType::$err_type.to_string()
+                    ),*
+                }
+            }
+
+            /// return the doc url associated with the error
+            fn url(&self) -> String {
+                format!("https://docs.meilisearch.com/errors#{}", self.name())
+            }
+        }
+        pub mod deserr_codes {
+            use super::{Code, ErrorCode};
+            $(
+                #[derive(Default)]
+                pub struct $code_ident;
+                impl ErrorCode for $code_ident {
+                    fn error_code(&self) -> Code {
+                        Code::$code_ident
+                    }
+                }
+            )*
+        }
+    }
+}
+
+// An exhaustive list of all the error codes used by meilisearch.
+make_error_codes! {
+ApiKeyAlreadyExists                   , InvalidRequest       , CONFLICT ;
+ApiKeyNotFound                        , InvalidRequest       , NOT_FOUND ;
+BadParameter                          , InvalidRequest       , BAD_REQUEST;
+BadRequest                            , InvalidRequest       , BAD_REQUEST;
+DatabaseSizeLimitReached              , Internal             , INTERNAL_SERVER_ERROR;
+DocumentNotFound                      , InvalidRequest       , NOT_FOUND;
+DumpAlreadyProcessing                 , InvalidRequest       , CONFLICT;
+DumpNotFound                          , InvalidRequest       , NOT_FOUND;
+DumpProcessFailed                     , Internal             , INTERNAL_SERVER_ERROR;
+DuplicateIndexFound                   , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyActions                , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyCreatedAt              , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyExpiresAt              , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyIndexes                , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyKey                    , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyUid                    , InvalidRequest       , BAD_REQUEST;
+ImmutableApiKeyUpdatedAt              , InvalidRequest       , BAD_REQUEST;
+ImmutableIndexCreatedAt               , InvalidRequest       , BAD_REQUEST;
+ImmutableIndexUid                     , InvalidRequest       , BAD_REQUEST;
+ImmutableIndexUpdatedAt               , InvalidRequest       , BAD_REQUEST;
+IndexAlreadyExists                    , InvalidRequest       , CONFLICT ;
+IndexCreationFailed                   , Internal             , INTERNAL_SERVER_ERROR;
+IndexNotFound                         , InvalidRequest       , NOT_FOUND;
+IndexPrimaryKeyAlreadyExists          , InvalidRequest       , BAD_REQUEST ;
+IndexPrimaryKeyMultipleCandidatesFound, InvalidRequest       , BAD_REQUEST;
+IndexPrimaryKeyNoCandidateFound       , InvalidRequest       , BAD_REQUEST ;
+Internal                              , Internal             , INTERNAL_SERVER_ERROR ;
+InvalidApiKey                         , Auth                 , FORBIDDEN ;
+InvalidApiKeyActions                  , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyDescription              , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyExpiresAt                , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyIndexes                  , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyLimit                    , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyName                     , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyOffset                   , InvalidRequest       , BAD_REQUEST ;
+InvalidApiKeyUid                      , InvalidRequest       , BAD_REQUEST ;
+InvalidContentType                    , InvalidRequest       , UNSUPPORTED_MEDIA_TYPE ;
+InvalidDocumentCsvDelimiter           , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentFields                 , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentRetrieveVectors        , InvalidRequest       , BAD_REQUEST ;
+MissingDocumentFilter                 , InvalidRequest       , BAD_REQUEST ;
+MissingDocumentEditionFunction        , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentFilter                 , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentGeoField               , InvalidRequest       , BAD_REQUEST ;
+InvalidVectorDimensions               , InvalidRequest       , BAD_REQUEST ;
+InvalidVectorsType                    , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentId                     , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentLimit                  , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentOffset                 , InvalidRequest       , BAD_REQUEST ;
+InvalidEmbedder                       , InvalidRequest       , BAD_REQUEST ;
+InvalidHybridQuery                    , InvalidRequest       , BAD_REQUEST ;
+InvalidIndexLimit                     , InvalidRequest       , BAD_REQUEST ;
+InvalidIndexOffset                    , InvalidRequest       , BAD_REQUEST ;
+InvalidIndexPrimaryKey                , InvalidRequest       , BAD_REQUEST ;
+InvalidIndexUid                       , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFacets              , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFacetsByIndex       , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFacetOrder          , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFederated           , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFederationOptions   , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchMaxValuesPerFacet   , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchMergeFacets         , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchQueryFacets         , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchQueryPagination     , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchQueryRankingRules   , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchWeight              , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchAttributesToSearchOn     , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchAttributesToCrop         , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchAttributesToHighlight    , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarAttributesToRetrieve    , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarRetrieveVectors         , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchAttributesToRetrieve     , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchRankingScoreThreshold    , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarRankingScoreThreshold   , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchRetrieveVectors          , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchCropLength               , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchCropMarker               , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchFacets                   , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchSemanticRatio            , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchLocales                  , InvalidRequest       , BAD_REQUEST ;
+InvalidFacetSearchFacetName           , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarId                      , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchFilter                   , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarFilter                  , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchHighlightPostTag         , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchHighlightPreTag          , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchHitsPerPage              , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarLimit                   , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchLimit                    , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchMatchingStrategy         , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarOffset                  , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchOffset                   , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchPage                     , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchQ                        , InvalidRequest       , BAD_REQUEST ;
+InvalidFacetSearchQuery               , InvalidRequest       , BAD_REQUEST ;
+InvalidFacetSearchName                , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchVector                   , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchShowMatchesPosition      , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchShowRankingScore         , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarShowRankingScore        , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchShowRankingScoreDetails  , InvalidRequest       , BAD_REQUEST ;
+InvalidSimilarShowRankingScoreDetails , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchSort                     , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchDistinct                 , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsDisplayedAttributes    , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsDistinctAttribute      , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsProximityPrecision     , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsFaceting               , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsFilterableAttributes   , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsPagination             , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsSearchCutoffMs         , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsEmbedders              , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsRankingRules           , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsSearchableAttributes   , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsSortableAttributes     , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsStopWords              , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsNonSeparatorTokens     , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsSeparatorTokens        , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsDictionary             , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsSynonyms               , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsTypoTolerance          , InvalidRequest       , BAD_REQUEST ;
+InvalidSettingsLocalizedAttributes    , InvalidRequest       , BAD_REQUEST ;
+InvalidState                          , Internal             , INTERNAL_SERVER_ERROR ;
+InvalidStoreFile                      , Internal             , INTERNAL_SERVER_ERROR ;
+InvalidSwapDuplicateIndexFound        , InvalidRequest       , BAD_REQUEST ;
+InvalidSwapIndexes                    , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskAfterEnqueuedAt            , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskAfterFinishedAt            , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskAfterStartedAt             , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskBeforeEnqueuedAt           , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskBeforeFinishedAt           , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskBeforeStartedAt            , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskCanceledBy                 , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskFrom                       , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskLimit                      , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskStatuses                   , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskTypes                      , InvalidRequest       , BAD_REQUEST ;
+InvalidTaskUids                       , InvalidRequest       , BAD_REQUEST  ;
+IoError                               , System               , UNPROCESSABLE_ENTITY;
+FeatureNotEnabled                     , InvalidRequest       , BAD_REQUEST ;
+MalformedPayload                      , InvalidRequest       , BAD_REQUEST ;
+MaxFieldsLimitExceeded                , InvalidRequest       , BAD_REQUEST ;
+MissingApiKeyActions                  , InvalidRequest       , BAD_REQUEST ;
+MissingApiKeyExpiresAt                , InvalidRequest       , BAD_REQUEST ;
+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 ;
+MissingSearchHybrid                   , InvalidRequest       , BAD_REQUEST ;
+MissingSwapIndexes                    , InvalidRequest       , BAD_REQUEST ;
+MissingTaskFilters                    , InvalidRequest       , BAD_REQUEST ;
+NoSpaceLeftOnDevice                   , System               , UNPROCESSABLE_ENTITY;
+PayloadTooLarge                       , InvalidRequest       , PAYLOAD_TOO_LARGE ;
+TooManySearchRequests                 , System               , SERVICE_UNAVAILABLE ;
+TaskNotFound                          , InvalidRequest       , NOT_FOUND ;
+TooManyOpenFiles                      , System               , UNPROCESSABLE_ENTITY ;
+TooManyVectors                        , InvalidRequest       , BAD_REQUEST ;
+UnretrievableDocument                 , Internal             , BAD_REQUEST ;
+UnretrievableErrorCode                , InvalidRequest       , BAD_REQUEST ;
+UnsupportedMediaType                  , InvalidRequest       , UNSUPPORTED_MEDIA_TYPE ;
+
+// Experimental features
+VectorEmbeddingError                  , InvalidRequest       , BAD_REQUEST ;
+NotFoundSimilarId                     , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentEditionContext         , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentEditionFunctionFilter  , InvalidRequest       , BAD_REQUEST ;
+EditDocumentsByFunctionError          , InvalidRequest       , BAD_REQUEST
+}
+
+impl ErrorCode for JoinError {
+    fn error_code(&self) -> Code {
+        Code::Internal
+    }
+}
+
+impl ErrorCode for milli::Error {
+    fn error_code(&self) -> Code {
+        use milli::{Error, UserError};
+
+        match self {
+            Error::InternalError(_) => Code::Internal,
+            Error::IoError(e) => e.error_code(),
+            Error::UserError(ref error) => {
+                match error {
+                    // TODO: wait for spec for new error codes.
+                    UserError::SerdeJson(_)
+                    | UserError::InvalidLmdbOpenOptions
+                    | UserError::DocumentLimitReached
+                    | UserError::UnknownInternalDocumentId { .. } => Code::Internal,
+                    UserError::InvalidStoreFile => Code::InvalidStoreFile,
+                    UserError::NoSpaceLeftOnDevice => Code::NoSpaceLeftOnDevice,
+                    UserError::MaxDatabaseSizeReached => Code::DatabaseSizeLimitReached,
+                    UserError::AttributeLimitReached => Code::MaxFieldsLimitExceeded,
+                    UserError::InvalidFilter(_) => Code::InvalidSearchFilter,
+                    UserError::InvalidFilterExpression(..) => Code::InvalidSearchFilter,
+                    UserError::MissingDocumentId { .. } => Code::MissingDocumentId,
+                    UserError::InvalidDocumentId { .. } | UserError::TooManyDocumentIds { .. } => {
+                        Code::InvalidDocumentId
+                    }
+                    UserError::MissingDocumentField(_) => Code::InvalidDocumentFields,
+                    UserError::InvalidFieldForSource { .. }
+                    | UserError::MissingFieldForSource { .. }
+                    | UserError::InvalidOpenAiModel { .. }
+                    | UserError::InvalidOpenAiModelDimensions { .. }
+                    | UserError::InvalidOpenAiModelDimensionsMax { .. }
+                    | UserError::InvalidSettingsDimensions { .. }
+                    | UserError::InvalidUrl { .. }
+                    | UserError::InvalidSettingsDocumentTemplateMaxBytes { .. }
+                    | UserError::InvalidPrompt(_)
+                    | UserError::InvalidDisableBinaryQuantization { .. } => {
+                        Code::InvalidSettingsEmbedders
+                    }
+                    UserError::TooManyEmbedders(_) => Code::InvalidSettingsEmbedders,
+                    UserError::InvalidPromptForEmbeddings(..) => Code::InvalidSettingsEmbedders,
+                    UserError::NoPrimaryKeyCandidateFound => Code::IndexPrimaryKeyNoCandidateFound,
+                    UserError::MultiplePrimaryKeyCandidatesFound { .. } => {
+                        Code::IndexPrimaryKeyMultipleCandidatesFound
+                    }
+                    UserError::PrimaryKeyCannotBeChanged(_) => Code::IndexPrimaryKeyAlreadyExists,
+                    UserError::InvalidDistinctAttribute { .. } => Code::InvalidSearchDistinct,
+                    UserError::SortRankingRuleMissing => Code::InvalidSearchSort,
+                    UserError::InvalidFacetsDistribution { .. } => Code::InvalidSearchFacets,
+                    UserError::InvalidSortableAttribute { .. } => Code::InvalidSearchSort,
+                    UserError::InvalidSearchableAttribute { .. } => {
+                        Code::InvalidSearchAttributesToSearchOn
+                    }
+                    UserError::InvalidFacetSearchFacetName { .. } => {
+                        Code::InvalidFacetSearchFacetName
+                    }
+                    UserError::CriterionError(_) => Code::InvalidSettingsRankingRules,
+                    UserError::InvalidGeoField { .. } => Code::InvalidDocumentGeoField,
+                    UserError::InvalidVectorDimensions { .. } => Code::InvalidVectorDimensions,
+                    UserError::InvalidVectorsMapType { .. }
+                    | UserError::InvalidVectorsEmbedderConf { .. } => Code::InvalidVectorsType,
+                    UserError::TooManyVectors(_, _) => Code::TooManyVectors,
+                    UserError::SortError(_) => Code::InvalidSearchSort,
+                    UserError::InvalidMinTypoWordLenSetting(_, _) => {
+                        Code::InvalidSettingsTypoTolerance
+                    }
+                    UserError::InvalidEmbedder(_) => Code::InvalidEmbedder,
+                    UserError::VectorEmbeddingError(_) | UserError::DocumentEmbeddingError(_) => {
+                        Code::VectorEmbeddingError
+                    }
+                    UserError::DocumentEditionCannotModifyPrimaryKey
+                    | UserError::DocumentEditionDocumentMustBeObject
+                    | UserError::DocumentEditionRuntimeError(_)
+                    | UserError::DocumentEditionCompilationError(_) => {
+                        Code::EditDocumentsByFunctionError
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl ErrorCode for file_store::Error {
+    fn error_code(&self) -> Code {
+        match self {
+            Self::IoError(e) => e.error_code(),
+            Self::PersistError(e) => e.error_code(),
+            Self::CouldNotParseFileNameAsUtf8 | Self::UuidError(_) => Code::Internal,
+        }
+    }
+}
+
+impl ErrorCode for tempfile::PersistError {
+    fn error_code(&self) -> Code {
+        self.error.error_code()
+    }
+}
+
+impl ErrorCode for HeedError {
+    fn error_code(&self) -> Code {
+        match self {
+            HeedError::Mdb(MdbError::MapFull) => Code::DatabaseSizeLimitReached,
+            HeedError::Mdb(MdbError::Invalid) => Code::InvalidStoreFile,
+            HeedError::Io(e) => e.error_code(),
+            HeedError::Mdb(_)
+            | HeedError::Encoding(_)
+            | HeedError::Decoding(_)
+            | HeedError::DatabaseClosing
+            | HeedError::BadOpenOptions { .. } => Code::Internal,
+        }
+    }
+}
+
+impl ErrorCode for io::Error {
+    fn error_code(&self) -> Code {
+        match self.raw_os_error() {
+            Some(5) => Code::IoError,
+            Some(24) => Code::TooManyOpenFiles,
+            Some(28) => Code::NoSpaceLeftOnDevice,
+            _ => Code::Internal,
+        }
+    }
+}
+
+/// Deserialization when `deserr` cannot parse an API key date.
+#[derive(Debug)]
+pub struct ParseOffsetDateTimeError(pub String);
+impl fmt::Display for ParseOffsetDateTimeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "`{original}` is not a valid date. It should follow the RFC 3339 format to represents a date or datetime in the future or specified as a null value. e.g. 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS'.", original = self.0)
+    }
+}
+
+/// Deserialization when `deserr` cannot parse a task date.
+#[derive(Debug)]
+pub struct InvalidTaskDateError(pub String);
+impl std::fmt::Display for InvalidTaskDateError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "`{}` is an invalid date-time. It should follow the YYYY-MM-DD or RFC 3339 date-time format.", self.0)
+    }
+}
+
+/// Deserialization error when `deserr` cannot parse a String
+/// into a bool.
+#[derive(Debug)]
+pub struct DeserrParseBoolError(pub String);
+impl fmt::Display for DeserrParseBoolError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "could not parse `{}` as a boolean, expected either `true` or `false`", self.0)
+    }
+}
+
+/// Deserialization error when `deserr` cannot parse a String
+/// into an integer.
+#[derive(Debug)]
+pub struct DeserrParseIntError(pub String);
+impl fmt::Display for DeserrParseIntError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "could not parse `{}` as a positive integer", self.0)
+    }
+}
+
+impl fmt::Display for deserr_codes::InvalidSearchSemanticRatio {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "the value of `semanticRatio` is invalid, expected a float between `0.0` and `1.0`."
+        )
+    }
+}
+
+impl fmt::Display for deserr_codes::InvalidMultiSearchWeight {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "the value of `weight` is invalid, expected a positive float (>= 0.0).")
+    }
+}
+
+impl fmt::Display for deserr_codes::InvalidSimilarId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "the value of `id` is invalid. \
+            A document identifier can be of type integer or string, \
+            only composed of alphanumeric characters (a-z A-Z 0-9), hyphens (-) and underscores (_), \
+            and can not be more than 512 bytes."
+        )
+    }
+}
+
+impl fmt::Display for deserr_codes::InvalidSearchRankingScoreThreshold {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "the value of `rankingScoreThreshold` is invalid, expected a float between `0.0` and `1.0`."
+        )
+    }
+}
+
+impl fmt::Display for deserr_codes::InvalidSimilarRankingScoreThreshold {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        deserr_codes::InvalidSearchRankingScoreThreshold.fmt(f)
+    }
+}
+
+#[macro_export]
+macro_rules! internal_error {
+    ($target:ty : $($other:path), *) => {
+        $(
+            impl From<$other> for $target {
+                fn from(other: $other) -> Self {
+                    Self::Internal(Box::new(other))
+                }
+            }
+        )*
+    }
+}

crates/meilisearch-types/src/facet_values_sort.rs

@@ -0,0 +1,33 @@
+use deserr::Deserr;
+use milli::OrderBy;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Deserr)]
+#[serde(rename_all = "camelCase")]
+#[deserr(rename_all = camelCase)]
+pub enum FacetValuesSort {
+    /// Facet values are sorted in alphabetical order, ascending from A to Z.
+    #[default]
+    Alpha,
+    /// Facet values are sorted by decreasing count.
+    /// The count is the number of records containing this facet value in the results of the query.
+    Count,
+}
+
+impl From<FacetValuesSort> for OrderBy {
+    fn from(val: FacetValuesSort) -> Self {
+        match val {
+            FacetValuesSort::Alpha => OrderBy::Lexicographic,
+            FacetValuesSort::Count => OrderBy::Count,
+        }
+    }
+}
+
+impl From<OrderBy> for FacetValuesSort {
+    fn from(val: OrderBy) -> Self {
+        match val {
+            OrderBy::Lexicographic => FacetValuesSort::Alpha,
+            OrderBy::Count => FacetValuesSort::Count,
+        }
+    }
+}

crates/meilisearch-types/src/features.rs

@@ -0,0 +1,18 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, Default, PartialEq, Eq)]
+#[serde(rename_all = "camelCase", default)]
+pub struct RuntimeTogglableFeatures {
+    pub vector_store: bool,
+    pub metrics: bool,
+    pub logs_route: bool,
+    pub edit_documents_by_function: bool,
+    pub contains_filter: bool,
+}
+
+#[derive(Default, Debug, Clone, Copy)]
+pub struct InstanceTogglableFeatures {
+    pub metrics: bool,
+    pub logs_route: bool,
+    pub contains_filter: bool,
+}

crates/meilisearch-types/src/index_uid.rs

@@ -0,0 +1,104 @@
+use std::borrow::Borrow;
+use std::error::Error;
+use std::fmt;
+use std::str::FromStr;
+
+use deserr::Deserr;
+
+use crate::error::{Code, ErrorCode};
+
+/// An index uid is composed of only ascii alphanumeric characters, - and _, between 1 and 400
+/// bytes long
+#[derive(Debug, Clone, PartialEq, Eq, Deserr, PartialOrd, Ord)]
+#[deserr(try_from(String) = IndexUid::try_from -> IndexUidFormatError)]
+pub struct IndexUid(String);
+
+impl IndexUid {
+    pub fn new_unchecked(s: impl AsRef<str>) -> Self {
+        Self(s.as_ref().to_string())
+    }
+
+    pub fn into_inner(self) -> String {
+        self.0
+    }
+
+    /// Return a reference over the inner str.
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl fmt::Display for IndexUid {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl std::ops::Deref for IndexUid {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl TryFrom<String> for IndexUid {
+    type Error = IndexUidFormatError;
+
+    fn try_from(uid: String) -> Result<Self, Self::Error> {
+        if !uid.chars().all(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_')
+            || uid.is_empty()
+            || uid.len() > 400
+        {
+            Err(IndexUidFormatError { invalid_uid: uid })
+        } else {
+            Ok(IndexUid(uid))
+        }
+    }
+}
+
+impl FromStr for IndexUid {
+    type Err = IndexUidFormatError;
+
+    fn from_str(uid: &str) -> Result<IndexUid, IndexUidFormatError> {
+        uid.to_string().try_into()
+    }
+}
+
+impl From<IndexUid> for String {
+    fn from(uid: IndexUid) -> Self {
+        uid.into_inner()
+    }
+}
+
+impl Borrow<String> for IndexUid {
+    fn borrow(&self) -> &String {
+        &self.0
+    }
+}
+
+#[derive(Debug)]
+pub struct IndexUidFormatError {
+    pub invalid_uid: String,
+}
+
+impl fmt::Display for IndexUidFormatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "`{}` is not a valid index uid. Index uid can be an \
+            integer or a string containing only alphanumeric \
+            characters, hyphens (-) and underscores (_), \
+            and can not be more than 512 bytes.",
+            self.invalid_uid,
+        )
+    }
+}
+
+impl Error for IndexUidFormatError {}
+
+impl ErrorCode for IndexUidFormatError {
+    fn error_code(&self) -> Code {
+        Code::InvalidIndexUid
+    }
+}

crates/meilisearch-types/src/index_uid_pattern.rs

@@ -0,0 +1,124 @@
+use std::borrow::Borrow;
+use std::error::Error;
+use std::fmt;
+use std::ops::Deref;
+use std::str::FromStr;
+
+use deserr::Deserr;
+use serde::{Deserialize, Serialize};
+
+use crate::error::{Code, ErrorCode};
+use crate::index_uid::{IndexUid, IndexUidFormatError};
+
+/// An index uid pattern is composed of only ascii alphanumeric characters, - and _, between 1 and 400
+/// bytes long and optionally ending with a *.
+#[derive(Serialize, Deserialize, Deserr, Debug, Clone, PartialEq, Eq, Hash)]
+#[deserr(try_from(&String) = FromStr::from_str -> IndexUidPatternFormatError)]
+pub struct IndexUidPattern(String);
+
+impl IndexUidPattern {
+    pub fn new_unchecked(s: impl AsRef<str>) -> Self {
+        Self(s.as_ref().to_string())
+    }
+
+    /// Matches any index name.
+    pub fn all() -> Self {
+        IndexUidPattern::from_str("*").unwrap()
+    }
+
+    /// Returns `true` if it matches any index.
+    pub fn matches_all(&self) -> bool {
+        self.0 == "*"
+    }
+
+    /// Returns `true` if the pattern matches a specific index name.
+    pub fn is_exact(&self) -> bool {
+        !self.0.ends_with('*')
+    }
+
+    /// Returns wether this index uid matches this index uid pattern.
+    pub fn matches(&self, uid: &IndexUid) -> bool {
+        self.matches_str(uid.as_str())
+    }
+
+    /// Returns wether this string matches this index uid pattern.
+    pub fn matches_str(&self, uid: &str) -> bool {
+        match self.0.strip_suffix('*') {
+            Some(prefix) => uid.starts_with(prefix),
+            None => self.0 == uid,
+        }
+    }
+}
+
+impl Deref for IndexUidPattern {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Borrow<str> for IndexUidPattern {
+    fn borrow(&self) -> &str {
+        &self.0
+    }
+}
+
+impl TryFrom<String> for IndexUidPattern {
+    type Error = IndexUidPatternFormatError;
+
+    fn try_from(uid: String) -> Result<Self, Self::Error> {
+        let result = match uid.strip_suffix('*') {
+            Some("") => Ok(IndexUidPattern(uid)),
+            Some(prefix) => IndexUid::from_str(prefix).map(|_| IndexUidPattern(uid)),
+            None => IndexUid::try_from(uid).map(IndexUid::into_inner).map(IndexUidPattern),
+        };
+
+        match result {
+            Ok(index_uid_pattern) => Ok(index_uid_pattern),
+            Err(IndexUidFormatError { invalid_uid }) => {
+                Err(IndexUidPatternFormatError { invalid_uid })
+            }
+        }
+    }
+}
+
+impl FromStr for IndexUidPattern {
+    type Err = IndexUidPatternFormatError;
+
+    fn from_str(uid: &str) -> Result<IndexUidPattern, IndexUidPatternFormatError> {
+        uid.to_string().try_into()
+    }
+}
+
+impl From<IndexUidPattern> for String {
+    fn from(IndexUidPattern(uid): IndexUidPattern) -> Self {
+        uid
+    }
+}
+
+#[derive(Debug)]
+pub struct IndexUidPatternFormatError {
+    pub invalid_uid: String,
+}
+
+impl fmt::Display for IndexUidPatternFormatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "`{}` is not a valid index uid pattern. Index uid patterns \
+            can be an integer or a string containing only alphanumeric \
+            characters, hyphens (-), underscores (_), and \
+            optionally end with a star (*).",
+            self.invalid_uid,
+        )
+    }
+}
+
+impl Error for IndexUidPatternFormatError {}
+
+impl ErrorCode for IndexUidPatternFormatError {
+    fn error_code(&self) -> Code {
+        Code::InvalidIndexUid
+    }
+}

crates/meilisearch-types/src/keys.rs

@@ -0,0 +1,371 @@
+use std::convert::Infallible;
+use std::hash::Hash;
+use std::str::FromStr;
+
+use deserr::{DeserializeError, Deserr, MergeWithError, ValuePointerRef};
+use enum_iterator::Sequence;
+use milli::update::Setting;
+use serde::{Deserialize, Serialize};
+use time::format_description::well_known::Rfc3339;
+use time::macros::{format_description, time};
+use time::{Date, OffsetDateTime, PrimitiveDateTime};
+use uuid::Uuid;
+
+use crate::deserr::{immutable_field_error, DeserrError, DeserrJsonError};
+use crate::error::deserr_codes::*;
+use crate::error::{Code, ErrorCode, ParseOffsetDateTimeError};
+use crate::index_uid_pattern::{IndexUidPattern, IndexUidPatternFormatError};
+
+pub type KeyId = Uuid;
+
+impl<C: Default + ErrorCode> MergeWithError<IndexUidPatternFormatError> for DeserrJsonError<C> {
+    fn merge(
+        _self_: Option<Self>,
+        other: IndexUidPatternFormatError,
+        merge_location: deserr::ValuePointerRef,
+    ) -> std::ops::ControlFlow<Self, Self> {
+        DeserrError::error::<Infallible>(
+            None,
+            deserr::ErrorKind::Unexpected { msg: other.to_string() },
+            merge_location,
+        )
+    }
+}
+
+#[derive(Debug, Deserr)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct CreateApiKey {
+    #[deserr(default, error = DeserrJsonError<InvalidApiKeyDescription>)]
+    pub description: Option<String>,
+    #[deserr(default, error = DeserrJsonError<InvalidApiKeyName>)]
+    pub name: Option<String>,
+    #[deserr(default = Uuid::new_v4(), error = DeserrJsonError<InvalidApiKeyUid>, try_from(&String) = Uuid::from_str -> uuid::Error)]
+    pub uid: KeyId,
+    #[deserr(error = DeserrJsonError<InvalidApiKeyActions>, missing_field_error = DeserrJsonError::missing_api_key_actions)]
+    pub actions: Vec<Action>,
+    #[deserr(error = DeserrJsonError<InvalidApiKeyIndexes>, missing_field_error = DeserrJsonError::missing_api_key_indexes)]
+    pub indexes: Vec<IndexUidPattern>,
+    #[deserr(error = DeserrJsonError<InvalidApiKeyExpiresAt>, try_from(Option<String>) = parse_expiration_date -> ParseOffsetDateTimeError, missing_field_error = DeserrJsonError::missing_api_key_expires_at)]
+    pub expires_at: Option<OffsetDateTime>,
+}
+
+impl CreateApiKey {
+    pub fn to_key(self) -> Key {
+        let CreateApiKey { description, name, uid, actions, indexes, expires_at } = self;
+        let now = OffsetDateTime::now_utc();
+        Key {
+            description,
+            name,
+            uid,
+            actions,
+            indexes,
+            expires_at,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+}
+
+fn deny_immutable_fields_api_key(
+    field: &str,
+    accepted: &[&str],
+    location: ValuePointerRef,
+) -> DeserrJsonError {
+    match field {
+        "uid" => immutable_field_error(field, accepted, Code::ImmutableApiKeyUid),
+        "actions" => immutable_field_error(field, accepted, Code::ImmutableApiKeyActions),
+        "indexes" => immutable_field_error(field, accepted, Code::ImmutableApiKeyIndexes),
+        "expiresAt" => immutable_field_error(field, accepted, Code::ImmutableApiKeyExpiresAt),
+        "createdAt" => immutable_field_error(field, accepted, Code::ImmutableApiKeyCreatedAt),
+        "updatedAt" => immutable_field_error(field, accepted, Code::ImmutableApiKeyUpdatedAt),
+        _ => deserr::take_cf_content(DeserrJsonError::<BadRequest>::error::<Infallible>(
+            None,
+            deserr::ErrorKind::UnknownKey { key: field, accepted },
+            location,
+        )),
+    }
+}
+
+#[derive(Debug, Deserr)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields = deny_immutable_fields_api_key)]
+pub struct PatchApiKey {
+    #[deserr(default, error = DeserrJsonError<InvalidApiKeyDescription>)]
+    pub description: Setting<String>,
+    #[deserr(default, error = DeserrJsonError<InvalidApiKeyName>)]
+    pub name: Setting<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct Key {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    pub uid: KeyId,
+    pub actions: Vec<Action>,
+    pub indexes: Vec<IndexUidPattern>,
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub expires_at: Option<OffsetDateTime>,
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339")]
+    pub updated_at: OffsetDateTime,
+}
+
+impl Key {
+    pub fn default_admin() -> Self {
+        let now = OffsetDateTime::now_utc();
+        let uid = Uuid::new_v4();
+        Self {
+            name: Some("Default Admin API Key".to_string()),
+            description: Some("Use it for anything that is not a search operation. Caution! Do not expose it on a public frontend".to_string()),
+            uid,
+            actions: vec![Action::All],
+            indexes: vec![IndexUidPattern::all()],
+            expires_at: None,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+
+    pub fn default_search() -> Self {
+        let now = OffsetDateTime::now_utc();
+        let uid = Uuid::new_v4();
+        Self {
+            name: Some("Default Search API Key".to_string()),
+            description: Some("Use it to search from the frontend".to_string()),
+            uid,
+            actions: vec![Action::Search],
+            indexes: vec![IndexUidPattern::all()],
+            expires_at: None,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+}
+
+fn parse_expiration_date(
+    string: Option<String>,
+) -> std::result::Result<Option<OffsetDateTime>, ParseOffsetDateTimeError> {
+    let Some(string) = string else { return Ok(None) };
+    let datetime = if let Ok(datetime) = OffsetDateTime::parse(&string, &Rfc3339) {
+        datetime
+    } else if let Ok(primitive_datetime) = PrimitiveDateTime::parse(
+        &string,
+        format_description!(
+            "[year repr:full base:calendar]-[month repr:numerical]-[day]T[hour]:[minute]:[second]"
+        ),
+    ) {
+        primitive_datetime.assume_utc()
+    } else if let Ok(primitive_datetime) = PrimitiveDateTime::parse(
+        &string,
+        format_description!(
+            "[year repr:full base:calendar]-[month repr:numerical]-[day] [hour]:[minute]:[second]"
+        ),
+    ) {
+        primitive_datetime.assume_utc()
+    } else if let Ok(date) = Date::parse(
+        &string,
+        format_description!("[year repr:full base:calendar]-[month repr:numerical]-[day]"),
+    ) {
+        PrimitiveDateTime::new(date, time!(00:00)).assume_utc()
+    } else {
+        return Err(ParseOffsetDateTimeError(string));
+    };
+    if datetime > OffsetDateTime::now_utc() {
+        Ok(Some(datetime))
+    } else {
+        Err(ParseOffsetDateTimeError(string))
+    }
+}
+
+#[derive(Copy, Clone, Serialize, Deserialize, Debug, Eq, PartialEq, Hash, Sequence, Deserr)]
+#[repr(u8)]
+pub enum Action {
+    #[serde(rename = "*")]
+    #[deserr(rename = "*")]
+    All = 0,
+    #[serde(rename = "search")]
+    #[deserr(rename = "search")]
+    Search,
+    #[serde(rename = "documents.*")]
+    #[deserr(rename = "documents.*")]
+    DocumentsAll,
+    #[serde(rename = "documents.add")]
+    #[deserr(rename = "documents.add")]
+    DocumentsAdd,
+    #[serde(rename = "documents.get")]
+    #[deserr(rename = "documents.get")]
+    DocumentsGet,
+    #[serde(rename = "documents.delete")]
+    #[deserr(rename = "documents.delete")]
+    DocumentsDelete,
+    #[serde(rename = "indexes.*")]
+    #[deserr(rename = "indexes.*")]
+    IndexesAll,
+    #[serde(rename = "indexes.create")]
+    #[deserr(rename = "indexes.create")]
+    IndexesAdd,
+    #[serde(rename = "indexes.get")]
+    #[deserr(rename = "indexes.get")]
+    IndexesGet,
+    #[serde(rename = "indexes.update")]
+    #[deserr(rename = "indexes.update")]
+    IndexesUpdate,
+    #[serde(rename = "indexes.delete")]
+    #[deserr(rename = "indexes.delete")]
+    IndexesDelete,
+    #[serde(rename = "indexes.swap")]
+    #[deserr(rename = "indexes.swap")]
+    IndexesSwap,
+    #[serde(rename = "tasks.*")]
+    #[deserr(rename = "tasks.*")]
+    TasksAll,
+    #[serde(rename = "tasks.cancel")]
+    #[deserr(rename = "tasks.cancel")]
+    TasksCancel,
+    #[serde(rename = "tasks.delete")]
+    #[deserr(rename = "tasks.delete")]
+    TasksDelete,
+    #[serde(rename = "tasks.get")]
+    #[deserr(rename = "tasks.get")]
+    TasksGet,
+    #[serde(rename = "settings.*")]
+    #[deserr(rename = "settings.*")]
+    SettingsAll,
+    #[serde(rename = "settings.get")]
+    #[deserr(rename = "settings.get")]
+    SettingsGet,
+    #[serde(rename = "settings.update")]
+    #[deserr(rename = "settings.update")]
+    SettingsUpdate,
+    #[serde(rename = "stats.*")]
+    #[deserr(rename = "stats.*")]
+    StatsAll,
+    #[serde(rename = "stats.get")]
+    #[deserr(rename = "stats.get")]
+    StatsGet,
+    #[serde(rename = "metrics.*")]
+    #[deserr(rename = "metrics.*")]
+    MetricsAll,
+    #[serde(rename = "metrics.get")]
+    #[deserr(rename = "metrics.get")]
+    MetricsGet,
+    #[serde(rename = "dumps.*")]
+    #[deserr(rename = "dumps.*")]
+    DumpsAll,
+    #[serde(rename = "dumps.create")]
+    #[deserr(rename = "dumps.create")]
+    DumpsCreate,
+    #[serde(rename = "snapshots.*")]
+    #[deserr(rename = "snapshots.*")]
+    SnapshotsAll,
+    #[serde(rename = "snapshots.create")]
+    #[deserr(rename = "snapshots.create")]
+    SnapshotsCreate,
+    #[serde(rename = "version")]
+    #[deserr(rename = "version")]
+    Version,
+    #[serde(rename = "keys.create")]
+    #[deserr(rename = "keys.create")]
+    KeysAdd,
+    #[serde(rename = "keys.get")]
+    #[deserr(rename = "keys.get")]
+    KeysGet,
+    #[serde(rename = "keys.update")]
+    #[deserr(rename = "keys.update")]
+    KeysUpdate,
+    #[serde(rename = "keys.delete")]
+    #[deserr(rename = "keys.delete")]
+    KeysDelete,
+    #[serde(rename = "experimental.get")]
+    #[deserr(rename = "experimental.get")]
+    ExperimentalFeaturesGet,
+    #[serde(rename = "experimental.update")]
+    #[deserr(rename = "experimental.update")]
+    ExperimentalFeaturesUpdate,
+}
+
+impl Action {
+    pub const fn from_repr(repr: u8) -> Option<Self> {
+        use actions::*;
+        match repr {
+            ALL => Some(Self::All),
+            SEARCH => Some(Self::Search),
+            DOCUMENTS_ALL => Some(Self::DocumentsAll),
+            DOCUMENTS_ADD => Some(Self::DocumentsAdd),
+            DOCUMENTS_GET => Some(Self::DocumentsGet),
+            DOCUMENTS_DELETE => Some(Self::DocumentsDelete),
+            INDEXES_ALL => Some(Self::IndexesAll),
+            INDEXES_CREATE => Some(Self::IndexesAdd),
+            INDEXES_GET => Some(Self::IndexesGet),
+            INDEXES_UPDATE => Some(Self::IndexesUpdate),
+            INDEXES_DELETE => Some(Self::IndexesDelete),
+            INDEXES_SWAP => Some(Self::IndexesSwap),
+            TASKS_ALL => Some(Self::TasksAll),
+            TASKS_CANCEL => Some(Self::TasksCancel),
+            TASKS_DELETE => Some(Self::TasksDelete),
+            TASKS_GET => Some(Self::TasksGet),
+            SETTINGS_ALL => Some(Self::SettingsAll),
+            SETTINGS_GET => Some(Self::SettingsGet),
+            SETTINGS_UPDATE => Some(Self::SettingsUpdate),
+            STATS_ALL => Some(Self::StatsAll),
+            STATS_GET => Some(Self::StatsGet),
+            METRICS_ALL => Some(Self::MetricsAll),
+            METRICS_GET => Some(Self::MetricsGet),
+            DUMPS_ALL => Some(Self::DumpsAll),
+            DUMPS_CREATE => Some(Self::DumpsCreate),
+            SNAPSHOTS_CREATE => Some(Self::SnapshotsCreate),
+            VERSION => Some(Self::Version),
+            KEYS_CREATE => Some(Self::KeysAdd),
+            KEYS_GET => Some(Self::KeysGet),
+            KEYS_UPDATE => Some(Self::KeysUpdate),
+            KEYS_DELETE => Some(Self::KeysDelete),
+            EXPERIMENTAL_FEATURES_GET => Some(Self::ExperimentalFeaturesGet),
+            EXPERIMENTAL_FEATURES_UPDATE => Some(Self::ExperimentalFeaturesUpdate),
+            _otherwise => None,
+        }
+    }
+
+    pub const fn repr(&self) -> u8 {
+        *self as u8
+    }
+}
+
+pub mod actions {
+    use super::Action::*;
+
+    pub(crate) const ALL: u8 = All.repr();
+    pub const SEARCH: u8 = Search.repr();
+    pub const DOCUMENTS_ALL: u8 = DocumentsAll.repr();
+    pub const DOCUMENTS_ADD: u8 = DocumentsAdd.repr();
+    pub const DOCUMENTS_GET: u8 = DocumentsGet.repr();
+    pub const DOCUMENTS_DELETE: u8 = DocumentsDelete.repr();
+    pub const INDEXES_ALL: u8 = IndexesAll.repr();
+    pub const INDEXES_CREATE: u8 = IndexesAdd.repr();
+    pub const INDEXES_GET: u8 = IndexesGet.repr();
+    pub const INDEXES_UPDATE: u8 = IndexesUpdate.repr();
+    pub const INDEXES_DELETE: u8 = IndexesDelete.repr();
+    pub const INDEXES_SWAP: u8 = IndexesSwap.repr();
+    pub const TASKS_ALL: u8 = TasksAll.repr();
+    pub const TASKS_CANCEL: u8 = TasksCancel.repr();
+    pub const TASKS_DELETE: u8 = TasksDelete.repr();
+    pub const TASKS_GET: u8 = TasksGet.repr();
+    pub const SETTINGS_ALL: u8 = SettingsAll.repr();
+    pub const SETTINGS_GET: u8 = SettingsGet.repr();
+    pub const SETTINGS_UPDATE: u8 = SettingsUpdate.repr();
+    pub const STATS_ALL: u8 = StatsAll.repr();
+    pub const STATS_GET: u8 = StatsGet.repr();
+    pub const METRICS_ALL: u8 = MetricsAll.repr();
+    pub const METRICS_GET: u8 = MetricsGet.repr();
+    pub const DUMPS_ALL: u8 = DumpsAll.repr();
+    pub const DUMPS_CREATE: u8 = DumpsCreate.repr();
+    pub const SNAPSHOTS_CREATE: u8 = SnapshotsCreate.repr();
+    pub const VERSION: u8 = Version.repr();
+    pub const KEYS_CREATE: u8 = KeysAdd.repr();
+    pub const KEYS_GET: u8 = KeysGet.repr();
+    pub const KEYS_UPDATE: u8 = KeysUpdate.repr();
+    pub const KEYS_DELETE: u8 = KeysDelete.repr();
+    pub const EXPERIMENTAL_FEATURES_GET: u8 = ExperimentalFeaturesGet.repr();
+    pub const EXPERIMENTAL_FEATURES_UPDATE: u8 = ExperimentalFeaturesUpdate.repr();
+}

crates/meilisearch-types/src/lib.rs

@@ -0,0 +1,22 @@
+pub mod compression;
+pub mod deserr;
+pub mod document_formats;
+pub mod error;
+pub mod facet_values_sort;
+pub mod features;
+pub mod index_uid;
+pub mod index_uid_pattern;
+pub mod keys;
+pub mod locales;
+pub mod settings;
+pub mod star_or;
+pub mod task_view;
+pub mod tasks;
+pub mod versioning;
+pub use milli::{heed, Index};
+use uuid::Uuid;
+pub use versioning::VERSION_FILE_NAME;
+pub use {milli, serde_cs};
+
+pub type Document = serde_json::Map<String, serde_json::Value>;
+pub type InstanceUid = Uuid;

crates/meilisearch-types/src/locales.rs

@@ -0,0 +1,166 @@
+use deserr::Deserr;
+use milli::LocalizedAttributesRule;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserr, Serialize, Deserialize)]
+#[deserr(rename_all = camelCase)]
+#[serde(rename_all = "camelCase")]
+pub struct LocalizedAttributesRuleView {
+    pub attribute_patterns: Vec<String>,
+    pub locales: Vec<Locale>,
+}
+
+impl From<LocalizedAttributesRule> for LocalizedAttributesRuleView {
+    fn from(rule: LocalizedAttributesRule) -> Self {
+        Self {
+            attribute_patterns: rule.attribute_patterns,
+            locales: rule.locales.into_iter().map(|l| l.into()).collect(),
+        }
+    }
+}
+
+impl From<LocalizedAttributesRuleView> for LocalizedAttributesRule {
+    fn from(view: LocalizedAttributesRuleView) -> Self {
+        Self {
+            attribute_patterns: view.attribute_patterns,
+            locales: view.locales.into_iter().map(|l| l.into()).collect(),
+        }
+    }
+}
+
+/// Generate a Locale enum and its From and Into implementations for milli::tokenizer::Language.
+///
+/// this enum implements `Deserr` in order to be used in the API.
+macro_rules! make_locale {
+    ($(($iso_639_1:ident, $iso_639_1_str:expr) => ($iso_639_3:ident, $iso_639_3_str:expr),)+) => {
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Deserr, Serialize, Deserialize, Ord, PartialOrd)]
+        #[deserr(rename_all = camelCase)]
+        #[serde(rename_all = "camelCase")]
+        pub enum Locale {
+            $($iso_639_1,)+
+            $($iso_639_3,)+
+            Cmn,
+        }
+
+        impl From<milli::tokenizer::Language> for Locale {
+            fn from(other: milli::tokenizer::Language) -> Locale {
+                match other {
+                    $(milli::tokenizer::Language::$iso_639_3 => Locale::$iso_639_3,)+
+                    milli::tokenizer::Language::Cmn => Locale::Cmn,
+                }
+            }
+        }
+
+        impl From<Locale> for milli::tokenizer::Language {
+            fn from(other: Locale) -> milli::tokenizer::Language {
+                match other {
+                    $(Locale::$iso_639_1 => milli::tokenizer::Language::$iso_639_3,)+
+                    $(Locale::$iso_639_3 => milli::tokenizer::Language::$iso_639_3,)+
+                    Locale::Cmn => milli::tokenizer::Language::Cmn,
+                }
+            }
+        }
+
+        impl std::str::FromStr for Locale {
+            type Err = LocaleFormatError;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                let locale = match s {
+                    $($iso_639_1_str => Locale::$iso_639_1,)+
+                    $($iso_639_3_str => Locale::$iso_639_3,)+
+                    "cmn" => Locale::Cmn,
+                    _ => return Err(LocaleFormatError { invalid_locale: s.to_string() }),
+                };
+
+                Ok(locale)
+            }
+        }
+
+        #[derive(Debug)]
+        pub struct LocaleFormatError {
+            pub invalid_locale: String,
+        }
+
+        impl std::fmt::Display for LocaleFormatError {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                let mut valid_locales = [$($iso_639_1_str),+,$($iso_639_3_str),+,"cmn"];
+                valid_locales.sort_by(|left, right| left.len().cmp(&right.len()).then(left.cmp(right)));
+                write!(f, "Unsupported locale `{}`, expected one of {}", self.invalid_locale, valid_locales.join(", "))
+            }
+        }
+
+        impl std::error::Error for LocaleFormatError {}
+    };
+}
+
+make_locale!(
+    (Af, "af") => (Afr, "afr"),
+    (Ak, "ak") => (Aka, "aka"),
+    (Am, "am") => (Amh, "amh"),
+    (Ar, "ar") => (Ara, "ara"),
+    (Az, "az") => (Aze, "aze"),
+    (Be, "be") => (Bel, "bel"),
+    (Bn, "bn") => (Ben, "ben"),
+    (Bg, "bg") => (Bul, "bul"),
+    (Ca, "ca") => (Cat, "cat"),
+    (Cs, "cs") => (Ces, "ces"),
+    (Da, "da") => (Dan, "dan"),
+    (De, "de") => (Deu, "deu"),
+    (El, "el") => (Ell, "ell"),
+    (En, "en") => (Eng, "eng"),
+    (Eo, "eo") => (Epo, "epo"),
+    (Et, "et") => (Est, "est"),
+    (Fi, "fi") => (Fin, "fin"),
+    (Fr, "fr") => (Fra, "fra"),
+    (Gu, "gu") => (Guj, "guj"),
+    (He, "he") => (Heb, "heb"),
+    (Hi, "hi") => (Hin, "hin"),
+    (Hr, "hr") => (Hrv, "hrv"),
+    (Hu, "hu") => (Hun, "hun"),
+    (Hy, "hy") => (Hye, "hye"),
+    (Id, "id") => (Ind, "ind"),
+    (It, "it") => (Ita, "ita"),
+    (Jv, "jv") => (Jav, "jav"),
+    (Ja, "ja") => (Jpn, "jpn"),
+    (Kn, "kn") => (Kan, "kan"),
+    (Ka, "ka") => (Kat, "kat"),
+    (Km, "km") => (Khm, "khm"),
+    (Ko, "ko") => (Kor, "kor"),
+    (La, "la") => (Lat, "lat"),
+    (Lv, "lv") => (Lav, "lav"),
+    (Lt, "lt") => (Lit, "lit"),
+    (Ml, "ml") => (Mal, "mal"),
+    (Mr, "mr") => (Mar, "mar"),
+    (Mk, "mk") => (Mkd, "mkd"),
+    (My, "my") => (Mya, "mya"),
+    (Ne, "ne") => (Nep, "nep"),
+    (Nl, "nl") => (Nld, "nld"),
+    (Nb, "nb") => (Nob, "nob"),
+    (Or, "or") => (Ori, "ori"),
+    (Pa, "pa") => (Pan, "pan"),
+    (Fa, "fa") => (Pes, "pes"),
+    (Pl, "pl") => (Pol, "pol"),
+    (Pt, "pt") => (Por, "por"),
+    (Ro, "ro") => (Ron, "ron"),
+    (Ru, "ru") => (Rus, "rus"),
+    (Si, "si") => (Sin, "sin"),
+    (Sk, "sk") => (Slk, "slk"),
+    (Sl, "sl") => (Slv, "slv"),
+    (Sn, "sn") => (Sna, "sna"),
+    (Es, "es") => (Spa, "spa"),
+    (Sr, "sr") => (Srp, "srp"),
+    (Sv, "sv") => (Swe, "swe"),
+    (Ta, "ta") => (Tam, "tam"),
+    (Te, "te") => (Tel, "tel"),
+    (Tl, "tl") => (Tgl, "tgl"),
+    (Th, "th") => (Tha, "tha"),
+    (Tk, "tk") => (Tuk, "tuk"),
+    (Tr, "tr") => (Tur, "tur"),
+    (Uk, "uk") => (Ukr, "ukr"),
+    (Ur, "ur") => (Urd, "urd"),
+    (Uz, "uz") => (Uzb, "uzb"),
+    (Vi, "vi") => (Vie, "vie"),
+    (Yi, "yi") => (Yid, "yid"),
+    (Zh, "zh") => (Zho, "zho"),
+    (Zu, "zu") => (Zul, "zul"),
+);

crates/meilisearch-types/src/settings.rs

@@ -0,0 +1,965 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::convert::Infallible;
+use std::fmt;
+use std::marker::PhantomData;
+use std::num::NonZeroUsize;
+use std::ops::{ControlFlow, Deref};
+use std::str::FromStr;
+
+use deserr::{DeserializeError, Deserr, ErrorKind, MergeWithError, ValuePointerRef};
+use fst::IntoStreamer;
+use milli::index::IndexEmbeddingConfig;
+use milli::proximity::ProximityPrecision;
+use milli::update::Setting;
+use milli::{Criterion, CriterionError, Index, DEFAULT_VALUES_PER_FACET};
+use serde::{Deserialize, Serialize, Serializer};
+
+use crate::deserr::DeserrJsonError;
+use crate::error::deserr_codes::*;
+use crate::facet_values_sort::FacetValuesSort;
+use crate::locales::LocalizedAttributesRuleView;
+
+/// The maximum number of results that the engine
+/// will be able to return in one search call.
+pub const DEFAULT_PAGINATION_MAX_TOTAL_HITS: usize = 1000;
+
+fn serialize_with_wildcard<S>(
+    field: &Setting<Vec<String>>,
+    s: S,
+) -> std::result::Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let wildcard = vec!["*".to_string()];
+    match field {
+        Setting::Set(value) => Some(value),
+        Setting::Reset => Some(&wildcard),
+        Setting::NotSet => None,
+    }
+    .serialize(s)
+}
+
+#[derive(Clone, Default, Debug, Serialize, PartialEq, Eq)]
+pub struct Checked;
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct Unchecked;
+
+impl<E> Deserr<E> for Unchecked
+where
+    E: DeserializeError,
+{
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        _value: deserr::Value<V>,
+        _location: deserr::ValuePointerRef,
+    ) -> Result<Self, E> {
+        unreachable!()
+    }
+}
+
+fn validate_min_word_size_for_typo_setting<E: DeserializeError>(
+    s: MinWordSizeTyposSetting,
+    location: ValuePointerRef,
+) -> Result<MinWordSizeTyposSetting, E> {
+    if let (Setting::Set(one), Setting::Set(two)) = (s.one_typo, s.two_typos) {
+        if one > two {
+            return Err(deserr::take_cf_content(E::error::<Infallible>(None, ErrorKind::Unexpected { msg: format!("`minWordSizeForTypos` setting is invalid. `oneTypo` and `twoTypos` fields should be between `0` and `255`, and `twoTypos` should be greater or equals to `oneTypo` but found `oneTypo: {one}` and twoTypos: {two}`.") }, location)));
+        }
+    }
+    Ok(s)
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Deserr)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(deny_unknown_fields, rename_all = camelCase, validate = validate_min_word_size_for_typo_setting -> DeserrJsonError<InvalidSettingsTypoTolerance>)]
+pub struct MinWordSizeTyposSetting {
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub one_typo: Setting<u8>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub two_typos: Setting<u8>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Deserr)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(deny_unknown_fields, rename_all = camelCase, where_predicate = __Deserr_E: deserr::MergeWithError<DeserrJsonError<InvalidSettingsTypoTolerance>>)]
+pub struct TypoSettings {
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub enabled: Setting<bool>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsTypoTolerance>)]
+    pub min_word_size_for_typos: Setting<MinWordSizeTyposSetting>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub disable_on_words: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub disable_on_attributes: Setting<BTreeSet<String>>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Deserr)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(rename_all = camelCase, deny_unknown_fields)]
+pub struct FacetingSettings {
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub max_values_per_facet: Setting<usize>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub sort_facet_values_by: Setting<BTreeMap<String, FacetValuesSort>>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Deserr)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(rename_all = camelCase, deny_unknown_fields)]
+pub struct PaginationSettings {
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    pub max_total_hits: Setting<usize>,
+}
+
+impl MergeWithError<milli::CriterionError> for DeserrJsonError<InvalidSettingsRankingRules> {
+    fn merge(
+        _self_: Option<Self>,
+        other: milli::CriterionError,
+        merge_location: ValuePointerRef,
+    ) -> ControlFlow<Self, Self> {
+        Self::error::<Infallible>(
+            None,
+            ErrorKind::Unexpected { msg: other.to_string() },
+            merge_location,
+        )
+    }
+}
+
+/// Holds all the settings for an index. `T` can either be `Checked` if they represents settings
+/// whose validity is guaranteed, or `Unchecked` if they need to be validated. In the later case, a
+/// call to `check` will return a `Settings<Checked>` from a `Settings<Unchecked>`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Deserr)]
+#[serde(
+    deny_unknown_fields,
+    rename_all = "camelCase",
+    bound(serialize = "T: Serialize", deserialize = "T: Deserialize<'static>")
+)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct Settings<T> {
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsDisplayedAttributes>)]
+    pub displayed_attributes: WildcardSetting,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsSearchableAttributes>)]
+    pub searchable_attributes: WildcardSetting,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsFilterableAttributes>)]
+    pub filterable_attributes: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsSortableAttributes>)]
+    pub sortable_attributes: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsRankingRules>)]
+    pub ranking_rules: Setting<Vec<RankingRuleView>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsStopWords>)]
+    pub stop_words: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsNonSeparatorTokens>)]
+    pub non_separator_tokens: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsSeparatorTokens>)]
+    pub separator_tokens: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsDictionary>)]
+    pub dictionary: Setting<BTreeSet<String>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsSynonyms>)]
+    pub synonyms: Setting<BTreeMap<String, Vec<String>>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsDistinctAttribute>)]
+    pub distinct_attribute: Setting<String>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsProximityPrecision>)]
+    pub proximity_precision: Setting<ProximityPrecisionView>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsTypoTolerance>)]
+    pub typo_tolerance: Setting<TypoSettings>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsFaceting>)]
+    pub faceting: Setting<FacetingSettings>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsPagination>)]
+    pub pagination: Setting<PaginationSettings>,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsEmbedders>)]
+    pub embedders: Setting<BTreeMap<String, Setting<milli::vector::settings::EmbeddingSettings>>>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsSearchCutoffMs>)]
+    pub search_cutoff_ms: Setting<u64>,
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default, error = DeserrJsonError<InvalidSettingsLocalizedAttributes>)]
+    pub localized_attributes: Setting<Vec<LocalizedAttributesRuleView>>,
+
+    #[serde(skip)]
+    #[deserr(skip)]
+    pub _kind: PhantomData<T>,
+}
+
+impl<T> Settings<T> {
+    pub fn hide_secrets(&mut self) {
+        let Setting::Set(embedders) = &mut self.embedders else {
+            return;
+        };
+
+        for mut embedder in embedders.values_mut() {
+            let Setting::Set(embedder) = &mut embedder else {
+                continue;
+            };
+
+            let Setting::Set(api_key) = &mut embedder.api_key else {
+                continue;
+            };
+
+            Self::hide_secret(api_key);
+        }
+    }
+
+    fn hide_secret(secret: &mut String) {
+        match secret.len() {
+            x if x < 10 => {
+                secret.replace_range(.., "XXX...");
+            }
+            x if x < 20 => {
+                secret.replace_range(2.., "XXXX...");
+            }
+            x if x < 30 => {
+                secret.replace_range(3.., "XXXXX...");
+            }
+            _x => {
+                secret.replace_range(5.., "XXXXXX...");
+            }
+        }
+    }
+}
+
+impl Settings<Checked> {
+    pub fn cleared() -> Settings<Checked> {
+        Settings {
+            displayed_attributes: Setting::Reset.into(),
+            searchable_attributes: Setting::Reset.into(),
+            filterable_attributes: Setting::Reset,
+            sortable_attributes: Setting::Reset,
+            ranking_rules: Setting::Reset,
+            stop_words: Setting::Reset,
+            synonyms: Setting::Reset,
+            non_separator_tokens: Setting::Reset,
+            separator_tokens: Setting::Reset,
+            dictionary: Setting::Reset,
+            distinct_attribute: Setting::Reset,
+            proximity_precision: Setting::Reset,
+            typo_tolerance: Setting::Reset,
+            faceting: Setting::Reset,
+            pagination: Setting::Reset,
+            embedders: Setting::Reset,
+            search_cutoff_ms: Setting::Reset,
+            localized_attributes: Setting::Reset,
+            _kind: PhantomData,
+        }
+    }
+
+    pub fn into_unchecked(self) -> Settings<Unchecked> {
+        let Self {
+            displayed_attributes,
+            searchable_attributes,
+            filterable_attributes,
+            sortable_attributes,
+            ranking_rules,
+            stop_words,
+            non_separator_tokens,
+            separator_tokens,
+            dictionary,
+            synonyms,
+            distinct_attribute,
+            proximity_precision,
+            typo_tolerance,
+            faceting,
+            pagination,
+            embedders,
+            search_cutoff_ms,
+            localized_attributes: localized_attributes_rules,
+            _kind,
+        } = self;
+
+        Settings {
+            displayed_attributes,
+            searchable_attributes,
+            filterable_attributes,
+            sortable_attributes,
+            ranking_rules,
+            stop_words,
+            non_separator_tokens,
+            separator_tokens,
+            dictionary,
+            synonyms,
+            distinct_attribute,
+            proximity_precision,
+            typo_tolerance,
+            faceting,
+            pagination,
+            embedders,
+            search_cutoff_ms,
+            localized_attributes: localized_attributes_rules,
+            _kind: PhantomData,
+        }
+    }
+}
+
+impl Settings<Unchecked> {
+    pub fn check(self) -> Settings<Checked> {
+        let displayed_attributes = match self.displayed_attributes.0 {
+            Setting::Set(fields) => {
+                if fields.iter().any(|f| f == "*") {
+                    Setting::Reset
+                } else {
+                    Setting::Set(fields)
+                }
+            }
+            otherwise => otherwise,
+        };
+
+        let searchable_attributes = match self.searchable_attributes.0 {
+            Setting::Set(fields) => {
+                if fields.iter().any(|f| f == "*") {
+                    Setting::Reset
+                } else {
+                    Setting::Set(fields)
+                }
+            }
+            otherwise => otherwise,
+        };
+
+        Settings {
+            displayed_attributes: displayed_attributes.into(),
+            searchable_attributes: searchable_attributes.into(),
+            filterable_attributes: self.filterable_attributes,
+            sortable_attributes: self.sortable_attributes,
+            ranking_rules: self.ranking_rules,
+            stop_words: self.stop_words,
+            synonyms: self.synonyms,
+            non_separator_tokens: self.non_separator_tokens,
+            separator_tokens: self.separator_tokens,
+            dictionary: self.dictionary,
+            distinct_attribute: self.distinct_attribute,
+            proximity_precision: self.proximity_precision,
+            typo_tolerance: self.typo_tolerance,
+            faceting: self.faceting,
+            pagination: self.pagination,
+            embedders: self.embedders,
+            search_cutoff_ms: self.search_cutoff_ms,
+            localized_attributes: self.localized_attributes,
+            _kind: PhantomData,
+        }
+    }
+
+    pub fn validate(self) -> Result<Self, milli::Error> {
+        self.validate_embedding_settings()
+    }
+
+    fn validate_embedding_settings(mut self) -> Result<Self, milli::Error> {
+        let Setting::Set(mut configs) = self.embedders else { return Ok(self) };
+        for (name, config) in configs.iter_mut() {
+            let config_to_check = std::mem::take(config);
+            let checked_config = milli::update::validate_embedding_settings(config_to_check, name)?;
+            *config = checked_config
+        }
+        self.embedders = Setting::Set(configs);
+        Ok(self)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
+pub struct Facets {
+    pub level_group_size: Option<NonZeroUsize>,
+    pub min_level_size: Option<NonZeroUsize>,
+}
+
+pub fn apply_settings_to_builder(
+    settings: &Settings<Checked>,
+    builder: &mut milli::update::Settings,
+) {
+    let Settings {
+        displayed_attributes,
+        searchable_attributes,
+        filterable_attributes,
+        sortable_attributes,
+        ranking_rules,
+        stop_words,
+        non_separator_tokens,
+        separator_tokens,
+        dictionary,
+        synonyms,
+        distinct_attribute,
+        proximity_precision,
+        typo_tolerance,
+        faceting,
+        pagination,
+        embedders,
+        search_cutoff_ms,
+        localized_attributes: localized_attributes_rules,
+        _kind,
+    } = settings;
+
+    match searchable_attributes.deref() {
+        Setting::Set(ref names) => builder.set_searchable_fields(names.clone()),
+        Setting::Reset => builder.reset_searchable_fields(),
+        Setting::NotSet => (),
+    }
+
+    match displayed_attributes.deref() {
+        Setting::Set(ref names) => builder.set_displayed_fields(names.clone()),
+        Setting::Reset => builder.reset_displayed_fields(),
+        Setting::NotSet => (),
+    }
+
+    match filterable_attributes {
+        Setting::Set(ref facets) => {
+            builder.set_filterable_fields(facets.clone().into_iter().collect())
+        }
+        Setting::Reset => builder.reset_filterable_fields(),
+        Setting::NotSet => (),
+    }
+
+    match sortable_attributes {
+        Setting::Set(ref fields) => builder.set_sortable_fields(fields.iter().cloned().collect()),
+        Setting::Reset => builder.reset_sortable_fields(),
+        Setting::NotSet => (),
+    }
+
+    match ranking_rules {
+        Setting::Set(ref criteria) => {
+            builder.set_criteria(criteria.iter().map(|c| c.clone().into()).collect())
+        }
+        Setting::Reset => builder.reset_criteria(),
+        Setting::NotSet => (),
+    }
+
+    match stop_words {
+        Setting::Set(ref stop_words) => builder.set_stop_words(stop_words.clone()),
+        Setting::Reset => builder.reset_stop_words(),
+        Setting::NotSet => (),
+    }
+
+    match non_separator_tokens {
+        Setting::Set(ref non_separator_tokens) => {
+            builder.set_non_separator_tokens(non_separator_tokens.clone())
+        }
+        Setting::Reset => builder.reset_non_separator_tokens(),
+        Setting::NotSet => (),
+    }
+
+    match separator_tokens {
+        Setting::Set(ref separator_tokens) => {
+            builder.set_separator_tokens(separator_tokens.clone())
+        }
+        Setting::Reset => builder.reset_separator_tokens(),
+        Setting::NotSet => (),
+    }
+
+    match dictionary {
+        Setting::Set(ref dictionary) => builder.set_dictionary(dictionary.clone()),
+        Setting::Reset => builder.reset_dictionary(),
+        Setting::NotSet => (),
+    }
+
+    match synonyms {
+        Setting::Set(ref synonyms) => builder.set_synonyms(synonyms.clone().into_iter().collect()),
+        Setting::Reset => builder.reset_synonyms(),
+        Setting::NotSet => (),
+    }
+
+    match distinct_attribute {
+        Setting::Set(ref attr) => builder.set_distinct_field(attr.clone()),
+        Setting::Reset => builder.reset_distinct_field(),
+        Setting::NotSet => (),
+    }
+
+    match proximity_precision {
+        Setting::Set(ref precision) => builder.set_proximity_precision((*precision).into()),
+        Setting::Reset => builder.reset_proximity_precision(),
+        Setting::NotSet => (),
+    }
+
+    match localized_attributes_rules {
+        Setting::Set(ref rules) => builder
+            .set_localized_attributes_rules(rules.iter().cloned().map(|r| r.into()).collect()),
+        Setting::Reset => builder.reset_localized_attributes_rules(),
+        Setting::NotSet => (),
+    }
+
+    match typo_tolerance {
+        Setting::Set(ref value) => {
+            match value.enabled {
+                Setting::Set(val) => builder.set_autorize_typos(val),
+                Setting::Reset => builder.reset_authorize_typos(),
+                Setting::NotSet => (),
+            }
+
+            match value.min_word_size_for_typos {
+                Setting::Set(ref setting) => {
+                    match setting.one_typo {
+                        Setting::Set(val) => builder.set_min_word_len_one_typo(val),
+                        Setting::Reset => builder.reset_min_word_len_one_typo(),
+                        Setting::NotSet => (),
+                    }
+                    match setting.two_typos {
+                        Setting::Set(val) => builder.set_min_word_len_two_typos(val),
+                        Setting::Reset => builder.reset_min_word_len_two_typos(),
+                        Setting::NotSet => (),
+                    }
+                }
+                Setting::Reset => {
+                    builder.reset_min_word_len_one_typo();
+                    builder.reset_min_word_len_two_typos();
+                }
+                Setting::NotSet => (),
+            }
+
+            match value.disable_on_words {
+                Setting::Set(ref words) => {
+                    builder.set_exact_words(words.clone());
+                }
+                Setting::Reset => builder.reset_exact_words(),
+                Setting::NotSet => (),
+            }
+
+            match value.disable_on_attributes {
+                Setting::Set(ref words) => {
+                    builder.set_exact_attributes(words.iter().cloned().collect())
+                }
+                Setting::Reset => builder.reset_exact_attributes(),
+                Setting::NotSet => (),
+            }
+        }
+        Setting::Reset => {
+            // all typo settings need to be reset here.
+            builder.reset_authorize_typos();
+            builder.reset_min_word_len_one_typo();
+            builder.reset_min_word_len_two_typos();
+            builder.reset_exact_words();
+            builder.reset_exact_attributes();
+        }
+        Setting::NotSet => (),
+    }
+
+    match faceting {
+        Setting::Set(FacetingSettings { max_values_per_facet, sort_facet_values_by }) => {
+            match max_values_per_facet {
+                Setting::Set(val) => builder.set_max_values_per_facet(*val),
+                Setting::Reset => builder.reset_max_values_per_facet(),
+                Setting::NotSet => (),
+            }
+            match sort_facet_values_by {
+                Setting::Set(val) => builder.set_sort_facet_values_by(
+                    val.iter().map(|(name, order)| (name.clone(), (*order).into())).collect(),
+                ),
+                Setting::Reset => builder.reset_sort_facet_values_by(),
+                Setting::NotSet => (),
+            }
+        }
+        Setting::Reset => {
+            builder.reset_max_values_per_facet();
+            builder.reset_sort_facet_values_by();
+        }
+        Setting::NotSet => (),
+    }
+
+    match pagination {
+        Setting::Set(ref value) => match value.max_total_hits {
+            Setting::Set(val) => builder.set_pagination_max_total_hits(val),
+            Setting::Reset => builder.reset_pagination_max_total_hits(),
+            Setting::NotSet => (),
+        },
+        Setting::Reset => builder.reset_pagination_max_total_hits(),
+        Setting::NotSet => (),
+    }
+
+    match embedders {
+        Setting::Set(value) => builder.set_embedder_settings(value.clone()),
+        Setting::Reset => builder.reset_embedder_settings(),
+        Setting::NotSet => (),
+    }
+
+    match search_cutoff_ms {
+        Setting::Set(cutoff) => builder.set_search_cutoff(*cutoff),
+        Setting::Reset => builder.reset_search_cutoff(),
+        Setting::NotSet => (),
+    }
+}
+
+pub enum SecretPolicy {
+    RevealSecrets,
+    HideSecrets,
+}
+
+pub fn settings(
+    index: &Index,
+    rtxn: &crate::heed::RoTxn,
+    secret_policy: SecretPolicy,
+) -> Result<Settings<Checked>, milli::Error> {
+    let displayed_attributes =
+        index.displayed_fields(rtxn)?.map(|fields| fields.into_iter().map(String::from).collect());
+
+    let searchable_attributes = index
+        .user_defined_searchable_fields(rtxn)?
+        .map(|fields| fields.into_iter().map(String::from).collect());
+
+    let filterable_attributes = index.filterable_fields(rtxn)?.into_iter().collect();
+
+    let sortable_attributes = index.sortable_fields(rtxn)?.into_iter().collect();
+
+    let criteria = index.criteria(rtxn)?;
+
+    let stop_words = index
+        .stop_words(rtxn)?
+        .map(|stop_words| -> Result<BTreeSet<_>, milli::Error> {
+            Ok(stop_words.stream().into_strs()?.into_iter().collect())
+        })
+        .transpose()?
+        .unwrap_or_default();
+
+    let non_separator_tokens = index.non_separator_tokens(rtxn)?.unwrap_or_default();
+    let separator_tokens = index.separator_tokens(rtxn)?.unwrap_or_default();
+    let dictionary = index.dictionary(rtxn)?.unwrap_or_default();
+
+    let distinct_field = index.distinct_field(rtxn)?.map(String::from);
+
+    let proximity_precision = index.proximity_precision(rtxn)?.map(ProximityPrecisionView::from);
+
+    let synonyms = index.user_defined_synonyms(rtxn)?;
+
+    let min_typo_word_len = MinWordSizeTyposSetting {
+        one_typo: Setting::Set(index.min_word_len_one_typo(rtxn)?),
+        two_typos: Setting::Set(index.min_word_len_two_typos(rtxn)?),
+    };
+
+    let disabled_words = match index.exact_words(rtxn)? {
+        Some(fst) => fst.into_stream().into_strs()?.into_iter().collect(),
+        None => BTreeSet::new(),
+    };
+
+    let disabled_attributes = index.exact_attributes(rtxn)?.into_iter().map(String::from).collect();
+
+    let typo_tolerance = TypoSettings {
+        enabled: Setting::Set(index.authorize_typos(rtxn)?),
+        min_word_size_for_typos: Setting::Set(min_typo_word_len),
+        disable_on_words: Setting::Set(disabled_words),
+        disable_on_attributes: Setting::Set(disabled_attributes),
+    };
+
+    let faceting = FacetingSettings {
+        max_values_per_facet: Setting::Set(
+            index
+                .max_values_per_facet(rtxn)?
+                .map(|x| x as usize)
+                .unwrap_or(DEFAULT_VALUES_PER_FACET),
+        ),
+        sort_facet_values_by: Setting::Set(
+            index
+                .sort_facet_values_by(rtxn)?
+                .into_iter()
+                .map(|(name, sort)| (name, sort.into()))
+                .collect(),
+        ),
+    };
+
+    let pagination = PaginationSettings {
+        max_total_hits: Setting::Set(
+            index
+                .pagination_max_total_hits(rtxn)?
+                .map(|x| x as usize)
+                .unwrap_or(DEFAULT_PAGINATION_MAX_TOTAL_HITS),
+        ),
+    };
+
+    let embedders: BTreeMap<_, _> = index
+        .embedding_configs(rtxn)?
+        .into_iter()
+        .map(|IndexEmbeddingConfig { name, config, .. }| (name, Setting::Set(config.into())))
+        .collect();
+    let embedders = if embedders.is_empty() { Setting::NotSet } else { Setting::Set(embedders) };
+
+    let search_cutoff_ms = index.search_cutoff(rtxn)?;
+
+    let localized_attributes_rules = index.localized_attributes_rules(rtxn)?;
+
+    let mut settings = Settings {
+        displayed_attributes: match displayed_attributes {
+            Some(attrs) => Setting::Set(attrs),
+            None => Setting::Reset,
+        }
+        .into(),
+        searchable_attributes: match searchable_attributes {
+            Some(attrs) => Setting::Set(attrs),
+            None => Setting::Reset,
+        }
+        .into(),
+        filterable_attributes: Setting::Set(filterable_attributes),
+        sortable_attributes: Setting::Set(sortable_attributes),
+        ranking_rules: Setting::Set(criteria.iter().map(|c| c.clone().into()).collect()),
+        stop_words: Setting::Set(stop_words),
+        non_separator_tokens: Setting::Set(non_separator_tokens),
+        separator_tokens: Setting::Set(separator_tokens),
+        dictionary: Setting::Set(dictionary),
+        distinct_attribute: match distinct_field {
+            Some(field) => Setting::Set(field),
+            None => Setting::Reset,
+        },
+        proximity_precision: Setting::Set(proximity_precision.unwrap_or_default()),
+        synonyms: Setting::Set(synonyms),
+        typo_tolerance: Setting::Set(typo_tolerance),
+        faceting: Setting::Set(faceting),
+        pagination: Setting::Set(pagination),
+        embedders,
+        search_cutoff_ms: match search_cutoff_ms {
+            Some(cutoff) => Setting::Set(cutoff),
+            None => Setting::Reset,
+        },
+        localized_attributes: match localized_attributes_rules {
+            Some(rules) => Setting::Set(rules.into_iter().map(|r| r.into()).collect()),
+            None => Setting::Reset,
+        },
+        _kind: PhantomData,
+    };
+
+    if let SecretPolicy::HideSecrets = secret_policy {
+        settings.hide_secrets()
+    }
+
+    Ok(settings)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserr)]
+#[deserr(try_from(&String) = FromStr::from_str -> CriterionError)]
+pub enum RankingRuleView {
+    /// Sorted by decreasing number of matched query terms.
+    /// Query words at the front of an attribute is considered better than if it was at the back.
+    Words,
+    /// Sorted by increasing number of typos.
+    Typo,
+    /// Sorted by increasing distance between matched query terms.
+    Proximity,
+    /// Documents with quey words contained in more important
+    /// attributes are considered better.
+    Attribute,
+    /// Dynamically sort at query time the documents. None, one or multiple Asc/Desc sortable
+    /// attributes can be used in place of this criterion at query time.
+    Sort,
+    /// Sorted by the similarity of the matched words with the query words.
+    Exactness,
+    /// Sorted by the increasing value of the field specified.
+    Asc(String),
+    /// Sorted by the decreasing value of the field specified.
+    Desc(String),
+}
+impl Serialize for RankingRuleView {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&format!("{}", Criterion::from(self.clone())))
+    }
+}
+impl<'de> Deserialize<'de> for RankingRuleView {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = RankingRuleView;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "the name of a valid ranking rule (string)")
+            }
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                let criterion = Criterion::from_str(v).map_err(|_| {
+                    E::invalid_value(serde::de::Unexpected::Str(v), &"a valid ranking rule")
+                })?;
+                Ok(RankingRuleView::from(criterion))
+            }
+        }
+        deserializer.deserialize_str(Visitor)
+    }
+}
+impl FromStr for RankingRuleView {
+    type Err = <Criterion as FromStr>::Err;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(RankingRuleView::from(Criterion::from_str(s)?))
+    }
+}
+impl fmt::Display for RankingRuleView {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt::Display::fmt(&Criterion::from(self.clone()), f)
+    }
+}
+impl From<Criterion> for RankingRuleView {
+    fn from(value: Criterion) -> Self {
+        match value {
+            Criterion::Words => RankingRuleView::Words,
+            Criterion::Typo => RankingRuleView::Typo,
+            Criterion::Proximity => RankingRuleView::Proximity,
+            Criterion::Attribute => RankingRuleView::Attribute,
+            Criterion::Sort => RankingRuleView::Sort,
+            Criterion::Exactness => RankingRuleView::Exactness,
+            Criterion::Asc(x) => RankingRuleView::Asc(x),
+            Criterion::Desc(x) => RankingRuleView::Desc(x),
+        }
+    }
+}
+impl From<RankingRuleView> for Criterion {
+    fn from(value: RankingRuleView) -> Self {
+        match value {
+            RankingRuleView::Words => Criterion::Words,
+            RankingRuleView::Typo => Criterion::Typo,
+            RankingRuleView::Proximity => Criterion::Proximity,
+            RankingRuleView::Attribute => Criterion::Attribute,
+            RankingRuleView::Sort => Criterion::Sort,
+            RankingRuleView::Exactness => Criterion::Exactness,
+            RankingRuleView::Asc(x) => Criterion::Asc(x),
+            RankingRuleView::Desc(x) => Criterion::Desc(x),
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Deserr, Serialize, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(error = DeserrJsonError<InvalidSettingsProximityPrecision>, rename_all = camelCase, deny_unknown_fields)]
+pub enum ProximityPrecisionView {
+    #[default]
+    ByWord,
+    ByAttribute,
+}
+
+impl From<ProximityPrecision> for ProximityPrecisionView {
+    fn from(value: ProximityPrecision) -> Self {
+        match value {
+            ProximityPrecision::ByWord => ProximityPrecisionView::ByWord,
+            ProximityPrecision::ByAttribute => ProximityPrecisionView::ByAttribute,
+        }
+    }
+}
+impl From<ProximityPrecisionView> for ProximityPrecision {
+    fn from(value: ProximityPrecisionView) -> Self {
+        match value {
+            ProximityPrecisionView::ByWord => ProximityPrecision::ByWord,
+            ProximityPrecisionView::ByAttribute => ProximityPrecision::ByAttribute,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq)]
+pub struct WildcardSetting(Setting<Vec<String>>);
+
+impl From<Setting<Vec<String>>> for WildcardSetting {
+    fn from(setting: Setting<Vec<String>>) -> Self {
+        Self(setting)
+    }
+}
+
+impl Serialize for WildcardSetting {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serialize_with_wildcard(&self.0, serializer)
+    }
+}
+
+impl<E: deserr::DeserializeError> Deserr<E> for WildcardSetting {
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        value: deserr::Value<V>,
+        location: ValuePointerRef<'_>,
+    ) -> Result<Self, E> {
+        Ok(Self(Setting::deserialize_from_value(value, location)?))
+    }
+}
+
+impl std::ops::Deref for WildcardSetting {
+    type Target = Setting<Vec<String>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod test {
+    use super::*;
+
+    #[test]
+    fn test_setting_check() {
+        // test no changes
+        let settings = Settings {
+            displayed_attributes: Setting::Set(vec![String::from("hello")]).into(),
+            searchable_attributes: Setting::Set(vec![String::from("hello")]).into(),
+            filterable_attributes: Setting::NotSet,
+            sortable_attributes: Setting::NotSet,
+            ranking_rules: Setting::NotSet,
+            stop_words: Setting::NotSet,
+            non_separator_tokens: Setting::NotSet,
+            separator_tokens: Setting::NotSet,
+            dictionary: Setting::NotSet,
+            synonyms: Setting::NotSet,
+            distinct_attribute: Setting::NotSet,
+            proximity_precision: Setting::NotSet,
+            typo_tolerance: Setting::NotSet,
+            faceting: Setting::NotSet,
+            pagination: Setting::NotSet,
+            embedders: Setting::NotSet,
+            localized_attributes: Setting::NotSet,
+            search_cutoff_ms: Setting::NotSet,
+            _kind: PhantomData::<Unchecked>,
+        };
+
+        let checked = settings.clone().check();
+        assert_eq!(settings.displayed_attributes, checked.displayed_attributes);
+        assert_eq!(settings.searchable_attributes, checked.searchable_attributes);
+
+        // test wildcard
+        // test no changes
+        let settings = Settings {
+            displayed_attributes: Setting::Set(vec![String::from("*")]).into(),
+            searchable_attributes: Setting::Set(vec![String::from("hello"), String::from("*")])
+                .into(),
+            filterable_attributes: Setting::NotSet,
+            sortable_attributes: Setting::NotSet,
+            ranking_rules: Setting::NotSet,
+            stop_words: Setting::NotSet,
+            non_separator_tokens: Setting::NotSet,
+            separator_tokens: Setting::NotSet,
+            dictionary: Setting::NotSet,
+            synonyms: Setting::NotSet,
+            distinct_attribute: Setting::NotSet,
+            proximity_precision: Setting::NotSet,
+            typo_tolerance: Setting::NotSet,
+            faceting: Setting::NotSet,
+            pagination: Setting::NotSet,
+            embedders: Setting::NotSet,
+            localized_attributes: Setting::NotSet,
+            search_cutoff_ms: Setting::NotSet,
+            _kind: PhantomData::<Unchecked>,
+        };
+
+        let checked = settings.check();
+        assert_eq!(checked.displayed_attributes, Setting::Reset.into());
+        assert_eq!(checked.searchable_attributes, Setting::Reset.into());
+    }
+}

crates/meilisearch-types/src/star_or.rs

@@ -0,0 +1,349 @@
+use std::fmt;
+use std::marker::PhantomData;
+use std::ops::ControlFlow;
+use std::str::FromStr;
+
+use deserr::{DeserializeError, Deserr, MergeWithError, ValueKind};
+use serde::de::Visitor;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::deserr::query_params::FromQueryParameter;
+
+/// A type that tries to match either a star (*) or
+/// any other thing that implements `FromStr`.
+#[derive(Debug, Clone)]
+pub enum StarOr<T> {
+    Star,
+    Other(T),
+}
+
+impl<T: FromStr> FromStr for StarOr<T> {
+    type Err = T::Err;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.trim() == "*" {
+            Ok(StarOr::Star)
+        } else {
+            T::from_str(s).map(StarOr::Other)
+        }
+    }
+}
+impl<T: fmt::Display> fmt::Display for StarOr<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            StarOr::Star => write!(f, "*"),
+            StarOr::Other(x) => fmt::Display::fmt(x, f),
+        }
+    }
+}
+
+impl<T: PartialEq> PartialEq for StarOr<T> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Star, Self::Star) => true,
+            (Self::Other(left), Self::Other(right)) if left.eq(right) => true,
+            _ => false,
+        }
+    }
+}
+
+impl<T: PartialEq + Eq> Eq for StarOr<T> {}
+
+impl<'de, T, E> Deserialize<'de> for StarOr<T>
+where
+    T: FromStr<Err = E>,
+    E: fmt::Display,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        /// Serde can't differentiate between `StarOr::Star` and `StarOr::Other` without a tag.
+        /// Simply using `#[serde(untagged)]` + `#[serde(rename="*")]` will lead to attempting to
+        /// deserialize everything as a `StarOr::Other`, including "*".
+        /// [`#[serde(other)]`](https://serde.rs/variant-attrs.html#other) might have helped but is
+        /// not supported on untagged enums.
+        struct StarOrVisitor<T>(PhantomData<T>);
+
+        impl<'de, T, FE> Visitor<'de> for StarOrVisitor<T>
+        where
+            T: FromStr<Err = FE>,
+            FE: fmt::Display,
+        {
+            type Value = StarOr<T>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a string")
+            }
+
+            fn visit_str<SE>(self, v: &str) -> Result<Self::Value, SE>
+            where
+                SE: serde::de::Error,
+            {
+                match v {
+                    "*" => Ok(StarOr::Star),
+                    v => {
+                        let other = FromStr::from_str(v).map_err(|e: T::Err| {
+                            SE::custom(format!("Invalid `other` value: {}", e))
+                        })?;
+                        Ok(StarOr::Other(other))
+                    }
+                }
+            }
+        }
+
+        deserializer.deserialize_str(StarOrVisitor(PhantomData))
+    }
+}
+
+impl<T> Serialize for StarOr<T>
+where
+    T: ToString,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            StarOr::Star => serializer.serialize_str("*"),
+            StarOr::Other(other) => serializer.serialize_str(&other.to_string()),
+        }
+    }
+}
+
+impl<T, E> Deserr<E> for StarOr<T>
+where
+    T: FromStr,
+    E: DeserializeError + MergeWithError<T::Err>,
+{
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        value: deserr::Value<V>,
+        location: deserr::ValuePointerRef,
+    ) -> Result<Self, E> {
+        match value {
+            deserr::Value::String(v) => {
+                if v == "*" {
+                    Ok(StarOr::Star)
+                } else {
+                    match T::from_str(&v) {
+                        Ok(parsed) => Ok(StarOr::Other(parsed)),
+                        Err(e) => Err(deserr::take_cf_content(E::merge(None, e, location))),
+                    }
+                }
+            }
+            _ => Err(deserr::take_cf_content(E::error::<V>(
+                None,
+                deserr::ErrorKind::IncorrectValueKind {
+                    actual: value,
+                    accepted: &[ValueKind::String],
+                },
+                location,
+            ))),
+        }
+    }
+}
+
+/// A type representing the content of a query parameter that can either not exist,
+/// be equal to a star (*), or another value
+///
+/// It is a convenient alternative to `Option<StarOr<T>>`.
+#[derive(Debug, Default, Clone, Copy)]
+pub enum OptionStarOr<T> {
+    #[default]
+    None,
+    Star,
+    Other(T),
+}
+
+impl<T> OptionStarOr<T> {
+    pub fn is_some(&self) -> bool {
+        match self {
+            Self::None => false,
+            Self::Star => false,
+            Self::Other(_) => true,
+        }
+    }
+    pub fn merge_star_and_none(self) -> Option<T> {
+        match self {
+            Self::None | Self::Star => None,
+            Self::Other(x) => Some(x),
+        }
+    }
+    pub fn try_map<U, E, F: Fn(T) -> Result<U, E>>(self, map_f: F) -> Result<OptionStarOr<U>, E> {
+        match self {
+            OptionStarOr::None => Ok(OptionStarOr::None),
+            OptionStarOr::Star => Ok(OptionStarOr::Star),
+            OptionStarOr::Other(x) => map_f(x).map(OptionStarOr::Other),
+        }
+    }
+}
+
+impl<T> FromQueryParameter for OptionStarOr<T>
+where
+    T: FromQueryParameter,
+{
+    type Err = T::Err;
+    fn from_query_param(p: &str) -> Result<Self, Self::Err> {
+        match p {
+            "*" => Ok(OptionStarOr::Star),
+            s => T::from_query_param(s).map(OptionStarOr::Other),
+        }
+    }
+}
+
+impl<T, E> Deserr<E> for OptionStarOr<T>
+where
+    E: DeserializeError + MergeWithError<T::Err>,
+    T: FromQueryParameter,
+{
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        value: deserr::Value<V>,
+        location: deserr::ValuePointerRef,
+    ) -> Result<Self, E> {
+        match value {
+            deserr::Value::String(s) => match s.as_str() {
+                "*" => Ok(OptionStarOr::Star),
+                s => match T::from_query_param(s) {
+                    Ok(x) => Ok(OptionStarOr::Other(x)),
+                    Err(e) => Err(deserr::take_cf_content(E::merge(None, e, location))),
+                },
+            },
+            _ => Err(deserr::take_cf_content(E::error::<V>(
+                None,
+                deserr::ErrorKind::IncorrectValueKind {
+                    actual: value,
+                    accepted: &[ValueKind::String],
+                },
+                location,
+            ))),
+        }
+    }
+}
+
+/// A type representing the content of a query parameter that can either not exist, be equal to a star (*), or represent a list of other values
+#[derive(Debug, Default, Clone)]
+pub enum OptionStarOrList<T> {
+    #[default]
+    None,
+    Star,
+    List(Vec<T>),
+}
+
+impl<T> OptionStarOrList<T> {
+    pub fn is_some(&self) -> bool {
+        match self {
+            Self::None => false,
+            Self::Star => false,
+            Self::List(_) => true,
+        }
+    }
+    pub fn map<U, F: Fn(T) -> U>(self, map_f: F) -> OptionStarOrList<U> {
+        match self {
+            Self::None => OptionStarOrList::None,
+            Self::Star => OptionStarOrList::Star,
+            Self::List(xs) => OptionStarOrList::List(xs.into_iter().map(map_f).collect()),
+        }
+    }
+    pub fn try_map<U, E, F: Fn(T) -> Result<U, E>>(
+        self,
+        map_f: F,
+    ) -> Result<OptionStarOrList<U>, E> {
+        match self {
+            Self::None => Ok(OptionStarOrList::None),
+            Self::Star => Ok(OptionStarOrList::Star),
+            Self::List(xs) => {
+                xs.into_iter().map(map_f).collect::<Result<Vec<_>, _>>().map(OptionStarOrList::List)
+            }
+        }
+    }
+    pub fn merge_star_and_none(self) -> Option<Vec<T>> {
+        match self {
+            Self::None | Self::Star => None,
+            Self::List(xs) => Some(xs),
+        }
+    }
+    pub fn push(&mut self, el: T) {
+        match self {
+            Self::None => *self = Self::List(vec![el]),
+            Self::Star => (),
+            Self::List(xs) => xs.push(el),
+        }
+    }
+}
+
+impl<T, E> Deserr<E> for OptionStarOrList<T>
+where
+    E: DeserializeError + MergeWithError<T::Err>,
+    T: FromQueryParameter,
+{
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        value: deserr::Value<V>,
+        location: deserr::ValuePointerRef,
+    ) -> Result<Self, E> {
+        match value {
+            deserr::Value::String(s) => {
+                let mut error = None;
+                let mut is_star = false;
+                // CS::<String>::from_str is infaillible
+                let cs = serde_cs::vec::CS::<String>::from_str(&s).unwrap();
+                let len_cs = cs.0.len();
+                let mut els = vec![];
+                for (i, el_str) in cs.into_iter().enumerate() {
+                    if el_str == "*" {
+                        is_star = true;
+                    } else {
+                        match T::from_query_param(&el_str) {
+                            Ok(el) => {
+                                els.push(el);
+                            }
+                            Err(e) => {
+                                let location =
+                                    if len_cs > 1 { location.push_index(i) } else { location };
+                                error = match E::merge(error, e, location) {
+                                    ControlFlow::Continue(e) => Some(e),
+                                    ControlFlow::Break(e) => return Err(e),
+                                };
+                            }
+                        }
+                    }
+                }
+                if let Some(error) = error {
+                    return Err(error);
+                }
+
+                if is_star {
+                    Ok(OptionStarOrList::Star)
+                } else {
+                    Ok(OptionStarOrList::List(els))
+                }
+            }
+            _ => Err(deserr::take_cf_content(E::error::<V>(
+                None,
+                deserr::ErrorKind::IncorrectValueKind {
+                    actual: value,
+                    accepted: &[ValueKind::String],
+                },
+                location,
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, Value};
+
+    use super::*;
+
+    #[test]
+    fn star_or_serde_roundtrip() {
+        fn roundtrip(content: Value, expected: StarOr<String>) {
+            let deserialized: StarOr<String> = serde_json::from_value(content.clone()).unwrap();
+            assert_eq!(deserialized, expected);
+            assert_eq!(content, serde_json::to_value(deserialized).unwrap());
+        }
+
+        roundtrip(json!("products"), StarOr::Other("products".to_string()));
+        roundtrip(json!("*"), StarOr::Star);
+    }
+}

crates/meilisearch-types/src/task_view.rs

@@ -0,0 +1,161 @@
+use milli::Object;
+use serde::Serialize;
+use time::{Duration, OffsetDateTime};
+
+use crate::error::ResponseError;
+use crate::settings::{Settings, Unchecked};
+use crate::tasks::{serialize_duration, Details, IndexSwap, Kind, Status, Task, TaskId};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskView {
+    pub uid: TaskId,
+    #[serde(default)]
+    pub index_uid: Option<String>,
+    pub status: Status,
+    #[serde(rename = "type")]
+    pub kind: Kind,
+    pub canceled_by: Option<TaskId>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub details: Option<DetailsView>,
+    pub error: Option<ResponseError>,
+    #[serde(serialize_with = "serialize_duration", default)]
+    pub duration: Option<Duration>,
+    #[serde(with = "time::serde::rfc3339")]
+    pub enqueued_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339::option", default)]
+    pub started_at: Option<OffsetDateTime>,
+    #[serde(with = "time::serde::rfc3339::option", default)]
+    pub finished_at: Option<OffsetDateTime>,
+}
+
+impl TaskView {
+    pub fn from_task(task: &Task) -> TaskView {
+        TaskView {
+            uid: task.uid,
+            index_uid: task.index_uid().map(ToOwned::to_owned),
+            status: task.status,
+            kind: task.kind.as_kind(),
+            canceled_by: task.canceled_by,
+            details: task.details.clone().map(DetailsView::from),
+            error: task.error.clone(),
+            duration: task.started_at.zip(task.finished_at).map(|(start, end)| end - start),
+            enqueued_at: task.enqueued_at,
+            started_at: task.started_at,
+            finished_at: task.finished_at,
+        }
+    }
+}
+
+#[derive(Default, Debug, PartialEq, Eq, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DetailsView {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub received_documents: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub indexed_documents: Option<Option<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edited_documents: Option<Option<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub primary_key: Option<Option<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub provided_ids: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deleted_documents: Option<Option<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub matched_tasks: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub canceled_tasks: Option<Option<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deleted_tasks: Option<Option<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub original_filter: Option<Option<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dump_uid: Option<Option<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub context: Option<Option<Object>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub function: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(flatten)]
+    pub settings: Option<Box<Settings<Unchecked>>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub swaps: Option<Vec<IndexSwap>>,
+}
+
+impl From<Details> for DetailsView {
+    fn from(details: Details) -> Self {
+        match details {
+            Details::DocumentAdditionOrUpdate { received_documents, indexed_documents } => {
+                DetailsView {
+                    received_documents: Some(received_documents),
+                    indexed_documents: Some(indexed_documents),
+                    ..DetailsView::default()
+                }
+            }
+            Details::DocumentEdition {
+                deleted_documents,
+                edited_documents,
+                original_filter,
+                context,
+                function,
+            } => DetailsView {
+                deleted_documents: Some(deleted_documents),
+                edited_documents: Some(edited_documents),
+                original_filter: Some(original_filter),
+                context: Some(context),
+                function: Some(function),
+                ..DetailsView::default()
+            },
+            Details::SettingsUpdate { mut settings } => {
+                settings.hide_secrets();
+                DetailsView { settings: Some(settings), ..DetailsView::default() }
+            }
+            Details::IndexInfo { primary_key } => {
+                DetailsView { primary_key: Some(primary_key), ..DetailsView::default() }
+            }
+            Details::DocumentDeletion {
+                provided_ids: received_document_ids,
+                deleted_documents,
+            } => DetailsView {
+                provided_ids: Some(received_document_ids),
+                deleted_documents: Some(deleted_documents),
+                original_filter: Some(None),
+                ..DetailsView::default()
+            },
+            Details::DocumentDeletionByFilter { original_filter, deleted_documents } => {
+                DetailsView {
+                    provided_ids: Some(0),
+                    original_filter: Some(Some(original_filter)),
+                    deleted_documents: Some(deleted_documents),
+                    ..DetailsView::default()
+                }
+            }
+            Details::ClearAll { deleted_documents } => {
+                DetailsView { deleted_documents: Some(deleted_documents), ..DetailsView::default() }
+            }
+            Details::TaskCancelation { matched_tasks, canceled_tasks, original_filter } => {
+                DetailsView {
+                    matched_tasks: Some(matched_tasks),
+                    canceled_tasks: Some(canceled_tasks),
+                    original_filter: Some(Some(original_filter)),
+                    ..DetailsView::default()
+                }
+            }
+            Details::TaskDeletion { matched_tasks, deleted_tasks, original_filter } => {
+                DetailsView {
+                    matched_tasks: Some(matched_tasks),
+                    deleted_tasks: Some(deleted_tasks),
+                    original_filter: Some(Some(original_filter)),
+                    ..DetailsView::default()
+                }
+            }
+            Details::Dump { dump_uid } => {
+                DetailsView { dump_uid: Some(dump_uid), ..DetailsView::default() }
+            }
+            Details::IndexSwap { swaps } => {
+                DetailsView { swaps: Some(swaps), ..Default::default() }
+            }
+        }
+    }
+}

crates/meilisearch-types/src/tasks.rs

@@ -0,0 +1,673 @@
+use core::fmt;
+use std::collections::HashSet;
+use std::fmt::{Display, Write};
+use std::str::FromStr;
+
+use enum_iterator::Sequence;
+use milli::update::IndexDocumentsMethod;
+use milli::Object;
+use roaring::RoaringBitmap;
+use serde::{Deserialize, Serialize, Serializer};
+use time::{Duration, OffsetDateTime};
+use uuid::Uuid;
+
+use crate::error::ResponseError;
+use crate::keys::Key;
+use crate::settings::{Settings, Unchecked};
+use crate::InstanceUid;
+
+pub type TaskId = u32;
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Task {
+    pub uid: TaskId,
+
+    #[serde(with = "time::serde::rfc3339")]
+    pub enqueued_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub started_at: Option<OffsetDateTime>,
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub finished_at: Option<OffsetDateTime>,
+
+    pub error: Option<ResponseError>,
+    pub canceled_by: Option<TaskId>,
+    pub details: Option<Details>,
+
+    pub status: Status,
+    pub kind: KindWithContent,
+}
+
+impl Task {
+    pub fn index_uid(&self) -> Option<&str> {
+        use KindWithContent::*;
+
+        match &self.kind {
+            DumpCreation { .. }
+            | SnapshotCreation
+            | TaskCancelation { .. }
+            | TaskDeletion { .. }
+            | IndexSwap { .. } => None,
+            DocumentAdditionOrUpdate { index_uid, .. }
+            | DocumentEdition { index_uid, .. }
+            | DocumentDeletion { index_uid, .. }
+            | DocumentDeletionByFilter { index_uid, .. }
+            | DocumentClear { index_uid }
+            | SettingsUpdate { index_uid, .. }
+            | IndexCreation { index_uid, .. }
+            | IndexUpdate { index_uid, .. }
+            | IndexDeletion { index_uid } => Some(index_uid),
+        }
+    }
+
+    /// Return the list of indexes updated by this tasks.
+    pub fn indexes(&self) -> Vec<&str> {
+        self.kind.indexes()
+    }
+
+    /// Return the content-uuid if there is one
+    pub fn content_uuid(&self) -> Option<Uuid> {
+        match self.kind {
+            KindWithContent::DocumentAdditionOrUpdate { content_file, .. } => Some(content_file),
+            KindWithContent::DocumentEdition { .. }
+            | KindWithContent::DocumentDeletion { .. }
+            | KindWithContent::DocumentDeletionByFilter { .. }
+            | KindWithContent::DocumentClear { .. }
+            | KindWithContent::SettingsUpdate { .. }
+            | KindWithContent::IndexDeletion { .. }
+            | KindWithContent::IndexCreation { .. }
+            | KindWithContent::IndexUpdate { .. }
+            | KindWithContent::IndexSwap { .. }
+            | KindWithContent::TaskCancelation { .. }
+            | KindWithContent::TaskDeletion { .. }
+            | KindWithContent::DumpCreation { .. }
+            | KindWithContent::SnapshotCreation => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum KindWithContent {
+    DocumentAdditionOrUpdate {
+        index_uid: String,
+        primary_key: Option<String>,
+        method: IndexDocumentsMethod,
+        content_file: Uuid,
+        documents_count: u64,
+        allow_index_creation: bool,
+    },
+    DocumentDeletion {
+        index_uid: String,
+        documents_ids: Vec<String>,
+    },
+    DocumentDeletionByFilter {
+        index_uid: String,
+        filter_expr: serde_json::Value,
+    },
+    DocumentEdition {
+        index_uid: String,
+        filter_expr: Option<serde_json::Value>,
+        context: Option<milli::Object>,
+        function: String,
+    },
+    DocumentClear {
+        index_uid: String,
+    },
+    SettingsUpdate {
+        index_uid: String,
+        new_settings: Box<Settings<Unchecked>>,
+        is_deletion: bool,
+        allow_index_creation: bool,
+    },
+    IndexDeletion {
+        index_uid: String,
+    },
+    IndexCreation {
+        index_uid: String,
+        primary_key: Option<String>,
+    },
+    IndexUpdate {
+        index_uid: String,
+        primary_key: Option<String>,
+    },
+    IndexSwap {
+        swaps: Vec<IndexSwap>,
+    },
+    TaskCancelation {
+        query: String,
+        tasks: RoaringBitmap,
+    },
+    TaskDeletion {
+        query: String,
+        tasks: RoaringBitmap,
+    },
+    DumpCreation {
+        keys: Vec<Key>,
+        instance_uid: Option<InstanceUid>,
+    },
+    SnapshotCreation,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IndexSwap {
+    pub indexes: (String, String),
+}
+
+impl KindWithContent {
+    pub fn as_kind(&self) -> Kind {
+        match self {
+            KindWithContent::DocumentAdditionOrUpdate { .. } => Kind::DocumentAdditionOrUpdate,
+            KindWithContent::DocumentEdition { .. } => Kind::DocumentEdition,
+            KindWithContent::DocumentDeletion { .. } => Kind::DocumentDeletion,
+            KindWithContent::DocumentDeletionByFilter { .. } => Kind::DocumentDeletion,
+            KindWithContent::DocumentClear { .. } => Kind::DocumentDeletion,
+            KindWithContent::SettingsUpdate { .. } => Kind::SettingsUpdate,
+            KindWithContent::IndexCreation { .. } => Kind::IndexCreation,
+            KindWithContent::IndexDeletion { .. } => Kind::IndexDeletion,
+            KindWithContent::IndexUpdate { .. } => Kind::IndexUpdate,
+            KindWithContent::IndexSwap { .. } => Kind::IndexSwap,
+            KindWithContent::TaskCancelation { .. } => Kind::TaskCancelation,
+            KindWithContent::TaskDeletion { .. } => Kind::TaskDeletion,
+            KindWithContent::DumpCreation { .. } => Kind::DumpCreation,
+            KindWithContent::SnapshotCreation => Kind::SnapshotCreation,
+        }
+    }
+
+    pub fn indexes(&self) -> Vec<&str> {
+        use KindWithContent::*;
+
+        match self {
+            DumpCreation { .. }
+            | SnapshotCreation
+            | TaskCancelation { .. }
+            | TaskDeletion { .. } => vec![],
+            DocumentAdditionOrUpdate { index_uid, .. }
+            | DocumentEdition { index_uid, .. }
+            | DocumentDeletion { index_uid, .. }
+            | DocumentDeletionByFilter { index_uid, .. }
+            | DocumentClear { index_uid }
+            | SettingsUpdate { index_uid, .. }
+            | IndexCreation { index_uid, .. }
+            | IndexUpdate { index_uid, .. }
+            | IndexDeletion { index_uid } => vec![index_uid],
+            IndexSwap { swaps } => {
+                let mut indexes = HashSet::<&str>::default();
+                for swap in swaps {
+                    indexes.insert(swap.indexes.0.as_str());
+                    indexes.insert(swap.indexes.1.as_str());
+                }
+                indexes.into_iter().collect()
+            }
+        }
+    }
+
+    /// Returns the default `Details` that correspond to this `KindWithContent`,
+    /// `None` if it cannot be generated.
+    pub fn default_details(&self) -> Option<Details> {
+        match self {
+            KindWithContent::DocumentAdditionOrUpdate { documents_count, .. } => {
+                Some(Details::DocumentAdditionOrUpdate {
+                    received_documents: *documents_count,
+                    indexed_documents: None,
+                })
+            }
+            KindWithContent::DocumentEdition { index_uid: _, filter_expr, context, function } => {
+                Some(Details::DocumentEdition {
+                    deleted_documents: None,
+                    edited_documents: None,
+                    original_filter: filter_expr.as_ref().map(|v| v.to_string()),
+                    context: context.clone(),
+                    function: function.clone(),
+                })
+            }
+            KindWithContent::DocumentDeletion { index_uid: _, documents_ids } => {
+                Some(Details::DocumentDeletion {
+                    provided_ids: documents_ids.len(),
+                    deleted_documents: None,
+                })
+            }
+            KindWithContent::DocumentDeletionByFilter { index_uid: _, filter_expr } => {
+                Some(Details::DocumentDeletionByFilter {
+                    original_filter: filter_expr.to_string(),
+                    deleted_documents: None,
+                })
+            }
+            KindWithContent::DocumentClear { .. } | KindWithContent::IndexDeletion { .. } => {
+                Some(Details::ClearAll { deleted_documents: None })
+            }
+            KindWithContent::SettingsUpdate { new_settings, .. } => {
+                Some(Details::SettingsUpdate { settings: new_settings.clone() })
+            }
+            KindWithContent::IndexCreation { primary_key, .. }
+            | KindWithContent::IndexUpdate { primary_key, .. } => {
+                Some(Details::IndexInfo { primary_key: primary_key.clone() })
+            }
+            KindWithContent::IndexSwap { swaps } => {
+                Some(Details::IndexSwap { swaps: swaps.clone() })
+            }
+            KindWithContent::TaskCancelation { query, tasks } => Some(Details::TaskCancelation {
+                matched_tasks: tasks.len(),
+                canceled_tasks: None,
+                original_filter: query.clone(),
+            }),
+            KindWithContent::TaskDeletion { query, tasks } => Some(Details::TaskDeletion {
+                matched_tasks: tasks.len(),
+                deleted_tasks: None,
+                original_filter: query.clone(),
+            }),
+            KindWithContent::DumpCreation { .. } => Some(Details::Dump { dump_uid: None }),
+            KindWithContent::SnapshotCreation => None,
+        }
+    }
+
+    pub fn default_finished_details(&self) -> Option<Details> {
+        match self {
+            KindWithContent::DocumentAdditionOrUpdate { documents_count, .. } => {
+                Some(Details::DocumentAdditionOrUpdate {
+                    received_documents: *documents_count,
+                    indexed_documents: Some(0),
+                })
+            }
+            KindWithContent::DocumentEdition { index_uid: _, filter_expr, context, function } => {
+                Some(Details::DocumentEdition {
+                    deleted_documents: Some(0),
+                    edited_documents: Some(0),
+                    original_filter: filter_expr.as_ref().map(|v| v.to_string()),
+                    context: context.clone(),
+                    function: function.clone(),
+                })
+            }
+            KindWithContent::DocumentDeletion { index_uid: _, documents_ids } => {
+                Some(Details::DocumentDeletion {
+                    provided_ids: documents_ids.len(),
+                    deleted_documents: Some(0),
+                })
+            }
+            KindWithContent::DocumentDeletionByFilter { index_uid: _, filter_expr } => {
+                Some(Details::DocumentDeletionByFilter {
+                    original_filter: filter_expr.to_string(),
+                    deleted_documents: Some(0),
+                })
+            }
+            KindWithContent::DocumentClear { .. } => {
+                Some(Details::ClearAll { deleted_documents: None })
+            }
+            KindWithContent::SettingsUpdate { new_settings, .. } => {
+                Some(Details::SettingsUpdate { settings: new_settings.clone() })
+            }
+            KindWithContent::IndexDeletion { .. } => None,
+            KindWithContent::IndexCreation { primary_key, .. }
+            | KindWithContent::IndexUpdate { primary_key, .. } => {
+                Some(Details::IndexInfo { primary_key: primary_key.clone() })
+            }
+            KindWithContent::IndexSwap { .. } => {
+                todo!()
+            }
+            KindWithContent::TaskCancelation { query, tasks } => Some(Details::TaskCancelation {
+                matched_tasks: tasks.len(),
+                canceled_tasks: Some(0),
+                original_filter: query.clone(),
+            }),
+            KindWithContent::TaskDeletion { query, tasks } => Some(Details::TaskDeletion {
+                matched_tasks: tasks.len(),
+                deleted_tasks: Some(0),
+                original_filter: query.clone(),
+            }),
+            KindWithContent::DumpCreation { .. } => Some(Details::Dump { dump_uid: None }),
+            KindWithContent::SnapshotCreation => None,
+        }
+    }
+}
+
+impl From<&KindWithContent> for Option<Details> {
+    fn from(kind: &KindWithContent) -> Self {
+        match kind {
+            KindWithContent::DocumentAdditionOrUpdate { documents_count, .. } => {
+                Some(Details::DocumentAdditionOrUpdate {
+                    received_documents: *documents_count,
+                    indexed_documents: None,
+                })
+            }
+            KindWithContent::DocumentEdition { .. } => None,
+            KindWithContent::DocumentDeletion { .. } => None,
+            KindWithContent::DocumentDeletionByFilter { .. } => None,
+            KindWithContent::DocumentClear { .. } => None,
+            KindWithContent::SettingsUpdate { new_settings, .. } => {
+                Some(Details::SettingsUpdate { settings: new_settings.clone() })
+            }
+            KindWithContent::IndexDeletion { .. } => None,
+            KindWithContent::IndexCreation { primary_key, .. } => {
+                Some(Details::IndexInfo { primary_key: primary_key.clone() })
+            }
+            KindWithContent::IndexUpdate { primary_key, .. } => {
+                Some(Details::IndexInfo { primary_key: primary_key.clone() })
+            }
+            KindWithContent::IndexSwap { .. } => None,
+            KindWithContent::TaskCancelation { query, tasks } => Some(Details::TaskCancelation {
+                matched_tasks: tasks.len(),
+                canceled_tasks: None,
+                original_filter: query.clone(),
+            }),
+            KindWithContent::TaskDeletion { query, tasks } => Some(Details::TaskDeletion {
+                matched_tasks: tasks.len(),
+                deleted_tasks: None,
+                original_filter: query.clone(),
+            }),
+            KindWithContent::DumpCreation { .. } => Some(Details::Dump { dump_uid: None }),
+            KindWithContent::SnapshotCreation => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Sequence)]
+#[serde(rename_all = "camelCase")]
+pub enum Status {
+    Enqueued,
+    Processing,
+    Succeeded,
+    Failed,
+    Canceled,
+}
+
+impl Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Status::Enqueued => write!(f, "enqueued"),
+            Status::Processing => write!(f, "processing"),
+            Status::Succeeded => write!(f, "succeeded"),
+            Status::Failed => write!(f, "failed"),
+            Status::Canceled => write!(f, "canceled"),
+        }
+    }
+}
+
+impl FromStr for Status {
+    type Err = ParseTaskStatusError;
+
+    fn from_str(status: &str) -> Result<Self, Self::Err> {
+        if status.eq_ignore_ascii_case("enqueued") {
+            Ok(Status::Enqueued)
+        } else if status.eq_ignore_ascii_case("processing") {
+            Ok(Status::Processing)
+        } else if status.eq_ignore_ascii_case("succeeded") {
+            Ok(Status::Succeeded)
+        } else if status.eq_ignore_ascii_case("failed") {
+            Ok(Status::Failed)
+        } else if status.eq_ignore_ascii_case("canceled") {
+            Ok(Status::Canceled)
+        } else {
+            Err(ParseTaskStatusError(status.to_owned()))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParseTaskStatusError(pub String);
+impl fmt::Display for ParseTaskStatusError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "`{}` is not a valid task status. Available statuses are {}.",
+            self.0,
+            enum_iterator::all::<Status>()
+                .map(|s| format!("`{s}`"))
+                .collect::<Vec<String>>()
+                .join(", ")
+        )
+    }
+}
+impl std::error::Error for ParseTaskStatusError {}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Sequence)]
+#[serde(rename_all = "camelCase")]
+pub enum Kind {
+    DocumentAdditionOrUpdate,
+    DocumentEdition,
+    DocumentDeletion,
+    SettingsUpdate,
+    IndexCreation,
+    IndexDeletion,
+    IndexUpdate,
+    IndexSwap,
+    TaskCancelation,
+    TaskDeletion,
+    DumpCreation,
+    SnapshotCreation,
+}
+
+impl Kind {
+    pub fn related_to_one_index(&self) -> bool {
+        match self {
+            Kind::DocumentAdditionOrUpdate
+            | Kind::DocumentEdition
+            | Kind::DocumentDeletion
+            | Kind::SettingsUpdate
+            | Kind::IndexCreation
+            | Kind::IndexDeletion
+            | Kind::IndexUpdate => true,
+            Kind::IndexSwap
+            | Kind::TaskCancelation
+            | Kind::TaskDeletion
+            | Kind::DumpCreation
+            | Kind::SnapshotCreation => false,
+        }
+    }
+}
+impl Display for Kind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Kind::DocumentAdditionOrUpdate => write!(f, "documentAdditionOrUpdate"),
+            Kind::DocumentEdition => write!(f, "documentEdition"),
+            Kind::DocumentDeletion => write!(f, "documentDeletion"),
+            Kind::SettingsUpdate => write!(f, "settingsUpdate"),
+            Kind::IndexCreation => write!(f, "indexCreation"),
+            Kind::IndexDeletion => write!(f, "indexDeletion"),
+            Kind::IndexUpdate => write!(f, "indexUpdate"),
+            Kind::IndexSwap => write!(f, "indexSwap"),
+            Kind::TaskCancelation => write!(f, "taskCancelation"),
+            Kind::TaskDeletion => write!(f, "taskDeletion"),
+            Kind::DumpCreation => write!(f, "dumpCreation"),
+            Kind::SnapshotCreation => write!(f, "snapshotCreation"),
+        }
+    }
+}
+impl FromStr for Kind {
+    type Err = ParseTaskKindError;
+
+    fn from_str(kind: &str) -> Result<Self, Self::Err> {
+        if kind.eq_ignore_ascii_case("indexCreation") {
+            Ok(Kind::IndexCreation)
+        } else if kind.eq_ignore_ascii_case("indexUpdate") {
+            Ok(Kind::IndexUpdate)
+        } else if kind.eq_ignore_ascii_case("indexSwap") {
+            Ok(Kind::IndexSwap)
+        } else if kind.eq_ignore_ascii_case("indexDeletion") {
+            Ok(Kind::IndexDeletion)
+        } else if kind.eq_ignore_ascii_case("documentAdditionOrUpdate") {
+            Ok(Kind::DocumentAdditionOrUpdate)
+        } else if kind.eq_ignore_ascii_case("documentEdition") {
+            Ok(Kind::DocumentEdition)
+        } else if kind.eq_ignore_ascii_case("documentDeletion") {
+            Ok(Kind::DocumentDeletion)
+        } else if kind.eq_ignore_ascii_case("settingsUpdate") {
+            Ok(Kind::SettingsUpdate)
+        } else if kind.eq_ignore_ascii_case("taskCancelation") {
+            Ok(Kind::TaskCancelation)
+        } else if kind.eq_ignore_ascii_case("taskDeletion") {
+            Ok(Kind::TaskDeletion)
+        } else if kind.eq_ignore_ascii_case("dumpCreation") {
+            Ok(Kind::DumpCreation)
+        } else if kind.eq_ignore_ascii_case("snapshotCreation") {
+            Ok(Kind::SnapshotCreation)
+        } else {
+            Err(ParseTaskKindError(kind.to_owned()))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ParseTaskKindError(pub String);
+impl fmt::Display for ParseTaskKindError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "`{}` is not a valid task type. Available types are {}.",
+            self.0,
+            enum_iterator::all::<Kind>()
+                .map(|k| format!(
+                    "`{}`",
+                    // by default serde is going to insert `"` around the value.
+                    serde_json::to_string(&k).unwrap().trim_matches('"')
+                ))
+                .collect::<Vec<String>>()
+                .join(", ")
+        )
+    }
+}
+impl std::error::Error for ParseTaskKindError {}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub enum Details {
+    DocumentAdditionOrUpdate {
+        received_documents: u64,
+        indexed_documents: Option<u64>,
+    },
+    SettingsUpdate {
+        settings: Box<Settings<Unchecked>>,
+    },
+    IndexInfo {
+        primary_key: Option<String>,
+    },
+    DocumentDeletion {
+        provided_ids: usize,
+        deleted_documents: Option<u64>,
+    },
+    DocumentDeletionByFilter {
+        original_filter: String,
+        deleted_documents: Option<u64>,
+    },
+    DocumentEdition {
+        deleted_documents: Option<u64>,
+        edited_documents: Option<u64>,
+        original_filter: Option<String>,
+        context: Option<Object>,
+        function: String,
+    },
+    ClearAll {
+        deleted_documents: Option<u64>,
+    },
+    TaskCancelation {
+        matched_tasks: u64,
+        canceled_tasks: Option<u64>,
+        original_filter: String,
+    },
+    TaskDeletion {
+        matched_tasks: u64,
+        deleted_tasks: Option<u64>,
+        original_filter: String,
+    },
+    Dump {
+        dump_uid: Option<String>,
+    },
+    IndexSwap {
+        swaps: Vec<IndexSwap>,
+    },
+}
+
+impl Details {
+    pub fn to_failed(&self) -> Self {
+        let mut details = self.clone();
+        match &mut details {
+            Self::DocumentAdditionOrUpdate { indexed_documents, .. } => {
+                *indexed_documents = Some(0)
+            }
+            Self::DocumentEdition { edited_documents, .. } => *edited_documents = Some(0),
+            Self::DocumentDeletion { deleted_documents, .. } => *deleted_documents = Some(0),
+            Self::DocumentDeletionByFilter { deleted_documents, .. } => {
+                *deleted_documents = Some(0)
+            }
+            Self::ClearAll { deleted_documents } => *deleted_documents = Some(0),
+            Self::TaskCancelation { canceled_tasks, .. } => *canceled_tasks = Some(0),
+            Self::TaskDeletion { deleted_tasks, .. } => *deleted_tasks = Some(0),
+            Self::SettingsUpdate { .. }
+            | Self::IndexInfo { .. }
+            | Self::Dump { .. }
+            | Self::IndexSwap { .. } => (),
+        }
+
+        details
+    }
+}
+
+/// Serialize a `time::Duration` as a best effort ISO 8601 while waiting for
+/// https://github.com/time-rs/time/issues/378.
+/// This code is a port of the old code of time that was removed in 0.2.
+pub fn serialize_duration<S: Serializer>(
+    duration: &Option<Duration>,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    match duration {
+        Some(duration) => {
+            // technically speaking, negative duration is not valid ISO 8601
+            if duration.is_negative() {
+                return serializer.serialize_none();
+            }
+
+            const SECS_PER_DAY: i64 = Duration::DAY.whole_seconds();
+            let secs = duration.whole_seconds();
+            let days = secs / SECS_PER_DAY;
+            let secs = secs - days * SECS_PER_DAY;
+            let hasdate = days != 0;
+            let nanos = duration.subsec_nanoseconds();
+            let hastime = (secs != 0 || nanos != 0) || !hasdate;
+
+            // all the following unwrap can't fail
+            let mut res = String::new();
+            write!(&mut res, "P").unwrap();
+
+            if hasdate {
+                write!(&mut res, "{}D", days).unwrap();
+            }
+
+            const NANOS_PER_MILLI: i32 = Duration::MILLISECOND.subsec_nanoseconds();
+            const NANOS_PER_MICRO: i32 = Duration::MICROSECOND.subsec_nanoseconds();
+
+            if hastime {
+                if nanos == 0 {
+                    write!(&mut res, "T{}S", secs).unwrap();
+                } else if nanos % NANOS_PER_MILLI == 0 {
+                    write!(&mut res, "T{}.{:03}S", secs, nanos / NANOS_PER_MILLI).unwrap();
+                } else if nanos % NANOS_PER_MICRO == 0 {
+                    write!(&mut res, "T{}.{:06}S", secs, nanos / NANOS_PER_MICRO).unwrap();
+                } else {
+                    write!(&mut res, "T{}.{:09}S", secs, nanos).unwrap();
+                }
+            }
+
+            serializer.serialize_str(&res)
+        }
+        None => serializer.serialize_none(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Details;
+    use crate::heed::types::SerdeJson;
+    use crate::heed::{BytesDecode, BytesEncode};
+
+    #[test]
+    fn bad_deser() {
+        let details = Details::TaskDeletion {
+            matched_tasks: 1,
+            deleted_tasks: None,
+            original_filter: "hello".to_owned(),
+        };
+        let serialised = SerdeJson::<Details>::bytes_encode(&details).unwrap();
+        let deserialised = SerdeJson::<Details>::bytes_decode(&serialised).unwrap();
+        meili_snap::snapshot!(format!("{:?}", details), @r###"TaskDeletion { matched_tasks: 1, deleted_tasks: None, original_filter: "hello" }"###);
+        meili_snap::snapshot!(format!("{:?}", deserialised), @r###"TaskDeletion { matched_tasks: 1, deleted_tasks: None, original_filter: "hello" }"###);
+    }
+}

crates/meilisearch-types/src/versioning.rs

@@ -0,0 +1,78 @@
+use std::fs;
+use std::io::{self, ErrorKind};
+use std::path::Path;
+
+/// The name of the file that contains the version of the database.
+pub const VERSION_FILE_NAME: &str = "VERSION";
+
+static VERSION_MAJOR: &str = env!("CARGO_PKG_VERSION_MAJOR");
+static VERSION_MINOR: &str = env!("CARGO_PKG_VERSION_MINOR");
+static VERSION_PATCH: &str = env!("CARGO_PKG_VERSION_PATCH");
+
+/// Persists the version of the current Meilisearch binary to a VERSION file
+pub fn create_current_version_file(db_path: &Path) -> io::Result<()> {
+    create_version_file(db_path, VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH)
+}
+
+pub fn create_version_file(
+    db_path: &Path,
+    major: &str,
+    minor: &str,
+    patch: &str,
+) -> io::Result<()> {
+    let version_path = db_path.join(VERSION_FILE_NAME);
+    fs::write(version_path, format!("{}.{}.{}", major, minor, patch))
+}
+
+/// Ensures Meilisearch version is compatible with the database, returns an error versions mismatch.
+pub fn check_version_file(db_path: &Path) -> anyhow::Result<()> {
+    let (major, minor, patch) = get_version(db_path)?;
+
+    if major != VERSION_MAJOR || minor != VERSION_MINOR {
+        return Err(VersionFileError::VersionMismatch { major, minor, patch }.into());
+    }
+
+    Ok(())
+}
+
+pub fn get_version(db_path: &Path) -> Result<(String, String, String), VersionFileError> {
+    let version_path = db_path.join(VERSION_FILE_NAME);
+
+    match fs::read_to_string(version_path) {
+        Ok(version) => parse_version(&version),
+        Err(error) => match error.kind() {
+            ErrorKind::NotFound => Err(VersionFileError::MissingVersionFile),
+            _ => Err(error.into()),
+        },
+    }
+}
+
+pub fn parse_version(version: &str) -> Result<(String, String, String), VersionFileError> {
+    let version_components = version.split('.').collect::<Vec<_>>();
+    let (major, minor, patch) = match &version_components[..] {
+        [major, minor, patch] => (major.to_string(), minor.to_string(), patch.to_string()),
+        _ => return Err(VersionFileError::MalformedVersionFile),
+    };
+    Ok((major, minor, patch))
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum VersionFileError {
+    #[error(
+        "Meilisearch (v{}) failed to infer the version of the database.
+        To update Meilisearch please follow our guide on https://www.meilisearch.com/docs/learn/update_and_migration/updating.",
+        env!("CARGO_PKG_VERSION").to_string()
+    )]
+    MissingVersionFile,
+    #[error("Version file is corrupted and thus Meilisearch is unable to determine the version of the database.")]
+    MalformedVersionFile,
+    #[error(
+        "Your database version ({major}.{minor}.{patch}) is incompatible with your current engine version ({}).\n\
+        To migrate data between Meilisearch versions, please follow our guide on https://www.meilisearch.com/docs/learn/update_and_migration/updating.",
+        env!("CARGO_PKG_VERSION").to_string()
+    )]
+    VersionMismatch { major: String, minor: String, patch: String },
+
+    #[error(transparent)]
+    IoError(#[from] std::io::Error),
+}