rustbase-rs 0.1.0

A Rust Rustbase driver
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

use client::Response;
use tokio::net::ToSocketAddrs;

mod client;
pub mod error;

pub struct Query;

impl Query {
    pub fn insert(key: &str, value: serde_json::Value) -> String {
        format!(
            "insert {} in {}",
            serde_json::to_string(&value).unwrap(),
            key
        )
    }

    pub fn get(key: &str) -> String {
        format!("get {}", key)
    }

    pub fn delete(key: &str) -> String {
        format!("delete {}", key)
    }

    pub fn update(key: &str, value: serde_json::Value) -> String {
        format!(
            "update {} in {}",
            serde_json::to_string(&value).unwrap(),
            key
        )
    }
}

#[derive(Debug)]
pub struct Rustbase {
    client: client::Client,
    database: String,
}

impl Rustbase {
    pub async fn connect(
        addr: impl ToSocketAddrs,
        database: String,
    ) -> Result<Self, std::io::Error> {
        let client = client::Client::connect(addr).await?;
        Ok(Self { client, database })
    }

    pub fn set_database(&mut self, database: String) {
        self.database = database;
    }

    fn parse_response(response: Response) -> error::Result<Response> {
        match response.status {
            client::Status::Ok => Ok(response),

            _ => Err(error::Error {
                message: response.message,
                status: response.status,
            }),
        }
    }

    pub async fn insert(&mut self, key: &str, value: serde_json::Value) -> error::Result<Response> {
        let query = Query::insert(key, value);

        let response = self
            .client
            .request(query, self.database.clone(), None)
            .await
            .unwrap();

        Self::parse_response(response)
    }

    pub async fn get(&mut self, key: &str) -> error::Result<Response> {
        let query = Query::get(key);

        let response = self
            .client
            .request(query, self.database.clone(), None)
            .await
            .unwrap();

        Self::parse_response(response)
    }

    pub async fn delete(&mut self, key: &str) -> error::Result<Response> {
        let query = Query::delete(key);

        let response = self
            .client
            .request(query, self.database.clone(), None)
            .await
            .unwrap();

        Self::parse_response(response)
    }

    pub async fn update(&mut self, key: &str, value: serde_json::Value) -> error::Result<Response> {
        let query = Query::update(key, value);

        let response = self
            .client
            .request(query, self.database.clone(), None)
            .await
            .unwrap();

        Self::parse_response(response)
    }
}