sqlxo 0.9.1

sqlxo: small SQL query builder + derives for filterable ORM-ish patterns
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use serde::{
	Deserialize,
	Serialize,
};
use sqlxo_traits::{
	WebLeaf,
	WebQueryModel,
	WebSortField,
};
use utoipa::{
	IntoParams,
	ToSchema,
};

mod builder;
mod page;
pub use page::{
	WebPage,
	WebPagination,
};
pub use sqlxo_traits::WebQueryError;

#[derive(
	Clone, Serialize, Deserialize, ToSchema, Debug, Default, IntoParams,
)]
#[serde(bound(deserialize = "Q: WebLeaf + Deserialize<'de>, S: \
                             WebSortField + Deserialize<'de>"))]
#[serde(deny_unknown_fields)]
#[into_params(parameter_in = Query)]
pub struct GenericWebFilter<Q, S>
where
	Q: WebLeaf + Serialize,
	S: WebSortField + Serialize,
{
	#[schema(no_recursion, nullable)]
	pub filter:    Option<GenericWebExpression<Q>>,
	#[schema(no_recursion, nullable)]
	pub sort:      Option<Vec<GenericWebSort<S>>>,
	#[schema(no_recursion, nullable)]
	pub search:    Option<String>,
	/// Zero-based page index.
	#[schema(nullable)]
	#[param(rename = "pageNo", example = 0)]
	#[serde(
		default,
		rename = "pageNo",
		deserialize_with = "crate::web::page::opt_non_negative_i64"
	)]
	pub page_no:   Option<i64>,
	/// Maximum number of elements to return.
	#[schema(nullable)]
	#[param(rename = "pageSize", example = 10)]
	#[serde(
		default,
		rename = "pageSize",
		deserialize_with = "crate::web::page::opt_positive_i64"
	)]
	pub page_size: Option<i64>,
}

#[derive(Clone, Serialize, Deserialize, ToSchema, Debug, IntoParams)]
#[serde(bound(deserialize = "Q: WebLeaf + Deserialize<'de>"))]
#[serde(deny_unknown_fields)]
#[into_params(parameter_in = Query)]
pub struct GenericWebMutationFilter<Q>
where
	Q: WebLeaf + Serialize,
{
	#[schema(no_recursion, nullable)]
	pub filter: Option<GenericWebExpression<Q>>,
}

#[derive(Clone, Serialize, Deserialize, ToSchema, Debug)]
#[serde(bound(deserialize = "Q: WebLeaf + Deserialize<'de>"))]
#[serde(untagged)]
pub enum GenericWebExpression<Q>
where
	Q: WebLeaf + Serialize,
{
	#[schema(no_recursion)]
	And {
		and: Vec<GenericWebExpression<Q>>,
	},
	#[schema(no_recursion)]
	Or {
		or: Vec<GenericWebExpression<Q>>,
	},
	Leaf(Q),
}

#[derive(Clone, Serialize, Deserialize, ToSchema, Debug)]
#[serde(bound(deserialize = "S: WebSortField + Deserialize<'de>"))]
#[serde(transparent)]
pub struct GenericWebSort<S>(pub S)
where
	S: WebSortField + Serialize;

pub type WebExpression<T> = GenericWebExpression<<T as WebQueryModel>::Leaf>;
pub type WebSort<T> = GenericWebSort<<T as WebQueryModel>::SortField>;
pub type WebReadFilter<T> = GenericWebFilter<
	<T as WebQueryModel>::Leaf,
	<T as WebQueryModel>::SortField,
>;
pub type WebFilter<T> = WebReadFilter<T>;
pub type WebUpdateFilter<T> =
	GenericWebMutationFilter<<T as WebQueryModel>::Leaf>;
pub type WebDeleteFilter<T> =
	GenericWebMutationFilter<<T as WebQueryModel>::Leaf>;