leaf_stream_types/
lib.rs

1pub use parity_scale_codec::{Decode, Encode};
2
3#[derive(Decode, Encode, Debug, Clone)]
4pub struct ModuleInit<Params = Vec<u8>> {
5    pub creator: String,
6    pub params: Params,
7}
8
9#[derive(Decode, Encode, Debug, Clone)]
10pub struct IncomingEvent<Payload = Vec<u8>, Params = Vec<u8>> {
11    pub payload: Payload,
12    pub params: Params,
13    pub user: String,
14}
15
16#[derive(Decode, Encode, Debug, Clone)]
17pub struct EventRequest<Payload = Vec<u8>, Params = Vec<u8>, Filter = Vec<u8>> {
18    pub requesting_user: String,
19    pub incoming_event: IncomingEvent<Payload, Params>,
20    pub filter: Option<Filter>,
21}
22
23#[derive(Decode, Encode, Debug, Clone, Default)]
24pub enum Inbound {
25    #[default]
26    Allow,
27    Block {
28        reason: String,
29    },
30}
31
32#[derive(Decode, Encode, Debug, Clone, Default)]
33pub enum Outbound {
34    #[default]
35    Allow,
36    Block,
37}
38
39#[derive(Decode, Encode, Debug, Clone, Default)]
40pub struct Process {
41    pub new_module: Option<[u8; 32]>,
42    pub new_params: Option<Vec<u8>>,
43}
44
45#[derive(Decode, Encode, Debug, Clone, Default)]
46pub struct SqlQuery {
47    pub sql: String,
48    pub params: Vec<(String, SqlValue)>,
49}
50
51#[derive(Decode, Encode, Debug, Clone, Default)]
52pub struct SqlRows {
53    pub rows: Vec<SqlRow>,
54    pub column_names: Vec<String>,
55}
56
57#[derive(Decode, Encode, Debug, Clone, Default)]
58pub struct SqlRow {
59    pub values: Vec<SqlValue>,
60}
61
62#[derive(Decode, Encode, Debug, Clone, Default)]
63pub enum SqlValue {
64    #[default]
65    Null,
66    Integer(i64),
67    Real(f64),
68    Text(String),
69    Blob(Vec<u8>),
70}
71impl From<()> for SqlValue {
72    fn from(_: ()) -> Self {
73        SqlValue::Null
74    }
75}
76impl From<i64> for SqlValue {
77    fn from(value: i64) -> Self {
78        Self::Integer(value)
79    }
80}
81impl From<f64> for SqlValue {
82    fn from(value: f64) -> Self {
83        SqlValue::Real(value)
84    }
85}
86impl From<String> for SqlValue {
87    fn from(value: String) -> Self {
88        SqlValue::Text(value)
89    }
90}
91impl From<Vec<u8>> for SqlValue {
92    fn from(value: Vec<u8>) -> Self {
93        SqlValue::Blob(value)
94    }
95}
96
97#[derive(thiserror::Error, Debug)]
98pub enum SqlError {
99    #[error("Invalid value type")]
100    InvalidValueType,
101    #[error("Invalid column count")]
102    InvalidColumnCount,
103}
104
105pub type SqlResult<T> = Result<T, SqlError>;
106
107pub trait FromValue: Sized {
108    fn from_value(value: SqlValue) -> SqlResult<Self>;
109}
110pub trait FromRow: Sized {
111    fn from_row(row: SqlRow) -> SqlResult<Self>;
112}
113pub trait FromRows: Sized {
114    fn from_rows(rows: SqlRows) -> SqlResult<Self>;
115}
116
117impl SqlValue {
118    pub fn parse_value<T: FromValue>(self) -> SqlResult<T> {
119        T::from_value(self)
120    }
121}
122impl SqlRow {
123    pub fn parse_row<T: FromRow>(self) -> SqlResult<T> {
124        T::from_row(self)
125    }
126}
127impl SqlRows {
128    pub fn parse_rows<T: FromRows>(self) -> SqlResult<T> {
129        T::from_rows(self)
130    }
131}
132
133impl<T: FromValue> FromValue for Option<T> {
134    fn from_value(value: SqlValue) -> SqlResult<Self> {
135        match value {
136            SqlValue::Null => Ok(None),
137            v => Ok(Some(T::from_value(v)?)),
138        }
139    }
140}
141
142impl FromValue for [u8; 32] {
143    fn from_value(value: SqlValue) -> SqlResult<Self> {
144        match value {
145            SqlValue::Blob(blob) => {
146                let bytes: [u8; 32] = blob.try_into().map_err(|_| SqlError::InvalidValueType)?;
147                Ok(bytes)
148            }
149            _ => Err(SqlError::InvalidValueType),
150        }
151    }
152}
153
154impl<T: FromRow> FromRows for Vec<T> {
155    fn from_rows(rows: SqlRows) -> SqlResult<Self> {
156        rows.rows
157            .into_iter()
158            .map(|row| T::from_row(row))
159            .collect::<SqlResult<Vec<_>>>()
160    }
161}
162
163impl FromValue for String {
164    fn from_value(value: SqlValue) -> SqlResult<Self> {
165        if let SqlValue::Text(x) = value {
166            Ok(x)
167        } else {
168            Err(SqlError::InvalidValueType)
169        }
170    }
171}
172impl FromValue for i64 {
173    fn from_value(value: SqlValue) -> SqlResult<Self> {
174        if let SqlValue::Integer(x) = value {
175            Ok(x)
176        } else {
177            Err(SqlError::InvalidValueType)
178        }
179    }
180}
181impl FromValue for f64 {
182    fn from_value(value: SqlValue) -> SqlResult<Self> {
183        if let SqlValue::Real(x) = value {
184            Ok(x)
185        } else {
186            Err(SqlError::InvalidValueType)
187        }
188    }
189}
190impl FromValue for Vec<u8> {
191    fn from_value(value: SqlValue) -> SqlResult<Self> {
192        if let SqlValue::Blob(x) = value {
193            Ok(x)
194        } else {
195            Err(SqlError::InvalidValueType)
196        }
197    }
198}
199
200impl FromValue for SqlValue {
201    fn from_value(value: SqlValue) -> SqlResult<Self> {
202        Ok(value)
203    }
204}
205
206macro_rules! impl_from_row {
207    ($($t:ident),*) => {
208        impl<$($t: FromValue),*> FromRow for ($( $t ),*) {
209            fn from_row(row: SqlRow) -> SqlResult<Self> {
210                let mut values = row.values.into_iter();
211                Ok((
212                    $(
213                        $t::from_value(values.next().ok_or(SqlError::InvalidColumnCount)?)?
214                    ),*
215                ))
216            }
217        }
218    };
219}
220impl<T: FromValue> FromRow for T {
221    fn from_row(row: SqlRow) -> SqlResult<Self> {
222        T::from_value(
223            row.values
224                .into_iter()
225                .next()
226                .ok_or(SqlError::InvalidColumnCount)?,
227        )
228    }
229}
230
231impl_from_row!(A, B);
232impl_from_row!(A, B, C);
233impl_from_row!(A, B, C, D);
234impl_from_row!(A, B, C, D, E);
235impl_from_row!(A, B, C, D, E, F);
236impl_from_row!(A, B, C, D, E, F, G);
leaf_stream_types/lib.rs

leaf_stream_types/
lib.rs
