idb 0.6.3

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

use std::collections::HashSet;

use crate::{Database, DatabaseEvent, Error, Event, Factory};

use super::ObjectStoreBuilder;

/// Builder for databases.
#[derive(Debug)]
pub struct DatabaseBuilder {
    name: String,
    version: Option<u32>,
    object_stores: Vec<ObjectStoreBuilder>,
}

impl DatabaseBuilder {
    /// Creates a new instance of [`DatabaseBuilder`].
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_owned(),
            version: None,
            object_stores: Vec::new(),
        }
    }

    /// Sets the version of the database.
    pub fn version(mut self, version: u32) -> Self {
        self.version = Some(version);
        self
    }

    /// Adds an object store.
    pub fn add_object_store(mut self, object_store: ObjectStoreBuilder) -> Self {
        self.object_stores.push(object_store);
        self
    }

    /// Builds the database.
    pub async fn build(self) -> Result<Database, Error> {
        let factory = Factory::new()?;
        let mut request = factory.open(&self.name, self.version)?;

        request.on_upgrade_needed(move |event| {
            let request = event.target().expect("open database request");

            let mut store_names: HashSet<_> = self
                .object_stores
                .iter()
                .map(|store| store.name().to_owned())
                .collect();

            let database = event.database().expect("database");

            for object_store in self.object_stores {
                object_store
                    .apply(&database, &request)
                    .expect("object store creation");
            }

            let db_store_names = database.store_names();
            let mut stores_to_remove = Vec::new();

            for db_store_name in db_store_names {
                if !store_names.remove(&db_store_name) {
                    stores_to_remove.push(db_store_name);
                }
            }

            for store_name in stores_to_remove {
                database
                    .delete_object_store(&store_name)
                    .expect("object store deletion");
            }
        });

        let mut database = request.await?;

        database.on_version_change(|event| {
            let database = event.database().expect("database");
            database.close();
        });

        Ok(database)
    }
}