1use client::Response;
2use tokio::net::ToSocketAddrs;
3
4mod client;
5pub mod error;
6
7pub struct Query;
8
9impl Query {
10 pub fn insert(key: &str, value: serde_json::Value) -> String {
11 format!(
12 "insert {} in {}",
13 serde_json::to_string(&value).unwrap(),
14 key
15 )
16 }
17
18 pub fn get(key: &str) -> String {
19 format!("get {}", key)
20 }
21
22 pub fn delete(key: &str) -> String {
23 format!("delete {}", key)
24 }
25
26 pub fn update(key: &str, value: serde_json::Value) -> String {
27 format!(
28 "update {} in {}",
29 serde_json::to_string(&value).unwrap(),
30 key
31 )
32 }
33}
34
35#[derive(Debug)]
36pub struct Rustbase {
37 client: client::Client,
38 database: String,
39}
40
41impl Rustbase {
42 pub async fn connect(
43 addr: impl ToSocketAddrs,
44 database: String,
45 ) -> Result<Self, std::io::Error> {
46 let client = client::Client::connect(addr).await?;
47 Ok(Self { client, database })
48 }
49
50 pub fn set_database(&mut self, database: String) {
51 self.database = database;
52 }
53
54 fn parse_response(response: Response) -> error::Result<Response> {
55 match response.status {
56 client::Status::Ok => Ok(response),
57
58 _ => Err(error::Error {
59 message: response.message,
60 status: response.status,
61 }),
62 }
63 }
64
65 pub async fn insert(&mut self, key: &str, value: serde_json::Value) -> error::Result<Response> {
66 let query = Query::insert(key, value);
67
68 let response = self
69 .client
70 .request(query, self.database.clone(), None)
71 .await
72 .unwrap();
73
74 Self::parse_response(response)
75 }
76
77 pub async fn get(&mut self, key: &str) -> error::Result<Response> {
78 let query = Query::get(key);
79
80 let response = self
81 .client
82 .request(query, self.database.clone(), None)
83 .await
84 .unwrap();
85
86 Self::parse_response(response)
87 }
88
89 pub async fn delete(&mut self, key: &str) -> error::Result<Response> {
90 let query = Query::delete(key);
91
92 let response = self
93 .client
94 .request(query, self.database.clone(), None)
95 .await
96 .unwrap();
97
98 Self::parse_response(response)
99 }
100
101 pub async fn update(&mut self, key: &str, value: serde_json::Value) -> error::Result<Response> {
102 let query = Query::update(key, value);
103
104 let response = self
105 .client
106 .request(query, self.database.clone(), None)
107 .await
108 .unwrap();
109
110 Self::parse_response(response)
111 }
112}