Creating our Database Migrations, Models, and Factories

In This Lesson

We'll work on structuring our database by defining our migrations, Lucid models, and model factories to aide in generating fake data we'll later index and search against with Meilisearch.

Created by: @tomgobich
Published: 11 months ago

Join the Discussion 0 comments

Be the first to comment!

Transcript

So let's go ahead and focus on getting our database set up next. So it's going to be our models, migrations, factories. So we'll stop our application, clear our terminal out.
And the very first thing that we actually need to do is finish out our user model. So whenever we ran our AdonisJS project creation, we were given a user model and then Jumpstart altered it
and added a couple more things on top of it. So what we want is a factory for our user model in addition to the model itself.
So what we want is a factory for our user model in addition to the model and migration that were already created for it. So instead of a terminal, we'll do node, ace, make, factory
and call it user there to create our user factory. The next thing that we want to do is create a model, migration, and factory for both our book and genre entities.
So we'll do node, ace, make, and we'll do model for our book and do hyphen m to create a migration for it, f to create a factory for it as well.
And then we're not doing any CRUD-based operations for these in this series, but if you were and you wanted to create a controller on top of it, you could also do C there as well.
Since we're not doing CRUD operations, we'll go ahead and leave that out here. So we'll hit enter there to create a model, migration, and factory for our book and we'll do node, ace, make, model for our genre
and do hyphen mf for that one as well. The last thing that we need is a migration to bind our book to a genre. And that is going to be a many-to-many relationship, so we need a pivot table to join them.
So we'll do node, ace, make, migration, book, underscore, genre, and hit enter to create that. The reason why we're doing book, underscore, genre
is to stick with AdonisJS's pivot table default naming convention. By default, AdonisJS will expect an underscore concatenation of the two entities we're binding with our pivot table in alphabetical order.
So our book would come first, followed by our genre. And then they're both going to be singular. Now, by default, something to watch for, the migration will create it as plural,
so we will want to alter that whenever we get to that step. Okay, let's go ahead and jump back into our text editor and we'll start with our migrations. So we'll jump into our database, migrations.
Again, as you'll see here, we already have one for our users and we're going to be searching based off of a full name string. So we're all set here as our user is already populated with that.
And then Jumpstart, in addition to making a few user model alterations, has also given us an email histories table, a password resets tokens table,
as well as the remember me tokens table. So we can go ahead and jump on down to our books migration because what we want to do is bind this first to our user
that's going to serve as our authors. So we'll do table integer user ID, make this unsigned and then have it reference so that we get a foreign key created for it.
The users table ID column, and then we'll make this not nullable. And then when deleted, so when our user is deleted,
we'll go ahead and have the book cascade delete along with it. In addition to that, we want a table string for the book's title. I'm going to go ahead and omit the column lengths off of all of these
just to simplify everything here a little bit further. And we'll make that not nullable. And then we'll do another string here with a blurb and a table dot.
Let's do this as a text for an excerpt, if I can spell it. There we go. The excerpt is going to be like the first chapter of the book and then the blurb is going to be about the book.
So like a summary. And then in addition to that, we can also do a timestamp for the book's publication date. So we'll do publish at there.
Okay, so that should be all that we need there for our book migration. Let's do our genres next. For this one, all we need is a string with a name and we can make that not nullable. And then in addition to that,
we now need to bind it to our books via our pivot table. So the first thing that we're going to want to do is, again, stick with the AdonisJS defaults.
So we'll switch that from plural to singular for our table name. So that is book underscore genre. And then we'll add in our book integer column.
So integer book underscore ID. Make that unsigned. References our books ID column. Make that not nullable.
And then we'll go ahead and cascade the deletion on this as well. Lastly, we need our integer for our genre ID. That too will be unsigned.
It's going to reference our genre's ID. Make that not nullable. And then we can go ahead and cascade that as well. As if the genre doesn't exist, then the book won't belong to that genre.
Now, it doesn't make sense for a book to belong to the same genre more than once. So in addition to our columns there, we can also add in a composite unique constraint
against our book ID and the genre ID to make sure that we don't get duplicates in this table. Perfect. Let's go ahead and run our migrations real quick just to make sure that we got everything right.
So node ace migration run. All right, perfect. Everything ran there A-OK. So we're good on that front. Our next step in this process is filling out our models.
As in order for us to fill out our factories, it's going to rely off of the types defined via the model. So we'll jump into our book first as we didn't need to add any columns
or alter any columns on our user. So we'll just need the relationship defined there. And for our book, we have an at column. We can declare this is a user ID of type number.
Then we have a column declare title of type string. Then we have another column declare blurb of type string or null.
And then we have a column declare. This is excerpt. I have a hard time saying and spelling that for some reason. And that is a string or null.
And then we have a column. And we can set that as a date time. Declare publish at as a lux and date time or null. Perfect.
While we're in here, let's go ahead and define our relationship. So we have our user relationship. So that is a belongs to. So import that from AdonisJS Lucid ORM
and use our user model for that relationship. Declare. And I'm going to call this user just to stick with our user ID name there even though it will serve as our author.
And then we'll do belongs to type of user. And then we'll get a red squiggly on that because that needs to be an import type. So we'll do command down on that squiggly and switch that to an import type.
All that did was add this type right there before the belongs to import in case you don't get that autocomplete option. In addition to that, we also have our many
to many relationship between our book and its genre. So we'll declare genres as a many to many type of genre.
And our book model should now be all set. Perfect. Let's now move on to our genre. So for this one, we just have a column declare name of type string.
And then this one too has a many to many relationship to our book model.
Declare that as books many to many type of book. Okay.
And then again, we need to command dot on that to switch that import to a type import. Perfect. Lastly, let's do our relationship for our user.
Command dot there to fix up all of those spacing issues. And I'm going to put this before the methods.
So just after our columns, Jumpstart added some methods onto this user model for authentication. So we'll declare this as has many and has many books.
So we'll use our book model there. Declare books as type has many type of book.
And then again, command dot to switch that to an import type. Perfect. So our relationships are all set up now as well as all of our column properties.
So we're ready to move on to our factories. So for our book, what we want to do is within the return object here,
define the same columns that we have defined on our model that we want filled out with fake data from our factory. So that would be like our title.
And for that, we can use Faker, which is provided to us via the callback. So Faker dot, and we should have book as an entity type.
And we can reach for title to create a fake title for our book. Now, there's no like blurb option within Faker for books.
If we go to Faker book dot, you'll see that we have author, format, genre, publisher, series, and title.
But we can still kind of get like a blurb like thing by using commerce. And then there is this product description. Technically, a book is a product, right?
So it still kind of fits. And then for our excerpt, we have just lorem.
That would make the most sense there as nothing within Faker is going to give us a full first paragraph of a book. So let's do paragraphs here and stub it with two paragraphs worth.
It's a very short chapter, but yeah, it'll do. And then for our publish at, there is Faker dot date. And then we can just set this to sometime in the past.
But there's plenty of other options if you want to include future dated books as well within your data set. But I'm just going to use past here and we will get a red squiggly on this. Actually, the red squiggly is coming up here.
But the same thing is true. It's because it's trying to assign a date to our date time. So we want to convert this to a Luxon date time.
So we'll import Luxon there and do from JS date and pass the Faker date through that.
So that it's converted to a Luxon date time to fit with our type within our book model. While we're here, we can also go ahead and set up our relationships since the factories do exist.
So we'll do relation user, provide a callback in that returns back our user factory. And this also has a relation to the genres and we'll provide it our genre factory for that. Perfect.
So now we're done with our book factory there. Move on to our genre next. This one will be short and sweet. Just have a name, Faker dot book. And then we saw previously we have a genre option there.
And then this one has one relationship to its books. So we'll just return a callback using that book factory for that. So whenever we create a relationship through the factory,
it's going to use the factory provided via the callback to actually create the instance of the related book. Lastly, we have our user factory here.
So we will return the full name, Faker dot person dot. And there should be a full name option in there. Then we have the user's email.
So we can use Faker dot internet dot. And there should be an email option within there. And then lastly, we have the user's password.
Now for this, I'd recommend not using Faker because it's actually going to use a fake value to populate the user's password.
And there's going to be no way for us to get that password back beyond resetting the password for the account.
Since we're just on local here, it makes sense to just give ourselves some known password that we can easily enter in case we need to enter in a preexisting user's account.
So we're just going to make all of our user's passwords something. So now anytime that we enter in a user's email, their password's always going to be something.
And then our user model, whenever this Faker creates it, is going to secure it inside of our database so that it doesn't actually read as something for us.

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.