How to complete restful api query with rust and actix-web? - rest

Question

I have some data, from the request's querystring, the structure like this:
Crates: serde_qs serde mongodb and its serde_helpers
filter: {
linkOperator: "and", // maybe 'or'
items: [
{
field: "parent",
operator: "is", // maybe 'isNot', 'isAnyOf'
value: "id"
},
{
field: "createdAt",
operator: "is", // maybe 'before', 'after', .etc
value: "RFC 3339 string"
}
]
}
I use the serde crate to handle it, the linkOperator as enum, items as its type. I use the mongodb as the database.
#[derive(Debug, Deserialize, Serialize, PartialEq)]
#[serde(tag = "linkOperator", content = "items", rename_all = "camelCase")]
pub enum Filter<T> {
And(Vec<T>),
Or(Vec<T>),
}
pub trait ToFilter {
fn to_filter(self) -> Document;
}
impl<T> Filter<T> {
pub fn to_filter(self) -> Document
where
T: ToFilter,
{
match self {
Filter::And(items) => {
let mut filter = vec![];
for item in items {
filter.push(item.to_filter());
}
doc! {
"$and": filter
}
}
Filter::Or(items) => {
let mut filter = vec![];
for item in items {
filter.push(item.to_filter());
}
doc! {
"$or": filter
}
}
}
}
}
Then, I further process it in the next progress. This enum is used to handle datetime. Use the content of the vec above. operator field as enum, value field as enum's inner type.
#[derive(Debug, Deserialize, Serialize, PartialEq)]
#[serde(rename_all = "camelCase", tag = "operator", content = "value")]
pub enum DateTimeFilter {
#[serde(deserialize_with = "deserialize_bson_datetime_from_rfc3339_string")]
Is(DateTime),
#[serde(deserialize_with = "deserialize_bson_datetime_from_rfc3339_string")]
Not(DateTime),
#[serde(deserialize_with = "deserialize_bson_datetime_from_rfc3339_string")]
After(DateTime),
#[serde(deserialize_with = "deserialize_bson_datetime_from_rfc3339_string")]
OnOrAfter(DateTime),
#[serde(deserialize_with = "deserialize_bson_datetime_from_rfc3339_string")]
Before(DateTime),
#[serde(deserialize_with = "deserialize_bson_datetime_from_rfc3339_string")]
OnOrBefore(DateTime),
IsEmpty,
IsNotEmpty,
}
impl DateTimeFilter {
pub fn to_filter(self, field: &'static str) -> Document {
match self {
DateTimeFilter::Is(value) => doc! { field: value },
DateTimeFilter::Not(value) => doc! { field: { "$ne": value } },
DateTimeFilter::After(value) => doc! { field: { "$gt": value } },
DateTimeFilter::OnOrAfter(value) => doc! { field: { "$gte": value } },
DateTimeFilter::Before(value) => doc! { field: { "$lt": value } },
DateTimeFilter::OnOrBefore(value) => doc! { field: { "$lte": value } },
DateTimeFilter::IsEmpty => doc! { field: { "$exists": false } },
DateTimeFilter::IsNotEmpty => doc! { field: { "$exists": true } },
}
}
}
There are some other enums which have a similar effect.
#[derive(Debug, Deserialize, Serialize, PartialEq)]
#[serde(rename_all = "camelCase", tag = "operator", content = "value")]
pub enum SingleSelectFilter<T> {
Is(T),
Not(T),
IsAnyOf(Vec<T>),
}
impl<T> SingleSelectFilter<T> {
pub fn to_filter(self, field: &'static str) -> Document
where
Bson: From<T> + From<Vec<T>>,
{
match self {
SingleSelectFilter::Is(value) => doc! { field: value },
SingleSelectFilter::Not(value) => doc! { field: { "$ne": value } },
SingleSelectFilter::IsAnyOf(values) => doc! { field: { "$in": values } },
}
}
}
I combine them.
#[derive(Debug, Deserialize, Serialize, PartialEq)]
pub struct PostQuery {
filter: Option<Filter<FilterField>>,
#[serde(flatten)]
sort: Option<Sort<SortField>>,
#[serde(flatten)]
pagination: Pagination,
}
/// add the new field here
#[derive(Debug, Deserialize, Serialize, PartialEq)]
#[serde(tag = "field", rename_all = "camelCase")]
pub enum FilterField {
Published(SingleSelectFilter<bool>),
PublishedAt(DateTimeFilter),
CreatedAt(DateTimeFilter),
Creator(SingleSelectFilter<ObjectId>),
}
impl ToFilter for FilterField {
fn to_filter(self) -> Document {
match self {
FilterField::Published(filter) => filter.to_filter("published"),
FilterField::PublishedAt(filter) => filter.to_filter("publishedAt"),
FilterField::CreatedAt(filter) => filter.to_filter("createdAt"),
FilterField::Creator(filter) => filter.to_filter("creator"),
}
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct AggregatedPost {
#[serde(rename = "_id")]
id: ObjectId,
title: String,
slug: String,
content: String,
categories: Vec<Category>,
tags: Vec<Tag>,
#[serde(rename = "publishedAt")]
published_at: DateTime,
published: bool,
#[serde(rename = "createdAt")]
created_at: DateTime,
pub creator: User,
}
pub async fn aggregate_posts(
query: PostQuery,
service: &Service,
) -> Result<(u64, Vec<Self>), AppError> {
let filter = match query.filter {
Some(filter) => filter.to_filter(),
None => doc! {},
};
let skip = query.pagination.skip();
let limit = query.pagination.limit();
let options = CountOptions::builder().skip(skip).limit(limit).build();
let count = service
.count::<Self>(filter.clone(), options, "posts")
.await?;
let mut pipeline = vec![
doc! {
"$match": filter
},
doc! {
"$skip": skip as u32
},
doc! {
"$limit": limit as u32
},
doc! {
"$lookup": {
"from": "categories",
"localField": "categories",
"foreignField": "_id",
"as": "categories"
}
},
doc! {
"$lookup": {
"from": "tags",
"localField": "tags",
"foreignField": "_id",
"as": "tags"
}
},
doc! {
"$lookup": {
"from": "users",
"localField": "creator",
"foreignField": "_id",
"as": "creator"
}
},
doc! {
"$unwind": {
"path": "$creator",
"preserveNullAndEmptyArrays": true
}
},
];
if query.sort.is_some() {
let sort = query.sort.unwrap().to_sort();
pipeline.insert(1, doc! { "$sort": sort });
}
match service
.aggregate_docs::<Self>(pipeline, None, "posts")
.await
{
Ok(posts) => Ok((count, posts)),
Err(error) => Err(error),
}
}
Use this is a router handler with serde_qs
pub async fn aggregate_posts(
session: Session,
service: Data<Service>,
query: QsQuery<PostQuery>,
) -> Result<HttpResponse, AppError> {
let user = protect(&session, &service).await?;
user.has_permission(
Permission::ReadAggregatedPosts,
"You don't have permission to get aggregated posts.",
)?;
let (count, posts) = AggregatedPost::aggregate_posts(query.into_inner(), &service).await?;
let posts_json = posts
.into_iter()
.map(|post| post.into_json(&user))
.collect::<Vec<Value>>();
Ok(HttpResponse::Ok().json(json!({ "count": count, "posts": posts_json })))
}
Finally, the problem arises. When I receive a request with a query like this.
filter: {
linkOperator: "and", // maybe 'or'
items: [
{
field: "published",
operator: "isAnyOf", // maybe 'before', 'after', .etc
value: [true]
}
]
}
My query error handler will generate the message like this. Custom("invalid type: string \"true\", expected a boolean")
pub fn query_error_handler(error: serde_qs::Error, _req: &HttpRequest) -> Error {
let app_error = match &error {
serde_qs::Error::Custom(message) => BadRequest(format!("Query params: {}.", message)),
_ => BadRequest("Invalid query params.".to_string()),
};
InternalError::from_response(error, app_error.error_response()).into()
}
My api test result
How can i convert the string to a bool value here? Or, have any other options to complete a query in restful api with actix-web?