Indexing users for mentioning: Build a Forum with Inertia and Laravel

00:04

They can't be hardcoded and we don't want to load in every single user into an array within the front end. That will just have a massive performance impact. So what we want to do is ideally load all of our users into MeliSearch in a separate index with their username and the label that we want to see over here. So basically we want to end up

00:25

with an index with a label and a value which is searchable for every single user. That way what we can do is using mentionable hook into the event. So when we type we're actually sending a request to MeliSearch which is very very fast to search for our users. So let's not get ahead of ourselves. Let's first of all figure out how we're going to

00:47

index this data into MeliSearch. Now we could and our first thought might be to hop over to the user model and go ahead and do what we did on our discussion and go ahead and use searchable. Now we could do that but the only issue with this is we don't really want the user searchable. We might later on but ideally we'd want a completely separate index just for user mentions. That would

01:12

keep things really clean and also really secure. We don't want to really index all of our user data. So what we're actually going to do is we're going to create out an entirely new model because Laravel Scout deals with models. We can't very easily and very cleanly index our own data and create our own indexes. So let's go ahead and create a model called user mention. So what this

01:34

is going to do is practically use the same table. It's going to look exactly the same as the users table but by having a separate model here for Laravel Scout that's going to allow us to control how we add this data in. So with this we're going to go ahead and actually set the table here to users. Now the reason that we do that is because within Laravel if we have user mention

02:00

that's going to look for like a user underscore mention table or something similar. So we're basically just creating a user model. We could if you think extend the user but let's try and keep this as simple as possible. So we want to use the searchable trait in here because we want this to be searchable and much like our discussion we want to make sure that we only index certain data.

02:25

So let's go and first of all actually tell Laravel Scout how we want this to be indexed as in the index name. So for that we use the searchable as method. So let's say users mentions and let's choose the data and really importantly the structure that we want this to be searchable as. So to searchable array and let's go ahead and return. This time we will use an array because we

02:56

need to build this up slightly differently. For the value that's just going to be the user's username. That's the thing that gets searchable on the client side. The label can be whatever we want. So in this case let's say the user's name and then let's append on some parentheses. Inside of these parentheses let's have an at and then let's append on their username like so. So it's basically

03:23

look like what we had before like this. Let's get rid of that semicolon and we should now be able to run Scout on this and see this indexed. So let's go ahead and do that now. php artisan scout import app models and user mention and let's see what we get. Okay so over to MeliSearch click on this and there we go. So now we have pretty much the structure that we would expect

03:50

here and that we need for our mentionable functionality but now inside of MeliSearch. Now we are pretty much done but there's one issue here. Let's go over to my profile section here. Now my username at the moment is AlexGS. Let's just check who else we've got in here. Let's say I want to change my username to Alex. Now I'm going to go ahead and do that now. Save that out

04:15

and let's have a look. Well inside of here the old value is still hanging around which is not good because if I do change my username that's going to be shown everywhere on the forum and then when people go ahead and search for my username they're going to be a bit confused as to why this is different. So let's set that back to AlexGS and look at how we can

04:35

manually index the user, the specific user, when anything like that changes. So to do this we're going to use a model observer so when the user is updated we can actually change the username around. So let's go ahead and make an observer here and we'll call this user observer. There's a load of ways to observe eloquent events within Laravel. In fact we already did this once over on the

05:00

discussion where we looked for or checked for when a particular discussion is being created. So you could do this directly inside of your user table but I'm going to go ahead and just use an observer. I just find it easier to find these things. So let's open up the user observer and in here we just want to create out a method that corresponds to the name of the eloquent event.

05:25

For us that's going to be when this user is updated. So let's create out an updated event here. We'll get the user into this so we can do something with them and what we can do within Laravel Scout is we can manually index a specific record. Now the problem here is we're getting through a user and not a user mention so we can't say something like user and then the method we

05:49

want is searchable. That will trigger an index over to Mellaserch or whichever software that we're using for search but this is not the mention this is the user itself which as we know does not have a searchable trait. So what we'll actually need to do is over on the user model set up a relationship here that hooks up to the user mention which as we know is a completely separate

06:14

model but it uses the same table. So let's go ahead and create out a mention relationship here and let's go ahead and say that this has one user mention and it's hooked up only by the id because it's the same thing as the user it's just a separate model for Laravel Scout. So a user has a mention which basically represents their mention and now we can say user mention searchable and

06:45

that will now trigger a search or index for the user mention and it should update. So lastly we just need to hook up the observer that we've just created with our model and we can do that over in the event service provider. Again there are loads of different ways to do this but a really good way to do this I don't think it's here by default is to create out an observers

07:13

property in here and then what we can do is give the class name that we want to register observers for and there could be multiple and we give the fully qualified class name to the user observer. So now when the user gets updated we find the mention model and we make that searchable e.g. we update it in our index. Let's try this out by setting my username back to

07:40

Alex and let's head over and let's go down and there it is so it's been updated in our index. Great now the other issue we have which isn't immediately obvious is if we log out here and we register a new account so yeah we've got a little issue there with some authorization which we'll look at later but if we register a new account so let's go over here and let's say abc we'll just

08:08

keep this really simple. What's not going to happen is if we head over to our meta search index we're not going to have that in there. Why? Because we are creating a user not a user mention so what we also want to do is when a user is created we also want to manually create a record for their mention inside of that index. So let's try this one more time I'm going to go ahead and

08:41

log out head over to register def and let's go ahead and see and this should now that we've added that eloquent event in and we open up meta search we should see it in there great. So now when user's registered they automatically get put into that user mention index which we can then use to search on the client side and when they update their username that also gets updated as well.

Sign up to access "Build a Forum with Inertia and Laravel" right now.

Episodes

Transcript

Episode summary

Episode discussion