Filtering by a Number or Array of Numbers

In This Lesson

We'll implement our number filtering system in which we'll allow our search APIs to accept a single number or an array of numbers to filter the data by. To validate this, we'll use the union rule from VineJS.

Created by: @tomgobich
Published: 1 year ago

Join the Discussion 0 comments

Be the first to comment!

Transcript

Just like we did with our string filter here, we want to add in an additional filter option within our app filters folder. So, new file on that.
And we'll call this file number_filter.ts. Just as we did with our string filter, we'll start with our roles.
So, we'll do number filter equals vine and import vine there using tab. And we're going to set this to a union. And this one's going to be a little bit more straightforward.
So, again, we're going to have a vine union if with a condition check for our value.
If the value is an array, so we can use array is array to check that.
Then we want to apply the validation rule vine array where each array member should be a number. So, we'll do vine number passed into vine array there.
If the value passed in is not an array, then we want to do vine union dot else. And assert that the values type should be a straight number. That is optional.
So, it can also be undefined. So, we're either going to get back an array of numbers or just a single number here for our number filter.
Just as we did with our string filter, let's go ahead and package this into a class called number_filter. And let's do our static get for our rule.
And we'll return back our number filter. And then we'll have our static build method.
Again, we need our generic of type T that extends a lucid model type from AdonisJS lucid types model.
And we want to accept in the query builder of type model query builder contract passing our T generic into it.
And then we want to accept in the column name for our where statement of type string. And the filter value that we can infer from our validation rule.
So, type of number filter for that. And if we check the type for our filter here, it should either be number, number array, or undefined. Perfect.
For our build to actually apply these in, again, let's just eliminate undefined out of the equation by doing a conditional to check and see if we don't have a filter value.
And if we don't, then we just return back. Otherwise, we can check to see if the type of our filter equals a number.
Then we go ahead and return query.where our column name equals the filter number passed in. And then lastly, that leaves our array of numbers.
So, we can do query. and rather than doing a where, we can do a where in that accepts as the first argument, the column that we want to provide the in statement against.
So, that would be our column name still. And then the array of values that we want to check against, which would again be our filter.
So, this one will accept in just a set value. So, maybe something like four. And this one will accept in an array of values that might be something like three or four.
For this one, we'll get back courses that have a status ID, difficulty ID, whatever that column name is, value of just four.
For this one, we'll get back status ID, difficulty ID, again, whatever that column name is, that match either three or four.
This union rule matches this one, and this union rule matches this one.
Since this is optional, we are also supporting that via our if not filter value return statement there as well.
All right, let's give that a save and apply these to, let's start with our validation rules.
So, we have our status ID, difficulty and access level IDs that all need to use our number filter and its rule.
So, we can apply that in there and replace all three of those with our number filter rule. All right, that looks good.
Let's give that a save, jump back over now into our search courses action so that we can apply these into our apply filter function.
So, it's going to look relatively similar to our string filter here.
We just need to do number filter dot build, pass the query in, search for, let's do our status ID first, filters dot status ID.
Then we'll have number filter build query difficulty ID, and we can do filters dot difficulty ID there.
And lastly, we have our access level. So, query access level ID, filters dot access level ID.
And now that we have those applied, we can get rid of all three of those ifs, give it a save, and let's jump back over into Hopscotch. Again, let's just test to make sure that nothing works here.
So, we're A-OK there. Next, let's try with a status ID of two, send that off. And it looks like I got a typo there.
We got a C instead of an S on status ID. So, let's go find where I accidentally did that. Right here. All right, cool. First spot we looked. Got that updated. Let's try that one more time. Okay, cool. There we go.
We get back one result now with a status ID of two, which is my first course. Switch that to three, and we get back 12.
So, if we do an array with two and three, we should get back 13, which we do indeed.
If we switch this to an array with just one value, that should behave the exact same as just providing that value straight, giving us back just one. So, awesome.
Now, we go through and test all of the combinations of all three, our status ID, difficulty, and status ID. But since they all behave and are applied similarly, I'm going to go ahead and assume that we are A-OK there.
What if we apply an ID that does not exist? So, I'm going to do just 10,000 there. Pretty much certain that that does not exist. We get back an empty array.
Again, not a validation error because we are not asserting that these actually exist inside of our database. What if we return back a string as our status ID?
For that, it's treating it as undefined because it's an empty string. If we add a test value into that, though, we get back our validation error that it must be number.
If for any reason, and this applies to the string one as well, you want this validation rule to say anything different than this,
maybe we want this to say status ID field must be a number or array of numbers or omitted, we could do that as well. So, let's jump back into our text editor, back into our number filter.
And off of our union, we can add an additional call to otherwise.
And this accepts in a callback function that will be called whenever the conditionals within our union array all return back falsy.
Since we have an else, though, that means that it will always capture it and will never result in our otherwise being called, which we'll fix here momentarily.
So, we can do underscore and we can get back the field information from this. The underscore that we've applied here is just the value that we're trying to validate against.
We don't need to use that to alter the error rule here. So, I'm just calling that underscore.
And what we can do is if our value does not match either one of these rules, then we can use our field context to report an error.
And the first argument to this is our error message. So, we could say something like field name, which in our case would be status ID with our test over in Hopscotch.
So, status ID must be a number, array of numbers or omitted. Then we want to give the rule name.
So, this could just be a generic name for this number filter rule. So, something like array of numbers or number optional.
And then we need to pass in the field context information as well. So, we can give that a save.
And now, if our union is not satisfied by the value provided, this otherwise will be called, reporting our custom error.
We're not quite done yet, but let's stop and see exactly what we get with this currently. Because right now, within our union, we're kind of satisfying both conditions.
It either needs to be an array or with our else, it needs to be a number or optional. So, technically, we're never going to fall back to this otherwise.
And then we can verify that by jumping back in our Hopscotch, sending it off one more time, and we still get our same validation error. Because our else is applied asserting that it should either be a number or undefined.
So, what we need to do is switch our else to another if to do an else if here. We can type the value in, and then we can check to see if we don't have a value,
or if the type of our value equals a number to satisfy the rule that we're applying there, type number or optional.
Now, we have a fallback where if we're providing in a string value, neither one of these if statements are going to be true, which will result in our otherwise being matched and utilized.
So, if we give that a save, jump back in the Hopscotch, send this off one more time, now we're getting our custom error status ID must be a number, array of numbers,
and we're committed with our custom rule and the field information there. Cool. So, now we have our advanced number filter set up as well,
allowing us to send either just a plain number or an array of numbers, and we also have a custom fallback error message as well if neither of those are met.

Adding an API to an AdonisJS Web App

43 Lessons

5h 31m

Introduction

API Authentication

Getting Started with APIs

Organization Resources

Courses

Searching

Rate Limiting

Rate Limiting an Organization's HTTP Requests

13m 59s

Stop losing your best ideas!

Use our integrated note feature to capture and organize your key insights. Take a note at any timestamp and jump instantly back to that moment in the video with a single click.