rexie 0.6.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
117
118
119
120
121
122
123
124
125
126
127
128

use idb::Index;
use wasm_bindgen::JsValue;

use crate::{Direction, KeyRange, Result};

/// Index of an object store.
pub struct StoreIndex {
    pub(crate) index: Index,
}

impl StoreIndex {
    /// Returns name of the index
    pub fn name(&self) -> String {
        self.index.name()
    }

    /// Returns weather the index has unique enabled
    pub fn unique(&self) -> bool {
        self.index.unique()
    }

    /// Returns weather the index has multi entry enabled
    pub fn multi_entry(&self) -> bool {
        self.index.multi_entry()
    }

    /// Gets a value from the store with given key
    pub async fn get(&self, key: JsValue) -> Result<Option<JsValue>> {
        self.index.get(key)?.await.map_err(Into::into)
    }

    /// Retrieves the keys of all objects inside the index
    /// See: [MDN:IDBIndex/getAllKeys](https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex/getAllKeys)
    pub async fn get_all_keys(
        &self,
        key_range: Option<KeyRange>,
        limit: Option<u32>,
    ) -> Result<Vec<JsValue>> {
        self.index
            .get_all_keys(key_range.map(Into::into), limit)?
            .await
            .map_err(Into::into)
    }

    /// Gets all values from the store with given key range and limit
    pub async fn get_all(
        &self,
        key_range: Option<KeyRange>,
        limit: Option<u32>,
    ) -> Result<Vec<JsValue>> {
        self.index
            .get_all(key_range.map(Into::into), limit)?
            .await
            .map_err(Into::into)
    }

    /// Scans all key-value pairs from the store with given key range, limit, offset and direction
    pub async fn scan(
        &self,
        key_range: Option<KeyRange>,
        limit: Option<u32>,
        offset: Option<u32>,
        direction: Option<Direction>,
    ) -> Result<Vec<(JsValue, JsValue)>> {
        let cursor = self
            .index
            .open_cursor(key_range.map(Into::into), direction)?
            .await?;

        match cursor {
            None => Ok(Vec::new()),
            Some(cursor) => {
                let mut cursor = cursor.into_managed();

                let mut result = Vec::new();

                match limit {
                    Some(limit) => {
                        if let Some(offset) = offset {
                            cursor.advance(offset).await?;
                        }

                        for _ in 0..limit {
                            let key = cursor.key()?;
                            let value = cursor.value()?;

                            match (key, value) {
                                (Some(key), Some(value)) => {
                                    result.push((key, value));
                                    cursor.next(None).await?;
                                }
                                _ => break,
                            }
                        }
                    }
                    None => {
                        if let Some(offset) = offset {
                            cursor.advance(offset).await?;
                        }

                        loop {
                            let key = cursor.key()?;
                            let value = cursor.value()?;

                            match (key, value) {
                                (Some(key), Some(value)) => {
                                    result.push((key, value));
                                    cursor.next(None).await?;
                                }
                                _ => break,
                            }
                        }
                    }
                }

                Ok(result)
            }
        }
    }

    /// Counts the number of key value pairs in the store
    pub async fn count(&self, key_range: Option<KeyRange>) -> Result<u32> {
        self.index
            .count(key_range.map(Into::into))?
            .await
            .map_err(Into::into)
    }
}