Crate rexie

Expand description

Rexie is an easy-to-use, futures based wrapper around IndexedDB that compiles to webassembly.

§Usage

To use Rexie, you need to add the following to your Cargo.toml:

[dependencies]
rexie = "0.6"

§Example

To create a new database, you can use the Rexie::builder method:

use rexie::*;

async fn build_database() -> Result<Rexie> {
   // Create a new database
   let rexie = Rexie::builder("test")
       // Set the version of the database to 1.0
       .version(1)
       // Add an object store named `employees`
       .add_object_store(
           ObjectStore::new("employees")
               // Set the key path to `id`
               .key_path("id")
               // Enable auto increment
               .auto_increment(true)
               // Add an index named `email` with the key path `email` with unique enabled
               .add_index(Index::new("email", "email").unique(true)),
       )
       // Build the database
       .build()
       .await?;

    // Check basic details of the database
    assert_eq!(rexie.name(), "test");
    assert_eq!(rexie.version(), Ok(1));
    assert_eq!(rexie.store_names(), vec!["employees"]);

    Ok(rexie)
}

To add an employee, you can use the Store::add method after creating a Transaction:

use rexie::*;

async fn add_employee(rexie: &Rexie, name: &str, email: &str) -> Result<u32> {
    // Create a new read-write transaction
    let transaction = rexie.transaction(&["employees"], TransactionMode::ReadWrite)?;
     
    // Get the `employees` store
    let employees = transaction.store("employees")?;
     
    // Create an employee
    let employee = serde_json::json!({
        "name": name,
        "email": email,
    });
    // Convert it to `JsValue`
    let employee = serde_wasm_bindgen::to_value(&employee).unwrap();

    // Add the employee to the store
    let employee_id = employees.add(&employee, None).await?;
     
    // Waits for the transaction to complete
    transaction.done().await?;

    // Return the employee id
    Ok(num_traits::cast(employee_id.as_f64().unwrap()).unwrap())
}

To get an employee, you can use the Store::get method after creating a Transaction:

use rexie::*;

async fn get_employee(rexie: &Rexie, id: u32) -> Result<Option<serde_json::Value>> {
    // Create a new read-only transaction
    let transaction = rexie.transaction(&["employees"], TransactionMode::ReadOnly)?;
     
    // Get the `employees` store
    let employees = transaction.store("employees")?;
     
    // Get the employee
    let employee = employees.get(id.into()).await?.unwrap();

    // Convert it to `serde_json::Value` from `JsValue`
    let employee: Option<serde_json::Value> = serde_wasm_bindgen::from_value(employee).unwrap();

    // Return the employee
    Ok(employee)
}

Structs§

Index
An index builder.
KeyRange
Represents a continuous interval over some data type that is used for keys.
ObjectStore
An object store builder.
Rexie
Rexie database (wrapper on top of indexed db)
RexieBuilder
Builder for creating a new database.
Store
An object store.
StoreIndex
Index of an object store.
Transaction
Transaction on the database

Enums§

Direction
Specifies the cursor direction.
Error
Error type for rexie crate
KeyPath
Represents key path of an object store
TransactionMode
Specifies the transaction mode.
TransactionResult
An enum that represents the result state of a transaction.

Type Aliases§