1#![allow(clippy::type_complexity, clippy::new_without_default)]
52
53extern crate self as che_orm;
54
55pub use che_orm_macros::{DbEnum, Model, ModelSerializer};
56
57pub use rusqlite;
58pub use serde;
59pub use serde_json;
60pub use time;
61
62mod query;
63mod schema;
64mod sql;
65mod types;
66
67#[cfg(feature = "sqlite")]
68mod connection;
69
70pub use query::*;
71pub use schema::*;
72pub use sql::*;
73pub use types::*;
74
75pub struct Rfc3339Timestamp<'a>(pub &'a time::OffsetDateTime);
77
78impl serde::Serialize for Rfc3339Timestamp<'_> {
79 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
80 where
81 S: serde::Serializer,
82 {
83 time::serde::rfc3339::serialize(self.0, serializer)
84 }
85}
86
87pub struct OptionalRfc3339Timestamp<'a>(pub &'a Option<time::OffsetDateTime>);
89
90impl serde::Serialize for OptionalRfc3339Timestamp<'_> {
91 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
92 where
93 S: serde::Serializer,
94 {
95 time::serde::rfc3339::option::serialize(self.0, serializer)
96 }
97}
98
99#[derive(Debug, Clone, Copy, PartialEq, Eq)]
100pub enum WriteMode {
101 Create,
102 Update { id: i64 },
103 Patch { id: i64 },
104}
105
106#[derive(Debug, Clone, PartialEq, Eq)]
107pub struct ValidationErrors {
108 pub detail: String,
109}
110
111impl From<serde_json::Error> for ValidationErrors {
112 fn from(error: serde_json::Error) -> Self {
113 Self {
114 detail: error.to_string(),
115 }
116 }
117}
118
119pub enum ValidatedWrite<M: Model> {
120 Create(InsertQuery<M>),
121 Update(UpdateQuery<M>),
122}
123
124impl<M: Model> ValidatedWrite<M> {
125 pub fn set<T, V>(self, field: ModelField<M, T>, value: V) -> Self
126 where
127 V: QueryValue<T>,
128 {
129 match self {
130 Self::Create(query) => Self::Create(query.set(field, value)),
131 Self::Update(query) => Self::Update(query.set(field, value)),
132 }
133 }
134}
135
136pub trait ModelWriteSerializer {
137 type Model: Model;
138
139 fn is_valid(
140 data: serde_json::Value,
141 mode: WriteMode,
142 ) -> Result<ValidatedWrite<Self::Model>, ValidationErrors>;
143}
144
145#[derive(Debug, Clone, Default, PartialEq, Eq)]
148pub enum PatchField<T> {
149 #[default]
150 Missing,
151 Value(T),
152}
153
154impl<T> PatchField<T> {
155 pub const fn is_missing(&self) -> bool {
156 matches!(self, Self::Missing)
157 }
158}
159
160impl<'de, T> serde::Deserialize<'de> for PatchField<T>
161where
162 T: serde::Deserialize<'de>,
163{
164 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
165 where
166 D: serde::Deserializer<'de>,
167 {
168 T::deserialize(deserializer).map(Self::Value)
169 }
170}
171
172pub fn deserialize_rfc3339<'de, D>(deserializer: D) -> Result<time::OffsetDateTime, D::Error>
174where
175 D: serde::Deserializer<'de>,
176{
177 time::serde::rfc3339::deserialize(deserializer)
178}
179
180pub fn deserialize_optional_rfc3339<'de, D>(
182 deserializer: D,
183) -> Result<Option<time::OffsetDateTime>, D::Error>
184where
185 D: serde::Deserializer<'de>,
186{
187 time::serde::rfc3339::option::deserialize(deserializer)
188}
189
190pub fn deserialize_patch_rfc3339<'de, D>(
192 deserializer: D,
193) -> Result<PatchField<time::OffsetDateTime>, D::Error>
194where
195 D: serde::Deserializer<'de>,
196{
197 deserialize_rfc3339(deserializer).map(PatchField::Value)
198}
199
200pub fn deserialize_patch_optional_rfc3339<'de, D>(
202 deserializer: D,
203) -> Result<PatchField<Option<time::OffsetDateTime>>, D::Error>
204where
205 D: serde::Deserializer<'de>,
206{
207 deserialize_optional_rfc3339(deserializer).map(PatchField::Value)
208}
209
210#[cfg(feature = "sqlite")]
211pub use connection::*;
212
213#[cfg(all(feature = "postgres", feature = "sqlite"))]
214compile_error!("features `postgres` and `sqlite` are mutually exclusive");
215
216#[cfg(not(any(feature = "postgres", feature = "sqlite")))]
217compile_error!("enable exactly one database backend: `postgres` or `sqlite`");
218
219#[cfg(test)]
220mod tests;