Crate typesense 

Typesense

A Rust client library for the Typesense API.

This library provides an ergonomic interface for interacting with Typesense. It supports multi-node configuration and WebAssembly.

Examples

The following examples demonstrate how to define a collection schema using the Typesense derive macro and create it on the server.

---

Native (Tokio)

This example shows the typical setup for a server-side application using the Tokio runtime. It includes features like connection timeouts and automatic request retries.

#[cfg(not(target_family = "wasm"))]
{
    use serde::{Deserialize, Serialize};
    use typesense::{Client, Typesense, ExponentialBackoff, prelude::*};
    use std::time::Duration;

    /// A struct representing a company document.
    #[derive(Typesense, Serialize, Deserialize, Debug)]
    #[typesense(
        collection_name = "companies",
        default_sorting_field = "num_employees"
    )]
    struct Company {
        company_name: String,
        num_employees: i32,
        #[typesense(facet)]
        country: String,
    }

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let client = Client::builder()
            .nodes(vec!["http://localhost:8108"])
            .api_key("xyz")
            .healthcheck_interval(Duration::from_secs(60))
            .retry_policy(ExponentialBackoff::builder().build_with_max_retries(3))
            .build()?;

        // Create the collection in Typesense
        let collection = client
            .collections()
            .create(Company::collection_schema())
            .await?;

        println!("Created collection: {:?}", collection);
        Ok(())
    }
}

---

WebAssembly (Wasm)

This example is tailored for a WebAssembly target. Key difference: Tokio-dependent features like .retry_policy() are disabled.

#[cfg(target_family = "wasm")]
{
    use serde::{Deserialize, Serialize};
    use typesense::{Client, Typesense, prelude::*};
    use std::time::Duration;
    use wasm_bindgen_futures::spawn_local;

    /// A struct representing a company document.
    #[derive(Typesense, Serialize, Deserialize, Debug)]
    #[typesense(
        collection_name = "companies",
        default_sorting_field = "num_employees"
    )]
    struct Company {
        company_name: String,
        num_employees: i32,
        #[typesense(facet)]
        country: String,
    }

    fn main() {
        spawn_local(async {
            let client = Client::builder()
                .nodes(vec!["http://localhost:8108"])
                .api_key("xyz")
                .healthcheck_interval(Duration::from_secs(60))
                // .retry_policy(...)  <-- disabled in Wasm
                .build()
                .unwrap();

            // Create the collection in Typesense
            match client.collections().create(Company::collection_schema()).await {
                Ok(collection) => println!("Created collection: {:?}", collection),
                Err(e) => eprintln!("Error creating collection: {}", e),
            }
        });
    }
}

Re-exports

pub use typesense_codegen as legacy;

pub use error::*;

Modules

error

Contains the error types for the Typesense client

models

Typesense generic models

prelude

The Typesense prelude.

Macros

execute_wrapper

Wraps api call in client::execute()

impl_to_typesense_field

macro used internally to add implementations of ToTypesenseField for several rust types.

Structs

Client

The main entry point for all interactions with the Typesense API.

ExponentialBackoff

Exponential backoff with optional jitter.

NodeConfig

Configuration for a single Typesense node.