cido 0.2.0

use async_graphql::InputType;

use super::*;
use crate::helper_macros::{is_none, is_none_range};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NestedIdWrapper<I>(pub(crate) I);

impl<I> NestedIdWrapper<I> {
  pub fn into_inner(self) -> I {
    self.0
  }
}

impl<I: InputType> InputType for NestedIdWrapper<I> {
  type RawValueType = Self;

  fn type_name() -> std::borrow::Cow<'static, str> {
    <String as InputType>::type_name()
  }

  fn create_type_info(registry: &mut async_graphql::registry::Registry) -> String {
    <String as InputType>::create_type_info(registry)
  }

  fn parse(value: Option<async_graphql::Value>) -> async_graphql::InputValueResult<Self> {
    I::parse(value).map(Self).map_err(|e| e.propagate())
  }

  fn to_value(&self) -> async_graphql::Value {
    self.0.to_value()
  }

  fn as_raw_value(&self) -> Option<&Self::RawValueType> {
    Some(self)
  }
}

filter!(NestedIdFilter: [NestedIdOperator; 20],
  extra_bounds: {},
  extra_binds: {},
  null { },
  primitive {
    0: Eq:eq:"",
    1: Not:not:"not",
    2: Gt:gt:"gt",
    3: Gte:gte:"gte",
    4: Lt:lt:"lt",
    5: Lte:lte:"lte",
    6: Contains:contains:"contains",
    7: ContainsNoCase:contains_nocase:"contains_nocase",
    8: NotContains:not_contains:"not_contains",
    9: NotContainsNoCase:not_contains_nocase:"not_contains_nocase",
    10: StartsWith:starts_with:"starts_with",
    11: StartsWithNoCase:starts_with_nocase:"starts_with_nocase",
    12: NotStartsWith:not_starts_with:"not_starts_with",
    13: NotStartsWithNoCase:not_starts_with_nocase:"not_starts_with_nocase",
    14: EndsWith:ends_with:"ends_with",
    15: EndsWithNoCase:ends_with_nocase:"ends_with_nocase",
    16: NotEndsWith:not_ends_with:"not_ends_with",
    17: NotEndsWithNoCase:not_ends_with_nocase:"not_ends_with_nocase"
  },
  primitives {
    18: In:in_:"in",
    19: NotIn:not_in:"not_in"
  }
);

filter!(OptionalNestedIdFilter: [OptionalNestedIdOperator; 21],
  extra_bounds: {},
  extra_binds: {},
  null { 20:Null:null:"null" },
    primitive {
      0: Eq:eq:"",
      1: Not:not:"not",
      2: Gt:gt:"gt",
      3: Gte:gte:"gte",
      4: Lt:lt:"lt",
      5: Lte:lte:"lte",
      6: Contains:contains:"contains",
      7: ContainsNoCase:contains_nocase:"contains_nocase",
      8: NotContains:not_contains:"not_contains",
      9: NotContainsNoCase:not_contains_nocase:"not_contains_nocase",
      10: StartsWith:starts_with:"starts_with",
      11: StartsWithNoCase:starts_with_nocase:"starts_with_nocase",
      12: NotStartsWith:not_starts_with:"not_starts_with",
      13: NotStartsWithNoCase:not_starts_with_nocase:"not_starts_with_nocase",
      14: EndsWith:ends_with:"ends_with",
      15: EndsWithNoCase:ends_with_nocase:"ends_with_nocase",
      16: NotEndsWith:not_ends_with:"not_ends_with",
      17: NotEndsWithNoCase:not_ends_with_nocase:"not_ends_with_nocase"
    },
    primitives {
      18: In:in_:"in",
      19: NotIn:not_in:"not_in"
    }
);

impl<I> TryFrom<NestedIdFilter<NestedIdWrapper<I>>> for BaseFilter<I> {
  type Error = async_graphql::Error;

  fn try_from(mut value: NestedIdFilter<NestedIdWrapper<I>>) -> Result<Self, Self::Error> {
    let mut this = BaseFilter::new();
    this.set_eq(value.take_eq().map(NestedIdWrapper::into_inner));
    this.set_not(value.take_not().map(NestedIdWrapper::into_inner));
    this.set_gt(value.take_gt().map(NestedIdWrapper::into_inner));
    this.set_gte(value.take_gte().map(NestedIdWrapper::into_inner));
    this.set_lt(value.take_lt().map(NestedIdWrapper::into_inner));
    this.set_lte(value.take_lte().map(NestedIdWrapper::into_inner));
    this.set_in_(
      value
        .take_in_()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_not_in(
      value
        .take_not_in()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    Ok(this)
  }
}

impl<I> TryFrom<OptionalNestedIdFilter<NestedIdWrapper<I>>> for OptionalBaseFilter<I> {
  type Error = async_graphql::Error;

  fn try_from(mut value: OptionalNestedIdFilter<NestedIdWrapper<I>>) -> Result<Self, Self::Error> {
    let mut this = OptionalBaseFilter::new();
    this.set_eq(value.take_eq().map(NestedIdWrapper::into_inner));
    this.set_not(value.take_not().map(NestedIdWrapper::into_inner));
    this.set_gt(value.take_gt().map(NestedIdWrapper::into_inner));
    this.set_gte(value.take_gte().map(NestedIdWrapper::into_inner));
    this.set_lt(value.take_lt().map(NestedIdWrapper::into_inner));
    this.set_lte(value.take_lte().map(NestedIdWrapper::into_inner));
    this.set_in_(
      value
        .take_in_()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_not_in(
      value
        .take_not_in()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_null(value.take_null());
    Ok(this)
  }
}

impl<I> TryFrom<NestedIdFilter<NestedIdWrapper<I>>> for StringFilter<I> {
  type Error = async_graphql::Error;

  fn try_from(mut value: NestedIdFilter<NestedIdWrapper<I>>) -> Result<Self, Self::Error> {
    let mut this = StringFilter::new();
    this.set_eq(value.take_eq().map(NestedIdWrapper::into_inner));
    this.set_not(value.take_not().map(NestedIdWrapper::into_inner));
    this.set_gt(value.take_gt().map(NestedIdWrapper::into_inner));
    this.set_gte(value.take_gte().map(NestedIdWrapper::into_inner));
    this.set_lt(value.take_lt().map(NestedIdWrapper::into_inner));
    this.set_contains(value.take_contains().map(NestedIdWrapper::into_inner));
    this.set_contains_nocase(
      value
        .take_contains_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_contains(value.take_not_contains().map(NestedIdWrapper::into_inner));
    this.set_not_contains_nocase(
      value
        .take_not_contains_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_starts_with(value.take_starts_with().map(NestedIdWrapper::into_inner));
    this.set_starts_with_nocase(
      value
        .take_starts_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_starts_with(
      value
        .take_not_starts_with()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_starts_with_nocase(
      value
        .take_not_starts_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_ends_with(value.take_ends_with().map(NestedIdWrapper::into_inner));
    this.set_ends_with_nocase(
      value
        .take_ends_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_ends_with(value.take_not_ends_with().map(NestedIdWrapper::into_inner));
    this.set_not_ends_with_nocase(
      value
        .take_not_ends_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_in_(
      value
        .take_in_()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_not_in(
      value
        .take_not_in()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    Ok(this)
  }
}

impl<I> TryFrom<OptionalNestedIdFilter<NestedIdWrapper<I>>> for OptionalStringFilter<I> {
  type Error = async_graphql::Error;

  fn try_from(mut value: OptionalNestedIdFilter<NestedIdWrapper<I>>) -> Result<Self, Self::Error> {
    let mut this = OptionalStringFilter::new();
    this.set_eq(value.take_eq().map(NestedIdWrapper::into_inner));
    this.set_not(value.take_not().map(NestedIdWrapper::into_inner));
    this.set_gt(value.take_gt().map(NestedIdWrapper::into_inner));
    this.set_gte(value.take_gte().map(NestedIdWrapper::into_inner));
    this.set_lt(value.take_lt().map(NestedIdWrapper::into_inner));
    this.set_contains(value.take_contains().map(NestedIdWrapper::into_inner));
    this.set_contains_nocase(
      value
        .take_contains_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_contains(value.take_not_contains().map(NestedIdWrapper::into_inner));
    this.set_not_contains_nocase(
      value
        .take_not_contains_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_starts_with(value.take_starts_with().map(NestedIdWrapper::into_inner));
    this.set_starts_with_nocase(
      value
        .take_starts_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_starts_with(
      value
        .take_not_starts_with()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_starts_with_nocase(
      value
        .take_not_starts_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_ends_with(value.take_ends_with().map(NestedIdWrapper::into_inner));
    this.set_ends_with_nocase(
      value
        .take_ends_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_not_ends_with(value.take_not_ends_with().map(NestedIdWrapper::into_inner));
    this.set_not_ends_with_nocase(
      value
        .take_not_ends_with_nocase()
        .map(NestedIdWrapper::into_inner),
    );
    this.set_in_(
      value
        .take_in_()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_not_in(
      value
        .take_not_in()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_null(value.take_null());
    Ok(this)
  }
}

impl<I> TryFrom<NestedIdFilter<NestedIdWrapper<I>>> for ByteaFilter<I> {
  type Error = async_graphql::Error;

  fn try_from(mut value: NestedIdFilter<NestedIdWrapper<I>>) -> Result<Self, Self::Error> {
    let mut this = ByteaFilter::new();
    this.set_eq(value.take_eq().map(NestedIdWrapper::into_inner));
    this.set_not(value.take_not().map(NestedIdWrapper::into_inner));
    this.set_gt(value.take_gt().map(NestedIdWrapper::into_inner));
    this.set_gte(value.take_gte().map(NestedIdWrapper::into_inner));
    this.set_lt(value.take_lt().map(NestedIdWrapper::into_inner));
    this.set_lte(value.take_lte().map(NestedIdWrapper::into_inner));
    this.set_contains(value.take_contains().map(NestedIdWrapper::into_inner));
    this.set_not_contains(value.take_not_contains().map(NestedIdWrapper::into_inner));
    this.set_in_(
      value
        .take_in_()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_not_in(
      value
        .take_not_in()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    Ok(this)
  }
}

impl<I> TryFrom<OptionalNestedIdFilter<NestedIdWrapper<I>>> for OptionalByteaFilter<I> {
  type Error = async_graphql::Error;

  fn try_from(mut value: OptionalNestedIdFilter<NestedIdWrapper<I>>) -> Result<Self, Self::Error> {
    let mut this = OptionalByteaFilter::new();
    this.set_eq(value.take_eq().map(NestedIdWrapper::into_inner));
    this.set_not(value.take_not().map(NestedIdWrapper::into_inner));
    this.set_gt(value.take_gt().map(NestedIdWrapper::into_inner));
    this.set_gte(value.take_gte().map(NestedIdWrapper::into_inner));
    this.set_lt(value.take_lt().map(NestedIdWrapper::into_inner));
    this.set_lte(value.take_lte().map(NestedIdWrapper::into_inner));
    this.set_contains(value.take_contains().map(NestedIdWrapper::into_inner));
    this.set_not_contains(value.take_not_contains().map(NestedIdWrapper::into_inner));
    this.set_in_(
      value
        .take_in_()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_not_in(
      value
        .take_not_in()
        .map(|vals| vals.into_iter().map(NestedIdWrapper::into_inner).collect()),
    );
    this.set_null(value.take_null());
    Ok(this)
  }
}