Welcome back.

We created our models using the php artisan make:model command

with the handy-m flag to create both a model and migration at the same time.

Next, we're going to connect our tables to our models using the Eloquent

relationships for our authors and books inside of the app directory.

For example, if an author has several books, then using Eloquent

relationship allows us to display all of the books by a specific author.

Let's get started.

First, let's navigate to the app directory and open the authors'.php model and

assign a variable using the protected access modifier like this.

This command is not necessary because Laravel automatically makes a connection

from the plural authors' table to the singular author model.

The reason we're using this command is to be explicit about what is happening here.

Otherwise, they would be, well, invisible.

So let's keep it for clarity's sake.

Next, let's define the relationship between authors and books like this.

When we add the public function, Laravel looks at the model defining the migration

and notices that we have an author_id column inside of the database table.

Laravel then makes the connection that $this author, singular, has many books.

Assuming that the author has more than one book, of course.

You may be asking yourself, if defining authors is optional.

Why are we covering this?

Which is a great question.

Imagine we have a database that was pre-built for

us without using this best practice.

In such a case, we would need to be explicit and

define the relationship using the foreign key and local key in your application.

Since we're building the database using best practices,

we can keep our code minimal.

To learn more about foreign keys and local keys, check out the teacher's notes below.

Next, let's define the book model and follow the same best practices.

As we discussed, we don't need to define the dollar table as

books because it's the plural of the book model.

But I like to be explicit when building models.

So let's use protected $table = 'books' like we did in the author model.

The same explicit relationship applies to the inverse relation of books

that belong to authors.

Remember, the book model will look for

an ID that belongs to author which is defined in the table as author_id.

Now that our relationships are defined, let's head over to our author and

book models to add the final touches by specifying which fields are changeable.

Protected access modifier fields,

by default are protected from mass assignment.

But we can assign columns that we want to change or

define as fillable such as name, title, company and email.

It's also worth mentioning that we wouldn't want to

use protected $fillable for

users with passwords because we wouldn't typically want to mass assign passwords.

Instead, we would enter them individually.

We could use $hidden to hide fields from displaying a password in the API response,

which we won't use in this course, but it's important to keep in mind.

Next, let's head over to the author.php file and add the name, title,

company and email, so we can specify them as fillable inside of an array like this

Notice that I didn't include ID.

Including ID as fillable would cause errors for

the consumer of the API because Laravel automatically assigns an ID for us.

Finally, let's head

over to the book model and

add $fillable

fields like this.

Sweet, we can now mass assign books and

authors columns in our database tables connected to our models.

Nice job, our Eloquent relationships are defined as specific

column fields, which is to say they're changeable.

To learn more about mass assignment, protected $fillable, and

how to avoid duplicate unique IDs, check the teacher’s notes below.

In the next section, we'll dive into factories and cedars to quickly add

test data for application using the powerful Faker library.

See you there.