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