rexie 0.4.2

Rexie is an easy-to-use, futures based wrapper around IndexedDB that compiles to webassembly
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

mod index;
mod store;

pub use self::{index::StoreIndex, store::Store};

use wasm_bindgen::{prelude::*, throw_str};
use web_sys::IdbTransaction;

use crate::{
    request::{wait_request, wait_transaction_abort},
    Error, Result,
};

/// Different transaction modes for indexed db
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransactionMode {
    ReadOnly,
    ReadWrite,
    ReadWriteFlush,
    Cleanup,
    VersionChange,
}

impl From<TransactionMode> for web_sys::IdbTransactionMode {
    fn from(mode: TransactionMode) -> Self {
        match mode {
            TransactionMode::ReadOnly => Self::Readonly,
            TransactionMode::ReadWrite => Self::Readwrite,
            TransactionMode::ReadWriteFlush => Self::Readwriteflush,
            TransactionMode::Cleanup => Self::Cleanup,
            TransactionMode::VersionChange => Self::Versionchange,
        }
    }
}

impl From<web_sys::IdbTransactionMode> for TransactionMode {
    fn from(mode: web_sys::IdbTransactionMode) -> Self {
        match mode {
            web_sys::IdbTransactionMode::Readonly => Self::ReadOnly,
            web_sys::IdbTransactionMode::Readwrite => Self::ReadWrite,
            web_sys::IdbTransactionMode::Readwriteflush => Self::ReadWriteFlush,
            web_sys::IdbTransactionMode::Cleanup => Self::Cleanup,
            web_sys::IdbTransactionMode::Versionchange => Self::VersionChange,
            _ => throw_str("invalid transaction mode"),
        }
    }
}

/// Transaction on the database
pub struct Transaction {
    pub(crate) idb_transaction: IdbTransaction,
}

impl Transaction {
    /// Returns mode of the transaction
    pub fn mode(&self) -> TransactionMode {
        self.idb_transaction
            .mode()
            .expect_throw("unable to get transaction mode")
            .into()
    }

    /// Returns names of all stores in the transaction
    pub fn store_names(&self) -> Vec<String> {
        let list = self.idb_transaction.object_store_names();

        let mut result = Vec::new();

        for index in 0..list.length() {
            if let Some(s) = list.get(index) {
                result.push(s);
            }
        }

        result
    }

    /// Aborts a transaction
    pub async fn abort(self) -> Result<()> {
        wait_transaction_abort(self.idb_transaction).await
    }

    /// Commits a transaction
    ///
    /// # Note
    ///
    /// Note that `commit()` doesn't normally have to be called — a transaction will automatically commit when all
    /// outstanding requests have been satisfied and no new requests have been made.
    ///
    /// [Reference](https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction/commit)
    pub async fn commit(self) -> Result<()> {
        let done = wait_request(&self.idb_transaction, Error::TransactionExecutionFailed);

        self.idb_transaction
            .commit()
            .map_err(Error::TransactionCommitFailed)?;

        done.await.map(|_| ())
    }

    /// Waits for a transaction to complete.
    pub async fn done(self) -> Result<()> {
        wait_request(self.idb_transaction, Error::TransactionExecutionFailed)
            .await
            .map(|_| ())
    }

    /// Returns a store in the transaction
    pub fn store(&self, store_name: &str) -> Result<Store> {
        Ok(Store::new(
            self.idb_transaction
                .object_store(store_name)
                .map_err(Error::ObjectStoreOpenFailed)?,
        ))
    }
}