Introduce WhereParam::None

[teenjuna]

Note: I encountered this in the same code as #114

Sometimes filters are optional. In my code, I had an argument of type Option<bool>. If the argument is None or Some(false), I don't need to filter. If it's Some(true), I need to apply a specific filter. Here is how it looks:

// `arg` is Option<bool>
client
    .model()
    .find_many(match arg {
        Some(bool) if bool => {
            vec![model::WhereParam::Not(vec![model::number::equals(None)])]
        }
        _ => vec![],
    })
    .exec()
    .await?
    .into_iter()
    .map(Into::into)
    .collect()

It's kinda fine here. The real problem will occur when there are two such arguments, because I'll need to combine all possible cases, eg None, None, None, Some(true), None, Some(false) and six more. Of course, I could for Option<bool> I could use .unwrap_or(false) and save myself some headache. But the problem persists.

What will solve this is the WhereParam::None variant (name may be different). This variant will be just ignored by the filter system. The snippet could look like this:

.find_many(vec![if arg.unwrap_or(false) {
    model::WhereParam::Not(vec![model::number::equals(None)])
} else {
    model::WhereParam::None
}])

In case there are more arguments, they can be passed as another members of vec.

[Brendonovich]

I don't think it should be the responsibility of PCR to provide a None variant, this sounds like it could more easily be done with builtin Rust features.

// Assuming they're all Option<bool> args
let arg1 = Some(true);
let arg2 = Some(false);
let arg3 = None as Option<bool>;

// If each arg was an enum you could put all of them in a Vec and filter_map to turn each
// variant into an Option<WhereParam>
let arg1 = arg1.unwrap_or(false).then(|| not![model::arg1::equals(None));
let arg2 = arg2.unwrap_or(false).then(|| not![model::arg2::equals(None));
let arg3 = arg3.unwrap_or(false).then(|| not![model::arg3::equals(None));

client
    .model()
    // Will filter out any None values and use the value inside Some(..)
    .find_many(vec![arg1, arg2, arg3].into_iter().filter_map(|a| a).collect())
    .exec()
    .await;

Thinking about it more, model::None would just be a more specialized Option::None anyway.

[teenjuna]

Yeah, that actually makes more sense 😅 I totally forgot about .filter option