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
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

use std::{
    future::{Future, IntoFuture},
    pin::Pin,
    task::{Context, Poll},
};

use tokio::sync::oneshot;
use web_sys::Event;

use crate::{Error, Transaction};

/// An enum that represents the result state of a transaction.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransactionResult {
    /// The transaction was committed.
    Committed,
    /// The transaction was aborted.
    Aborted,
}

impl TransactionResult {
    /// Returns `true` if the transaction was committed.
    pub fn is_committed(&self) -> bool {
        matches!(self, Self::Committed)
    }

    /// Returns `true` if the transaction was aborted.
    pub fn is_aborted(&self) -> bool {
        matches!(self, Self::Aborted)
    }
}

/// Future that resolved when transaction is completed. Either successfully or with an error.
pub struct TransactionFuture {
    _inner: Transaction,
    abort_receiver: oneshot::Receiver<()>,
    success_receiver: oneshot::Receiver<()>,
    error_receiver: oneshot::Receiver<Error>,
}

impl IntoFuture for Transaction {
    type Output = <Self::IntoFuture as Future>::Output;

    type IntoFuture = TransactionFuture;

    fn into_future(mut self) -> Self::IntoFuture {
        let (abort_sender, abort_receiver) = oneshot::channel();
        let (error_sender, error_receiver) = oneshot::channel();
        let (success_sender, success_receiver) = oneshot::channel();

        self.on_abort(move |_| {
            let _ = abort_sender.send(());
        });

        self.on_complete(move |_| {
            let _ = success_sender.send(());
        });

        self.on_error(move |event| {
            let result = error_callback(event);
            let _ = error_sender.send(result);
        });

        Self::IntoFuture {
            _inner: self,
            abort_receiver,
            success_receiver,
            error_receiver,
        }
    }
}

impl Future for TransactionFuture {
    type Output = Result<TransactionResult, Error>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();

        if let Poll::Ready(err) = Pin::new(&mut this.error_receiver).poll(cx) {
            return match err {
                Ok(err) => Poll::Ready(Err(err)),
                Err(_) => Poll::Ready(Err(Error::OneshotChannelReceiveError)),
            };
        }

        if let Poll::Ready(result) = Pin::new(&mut this.success_receiver).poll(cx) {
            return match result {
                Ok(_) => Poll::Ready(Ok(TransactionResult::Committed)),
                Err(_) => Poll::Ready(Err(Error::OneshotChannelReceiveError)),
            };
        }

        if let Poll::Ready(result) = Pin::new(&mut this.abort_receiver).poll(cx) {
            return match result {
                Ok(_) => Poll::Ready(Ok(TransactionResult::Aborted)),
                Err(_) => Poll::Ready(Err(Error::OneshotChannelReceiveError)),
            };
        }

        Poll::Pending
    }
}

fn error_callback(event: Event) -> Error {
    error_callback_inner(event).unwrap_err()
}

fn error_callback_inner(event: Event) -> Result<(), Error> {
    let transaction = Transaction::try_from(event.target().ok_or(Error::EventTargetNotFound)?)?;
    let error = transaction.error();

    match error {
        None => Err(Error::DomExceptionNotFound),
        Some(error) => Err(Error::DomException(error)),
    }
}