No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Introducción a Laravel 6

Curso de Introducción a Laravel 6

Profesor Italo Morales F

Profesor Italo Morales F

Relaciones de tablas

14/37
Recursos

Aportes 44

Preguntas 10

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Relaciones de tablas


Para crear una relación con una tabla externa tendremos que escribir el siguiente dentro de la clase de la tabla en el método up()

// Para que asegurar que el dato siempre sea positivo
$table->unsignedBigInteger('user_id');

// Para crear llaves foraneas y unirse a la siguiente la tabla externa 
$table->foreign('user_id')->references('id')->on('users');

Así quedaría el código:

public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();

            $table->unsignedBigInteger('user_id');
            $table->string('title');

            $table->foreign('user_id')->references('id')->on('users');

            $table->timestamps();
        });
    }

Ahora nos toca refrescar las tablas, para eso vamos a utilizar el siguiente comando:

php artisan migrate:refresh --seed

💚 Si les sale este error:

Illuminate\Database\QueryException 

  SQLSTATE[23000]: Integrity constraint violation: 1451 Cannot delete or update a parent row: a foreign key constraint fails (SQL: drop table if exists `users`)

Tendrás que proceder poner en la tabla que estás creado una relación el siguiente código dentro del método down()

public function down()
    {
        // El siguiente código:
        Schema::dropIfExists('posts');
        Schema::dropIfExists('users');
    }

😋 Este error sucede porque para crear de nuevo las tablas, Laravel necesita que primero se borre la tabla hijo antes de borrar la tabla padre. La tabla hijo en este caso sería posts perp como Laravel primero va ha leer la tabla padre debemos poner esta sentencia en esta tabla.

  • rand($min, $max) → Es una función que genera aleatoriamente un número dentro de los dos parámetros que le damos.

En Laravel 8x, para crear semillas de datos que van ser ejecutados por php artisan migration, tenemos que escribir la sentencia así:

public function run()
    {
        \App\Models\User::factory(4)->create();
        \App\Models\Post::factory(12)->create();
        // factory(App\Models\User::class, 3)->create();
        // factory(App\Models\Post::class, 12)->create();
    }

💢 Recuerda que la configuración que hicimos con las migraciones solamente afectaron a la Database, no a nuestro modelo.

Tenemos que ir a los archivos de los modelos de las tablas y especificar que hicimos la relación entre esas tablas, vamos a su clase y creamos el siguiente método:

// User.php => Aquí dejaremos una sentencia que significa que
// un usuario tiene muchos posts
public function posts()
{
    return $this->hasMany(Post::class);
}

// Post.php => Aquí dejaremos una sentencia que significa que
// un post le pertence a un usuario.
public function user()
{
    return $this->belongsTo(User::class);
}

Aquí hay más información de** todas las relaciones posibles **usando **Eloquent **

https://laravel.com/docs/7.x/eloquent-relationships

  • Relaciones de tablas: trabajaremos sobre el ejemplo creado anteriormente, para ello tenemos que hacer las siguientes modificaciones:

    • En el archivo que se encuentra en la carpeta de migration y que hace referencia a posts añadimos lo siguiente:
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');  //AGREGAMOS ESTE CAMPO PARA NUESTRA LLAVE FORÁNEA
            $table->string('title');
            /*AQUI AGREGAMOS LA DECLARACIÓN DE LA LLAVE 			
            FORNEA  (user_id) es el campo de mi tabla, id el campo de la tabla donde quiero hacer referencia mi llave foranea y  users es la tabla */
            $table->foreign('user_id')->references('id')->on('users');  
            $table->timestamps();
        });
    }
    

    AQUÍ AÑADIMOS UN NUEVO CAMPO AL MODELO DE MIGRACIÓN DE NUESTRA TABLA POST

    • Ahora en el archivo que se encuentra dentro de nuestra carpeta factoriesañadimos lo siguiente al archivo PostFactory.php
    $factory->define(Post::class, function (Faker $faker) {
        return [
            'user_id' => rand(1,4), //AÑADIMOS EL CAMPO DE NUESTRA LLAVE FORANEA Y AGREGAMOS LA FUNCION RAND (el cual nos permite generar numeros random que va del 1 al 4)
            'title'=> $faker->sentence
        ];
    });
    
    • Ahora como hicimos modificaciones en nuestro archivo de migración tenemos que reflejarlo en la base de datos, para ello ejecutamos el comando:
    php artisan migrate:refresh
    

    ejecutar este comando tiene un inconveniente, el cual radica en que si teníamos registros en nuestra base de datos estos se borraran. Para evitar esto tenemos que configurar lo siguiente:

    • Para evitar que se borren nuestro registros al ingresar el comando anterior configuramos unas semilla( dentro de la carpeta seeds).

    seeds>DatabaseSeeder.php

    //configuración inicial semilla
    public function run()
    {
        // $this->call(UserSeeder::class);
        factory(App\User::class,4)->create();
        factory(App\Post::class,30)->create();
    }
    
    • Ahora podemos ejecutar nuevamente el comando para refrescar nuestra base de datos con nuestros cambios, pero debemos agregar una opción más:
    php artisan migrate:refresh --seed
    

    Ahora si tenemos nuestras tablas actualizadas y con datos llenos

  • Todo esto nos ayudo para crear un archivo de migración que tenga relación entre dos tablas y que podamos crear registros aleatorios en el, sin embargo laravel aún no conoce esta relación que creamos, para hacer conocer a laravel de estos cambios hacemos lo siguiente :

    • Vamos al modelo Post.php y agregamos la siguiente función:
     //Un post pertenece a un usuario
     public function user(){
         return $this->belongsTo(User::class);
     }
    
    • Vamos al modelo User.php y agregamos la siguiente función:
     //Relación : Un usuario tiene muchos post
     public function posts(){
         return $this->hasMany(Post::class);
     }
    
  • Ahora si podemos empezar a realizar operaciones con nuestras tablas relacionadas (estos ejemplos se lo realizó en el archivo web.php)

    • ejemplo de operaciones en la tabla user:
    use App\User;
    Route::get('users', function () {
        $users = User::get();
        
        foreach($users as $user){
            echo "
            $user->id 
            <strong>{$user->name}</strong>
            {$user->posts->count()} posts
            <br>";
        }
    });
    
    • ejemplo de operaciones en la tabla post:
    Route::get('posts', function () {
        $posts = Post::get();
    
        foreach($posts as $post){
            echo "
            $post->id 
            <strong>{$post->user->name}</strong>
            $post->title 
            <br>";
        }
    });
    

Acabo de crear una tabla con sus campos propios y los de auditoria, siempre estoy acostumbrado a trabajar con CreatedBy, CreatedDate, ModifiedBy, ModifiedDate y IsDeleted. El created_at y updated_at me lo da $table->timestamps(); y el created_by y modified_by los hice de la siguiente forma, que les parece?

	   // Audits fields
            $table->timestamps();
            $table->unsignedBigInteger('created_by');
            $table->unsignedBigInteger('modified_by');
            $table->softDeletes();

            // Foreign keys
            $table->foreign('created_by')->references('id')->on('users');
            $table->foreign('modified_by')->references('id')->on('users');

Estoy utilizando la versión de Laravel 8 y este es el código que utilice para crear el seeder y poderlo ejecutar desde la consola una vez lo configuró como el instructor muestra

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use App\Models\User;
use App\Models\Post;

class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        // \App\Models\User::factory(10)->create();
        User::factory(5)->create();        
        Post::factory(30)->create();
    }
}

Ok… Se me hace un tanto curioso que en los comentarios nadie haya puesto este problema, pero el caso es que al acceder a los datos en las rutas:

Route::get('posts', function () {
    $posts = Post::get();

    foreach ($posts as $post) {
        echo "
        $post->id 
        <strong>{$post->user->name}</strong> 
        $post->title <br>";
    }
});

Me saltaba el error trying to get property 'name' of non-object laravel por lo que buscando en internet encontré que tenía también que especificar el nombre del campo de la clave foránea en el belongsTo() del archivo Post.php:

public function user()
    {
        return $this->belongsTo(User::class, 'fk_user_id');
    }

Con esto ya me aparecieron correctamente los registros, desconozco totalmente si esto influya en la versión de Laravel, yo uso la 7.11.0.

Espero les haya servido si a alguien le saltó el mismo error, y si saben por qué me pudo haber pasado a mi de esta forma agradecería que me lo dijeran 😄

Hola!! Si quieren formar parte de un grupo de estudios de Devs, les dejo un link a un grupo de Telegram que está muy chulo.

https://t.me/HackTzi

También tienen una organización de GitHub, únete por aquí:

https://github.com/HackTzi

Para crear las relaciones de una llave foranea se usa de la siguiente forma:

// nombre del campo que va a contener el ID de la otra tabla a relacionar
$table->unsignedBigInteger('user_id');  //esto crea un Entero Grande sin signo 
/*
$table->foreign('campo de la table actual')
->references('campo de llave primaria de la otra tabla')
->on('tabla a relacionar');
*/
$table->foreign('user_id')->references('id')->on('users');

me daba error por el use App\User; como usa, pero en la version actual de laravel toca aumentar App\Models\User

use App\Post;



Route::get('eloquent', function () {
    $posts = Post::where('id','>=','10')
    ->orderBy('id','DESC')
    ->take(3)
    ->get();

    foreach ($posts as $post) {
        echo "$post->id $post->title <br>";
    }
});

Route::get('posts', function () {
    $posts = Post::get();

    foreach ($posts as $post) {
        echo "$post->id
        <strong>{$post->user->name} </strong>
        $post->title <br>";
    }
});
use App\User;
Route::get('users', function () {
    $users = User::get();

    foreach ($users as $user) {
        echo "$user->id
        <strong>{$user->name} </strong>
        {$user->posts->count()} posts <br>";
    }
});

La verdad tengo problemas con los comandos y la base de datos porque ningun comando me migra ni me refresca en la base de datos, no da ningun error solo me aparece esto pero no hace absolutamente nada… la base de datos se queda igual. estoy en xampp

Casa@DESKTOP-MBM1C0S MINGW32 /c/xampp/htdocs/laravel/eloquent
$ php artisan migrate:refresh --seed
Nothing to rollback.
Migrating: 2014_10_12_000000_create_users_table

   Illuminate\Database\QueryException

  SQLSTATE[42S01]: Base table or view already exists: 1050 Table 'users' already
 exists (SQL: create table `users` (`id` bigint unsigned not null auto_increment
 primary key, `name` varchar(255) not null, `email` varchar(255) not null, `emai
l_verified_at` timestamp null, `password` varchar(255) not null, `remember_token
` varchar(100) null, `created_at` timestamp null, `updated_at` timestamp null) d
efault character set utf8mb4 collate 'utf8mb4_unicode_ci')

  at C:\xampp\htdocs\laravel\eloquent\vendor\laravel\framework\src\Illuminate\Da
tabase\Connection.php:669
    665|         // If an exception occurs when attempting to run a query, we'll
 format the error
    666|         // message to include the bindings with SQL, which will make th
is exception a
    667|         // lot more helpful to the developer instead of just the databa
se's errors.
    668|         catch (Exception $e) {
  > 669|             throw new QueryException(
    670|                 $query, $this->prepareBindings($bindings), $e
    671|             );
    672|         }
    673|

  1   C:\xampp\htdocs\laravel\eloquent\vendor\laravel\framework\src\Illuminate\D
atabase\Connection.php:463
      PDOException::("SQLSTATE[42S01]: Base table or view already exists: 1050 T
able 'users' already exists")

  2   C:\xampp\htdocs\laravel\eloquent\vendor\laravel\framework\src\Illuminate\D
atabase\Connection.php:463
      PDOStatement::execute()

RESUMEN
1
"database/migrations/_Create_posts_table
$table->unsignedBigInteger("user_id") ; //relacionar con el id de 	table users
$table->foreign("user_id")->references("id")->on("users") ;  
		//relacion          ||campo                ||donde esta el campo

2 "TERMINAL"
php artisan migrate:refresh //esto actualiza los archivos actuales

3
"database/seeds/DatabaseSeeder.php"
"repoblamos la DB cada vez que migramos"
        factory(App\User::class, 4)->create();
        factory(App\Post::class, 30)->create();

4
"database/factories/PostFactory.php"
agregar la columna "user_id" a la fabrica de datos de prueba
"user_id"=> rand(1,4),
"title"=>$faker->sentence

5
"TERMINAL"
volvemos a hacer el refresh pero con el atributo --seed
php artisan migrate:refresh --seed

6
TODO MUY LINDO DESDE LA VISTA DE LA BASE DE DATOS
PERO AHORA HAY QUE AVISARLE A LARAVEL por ende hay que ir a actualizar los models
"User.php"
debemos especificar que tipo de relacion relacion:
-un user puede tener muchos posts
    public function posts(){
        return $this->hasMany(Post::class);
    }

"Post.php
debemos especificar que tipo de relacion relacion:
-cada Post le pertenece a 1 User
 public function user(){
        return $this->belongsTo(User::class);
    }

7
"routes/web.php"
A) IMPRIMIREMOS LOS POSTS SU ID ,EL NOMBRE DE SU USER , SU TITLE

Route::get('/posts', function () {
    $posts = Post::get();

    foreach($posts as $post){
        echo "
        $post->id 
        <strong>{$post->user->name}</strong>  //class||method||user owner name
        $post->title 
        <br/>";
    }
});

B)IMPRIMIREMOS LOS USERS y la cantidad de posts que tienen
Route::get('/users', function () {
    $users = User::all();

    foreach($users as $user){
        echo "
        $user->id 
        $user->name
        {$user->posts->count()} posts //class||method|| contar 
        <br/>";
    }
});


EXPLICACION:t
enemos acceso a estos valores
POST:
{$post->user->name}
USER:
 {$user->posts->count()}

PORQUE EL METODO "user" existe en el model Post 
y el  metodo "posts" existe en el model User


MORALEJA
LOS MODELS SON MUY IMPORTANTES PORQUE SON LA REPRESENTACION DE LA TABLA EN BASE DE DATOS
y con los metodos que usemos podemos listar , eliminar, consultar etc

Excelente clase! Este curso se esta poniendo cada vez mejor 😄

para que los seeders funcionene cuando se refresca la BD se debe de usar la opcion –seed

php artisan migrate:refresh --seed

Aqui lo correcto hubiera sido haber creado una migración extra indicando que a la tabla Posts se le agregará el campo user_id.

Buenas , al ejercutar el comado “migrate:refresh --seed” , me ha dado el error que la tabla posts ya existia
Alguna idea que hago mal??, la he tenido que borrar y ejecutar el migrate sin refresh
Gracias

Hola, tome estos apuntes hace algun tiempo pero creo aun son utiles, para entender de manera grafica las relaciones, tienen ejemplo de codigo para cada realcion.
.
Notese que en la relacion mucho a muchos la tabla pivote debe tener una nomenclatura clara y en orden alfabetico
.

.

.
En el ejemplo siguiente de acuerdo a la documentacion de laravel, la tabla debe llamarse curso_estudiante
.

.

Para refrescar los nuevos campos que queremos en nuestra base de datos, ejecutamos el siguiente comando:

php artisan migrate:refresh

Cuando usamos este comando, existe un problema, se nos borran los datos.

Sin embargo, gracias a la tecnología de Tinker, podemos irnos al archivo database/seeds/DatabaseSeeder.php y colocar una cantidad de usuarios por defecto que desearía que aparezcan cada vez que refresque. Podemos hacer algo como esto:

    public function run()
    {
        factory(App\User::class, 4)->create();
        factory(App\Post::class, 30)->create();
    }

Usamos el parámetro de refresh y los datos de semilla.

Para los que le salga error al usar el comando php artisan migrate:refresh
Illuminate\Database\QueryException : SQLSTATE[42S01]: Base table or view already exists: 1050 Table ‘posts’ already exists (SQL: create table posts (id bigint unsigned not null auto_increment primary key, user_id bigint unsigned not null, title varchar(255) not null, created_at timestamp null, updated_at timestamp null) default character set utf8mb4 collate ‘utf8mb4_unicode_ci’)

a mi me funciono borrando las tablas manualmente en la base de datos.

Cuando usar
hasMany- hasOne // belongsTo- belongsMany

Leyendo la documentación de laravel y buscando en foros. Encontre que hasMany o hasOne la usamos cuando tenemos nuestros datos en una misma table. Pero cuando la table esta relacionada con otra utilizamos belongsTo- belongsMany

Si uso el Strong me salen mal los datos, me sale un Json Viewer, al eliminar las etiquetas strong se soluciona

Excelente clase, he tomado mis apuntes en ppt, por lo tanto me he tardado varios días ias en hacer este curso, lo que mas me gusta es que me siento con capacidad de solucionar varios fails que se presentan gracias a este curso y al de programación orientada a objetos con php.

Tomar en cuenta que acceder al User en el Post, se genera una consulta extra por cada Post. Para evitar esto podemos usar Post::all()->load(‘user’) y solamente utilizará una consulta para obtener a todos los users de los posts e internamente Laravel los relacionará.

I love laravel and eloquent

Podemos ahorrar lineas de codigo utilizando:

            $table->foreignId('user_id')->constrained('users');

En lugar de

	$table->unsignedBigInteger('user_id');
        $table->foreign('user_id')->references('id')->on('users');

Nota: foreignId es un alias de unsignedBigInteger

// PASO A PASO PARA LA GENERACIÓN DE DOS TABLAS RELACIONADAS, PADRE E HIJO
/*
1. CREAR BD
2. CONECTAR LARAVEL CON BD EN .env
3. GENERAR LOS DOS MODELOS, LOS FACTORIES Y LOS MIGRATIONS DE CADA TABLA

    - php artisan make:model Padre -m -f
    - php artisan make:model Hijo -m -f

    3.1 MODELOS [app/nomModel.php]: se establecen las reglas de relacion entre las tablas
    3.2 FACTORIES [database/factories/nomFactory.php]: Contiene informacion de generacion de contenido generico para las tablas
    3.3. MIGRATIONS [database/migrations/nomMigrations.php]:  estructura de la tabla en php que genera el sql e la misma

4. Modificar los migrations: estructura de las tablas y relaciones. 

        Eje: Padre

        public function up()
        {
            Schema::create('padres', function (Blueprint $table) {
                $table->bigIncrements('id');
                $table->string('name', 120);
                $table->string('phone', 50);
                $table->integer('age');
                $table->timestamps();
            });
        }

        Eje Hijo: 

        public function up()
        {
            Schema::create('hijos', function (Blueprint $table) {
                $table->id();

                // CREAMOS LA LLAVE FORANEA Y LA ENLAZAMOS CON EL PADRE
                $table->unsignedBigInteger('padre_id');
                $table->foreign('padre_id')->references('id')->on('padres'); // Padres es el nombre del esquema

                $table->string('name', 120);
                $table->string('phone', 50);
                $table->integer('age');
                $table->timestamps();
            });
        }

        APLICAMOS ACTUALIZACION EN BD DE LOS CAMBIOS EN LOS /migratiosn/

        php artisan migrate:refresh => Tablas creadas en BD

5. MODIFICAMOS EL /database/seeds/DatabaseSeeder.php PARA EJECUTAR COMANDO QUE GENERE DATOS GENERICOS PARA LAS TABLAS ASI:

        use App\Padre;
        use App\Hijo;

        public function run()
        {
            factory(App\Padre::class, 2)->create();     //  Crea 4 padres
            factory(App\Hijo::class, 12)->create();     //  Crea 12 hijos
        }

6. EDITAMOS LOS FACTORIES PARA GENERACION DE DATOS DE EJEMPLO DE CADA TABLA, EL PASO ANTERIOR IRA A ELLOS Y EJECUTARA EL FACTORY:
   EN ESTOS FACTORY SE ESTABLECE DE QUE TIPO DE DATOS ES CADA CAMPO PARA PODER GENERARLOS DINAMICAMENTE:

        RUTA 1: /database/factories/PadreFactory.php

            $factory->define(Padre::class, function (Faker $faker) {
                return [
                    'name' => $faker->sentence,
                    'phone' => $faker->phoneNumber,
                    'age' => $faker->numberBetween(18, 65)
                ];
            });

        RUTA 2: /database/factories/HijoFactory.php

            $factory->define(Hijo::class, function (Faker $faker) {
                return [
                    'padre_id' => rand(1, 2), //PORQUE SE CREARON SOLO DOS PADRES
                    'name' => $faker->sentence,
                    'phone' => rand(3000000000, 3900000000), 
                    'age'  => rand(1, 18),
                ];
            });

7. EJECUTAMOS COMANDOS PARA COMPILAR LO EDITADO Y GENERAR LOS DATOS PARA LAS TABLAS.

            php artisan migrate:refresh --seed

8. CREAMOS RELACION ENTRE LAS TABLAS EN LOS MODELOS DE CADA UNA [/App/nomModel.php]:

        - AL MODELO DEL PADRE LE DECIMOS QUE PUEDE TENER MUCHOS HIJOS => Agregamos la funcion a /App/Padre.php:
                
                public function hijo()
                {
                    return $this->hasMany(Hijo::class);
                }

        - AL MODELO DEL HIJO LE DECIMOS QUE PERTENECE A UN UNICO PADRE => Agregamos la funcion a /App/Hijo.php:

                public function padre(){
                    return $this->belongsTo(Padre::class);
                }

8. EJECUTAMOS COMANDO PARA GENERAR DATOS ALEATORIOS DEFINIDOS EN FACTORIES PARA CADA TABLA:

        - php artisan migrate:refresh --seed

9. MODIFICAMOS RUTAS EN [routes/web.php] asi:

        // LISTA LOS HIJOS CON EL NOMBRE DE SU PADRE: http://eloquentpersonal.test/hijos
        Route::get('hijos', function () {
            $hijos = Hijo::all();
            
            foreach ($hijos as $hijo) {
                echo "$hijo->id     |   $hijo->name |   $hijo->age  |   $hijo->phone    | <strong>{$hijo->padre->name}</strong></br>";
            }
        });


        // Lista los posts que tiene un usuario:  http://eloquentpersonal.test/padres
        // {$padre->hijo->count()} => debe ser el nombre de la funcion creada en el modelo padre como relacion entre las dos tablas
        use App\Padre;
        Route::get('padres', function () {
            $padres = Padre::all();
            foreach ($padres as $padre) {
                echo "$padre->id     |   <strong>$padre->name</strong>   |   {$padre->hijo->count()} hijos</br>";
            }
        });

*/

Las relaciones que creamos aquí nos permiten tener la consistencia en la BD y realizar las buenas practicas como se debe excelente!!!

para cuando se recrea la BD podemos usar los Seeders para llamar al factory y crear los datos falsos necesarios

Los seeders se encuentran en la ruta:

database > seeds > archivos de seeders

Muy bien explicado la forma en la que se relacionan dos tablas y como se puede consultar la información para hacer un sitio web.

Hola, ¿Alguien sabe por qué se muestran esos datos adicionales y los botones de la derecha? Muchas gracias!

.

Me encanta como trabaja las consultas con la base de datos, genial.

También podemos acceder a un id aleatorio directamente del modelo User por ejemplo:

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\User; //Importamos el modelo
use App\Post;
use Faker\Generator as Faker;

$factory->define(Post::class, function (Faker $faker) {
    return [
        'title' => $faker->sentence,
        'user_id' => User::all()->random()->id, //obtenemos el id aleatorio
    ];
});

Compañeros alguien que me de una mano y me brinde su asesoria. Tengo un incoveniente al intentar hacer la relacion de las siguientes tablas
Ya que necesito que en usuarios la identificacion NO me quede como un campo auto incremental, para poder enlazar adecuadamente con la otra tabla.

estoy asombrado, cosas como las benditas llaves para pasar a mas de 2 niveles de relacion de clases en donde rayos aprendio eso el profesor??? yo no lo sabia no habia visto eso en ningun lado desde laravel 5

Lo que hace Eloquent es genial porque literal te enlista la relacion con tu modelo original, la pone como si fuera un campo más de etu base de datos, pero en realidad es la otra tabla que ya viene pegada, es simplemente genial:D

Documentación Laravel Eloquent 8.x

https://laravel.com/docs/8.x/eloquent#introduction

Saludos.

Esto es una consulta. Al usar count() me da este error?

“Error
Call to a member function count() on null”

use App\User;
Route::get(‘users’, function () {
$users = User::all();
foreach ($users as $user){
echo “
$user->id
<strong> $user->name</strong>
{$user->posts->count()} posts <br>”;
}
});

Programar en PHP es literalmente mezclar álgebra e inglés en un nuevo idioma

posteando y buscando información encontré esto espero sea de ayuda
'user_id' => factory(App\User::class)

En el modelo es una buena practica incluir el metodo SoftDeletes.
dejo el enlace de la documentación para que se informen mas.
https://laravel.com/docs/8.x/eloquent#soft-deleting

Al correr al recargar la migración me marcó un erro ya que

            $table->foreignBigInteger('user_id');

suele trabajar en conjunto con

            $table->bigIncrements('id');

entonces mi versión de Laravel 7.X me pone las migraciones así

            $table->id();

para ello nada mas al poner la llave foranea nada más hay que hacerlo de esta forma

            $table->foreignId('user_id');

Lo demás es igual. Saludos

los metodos unsignedBig, increments donde consigo una lista de esos metodos?v