Struct meilisearch_sdk::key::KeyBuilder

pub struct KeyBuilder {
    pub actions: Vec<Action>,
    pub description: String,
    pub expires_at: Option<OffsetDateTime>,
    pub indexes: Vec<String>,
}

The KeyBuilder is an analog to the Key type but without all the fields managed by Meilisearch. It’s used to create Key.

Example

let client = Client::new("http://localhost:7700", "masterKey");

let key = KeyBuilder::new("My little lovely test key")
  .with_action(Action::DocumentsAdd)
  .with_index("*")
  .create(&client).await.unwrap();

assert_eq!(key.description, "My little lovely test key");

Fields

actions: Vec<Action>

description: String

expires_at: Option<OffsetDateTime>

indexes: Vec<String>

Implementations

impl KeyBuilder

pub fn new(description: impl AsRef<str>) -> KeyBuilder

Create a KeyBuilder with only a description.

Example

let builder = KeyBuilder::new("My little lovely test key");

pub fn with_actions(
    &mut self,
    actions: impl IntoIterator<Item = Action>
) -> &mut Self

Declare a set of actions the Key will be able to execute.

Example

let mut builder = KeyBuilder::new("My little lovely test key");
builder.with_actions(vec![Action::Search, Action::DocumentsAdd]);

pub fn with_action(&mut self, action: Action) -> &mut Self

Add one action the Key will be able to execute.

Example

let mut builder = KeyBuilder::new("My little lovely test key");
builder.with_action(Action::DocumentsAdd);

pub fn with_expires_at(&mut self, expires_at: OffsetDateTime) -> &mut Self

Set the expiration date of the Key.

Example

use time::{OffsetDateTime, Duration};
let mut builder = KeyBuilder::new("My little lovely test key");
// create a key that expires in two weeks from now
builder.with_expires_at(OffsetDateTime::now_utc() + Duration::WEEK * 2);

pub fn with_indexes(
    &mut self,
    indexes: impl IntoIterator<Item = impl AsRef<str>>
) -> &mut Self

Set the indexes the Key can manage.

Example

let mut builder = KeyBuilder::new("My little lovely test key");
builder.with_indexes(vec!["test", "movies"]);

pub fn with_index(&mut self, index: impl AsRef<str>) -> &mut Self

Add one index the Key can manage.

Example

let mut builder = KeyBuilder::new("My little lovely test key");
builder.with_index("test");

pub async fn create(&self, client: &Client) -> Result<Key, Error>

Create a Key from the builder.

Example

let client = Client::new("http://localhost:7700", "masterKey");
let key = KeyBuilder::new("My little lovely test key")
  .create(&client).await.unwrap();

assert_eq!(key.description, "My little lovely test key");

Trait Implementations

impl AsRef<KeyBuilder> for KeyBuilder

fn as_ref(&self) -> &KeyBuilder

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for KeyBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for KeyBuilder

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.