feat: Add queryVector to search responses and support index renaming

Author: kumarUjjawal

.code-samples.meilisearch.yaml

@@ -94,6 +94,11 @@ update_an_index_1: |-
     .execute()
     .await
     .unwrap();
+rename_an_index_1: |-
+  curl \
+    -X PATCH 'MEILISEARCH_URL/indexes/INDEX_A' \
+    -H 'Content-Type: application/json' \
+    --data-binary '{ "uid": "INDEX_B" }'
 delete_an_index_1: |-
   client.index("movies")
     .delete()

src/client.rs

@@ -27,6 +27,8 @@ pub struct Client<Http: HttpClient = DefaultHttpClient> {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SwapIndexes {
     pub indexes: (String, String),
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rename: Option<bool>,
 }
 
 #[cfg(feature = "reqwest")]
@@ -202,7 +204,7 @@ impl<Http: HttpClient> Client<Http> {
     ///
     /// [1]: https://www.meilisearch.com/docs/learn/multi_search/multi_search_vs_federated_search#what-is-federated-search
     #[must_use]
-    pub fn multi_search(&self) -> MultiSearchQuery<Http> {
+    pub fn multi_search(&self) -> MultiSearchQuery<'_, '_, Http> {
         MultiSearchQuery::new(self)
     }
 
@@ -532,6 +534,7 @@ impl<Http: HttpClient> Client<Http> {
     ///             "swap_index_1".to_string(),
     ///             "swap_index_2".to_string(),
     ///         ),
+    ///         rename: None,
     ///     }])
     ///     .await
     ///     .unwrap();
@@ -1249,6 +1252,7 @@ mod tests {
                     "test_swapping_two_indexes_1".to_string(),
                     "test_swapping_two_indexes_2".to_string(),
                 ),
+                rename: None,
             }])
             .await
             .unwrap();
@@ -1351,6 +1355,37 @@ mod tests {
         assert_eq!(tasks.limit, 20);
     }
 
+    #[meilisearch_test]
+    async fn test_rename_index_via_swap(client: Client, name: String) -> Result<(), Error> {
+        let from = format!("{name}_from");
+        let to = format!("{name}_to");
+
+        client
+            .create_index(&from, None)
+            .await?
+            .wait_for_completion(&client, None, None)
+            .await?;
+
+        let task = client
+            .swap_indexes([&SwapIndexes {
+                indexes: (from.clone(), to.clone()),
+                rename: Some(true),
+            }])
+            .await?;
+        task.wait_for_completion(&client, None, None).await?;
+
+        let new_index = client.get_index(&to).await?;
+        assert_eq!(new_index.uid, to);
+
+        new_index
+            .delete()
+            .await?
+            .wait_for_completion(&client, None, None)
+            .await?;
+
+        Ok(())
+    }
+
     #[meilisearch_test]
     async fn test_get_tasks_with_params(client: Client) {
         let query = TasksSearchQuery::new(&client);

src/documents.rs

@@ -86,7 +86,7 @@ pub struct DocumentQuery<'a, Http: HttpClient> {
 
 impl<'a, Http: HttpClient> DocumentQuery<'a, Http> {
     #[must_use]
-    pub fn new(index: &Index<Http>) -> DocumentQuery<Http> {
+    pub fn new(index: &Index<Http>) -> DocumentQuery<'_, Http> {
         DocumentQuery {
             index,
             fields: None,
@@ -200,7 +200,7 @@ pub struct DocumentsQuery<'a, Http: HttpClient> {
 
 impl<'a, Http: HttpClient> DocumentsQuery<'a, Http> {
     #[must_use]
-    pub fn new(index: &Index<Http>) -> DocumentsQuery<Http> {
+    pub fn new(index: &Index<Http>) -> DocumentsQuery<'_, Http> {
         DocumentsQuery {
             index,
             offset: None,
@@ -332,7 +332,7 @@ pub struct DocumentDeletionQuery<'a, Http: HttpClient> {
 
 impl<'a, Http: HttpClient> DocumentDeletionQuery<'a, Http> {
     #[must_use]
-    pub fn new(index: &Index<Http>) -> DocumentDeletionQuery<Http> {
+    pub fn new(index: &Index<Http>) -> DocumentDeletionQuery<'_, Http> {
         DocumentDeletionQuery {
             index,
             filter: None,

src/indexes.rs

@@ -276,7 +276,7 @@ impl<Http: HttpClient> Index<Http> {
     /// # });
     /// ```
     #[must_use]
-    pub fn search(&self) -> SearchQuery<Http> {
+    pub fn search(&self) -> SearchQuery<'_, Http> {
         SearchQuery::new(self)
     }
 
@@ -1773,15 +1773,19 @@ pub struct IndexUpdater<'a, Http: HttpClient> {
     pub client: &'a Client<Http>,
     #[serde(skip_serializing)]
     pub uid: String,
+    /// New uid to rename the index to
+    #[serde(rename = "uid", skip_serializing_if = "Option::is_none")]
+    pub new_uid: Option<String>,
     pub primary_key: Option<String>,
 }
 
 impl<'a, Http: HttpClient> IndexUpdater<'a, Http> {
-    pub fn new(uid: impl AsRef<str>, client: &Client<Http>) -> IndexUpdater<Http> {
+    pub fn new(uid: impl AsRef<str>, client: &Client<Http>) -> IndexUpdater<'_, Http> {
         IndexUpdater {
             client,
             primary_key: None,
             uid: uid.as_ref().to_string(),
+            new_uid: None,
         }
     }
     /// Define the new `primary_key` to set on the [Index].
@@ -1829,6 +1833,12 @@ impl<'a, Http: HttpClient> IndexUpdater<'a, Http> {
         self
     }
 
+    /// Define a new `uid` to rename the index.
+    pub fn with_uid(&mut self, new_uid: impl AsRef<str>) -> &mut IndexUpdater<'a, Http> {
+        self.new_uid = Some(new_uid.as_ref().to_string());
+        self
+    }
+
     /// Execute the update of an [Index] using the [`IndexUpdater`].
     ///
     /// # Example
@@ -1976,7 +1986,7 @@ pub struct IndexesQuery<'a, Http: HttpClient> {
 
 impl<'a, Http: HttpClient> IndexesQuery<'a, Http> {
     #[must_use]
-    pub fn new(client: &Client<Http>) -> IndexesQuery<Http> {
+    pub fn new(client: &Client<Http>) -> IndexesQuery<'_, Http> {
         IndexesQuery {
             client,
             offset: None,
@@ -2223,6 +2233,40 @@ mod tests {
         Ok(())
     }
 
+    #[meilisearch_test]
+    async fn test_rename_index_via_update(client: Client, name: String) -> Result<(), Error> {
+        let from = format!("{name}_from");
+        let to = format!("{name}_to");
+
+        // Create source index
+        client
+            .create_index(&from, None)
+            .await?
+            .wait_for_completion(&client, None, None)
+            .await?;
+
+        // Rename using index update
+        IndexUpdater::new(&from, &client)
+            .with_uid(&to)
+            .execute()
+            .await?
+            .wait_for_completion(&client, None, None)
+            .await?;
+
+        // New index should exist
+        let new_index = client.get_index(&to).await?;
+        assert_eq!(new_index.uid, to);
+
+        // cleanup
+        new_index
+            .delete()
+            .await?
+            .wait_for_completion(&client, None, None)
+            .await?;
+
+        Ok(())
+    }
+
     #[meilisearch_test]
     async fn test_add_documents_ndjson(client: Client, index: Index) -> Result<(), Error> {
         let ndjson = r#"{ "id": 1, "body": "doggo" }{ "id": 2, "body": "catto" }"#.as_bytes();

src/search.rs

@@ -121,6 +121,16 @@ pub struct SearchResults<T> {
     pub query: String,
     /// Index uid on which the search was made.
     pub index_uid: Option<String>,
+    /// The query vector returned when `retrieveVectors` is enabled.
+    /// Accept multiple possible field names to be forward/backward compatible with server variations.
+    #[serde(
+        rename = "queryVector",
+        alias = "query_vector",
+        alias = "queryEmbedding",
+        alias = "query_embedding",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub query_vector: Option<Vec<f32>>,
 }
 
 fn serialize_attributes_to_crop_with_wildcard<S: Serializer>(
@@ -2017,6 +2027,44 @@ pub(crate) mod tests {
         Ok(())
     }
 
+    #[meilisearch_test]
+    async fn test_query_vector_in_response(client: Client, index: Index) -> Result<(), Error> {
+        setup_embedder(&client, &index).await?;
+        setup_test_index(&client, &index).await?;
+
+        let mut query = SearchQuery::new(&index);
+        let qv = vectorize(false, 0);
+        query
+            .with_hybrid("default", 1.0)
+            .with_vector(&qv)
+            .with_retrieve_vectors(true);
+
+        let results: SearchResults<Document> = index.execute_query(&query).await?;
+
+        if results.query_vector.is_none() {
+            use crate::request::Method;
+            let url = format!("{}/indexes/{}/search", index.client.get_host(), index.uid);
+            let raw: serde_json::Value = index
+                .client
+                .http_client
+                .request::<(), &SearchQuery<_>, serde_json::Value>(
+                    &url,
+                    Method::Post {
+                        body: &query,
+                        query: (),
+                    },
+                    200,
+                )
+                .await
+                .unwrap();
+            eprintln!("DEBUG raw search response: {}", raw);
+        }
+
+        assert!(results.query_vector.is_some());
+        assert_eq!(results.query_vector.as_ref().unwrap().len(), 11);
+        Ok(())
+    }
+
     #[meilisearch_test]
     async fn test_hybrid(client: Client, index: Index) -> Result<(), Error> {
         setup_embedder(&client, &index).await?;