use super::{Mongo, MongoCarrier, MongoOperator, field_path, membership};
use crate::{
BooleanFilter,
comparison::{At, Backend, ComplexComparison, ToDatabaseComparison, TryFromFilter},
graphql::filter::{map_operand, map_operands},
};
mongo_comparison_kind! {
MongoBooleanComparison {
one { eq, ne }
many { in_, not_in }
}
}
impl<V> MongoBooleanComparison<V> {
pub fn try_from_filter_with<E, F>(filter: BooleanFilter, mut f: F) -> Result<Self, E>
where
F: FnMut(bool) -> Result<V, E>,
{
Ok(Self {
eq: map_operand(filter.eq, &mut f)?,
ne: map_operand(filter.ne, &mut f)?,
in_: map_operands(filter.in_, &mut f)?,
not_in: map_operands(filter.not_in, &mut f)?,
})
}
}
impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for BooleanFilter {
type Comparison = MongoBooleanComparison<V>;
}
impl<V: TryFrom<bool>> TryFromFilter<BooleanFilter> for MongoBooleanComparison<V> {
type Error = V::Error;
fn try_from_filter(filter: BooleanFilter) -> Result<Self, Self::Error> {
Self::try_from_filter_with(filter, V::try_from)
}
}
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoBooleanComparison<V> {
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error> {
let field = field_path(at);
for (slot, op) in [(&self.eq, MongoOperator::Eq), (&self.ne, MongoOperator::Ne)] {
if let Some(value) = slot {
builder.merge(&field, op, value.to_bson());
}
}
for (slot, op) in [
(&self.in_, MongoOperator::In),
(&self.not_in, MongoOperator::Nin),
] {
if let Some(values) = slot {
builder.merge(&field, op, membership(values));
}
}
Ok(builder)
}
}
#[cfg(test)]
mod tests;