Understanding relationships in Laravel (in migrations and in its Eloquent ORM)

1) Should the relationships between tables be done both at the migration level (as I have done) and at the model level (in my case I have an empty model)?

The migration relationships help at the database level, don't forget that the database is very independent of what happens in php ( laravel), for example when trying to eliminate a tuple that has dependent tuples thanks to a foreign key, the database will inform us that this tuple cannot be eliminated until it has no more dependents.

Making the relationship at the model level is to be handled in laravel(php), which as I said is independent of the database and these relationships make queries with Eloquent easier to do, what's more, it is not necessary to know sql to make inquiries.

So the answer is: In neither of the two is it mandatory, in the migrations it would be so that your database remains as complete as possible and in the models so that at the time of development your life is easier. ;)

2)If the answer is yes, would I have to put something like this in my models? :

 public function comments()
{
    return $this->hasMany('App\Comment');
}

Answer: There are several methods to perform the relationships:

One To One
One To Many
One To Many (Inverse)
Many To Many
Defining Custom Intermediate Table Models
Has One Through
Has Many Through

So I invite you to read the Laravel documentation since they are explained in detail there and I don't think I can do better than that.

3) Why should it be in a function and what is the meaning of the name?

Depending on the relationship that exists between models: If 1 World has N Classes, its inverse would be: 1 Class belongs to 1 World, Then in your models you would have something like this:

class Mundo extends Model
{
    public function clases() {
       return $this->hasMany(Clase::class); // has many = tiene muchos(as)
       //si lo leemos diria algo asi: 1 Mundo tiene muchas clases
    }
}
class Clase extends Model
{
    public function mundo() {
        return $this->belongsTo(Mundo::class);  //belongs To= pertenece a
       //si lo leemos diria algo asi: 1 clase pertenece a 1 mundo
    }
}

You see the simplicity of the subject.

Access and use:

$clase='media';
$mundos=App\Mundo::with(["clases"=>function($query)use($clase){
    $query->where("descripcion",'like','%'.$clase.'%');
}])->where("nombre","ABC")->get();
//Como la relacion es de una a muchos, `clases es un array y es necesario recorrerlos por un foreach`
foreach($mundos as $mundo){
    dump($mundo->nombre);
    foreach($mundo->clases as $clase){
        dump($clase->nombre);
    }
}

$clases=App\Clase::with("mundo")->get();
//Como la relación es de una a una, `mundo es un objeto y se acede como tal`
foreach($clases as $clase){
    dump($clase->mundo->nombre);
    // lo interesante es que puedes acceder a los hermanos de esa clase con:
    dump($clase->mundo->clases);//este deberia se un array
}

4) Is it bad to make a relationship at the migration level but not at the model level? I don't understand the need to do it twice(Migration and model)

I think I've already explained everything and doing it twice isn't necessary, but if you don't want to have problems with your progress or with the system itself, I recommend that you keep doing it that way.

To begin with, you say that:

1 World has N Classes and on the other hand 1 World has N Races

Well, in the World model you should have the relation to Classes and to Races. In the Classes model you should have the relationship with respect to World and in the Races model, with respect to World.

But, before defining these relationships in the models, you must be clear about what type of relationship it is because everything has its counterpart, whether the relationship is one to one, one to many or many to many.

Example:

Yes:

1 World has N Classes

A) If a Class belongs to a single World, it would be in a one-to-many relationship.

B) If a Class belonged to many Worlds, you would be in a many-to-many relationship.

Example, if it were the case of option (A):

For a one-to-many relationship,

The Mundo model should have:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Mundo extends Model
{
    public function razas() {
       return $this->hasMany(Raza::class);  
    }

}

The counterpart for the Race model, in a one-to-many relationship, would be:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Raza extends Model
{
    public function mundo() {
       return $this->belongsTo(Mundo::class);  
    }

}

Note the singular or plural of the function names, that is important. Since as 1 World has many Races, the eloquent query that you will use to know the classes that correspond to the World with id = 1, would be simply:

Mundo::find(1)->clases; 

Regarding migrations:

For this type of relationship (one to many), in this case, the breeds table must have:

$table->integer('mundo_id')->unsigned();

The field has to be named, name of the model of its counterpart (world) concatenated with "_id".

I think it's good practice, as you've done, to define your foreign keys in migrations, although you could also specify them in model functions.