Indexing products in Meilisearch: Build an E-Commerce Platform

00:05

You don't necessarily have to use MeliSearch, you could use something else if you wanted to, but it makes a little bit more sense because it's free, it's open source, we can go ahead and just start to work with it very easily. So Laravel Scout will assist, it will be the kind of middle of our search engine and our app, so we can get everything indexed exactly as we need it,

00:25

and we can pull it out as well. So if you haven't worked with Laravel Scout before, let's go through over to the introduction and the installation section and let's pull it in and just start to play around with it. So I'm going to go ahead and install that and let's go down and publish our config file in case we need to tweak that. And then the only other thing

00:45

we really need to do is just add the searchable trait to any of the models that we want to be indexed. In our case that's just our product, so let's come up to the top of our product and go ahead and use the searchable trait in here and make sure we pull that in. Again, we might need to just re-index our workspace, so let's do that. Okay, so that's pulled in.

01:04

Now, technically, we can go ahead and just start to index stuff. Of course, we need to think about the driver prerequisites, so we need to actually make sure that we have the MeliSearchPHP library pulled in. So let's go ahead and do that and then just before we start to index, we'll talk about running MeliSearch and what we need to do. So we've gone ahead and pulled in the MeliSearchPHP

01:24

library. Now, what we need to do is just switch over the Scout driver, set the MeliSearch host, and the MeliSearch key. Now, these are going to be exactly what we need, so let's go ahead and just copy them over to our EMV file just for now, and let's just check if we don't have anything to do with Scout in here at the moment, which we don't, so we can just pop them at the bottom.

01:43

Okay, so let's talk about MeliSearch. I already have this installed on my system, and if you don't, it really depends on which operating system you're working with. If you are working with Mac, then you can just do brew install and MeliSearch, and that will go ahead and install that for you, and what we're going to do is directly within the root of our project,

02:03

not that it really matters, we're just going to go ahead and once we have this installed, run MeliSearch. Now, what that's going to do is it's going to set up a local MeliSearch installation for you, which doesn't technically have any kind of security because as you can see here, we've got no master key found. The server will accept unidentified requests. We're going to

02:22

have to leave this running. That's our MeliSearch server listening, and you can see it's listening on local 7700, which if we head over to here is exactly the MeliSearch host that we're working with, and the MeliSearch master key just doesn't really matter at the moment. So that's MeliSearch running. Now, a really good thing about MeliSearch is we can actually open this up locally, so you

02:45

can see here that we're now technically inside of our MeliSearch server, and we can select an index here and start to look through. We can start to search for results. At the moment though, obviously nothing has been indexed, so our goal is to go ahead and index our products and see them in MeliSearch. So let's look at the very basics of this first of all. So I'm going to go ahead and

03:06

pull up my console, and I'm going to run php artisan scout import. That's going to be a new artisan command that is registered, and we're going to go ahead and choose the model that we want to import, which as we know is app models and product. So let's run this and just see what happens. Okay, so we've got imported models up to id of one. That is of course because over in our

03:27

database we only have one product. We'll check some more out in a second, but if we just head over to MeliSearch now, you can see that sure enough all of them details have now been indexed into MeliSearch, and we can start to query on these. We can start to add facets, any of the more advanced stuff that we're going to be doing in this course. So that's all of the details for

03:48

our product indexed into MeliSearch, but we really want to start to control the type of data that we are indexing. We might for example want to include a formatted price. We're not actually going to do that because we're going to be plucking out the details slightly differently, but let's look at how we can actually start to customize what data gets sent into MeliSearch. So under our product

04:11

model, let's go up to, well we can just put this at the bottom, it doesn't really matter too much. We're going to go ahead and start to customize this now. So to do this we're going to go ahead and create out a method called toSearchableArray, which Laravel Scout is going to call in order to get the data that you want to send through to either MeliSearch or any other service that

04:34

it supports. And really all you need to do here is just return, as the method name suggests, an array with the data that you want to see. And because we're directly within the model, we can just say something like this ID for example. So let's say that we just wanted to index the ID of our product. Obviously we're not going to do that, but we can just about get away

04:52

with that. Now if you want to go ahead and flush all of the records for a particular model out of Scout, you can run flush. It's a good idea to do that before you go ahead and re-import this if you've made any changes. So let's go ahead and say Scout import, and just pull app models and product back in there. And let's just redo that again, come over and give that a refresh, and

05:13

there we go. We've got a record in here, but we just have an ID of one. So not the most useful. So what we're going to do is control this data, think about the kind of data that we want to import. We're going to make this a lot more advanced later because we're going to need to get all of the variation types that we can create faceting on which will allow us to implement

05:32

our filters. But for now let's just fill out some really simple information here just so we don't overload this. So let's say the title, that's pretty important, the slug. So let's go ahead and pull that slug in, and that's pretty much it because when we are grabbing these records out, we're actually going to be redoing a database lookup by the ID. So let's say that if someone

05:53

searches for Nike and they get product ID 11015 back, we're going to take this array and we're going to do something like product find and then we're going to pass that array in to re-get out a collection of products which we can then iterate through. And that means that we'll have all of our relationships in there already, slightly slower because we're going to be performing an additional

06:14

database query, but to be honest the convenience is worth the extra query. If none of that makes sense at the moment, don't worry, we'll get to that a little bit later. The reason that we're including the title and potentially the slug is because we need some sort of data in here so a user can search for something. For example, if they search Nike and we only have the ID index,

06:35

they're not going to get any results back because nothing inside of this store is going to have the word Nike in it. Okay, so let's go ahead and include the price as well because eventually we're going to implement our price filter which is really important. So we really need the price in here and we'll also go ahead and index the category IDs as well so we can filter on those

06:59

as well. So if we look inside of here we don't actually have a categories method, so let's go ahead and add that in really quickly now. I'm just going to sort of pop these anywhere, so let's say categories and we're going to say this belongs to many because we have a belongs to many relationship and category class. There we go. So now we're going to say this categories and what we want

07:25

to do is grab the collection back but only pluck out the ID of this. So this will give us back like one two three and then we can use that to filter based on the category that we've chosen. Okay, so now that we've got that in there let's just go ahead and rerun flush and import and it looks like we've got an error. So let's go ahead and check out what we've got here. Okay, so category

07:46

product does not exist. Let's just head over to our category model really quickly and yeah it doesn't look like we've got that hooked up. Well, we should have and yeah we didn't actually hook this up. So let's go ahead and leave that for the next episode then because that's probably going to be a little bit longer. Let's get rid of the category IDs for now and let's just re-import

08:09

those. Come over and there we go. So we've got the basic information about this product. We've got a searchable title and slug which is really important. We've got a price for filtering and as we've discovered in this episode we don't have a category product hooked up. So let's go over to the next episode create that out and then we can come back to this a little bit later.

Sign up to access "Build an E-Commerce Platform" right now.

Episodes

Transcript

Episode summary

Episode discussion