idb 0.6.4

A futures based crate for interacting with IndexedDB on browsers using 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
129
130
131
132
133
134
135
136
137
138

use js_sys::Array;
use wasm_bindgen::{JsCast, JsValue};
use web_sys::DomException;

use crate::{utils::array_to_vec, Cursor, Error, KeyCursor};

pub trait OutputMapper {
    type Output;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error>;
}

pub struct NullCheckMapper;

impl OutputMapper for NullCheckMapper {
    type Output = JsValue;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.and_then(|value| {
            if value.is_null() || value.is_undefined() {
                Err(Error::UnexpectedJsType("JsValue", value))
            } else {
                Ok(value)
            }
        })
    }
}

pub struct IgnoreMapper;

impl OutputMapper for IgnoreMapper {
    type Output = ();

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.map(|_| ())
    }
}

pub struct OptionMapper;

impl OutputMapper for OptionMapper {
    type Output = Option<JsValue>;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.map(|value| {
            if value.is_null() || value.is_undefined() {
                None
            } else {
                Some(value)
            }
        })
    }
}

pub struct U32Mapper;

impl OutputMapper for U32Mapper {
    type Output = u32;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.and_then(|value| {
            if value.is_null() || value.is_undefined() {
                Ok(0)
            } else {
                value
                    .as_f64()
                    .and_then(num_traits::cast)
                    .ok_or(Error::UnexpectedJsType("u32", value))
            }
        })
    }
}

pub struct VecMapper;

impl OutputMapper for VecMapper {
    type Output = Vec<JsValue>;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.and_then(|value| {
            if value.is_null() || value.is_undefined() {
                Ok(vec![])
            } else {
                let array: Array = value
                    .dyn_into()
                    .map_err(|err| Error::UnexpectedJsType("Array", err))?;

                Ok(array_to_vec(array))
            }
        })
    }
}

pub struct CursorMapper;

impl OutputMapper for CursorMapper {
    type Output = Option<Cursor>;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.and_then(|value| {
            if value.is_null() || value.is_undefined() {
                Ok(None)
            } else {
                let cursor = Cursor::try_from(value)?;
                Ok(Some(cursor))
            }
        })
    }
}

pub struct KeyCursorMapper;

impl OutputMapper for KeyCursorMapper {
    type Output = Option<KeyCursor>;

    fn map(value: Result<JsValue, Error>) -> Result<Self::Output, Error> {
        value.and_then(|value| {
            if value.is_null() || value.is_undefined() {
                Ok(None)
            } else {
                let cursor = KeyCursor::try_from(value)?;
                Ok(Some(cursor))
            }
        })
    }
}

pub struct ErrorMapper;

impl ErrorMapper {
    pub fn map(value: Result<Option<DomException>, Error>) -> Error {
        match value {
            Err(err) => err,
            Ok(None) => Error::DomExceptionNotFound,
            Ok(Some(exception)) => Error::DomException(exception),
        }
    }
}