idb 0.6.5

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

use num_traits::ToPrimitive;
use wasm_bindgen::{JsCast, JsValue};
use web_sys::IdbVersionChangeEvent;

use crate::{request::OpenDatabaseRequest, Database, DatabaseEvent, Error, Event};

/// Event triggered when the database version changes, as the result of an [`OpenDatabaseRequest::on_upgrade_needed`](crate::request::OpenDatabaseRequest::on_upgrade_needed) event
/// handler function.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VersionChangeEvent {
    inner: IdbVersionChangeEvent,
}

impl VersionChangeEvent {
    /// Returns previous version of database.
    pub fn old_version(&self) -> Result<u32, Error> {
        self.inner
            .old_version()
            .to_u32()
            .ok_or(Error::NumberConversionError)
    }

    /// Returns new version of database.
    pub fn new_version(&self) -> Result<Option<u32>, Error> {
        self.inner
            .new_version()
            .map(|new| new.to_u32().ok_or(Error::NumberConversionError))
            .transpose()
    }
}

impl Event for VersionChangeEvent {
    type Target = OpenDatabaseRequest;

    fn target(&self) -> Result<Self::Target, Error> {
        let target = self.inner.target().ok_or(Error::EventTargetNotFound)?;
        OpenDatabaseRequest::try_from(target)
    }
}

impl DatabaseEvent for VersionChangeEvent {
    fn database(&self) -> Result<Database, Error> {
        let target = self.target()?;
        target.database()
    }
}

impl From<IdbVersionChangeEvent> for VersionChangeEvent {
    fn from(inner: IdbVersionChangeEvent) -> Self {
        Self { inner }
    }
}

impl From<VersionChangeEvent> for IdbVersionChangeEvent {
    fn from(event: VersionChangeEvent) -> Self {
        event.inner
    }
}

impl TryFrom<JsValue> for VersionChangeEvent {
    type Error = Error;

    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
        value
            .dyn_into::<IdbVersionChangeEvent>()
            .map(Into::into)
            .map_err(|value| Error::UnexpectedJsType("IdbVersionChangeEvent", value))
    }
}

impl From<VersionChangeEvent> for JsValue {
    fn from(value: VersionChangeEvent) -> Self {
        value.inner.into()
    }
}