micron 0.1.0

Build web apps fast. Repeat.
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

//! Database storage based on `redb`.
//!
//! `redb` design document: https://github.com/cberner/redb/blob/master/docs/design.md

use std::str::FromStr;
use std::sync::Arc;

use redb::{Database, ReadableTable, TableDefinition, TableHandle};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::{ErrorKind, Result};

use super::{decode, encode, Identifiable};

#[derive(Clone, Debug)]
pub struct ReDb {
    db: Arc<Database>,
}

impl ReDb {
    pub async fn new() -> Result<Self> {
        let db = Database::create("db.redb")?;

        let mut wx = db.begin_write().unwrap();
        wx.open_table(TableDefinition::<&[u8], &[u8]>::new("access_tokens"))
            .unwrap();
        wx.commit().unwrap();

        Ok(Self { db: Arc::new(db) })
    }

    pub fn get_collection<T: DeserializeOwned>(&self, collection: &str) -> Result<Vec<T>> {
        let rd = self.db.begin_read().unwrap();
        let mut out = Vec::new();
        {
            let table = rd
                .open_table(redb::TableDefinition::<&[u8], &[u8]>::new(collection))
                .unwrap();
            for entry in table.iter().unwrap() {
                let (_, bytes) = entry.unwrap();
                let value: T = decode(&bytes.value())?;
                out.push(value);
            }
        }
        Ok(out)
    }

    pub fn get<T: DeserializeOwned>(&self, collection: &str, id: Uuid) -> Result<T> {
        let rd = self.db.begin_read().unwrap();

        if !rd.list_tables().unwrap().any(|th| th.name() == collection) {
            // create the table first
            rd.close();
            let wx = self.db.begin_write().unwrap();
            wx.open_table(redb::TableDefinition::<&[u8], &[u8]>::new(collection))
                .unwrap();
            wx.commit().unwrap();
        }

        let rd = self.db.begin_read().unwrap();
        {
            let table = rd
                .open_table(redb::TableDefinition::<&[u8], &[u8]>::new(collection))
                .unwrap();
            for entry in table.iter().unwrap() {
                let (id_bytes, value_bytes) = entry.unwrap();
                let _id = Uuid::from_slice(&id_bytes.value())?;
                if _id == id {
                    let value: T = decode(&value_bytes.value())?;
                    return Ok(value);
                }
            }
            Err(ErrorKind::DbError(format!(
                "entity with id '{}' not found in collection {}",
                id, collection
            ))
            .into())
        }
    }

    pub fn set<T: Serialize + Identifiable>(&self, collection: &str, value: &T) -> Result<()> {
        self.set_raw(collection, value, value.get_id())?;
        Ok(())
    }

    pub fn set_raw<T: Serialize>(&self, collection: &str, value: &T, id: Uuid) -> Result<()> {
        let wx = self.db.begin_write().unwrap();
        {
            let mut table = wx
                .open_table(redb::TableDefinition::<&[u8], &[u8]>::new(collection))
                .unwrap();
            let encoded = encode(value)?;
            table
                .insert(id.as_bytes().as_slice(), encoded.as_slice())
                .unwrap();
        }

        wx.commit().unwrap();

        Ok(())
    }

    pub fn remove(&self, collection: &str, id: Uuid) -> Result<()> {
        let wx = self.db.begin_write().unwrap();
        {
            let mut table = wx
                .open_table(redb::TableDefinition::<&[u8], &[u8]>::new(collection))
                .unwrap();
            table.remove(id.as_bytes().as_slice()).unwrap();
        }

        Ok(())
    }
}