Skip to main content

che_orm/
lib.rs

1//! `che-orm` — экспериментальная типизированная ORM для Rust.
2//!
3//! Runtime сейчас ориентирован на SQLite: [`Database`] предоставляет async
4//! pool и high-level CRUD/query facade, а [`Model`] derive генерирует metadata,
5//! row decoding и insert values. SQL можно также использовать отдельно через
6//! [`SqlCompiler`].
7//!
8//! Основной рабочий сценарий:
9//!
10//! ```ignore
11//! use che_orm::{Database, Model};
12//!
13//! # #[derive(Debug, Model)]
14//! # #[orm(table = "users")]
15//! # struct User {
16//! #     #[orm(primary_key)]
17//! #     id: i64,
18//! #     name: String,
19//! # }
20//! # #[tokio::main]
21//! # async fn run() -> Result<(), che_orm::OrmError> {
22//! let database = Database::connect_in_memory()?;
23//! database.create_table::<User>().await?;
24//! let user = database
25//!     .create::<User>()
26//!     .set(User::NAME, "Alice")
27//!     .execute()
28//!     .await?;
29//! let loaded = database.get::<User>(user.id).await?;
30//! assert!(loaded.is_some());
31//! # Ok(())
32//! # }
33//! ```
34//!
35//! Fixed string choices use [`DbEnum`]. It owns the JSON and database value,
36//! so a variant has one canonical representation everywhere:
37//!
38//! ```ignore
39//! # use che_orm::DbEnum;
40//! #[derive(Debug, Clone, Copy, DbEnum)]
41//! enum TaskStatus {
42//!     Draft,
43//!     #[db_enum(rename = "in_progress")]
44//!     InProgress,
45//! }
46//! ```
47//!
48//! Do not derive `serde::Serialize` or `serde::Deserialize` for a `DbEnum`;
49//! the derive generates both implementations.
50
51#![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
75#[derive(Debug, Clone, Copy, PartialEq, Eq)]
76pub enum WriteMode {
77    Create,
78    Update { id: i64 },
79    Patch { id: i64 },
80}
81
82#[derive(Debug, Clone, PartialEq, Eq)]
83pub struct ValidationErrors {
84    pub detail: String,
85}
86
87impl From<serde_json::Error> for ValidationErrors {
88    fn from(error: serde_json::Error) -> Self {
89        Self {
90            detail: error.to_string(),
91        }
92    }
93}
94
95pub enum ValidatedWrite<M: Model> {
96    Create(InsertQuery<M>),
97    Update(UpdateQuery<M>),
98}
99
100impl<M: Model> ValidatedWrite<M> {
101    pub fn set<T, V>(self, field: ModelField<M, T>, value: V) -> Self
102    where
103        V: QueryValue<T>,
104    {
105        match self {
106            Self::Create(query) => Self::Create(query.set(field, value)),
107            Self::Update(query) => Self::Update(query.set(field, value)),
108        }
109    }
110}
111
112pub trait ModelWriteSerializer {
113    type Model: Model;
114
115    fn is_valid(
116        data: serde_json::Value,
117        mode: WriteMode,
118    ) -> Result<ValidatedWrite<Self::Model>, ValidationErrors>;
119}
120
121/// A JSON patch value. `Missing` means that the property was not sent;
122/// `Value(None)` represents an explicit JSON null.
123#[derive(Debug, Clone, Default, PartialEq, Eq)]
124pub enum PatchField<T> {
125    #[default]
126    Missing,
127    Value(T),
128}
129
130impl<T> PatchField<T> {
131    pub const fn is_missing(&self) -> bool {
132        matches!(self, Self::Missing)
133    }
134}
135
136impl<'de, T> serde::Deserialize<'de> for PatchField<T>
137where
138    T: serde::Deserialize<'de>,
139{
140    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
141    where
142        D: serde::Deserializer<'de>,
143    {
144        T::deserialize(deserializer).map(Self::Value)
145    }
146}
147
148#[cfg(feature = "sqlite")]
149pub use connection::*;
150
151#[cfg(all(feature = "postgres", feature = "sqlite"))]
152compile_error!("features `postgres` and `sqlite` are mutually exclusive");
153
154#[cfg(not(any(feature = "postgres", feature = "sqlite")))]
155compile_error!("enable exactly one database backend: `postgres` or `sqlite`");
156
157#[cfg(test)]
158mod tests;