real-time-sqlx 0.1.1

Real-time SQLx backend for Tauri
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

//! Serialize and deserialize database operations from JSON

use serde::{Deserialize, Serialize};

use crate::{error::DeserializeError, queries::serialize::FinalType};

/// Generic JSON object type
pub type JsonObject = serde_json::Map<String, serde_json::Value>;

/// Coerce a JSON value to a JSON object
pub fn object_from_value(value: serde_json::Value) -> Result<JsonObject, DeserializeError> {
    match value {
        serde_json::Value::Object(obj) => Ok(obj),
        value => Err(DeserializeError::IncompatibleValue(value)),
    }
}

/// Coerce a JSON value to a JSON object array
pub fn object_array_from_value(
    value: serde_json::Value,
) -> Result<Vec<JsonObject>, DeserializeError> {
    match value {
        serde_json::Value::Array(array) => {
            let mut objects = Vec::new();
            for item in array {
                objects.push(object_from_value(item)?);
            }
            Ok(objects)
        }
        value => Err(DeserializeError::IncompatibleValue(value)),
    }
}

/// Entities related to a specific table
pub trait Tabled {
    fn get_table(&self) -> &str;
}

/// An incoming granular operation to be performed in the database
/// The data can be partial or complete, depending on the operation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum GranularOperation {
    #[serde(rename = "create")]
    Create { table: String, data: JsonObject },
    #[serde(rename = "create_many")]
    CreateMany {
        table: String,
        data: Vec<JsonObject>,
    },
    #[serde(rename = "update")]
    Update {
        table: String,
        id: FinalType,
        data: JsonObject,
    },
    #[serde(rename = "delete")]
    Delete { table: String, id: FinalType },
}

impl Tabled for GranularOperation {
    /// Helper method to get the table name from the operation
    fn get_table(&self) -> &str {
        match self {
            GranularOperation::Create { table, .. } => table,
            GranularOperation::CreateMany { table, .. } => table,
            GranularOperation::Update { table, .. } => table,
            GranularOperation::Delete { table, .. } => table,
        }
    }
}

/// An outgoing operation notification to be sent to clients
/// The data sent back is always complete, hence the generic parameter.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum OperationNotification<T> {
    #[serde(rename = "create")]
    Create { table: String, data: T },
    #[serde(rename = "create_many")]
    CreateMany { table: String, data: Vec<T> },
    #[serde(rename = "update")]
    Update {
        table: String,
        id: FinalType,
        data: T,
    },
    #[serde(rename = "delete")]
    Delete {
        table: String,
        id: FinalType,
        data: T,
    },
}

impl<T> Tabled for OperationNotification<T> {
    /// Helper method to get the table name from the operation
    fn get_table(&self) -> &str {
        match self {
            OperationNotification::Create { table, .. } => table,
            OperationNotification::CreateMany { table, .. } => table,
            OperationNotification::Update { table, .. } => table,
            OperationNotification::Delete { table, .. } => table,
        }
    }
}