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
109
110
111
112
113

use serde::{
	Deserialize,
	Serialize,
};
use utoipa::{
	IntoParams,
	ToSchema,
};

use crate::blocks::Page;

/// Standard pagination sent as **query** parameters.
///
/// *If the caller omits either field Axum fills in the defaults.*
#[derive(Deserialize, Serialize, Debug, Clone, Copy, IntoParams, ToSchema)]
#[serde(default, rename_all = "camelCase")]
pub struct WebPagination {
	/// Offset in pages to start from
	#[serde(deserialize_with = "non_negative_i64", rename = "pageNo")]
	#[param(example = 0)]
	pub page: i64,

	/// Maximum number of elements to return  
	#[serde(deserialize_with = "positive_i64")]
	#[param(example = 10)]
	pub page_size: i64,
}

fn non_negative_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
	D: serde::Deserializer<'de>,
{
	let v = i64::deserialize(deserializer)?;
	if v < 0 {
		Err(serde::de::Error::custom("offset must be >= 0"))
	} else {
		Ok(v)
	}
}

fn positive_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
	D: serde::Deserializer<'de>,
{
	let v = i64::deserialize(deserializer)?;
	if v <= 0 {
		Err(serde::de::Error::custom("page_size must be > 0"))
	} else {
		Ok(v)
	}
}

pub(crate) fn opt_non_negative_i64<'de, D>(
	deserializer: D,
) -> Result<Option<i64>, D::Error>
where
	D: serde::Deserializer<'de>,
{
	let value = Option::<i64>::deserialize(deserializer)?;
	match value {
		Some(v) if v < 0 => {
			Err(serde::de::Error::custom("offset must be >= 0"))
		}
		_ => Ok(value),
	}
}

pub(crate) fn opt_positive_i64<'de, D>(
	deserializer: D,
) -> Result<Option<i64>, D::Error>
where
	D: serde::Deserializer<'de>,
{
	let value = Option::<i64>::deserialize(deserializer)?;
	match value {
		Some(v) if v <= 0 => {
			Err(serde::de::Error::custom("page_size must be > 0"))
		}
		_ => Ok(value),
	}
}

impl Default for WebPagination {
	fn default() -> Self {
		WebPagination {
			page:      0,
			page_size: i32::MAX as i64,
		}
	}
}

/// Standard pagination response.
#[derive(Serialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct WebPage<T> {
	pub items:       Vec<T>,
	pub page_size:   i64,
	pub page:        i64,
	pub total:       i64,
	pub total_pages: i64,
}

impl<T> From<Page<T>> for WebPage<T> {
	fn from(value: Page<T>) -> Self {
		Self {
			items:       value.items,
			page_size:   value.page_size,
			page:        value.page,
			total:       value.total,
			total_pages: value.total_pages,
		}
	}
}