Merge branch 'main' into feat/attributes

Author: kumarUjjawal

.code-samples.meilisearch.yaml

@@ -142,6 +142,13 @@ get_documents_post_1: |-
     .execute::<Movies>()
     .await
     .unwrap();
+get_documents_by_ids_1: |-
+  let index = client.index("books");
+  let documents: DocumentsResults = DocumentsQuery::new(&index)
+    .with_ids(["1", "2"]) // retrieve documents by IDs
+    .execute::<Movies>()
+    .await
+    .unwrap();
 add_or_replace_documents_1: |-
   let task: TaskInfo = client
     .index("movies")
@@ -728,10 +735,16 @@ distinct_attribute_guide_1: |-
     .set_distinct_attribute("product_id")
     .await
     .unwrap();
+compact_index_1: |-
+  let task: TaskInfo = client
+    .index("INDEX_UID")
+    .compact()
+    .await
+    .unwrap();
 field_properties_guide_searchable_1: |-
   let searchable_attributes = [
     "title",
-    "overvieww",
+    "overview",
     "genres"
   ];
 
@@ -743,7 +756,7 @@ field_properties_guide_searchable_1: |-
 field_properties_guide_displayed_1: |-
   let displayed_attributes = [
     "title",
-    "overvieww",
+    "overview",
     "genres",
     "release_date"
   ];
@@ -1974,6 +1987,20 @@ search_parameter_reference_retrieve_vectors_1: |-
     .execute()
     .await
     .unwrap();
+search_parameter_reference_media_1: |-
+  let results = index
+    .search()
+    .with_hybrid("EMBEDDER_NAME", 0.5)
+    .with_media(json!({
+      "FIELD_A": "VALUE_A",
+      "FIELD_B": {
+        "FIELD_C": "VALUE_B",
+        "FIELD_D": "VALUE_C"
+      }
+    }))
+    .execute()
+    .await
+    .unwrap();
 update_embedders_1: |-
   let embedders = HashMap::from([(
     String::from("default"),

examples/web_app_graphql/Cargo.toml

@@ -12,7 +12,7 @@ actix-web = "4.4.0"
 async-graphql = "6.0.11"
 async-graphql-actix-web = "6.0.11"
 diesel = { version = "2.1.4", features = ["postgres"] }
-diesel-async = { version = "0.6.1", features = ["postgres", "deadpool"] }
+diesel-async = { version = "0.7.3", features = ["postgres", "deadpool"] }
 diesel_migrations = "2.1.0"
 dotenvy = "0.15.7"
 env_logger = "0.11.3"

src/documents.rs

@@ -202,6 +202,15 @@ pub struct DocumentsQuery<'a, Http: HttpClient> {
     /// Read the [dedicated guide](https://www.meilisearch.com/docs/learn/filtering_and_sorting) to learn the syntax.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub filter: Option<&'a str>,
+
+    /// Retrieve documents by their IDs.
+    ///
+    /// When `ids` is provided, the SDK will call the `/documents/fetch` endpoint with a POST request.
+    ///
+    /// Note: IDs are represented as strings to keep consistency with [`Index::get_document`]. If your IDs
+    /// are numeric, pass them as strings (e.g., `"1"`, `"2"`).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ids: Option<Vec<&'a str>>,
 }
 
 impl<'a, Http: HttpClient> DocumentsQuery<'a, Http> {
@@ -214,6 +223,7 @@ impl<'a, Http: HttpClient> DocumentsQuery<'a, Http> {
             fields: None,
             sort: None,
             filter: None,
+            ids: None,
         }
     }
 
@@ -314,6 +324,29 @@ impl<'a, Http: HttpClient> DocumentsQuery<'a, Http> {
         self
     }
 
+    /// Specify a list of document IDs to retrieve.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*, documents::*};
+    /// # use serde::{Deserialize, Serialize};
+    /// #
+    /// # let MEILISEARCH_URL = option_env!("MEILISEARCH_URL").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// # let client = Client::new(MEILISEARCH_URL, Some(MEILISEARCH_API_KEY)).unwrap();
+    /// let index = client.index("get_documents_by_ids_example");
+    /// let mut query = DocumentsQuery::new(&index);
+    /// query.with_ids(["1", "2"]);
+    /// ```
+    pub fn with_ids(
+        &mut self,
+        ids: impl IntoIterator<Item = &'a str>,
+    ) -> &mut DocumentsQuery<'a, Http> {
+        self.ids = Some(ids.into_iter().collect());
+        self
+    }
+
     /// Execute the get documents query.
     ///
     /// # Example
@@ -468,6 +501,19 @@ mod tests {
         Ok(())
     }
 
+    #[meilisearch_test]
+    async fn test_get_documents_by_ids(client: Client, index: Index) -> Result<(), Error> {
+        setup_test_index(&client, &index).await?;
+
+        let documents = DocumentsQuery::new(&index)
+            .with_ids(["1", "3"]) // retrieve by IDs
+            .execute::<MyObject>()
+            .await?;
+
+        assert_eq!(documents.results.len(), 2);
+        Ok(())
+    }
+
     #[meilisearch_test]
     async fn test_delete_documents_with(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;

src/features.rs

@@ -14,6 +14,8 @@ pub struct ExperimentalFeaturesResult {
     pub contains_filter: bool,
     pub network: bool,
     pub edit_documents_by_function: bool,
+    #[serde(default)]
+    pub multimodal: bool,
 }
 
 /// Struct representing the experimental features request.
@@ -45,6 +47,8 @@ pub struct ExperimentalFeatures<'a, Http: HttpClient> {
     pub network: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub edit_documents_by_function: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub multimodal: Option<bool>,
 }
 
 impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
@@ -57,6 +61,7 @@ impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
             network: None,
             contains_filter: None,
             edit_documents_by_function: None,
+            multimodal: None,
         }
     }
 
@@ -140,6 +145,11 @@ impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
         self.network = Some(network);
         self
     }
+
+    pub fn set_multimodal(&mut self, multimodal: bool) -> &mut Self {
+        self.multimodal = Some(multimodal);
+        self
+    }
 }
 
 #[cfg(test)]
@@ -155,6 +165,7 @@ mod tests {
         features.set_contains_filter(true);
         features.set_network(true);
         features.set_edit_documents_by_function(true);
+        features.set_multimodal(true);
         let _ = features.update().await.unwrap();
 
         let res = features.get().await.unwrap();
@@ -163,5 +174,6 @@ mod tests {
         assert!(res.contains_filter);
         assert!(res.network);
         assert!(res.edit_documents_by_function);
+        assert!(res.multimodal);
     }
 }

src/indexes.rs

@@ -517,7 +517,7 @@ impl<Http: HttpClient> Index<Http> {
         &self,
         documents_query: &DocumentsQuery<'_, Http>,
     ) -> Result<DocumentsResults<T>, Error> {
-        if documents_query.filter.is_some() {
+        if documents_query.filter.is_some() || documents_query.ids.is_some() {
             let url = format!("{}/indexes/{}/documents/fetch", self.client.host, self.uid);
             return self
                 .client
@@ -1325,6 +1325,55 @@ impl<Http: HttpClient> Index<Http> {
         Ok(self.primary_key.as_deref())
     }
 
+    /// Compact this index to reduce disk usage.
+    ///
+    /// Triggers a compaction task for the current index. Once completed, the
+    /// index data is compacted on disk.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*, tasks::Task};
+    /// # let MEILISEARCH_URL = option_env!("MEILISEARCH_URL").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// # tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
+    /// # let client = Client::new(MEILISEARCH_URL, Some(MEILISEARCH_API_KEY)).unwrap();
+    /// # let index = client
+    /// #   .create_index("compact_example", None)
+    /// #   .await
+    /// #   .unwrap()
+    /// #   .wait_for_completion(&client, None, None)
+    /// #   .await
+    /// #   .unwrap()
+    /// #   .try_make_index(&client)
+    /// #   .unwrap();
+    ///
+    /// let task = index
+    ///     .compact()
+    ///     .await
+    ///     .unwrap()
+    ///     .wait_for_completion(&client, None, None)
+    ///     .await
+    ///     .unwrap();
+    ///
+    /// assert!(matches!(task, Task::Succeeded { .. }));
+    /// # index.delete().await.unwrap().wait_for_completion(&client, None, None).await.unwrap();
+    /// # });
+    /// ```
+    pub async fn compact(&self) -> Result<TaskInfo, Error> {
+        self.client
+            .http_client
+            .request::<(), (), TaskInfo>(
+                &format!("{}/indexes/{}/compact", self.client.host, self.uid),
+                Method::Post {
+                    query: (),
+                    body: (),
+                },
+                202,
+            )
+            .await
+    }
+
     /// Get a [Task] from a specific [Index] to keep track of [asynchronous operations](https://www.meilisearch.com/docs/learn/advanced/asynchronous_operations).
     ///
     /// # Example
@@ -2441,4 +2490,16 @@ mod tests {
         }
         Ok(())
     }
+
+    #[meilisearch_test]
+    async fn test_compact_index_succeeds(client: Client, index: Index) -> Result<(), Error> {
+        let task = index
+            .compact()
+            .await?
+            .wait_for_completion(&client, None, None)
+            .await?;
+
+        assert!(task.is_success());
+        Ok(())
+    }
 }