tauri-plugin-persistence 0.1.0

A wrapper plugin for several persistence backends, focused on managing complex project folders with less boilerplate.
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

use std::{collections::HashMap, sync::Arc};

use polodb_core::{Database, Transaction};
use serde::{Deserialize, Serialize};
use specta::Type;
use tokio::{fs::{File, OpenOptions}, sync::Mutex};

#[derive(Clone)]
pub struct ContextDB {
    #[allow(dead_code)]
    pub name: String,
    pub path: String,
    pub database: Arc<Mutex<Database>>,
    pub transactions: Arc<Mutex<HashMap<bson::Uuid, Arc<Mutex<Transaction>>>>>,
}

#[derive(Clone, Serialize, Deserialize, Debug, Type)]
#[serde(rename_all = "snake_case", tag = "mode")]
pub enum FileHandleMode {
    Create {
        new: bool,
        overwrite: bool
    },
    Write {
        overwrite: bool
    },
    Read {}
}

impl FileHandleMode {
    pub fn create_new(overwrite: bool) -> Self {
        Self::Create { new: true, overwrite }
    }

    pub fn create_or_open(overwrite: bool) -> Self {
        Self::Create { new: false, overwrite }
    }

    pub fn append() -> Self {
        Self::Write { overwrite: false }
    }

    pub fn overwrite() -> Self {
        Self::Write { overwrite: true }
    }

    pub fn read() -> Self {
        Self::Read {  }
    }

    pub fn create(&self) -> bool {
        if let Self::Create { .. } = self {
            true
        } else {
            false
        }
    }

    pub fn writeable(&self) -> bool {
        match self {
            Self::Create {..} | Self::Write {..} => true,
            _ => false
        }
    }

    pub fn readable(&self) -> bool {
        match self {
            Self::Read {} => true,
            _ => false
        }
    }
}

impl Into<OpenOptions> for FileHandleMode {
    fn into(self) -> OpenOptions {
        let mut base = OpenOptions::new();
        match self {
            Self::Create { new, overwrite: true } => base.create(true).write(true).create_new(new),
            Self::Create {new, overwrite: false} => base.create(true).append(true).create_new(new),
            Self::Write { overwrite: true } => base.write(true),
            Self::Write { overwrite: false } => base.append(true),
            Self::Read {  } => base.read(true)
        }.clone()
    }
}

#[derive(Clone)]
pub struct ContextFileHandle {
    pub id: bson::Uuid,
    pub path: String,
    pub handle: async_dup::Arc<async_dup::Mutex<File>>,
    pub mode: FileHandleMode
}

#[derive(Clone)]
pub struct ContextState {
    #[allow(dead_code)]
    pub name: String,
    pub root_path: String,
    pub databases: Arc<Mutex<HashMap<String, ContextDB>>>,
    pub files: Arc<Mutex<HashMap<bson::Uuid, ContextFileHandle>>>,
}

pub type PluginState = Mutex<HashMap<String, ContextState>>;