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