Laravel - Seeding Many-to-Many Relationship

Populating Many-to-Many Relationships with Laravel Seeding

In this post, we'll discuss how to populate a many-to-many relationship between two tables when seeding data in your Laravel project. We will focus on the example of seeding users and roles with their corresponding junction table, role_user. To start, let's first create the necessary models for users and roles: For your User model, add the following code to implement many-to-many relationships with roles and other entities:

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    public function roles()
    {
        return $this->belongsToMany('App\Role');
    }
}

Similarly, create the Role model:

namespace App;

use Illuminate\Database\Eloquent\Model;

class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany('App\User');
    }
}

Now that we have our models in place, let's create the related factory files to populate them during seeding: For your User model, add the following code in the Factory file:

$factory->define(App\User::class, function (Faker\Generator $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => $password ?: $password = bcrypt('secret'),
    ];
});

Similarly, for your Role model, add the following code in the Factory file:

$factory->define(App\Role::class, function (Faker\Generator $faker) {
    return [
        'role' => $faker->realText($maxNbChars = 2),
        'description' => $faker->realText($maxNbChars = 20),
    ];
});

For the seed file, we need to set up the relationship between users and roles. Since there is a junction table (role_user) that connects both tables, we won't have a direct association. Let's create two loops to assign each user with a random role and assign roles to users:

public function run()
{
    factory(App\User::class, 50)->create()->each(function ($u) {
        $u->roles()->save(factory(App\Role::class)->make());
    });

    factory(App\Role::class, 20)->create()->each(function ($u) {
        $u->users()->save(factory(App\User::class)->make());
    });
}

In this code, we first create 50 users and assign them a randomly chosen role by creating the relationships. Then, we create 20 roles and associate them with various users. This approach ensures that each user can be associated with multiple roles and vice versa. Now that you have your seeding set up correctly to populate both tables, let's run the commands:

php artisan migrate:refresh --seed

This command will first refresh the database, dropping all existing table data and running the migrations again. After refreshing, it will proceed to seed your tables with the provided factory data, establishing a many-to-many relationship between the users and roles tables through their junction table (role_user). And that's how you can easily populate a many-to-many relationship in Laravel using its built-in features. If any issues arise, feel free to consult the Laravel documentation or reach out to our team at https://laravelcompany.com for support.