Creating A Meilisearch Service to Initialize Admin & Search Instances

In This Lesson

We'll create a singleton Meilisearch service to simplify operations against our Meilisearch database by allowing us to specify whether we want to simply search or perform an admin authorized operation.

Created by: @tomgobich
Published: 11 months ago

Join the Discussion 0 comments

Be the first to comment!

Transcript

ready to index that data inside of our Milysearch database so that we can search against it as documents. Now, we've been talking about indexes and documents thus far, but we haven't really
explained the difference between the two. Indexes are like collections of documents. It's our tables, essentially.
And then the documents itself are the rows that we'll search against. So the documents are the actual data that we'll get back as our search results.
Indexes are the buckets we're going to be searching within. And after we're done with our command here, we'll actually get to see that within Milysearch's UI dashboard to drive home the difference there a little bit further.
So without further ado, let's go ahead and do node ace make command, and we'll call this command Milysearch underscore index. Hit enter to create that.
And now if we do node ace, this will list out all of our ace commands. We should see this Milysearch section with a Milysearch colon index command.
Right now, if we were to run that, so node ace Milysearch index, all it's going to do is print out a hello world message. So we need to fill out what we want that command to do yet.
Before we do that, however, let's go ahead and also make a service. So node ace make service, and we'll just call this search.
We'll set up this simple service to be able to perform search and administrative search operations against Milysearch. To aid ourselves with that, there's also a Milysearch JavaScript package that kind of
gives us an SDK to integrate with the Milysearch API that we have running inside of our terminal.
So we can do npm i and install the Milysearch package there inside of our project. Perfect. I'm going to go ahead and clear that out. We don't want to run our server quite yet.
Let's next jump over into our text editor, and we should see two new folders. We have a services folder within our app directory, and we now have a commands folder within the root of our project.
If we take a look real quick at that command, we'll see that it just simply logs out that message that we saw whenever we ran it. Before we complete this command, though, let's first fill out our service so that we actually
have something to integrate with that Milysearch package that we've installed. So we're going to treat this as a singleton here. So when we're done with it, what we're going to do is go ahead and create a new instance of it inside of this file.
So do const search equals new search service, and then we'll go ahead and export default search so that we have a name given so that we can easily import this elsewhere just by
using and referencing search. This search service is going to house instances of the Milysearch package that we've installed.
So let's go ahead and import Milysearch from Milysearch, and let's define two different types. We'll type these out as our search key.
We're going to have one as a literal search and another as admin. These will be the two different instances that we're going to house inside of our search service.
Admin will be for administrative operations like managing our indexed data and documents, and then search will be for actually performing search operations against that data.
As you might have assumed, our admin instance is going to connect using our administrative key, and then our search instance is going to connect using our search key that we've set up here inside of our project.
So we'll just set up a private instances map inside of our search service instance, and the key here is going to be our search key, and the value is going to be an instance of
Milysearch, and we'll set this up as a new map. And we'll make this similar to other AdonisJS packages.
So we'll have a use method that accepts in a key that is one of our two search keys.
We'll have this default to the lesser privileged search key if it is omitted. When we call this use method, what we want to do is check to see whether or not our instances,
so we'll reach through our instances there, has the key that we're after. So if it has an instance already created, then we just want to go ahead and return that
instance by getting it out of our map. If our instances map does not have that key yet, then what we want to do is initialize it.
So we'll create a new private method called init that accepts in the key that we want
to create as our search key, and then we need to grab the Milysearch API key out of our environment variables. So first, we'll go ahead and check to see whether or not the key that we're after is
our admin key. If it is, then we'll reach through our environment variables and import that from our startenv to get the Milysearch admin key.
Otherwise, we'll go ahead and reach through to get our search key. Great. Once we have our API key, what we then want to do is create a new instance of Milysearch.
So we'll do const, just call this instance equals new, and reach through to Milysearch there. And we need to provide this, our host URL that our Milysearch server there is running
at, and that's that localhost 7700 that we've seen in previous lessons that we've set up inside of our environment variables as Milysearch host.
And then we also need to pass through our API key to authorize any requests that we make with this instance.
Once we have that instance, we can go ahead and add it into our instances.
So we'll set the key as instance, and then we can return the instance back so that we can use it directly.
Down inside of our use method now, all that we need to do is return this init and pass that key in to finish this service out.
So we'll be able to use this service as such. So we've created our new search instance right there that will serve as a singleton by exporting an instance from this file directly.
We can reach through to search, and then we have our one public use method that then allows us to specify whether we want to perform an administrative operation or a search operation.
If we do admin, then we have access to an authorized instance to perform any administrative tasks.
If we use search, we have the same list of methods available, but we're only going to be authorized to perform search-based operations.
So now that we have our service ready, we can jump into our command to start indexing our data.

Building A Multi-Search with Meilisearch & AdonisJS

12 Lessons

1h 38m

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.