turingdb_helpers/field.rs
1use crate::commands::{from_op, TuringOp};
2use anyhow::Result;
3use serde::Serialize;
4
5/// ### Handles all queries releated to fields
6/// ```rust
7///#[derive(Debug, Serialize, Clone)]
8///pub struct FieldQuery {
9/// db: String,
10/// document: String,
11/// field: String,
12/// payload: Option<T>,
13///}
14///```
15#[derive(Debug, Serialize, Clone)]
16pub struct FieldQuery<T> {
17 db: String,
18 document: String,
19 field: String,
20 payload: Option<T>,
21}
22
23impl<T> FieldQuery<T>
24where
25 T: serde::Serialize,
26{
27 /// ### Initialize a new empty field
28 /// #### Usage
29 /// ```rust
30 /// use crate::FieldQuery;
31 ///
32 /// FieldQuery::new()
33 /// ```
34 pub async fn new() -> Self {
35 Self {
36 db: Default::default(),
37 document: Default::default(),
38 field: Default::default(),
39 payload: Default::default(),
40 }
41 }
42 /// ### Add a database name
43 /// #### Usage
44 /// ```rust
45 /// use crate::FieldQuery;
46 ///
47 /// let mut foo = FieldQuery::new();
48 /// foo.db("db_name");
49 /// ```
50 pub async fn db(&mut self, name: &str) -> &Self {
51 self.db = name.into();
52
53 self
54 }
55 /// ### Add a document name
56 /// #### Usage
57 /// ```rust
58 /// use crate::FieldQuery;
59 ///
60 /// let mut foo = FieldQuery::new();
61 /// foo
62 /// .db("db_name")
63 /// .document("document_name");
64 /// ```
65 pub async fn document(&mut self, name: &str) -> &Self {
66 self.document = name.into();
67
68 self
69 }
70 /// ### Add a field name
71 /// #### Usage
72 /// ```rust
73 /// use crate::FieldQuery;
74 ///
75 /// let mut foo = FieldQuery::new();
76 /// foo
77 /// .db("db_name")
78 /// .document("document_name")
79 /// .field("field_name");
80 /// ```
81 pub async fn field(&mut self, name: &str) -> &Self {
82 self.field = name.into();
83
84 self
85 }
86 /// ### Add a payload of bytes
87 /// This takes a generic value and convertes it into bytes using bincode
88 /// #### Usage
89 /// ```rust
90 /// use crate::FieldQuery;
91 ///
92 /// let mut foo = FieldQuery::new();
93 /// foo
94 /// .db("db_name")
95 /// .document("document_name")
96 /// .field("field_name")
97 /// .payload("my_data_converted_into_bytes".as_bytes());
98 /// ```
99 pub async fn payload(&mut self, value: T) -> &Self {
100 self.payload = Some(value);
101
102 self
103 }
104 /// ### Inserts a `key/value` to a document in a database
105 /// #### Usage
106 /// ```rust
107 /// use crate::FieldQuery;
108 ///
109 /// let mut foo = FieldQuery::new();
110 /// foo
111 /// .db("db_name")
112 /// .document("document_name")
113 /// .field("field_name")
114 /// .payload("my_data_converted_into_bytes".as_bytes())
115 /// .set()
116 /// ```
117 pub async fn set(&self) -> Result<Vec<u8>> {
118 let mut packet = from_op(&TuringOp::FieldInsert).to_vec();
119 packet.extend_from_slice(self.db.as_bytes());
120
121 let data = bincode::serialize::<Self>(self)?;
122 packet.extend_from_slice(&data);
123
124 Ok(packet)
125 }
126 /// ### Gets a `value` to a document in a database by `key`
127 /// #### Usage
128 /// ```rust
129 /// use crate::FieldQuery;
130 ///
131 /// let mut foo = FieldQuery::new();
132 /// foo
133 /// .db("db_name")
134 /// .document("document_name")
135 /// .field("field_name")
136 /// .get();
137 /// ```
138 pub async fn get(&self) -> Result<Vec<u8>> {
139 let mut packet = from_op(&TuringOp::FieldGet).to_vec();
140 packet.extend_from_slice(self.db.as_bytes());
141
142 let data = bincode::serialize::<Self>(self)?;
143 packet.extend_from_slice(&data);
144
145 Ok(packet)
146 }
147 /// ### List all the `keys` in a document
148 /// #### Usage
149 /// ```rust
150 /// use crate::FieldQuery;
151 ///
152 /// let mut foo = FieldQuery::new();
153 /// foo
154 /// .db("db_name")
155 /// .document("document_name")
156 /// .list();
157 /// ```
158 pub fn list(&self) -> Result<Vec<u8>> {
159 let mut packet = from_op(&TuringOp::FieldList).to_vec();
160 packet.extend_from_slice(self.db.as_bytes());
161
162 let data = bincode::serialize::<Self>(self)?;
163 packet.extend_from_slice(&data);
164
165 Ok(packet)
166 }
167 /// ### Removes a `value` from a document in a database by `key`
168 /// #### Usage
169 /// ```rust
170 /// use crate::FieldQuery;
171 ///
172 /// let mut foo = FieldQuery::new();
173 /// foo
174 /// .db("db_name")
175 /// .document("document_name")
176 /// .field("field_name")
177 /// .remove();
178 /// ```
179 pub fn remove(&self) -> Result<Vec<u8>> {
180 let mut packet = from_op(&TuringOp::FieldRemove).to_vec();
181 packet.extend_from_slice(self.db.as_bytes());
182
183 let data = bincode::serialize::<Self>(self)?;
184 packet.extend_from_slice(&data);
185
186 Ok(packet)
187 }
188 /// ### Modifies a `value` in a document in a database by its `key`
189 /// #### Usage
190 /// ```rust
191 /// use crate::FieldQuery;
192 ///
193 /// let mut foo = FieldQuery::new();
194 /// foo
195 /// .db("db_name")
196 /// .document("document_name")
197 /// .field("field_name")
198 /// .payload("my_data_converted_into_bytes".as_bytes())
199 /// .modify()
200 /// ```
201 pub fn modify(&self) -> Result<Vec<u8>> {
202 let mut packet = from_op(&TuringOp::FieldModify).to_vec();
203 packet.extend_from_slice(self.db.as_bytes());
204
205 let data = bincode::serialize::<Self>(self)?;
206 packet.extend_from_slice(&data);
207
208 Ok(packet)
209 }
210}