Update tenant token api for v0.28.1

Cargo.toml

@@ -20,6 +20,7 @@ serde_json = "1.0"
 time = { version = "0.3.7", features = ["serde-well-known", "formatting", "parsing"] }
 jsonwebtoken = { version = "8", default-features = false }
 yaup = "0.2.0"
+uuid = { version = "1.1.2", features =  ["v4"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 futures = "0.3"

src/client.rs

@@ -806,19 +806,21 @@ impl Client {
     /// #
     /// # futures::executor::block_on(async move {
     /// # let client = client::Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
-    /// let token = client.generate_tenant_token(serde_json::json!(["*"]), None, None).unwrap();
+    /// let api_key_uid = "76cf8b87-fd12-4688-ad34-260d930ca4f4".to_string();
+    /// let token = client.generate_tenant_token(api_key_uid, serde_json::json!(["*"]), None, None).unwrap();
     /// let client = client::Client::new(MEILISEARCH_HOST, token);
     /// # });
     /// ```
     pub fn generate_tenant_token(
         &self,
+        api_key_uid: String,
         search_rules: serde_json::Value,
         api_key: Option<&str>,
         expires_at: Option<OffsetDateTime>,
     ) -> Result<String, Error> {
         let api_key = api_key.unwrap_or(&self.api_key);
 
-        crate::tenant_tokens::generate_tenant_token(search_rules, api_key, expires_at)
+        crate::tenant_tokens::generate_tenant_token(api_key_uid, search_rules, api_key, expires_at)
     }
 }
 

src/documents.rs

@@ -0,0 +1,232 @@
+use crate::{errors::Error, indexes::Index};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct DocumentsResults<T> {
+    pub results: Vec<T>,
+    pub limit: u32,
+    pub offset: u32,
+    pub total: u32,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct DocumentsQuery<'a> {
+    #[serde(skip_serializing)]
+    pub index: &'a Index,
+
+    /// The number of documents to skip.
+    /// If the value of the parameter `offset` is `n`, the `n` first documents will not be returned.
+    /// This is helpful for pagination.
+    ///
+    /// Example: If you want to skip the first document, set offset to `1`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub offset: Option<usize>,
+
+    /// The maximum number of documents returned.
+    /// If the value of the parameter `limit` is `n`, there will never be more than `n` documents in the response.
+    /// This is helpful for pagination.
+    ///
+    /// Example: If you don't want to get more than two documents, set limit to `2`.
+    /// Default: `20`
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+
+    pub fields: Option<Vec<&'a str>>,
+}
+
+impl<'a> DocumentsQuery<'a> {
+    pub fn new(index: &Index) -> DocumentsQuery {
+        DocumentsQuery {
+            index,
+            offset: None,
+            limit: None,
+            fields: None,
+        }
+    }
+
+    /// Specify the offset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*, documents::*};
+    /// #
+    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
+    ///
+    /// let index = client.index("documents_query_offset");
+    ///
+    /// let mut documents_query = DocumentsQuery::new(&index);
+    ///
+    /// documents_query.with_offset(1);
+    /// ```
+    pub fn with_offset(&mut self, offset: usize) -> &mut DocumentsQuery<'a> {
+        self.offset = Some(offset);
+        self
+    }
+
+    /// Specify the limit.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*, documents::*};
+    /// #
+    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
+    ///
+    /// let index = client.index("documents_query_offset");
+    ///
+    /// let mut documents_query = DocumentsQuery::new(&index);
+    ///
+    /// documents_query.with_offset(1);
+    /// ```
+    pub fn with_limit(&mut self, limit: usize) -> &mut DocumentsQuery<'a> {
+        self.limit = Some(limit);
+        self
+    }
+
+    /// Specify the fields to return in the documents.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*, documents::*};
+    /// #
+    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
+    /// let index = client.index("documents_query_offset");
+    ///
+    /// let mut documents_query = DocumentsQuery::new(&index);
+    ///
+    /// documents_query.with_fields(["title"]);
+    /// ```
+    pub fn with_fields(
+        &mut self,
+        fields: impl IntoIterator<Item = &'a str>,
+    ) -> &mut DocumentsQuery<'a> {
+        self.fields = Some(fields.into_iter().collect());
+        self
+    }
+
+    /// Specify the limit.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*, documents::*};
+    /// # use serde::{Deserialize, Serialize};
+    /// #
+    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
+    ///
+    /// # futures::executor::block_on(async move {
+    /// # let index = client.create_index("documents_query_execute", None).await.unwrap().wait_for_completion(&client, None, None).await.unwrap().try_make_index(&client).unwrap();
+    /// #[derive(Debug, Serialize, Deserialize, PartialEq)]
+    /// struct MyObject {
+    ///     id: Option<usize>,
+    ///     kind: String,
+    /// }
+    /// let index = client.index("documents_query_execute");
+    ///
+    /// let mut documents_query = DocumentsQuery::new(&index);
+    ///
+    /// documents_query.with_offset(1).execute::<MyObject>().await.unwrap();
+    /// # });
+    /// ```
+    pub async fn execute<T: DeserializeOwned + 'static>(
+        &self,
+    ) -> Result<DocumentsResults<T>, Error> {
+        self.index.get_documents_with::<T>(self).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{client::*, indexes::*};
+    use meilisearch_test_macro::meilisearch_test;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
+    struct MyObject {
+        id: Option<usize>,
+        kind: String,
+    }
+
+    async fn setup_test_index(client: &Client, index: &Index) -> Result<(), Error> {
+        let t0 = index
+            .add_documents(
+                &[
+                    MyObject {
+                        id: Some(0),
+                        kind: "text".into(),
+                    },
+                    MyObject {
+                        id: Some(1),
+                        kind: "text".into(),
+                    },
+                    MyObject {
+                        id: Some(2),
+                        kind: "title".into(),
+                    },
+                    MyObject {
+                        id: Some(3),
+                        kind: "title".into(),
+                    },
+                ],
+                None,
+            )
+            .await?;
+
+        t0.wait_for_completion(client, None, None).await?;
+
+        Ok(())
+    }
+
+    #[meilisearch_test]
+    async fn test_get_documents_with_execute(client: Client, index: Index) -> Result<(), Error> {
+        setup_test_index(&client, &index).await?;
+        // let documents = index.get_documents(None, None, None).await.unwrap();
+        let documents = DocumentsQuery::new(&index)
+            .with_limit(1)
+            .with_offset(1)
+            .with_fields(["kind"])
+            .execute::<MyObject>()
+            .await
+            .unwrap();
+
+        assert_eq!(documents.limit, 1);
+        assert_eq!(documents.offset, 1);
+        assert_eq!(documents.results.len(), 1);
+
+        Ok(())
+    }
+    #[meilisearch_test]
+    async fn test_get_documents_with_only_one_param(
+        client: Client,
+        index: Index,
+    ) -> Result<(), Error> {
+        setup_test_index(&client, &index).await?;
+        // let documents = index.get_documents(None, None, None).await.unwrap();
+        let documents = DocumentsQuery::new(&index)
+            .with_limit(1)
+            .execute::<MyObject>()
+            .await
+            .unwrap();
+
+        assert_eq!(documents.limit, 1);
+        assert_eq!(documents.offset, 0);
+        assert_eq!(documents.results.len(), 1);
+
+        Ok(())
+    }
+}

src/errors.rs

@@ -36,6 +36,10 @@ pub enum Error {
     HttpError(String),
     // The library formating the query parameters encountered an error.
     Yaup(yaup::Error),
+    // The library validating the format of an uuid.
+    Uuid(uuid::Error),
+    // Error thrown in case the version of the Uuid is not v4.
+    InvalidUuid4Version,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -75,6 +79,12 @@ impl From<yaup::Error> for Error {
     }
 }
 
+impl From<uuid::Error> for Error {
+    fn from(error: uuid::Error) -> Error {
+        Error::Uuid(error)
+    }
+}
+
 /// The type of error that was encountered.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -194,7 +204,9 @@ impl std::fmt::Display for Error {
             Error::TenantTokensInvalidApiKey => write!(fmt, "The provided api_key is invalid."),
             Error::TenantTokensExpiredSignature => write!(fmt, "The provided expires_at is already expired."),
             Error::InvalidTenantToken(e) => write!(fmt, "Impossible to generate the token, jsonwebtoken encountered an error: {}", e),
-            Error::Yaup(e) => write!(fmt, "Internal Error: could not parse the query parameters: {}", e)
+            Error::Yaup(e) => write!(fmt, "Internal Error: could not parse the query parameters: {}", e),
+            Error::Uuid(e) => write!(fmt, "The uid of the token has bit an uuid4 format: {}", e),
+            Error::InvalidUuid4Version => write!(fmt, "The uid provided to the token is not of version uuidv4")
         }
     }
 }