Introducción

Este es un nuevo tutorial de creación de CRUD usando PHP 8 con Composer y Laravel 8.

En este ejemplo crearemos un proyecto desde cero, si es la primera vez que realiza un proyecto en Laravel, no se preocupe en este tutorial iré paso a paso, desde la instalación de Laravel hasta ejecutar la aplicación y probar los APIS con Postman.

Para instalar todo lo necesario, lo haremos de manera sencilla, con la instalación de XAMPP.

CRUD

En el desarrollo de software CRUD son los acrónimos de Create, Read, Update y Delete por sus siglas en inglés.
Esto se refiere a las funciones en la base de datos o la capa de persistencia en un aplicación o software.

Laravel

Modelo Vista Controlador (MVC)

Es un patrón en el diseño de software comúnmente utilizado para implementar interfaces de usuario, datos y lógica de control. Este modelo enfatiza una separación entre la lógica de negocios y su visualización.

Composer

Composer es un sistema de gestión de paquetes para programar en PHP el cual provee los formatos estándar necesarios para manejar dependencias y librerías de PHP.

En este caso Laravel utiliza Composer para la gestión de dependencias.

• XAMPP https://www.apachefriends.org/download.html
• Visual Studio Code (como editor de texto) https://code.visualstudio.com/download/
• Postman https://www.postman.com/downloads/ para enviar peticiones HTTP REST
• Composer https://getcomposer.org/download/

Para descargar el instalador de Composer, puede hacerlo directamente con Composer-Setup exe, tal como se muestra en la imagen de abajo.

Una vez instalado todas las herramientas necesarias, procedemos a crear el proyecto

Paso 1.- Descargar el instalador de Laravel

Abrimos la terminal o consola de comandos (bash, power Shell, etc.) e ingresamos la siguiente línea de comando.

composer global require laravel/installer

Paso 2.- Crear proyecto

Una vez que haya instalado el instalador de laravel, procedemos a crear el proyecto de una manera sencilla.
Nuestro proyecto de ejemplo se llama myblog el código de abajo instalará todos los paquetes necesarios para el funcionamiento del proyecto.

laravel new myblog

La creación del nuevo proyecto, tardará unos cuantos segundos, ya que instala todos los paquetes necesarios para la correcta funcionalidad de la aplicación.

Paso 3.- Probar proyecto

Procedemos a ejecutar el proyecto, para ver la correcta funcionalidad.

Paso 3.1.- Entramos a la carpeta del directorio

cd myblog

Paso 3.2.- Ejecutamos el proyecto

php artisan serve

Verá el siguiente resultado en su línea de comando.

$ php artisan serve
Starting Laravel development server: http://127.0.0.1:8000
            

Después de ejecutar el comando anterior, con eso inició el servidor de desarrollo Laravel y enseguida se abrirá su navegador (en mi caso Google Chrome ) en http://127.0.0.1:8000/, en su navegador podrá ver una vista como la imagen de abajo.

¡Listo! todo funciona correctamente, si desea terminar la ejecución teclee Ctrl + C

Paso 4.- Creación de la base de datos con XAMPP

Antes de realizar la migración, debemos de crear una base de datos en XAMPP.

• Abrir el panel de control de XAMPP

Tal como se ve en la imagen de arriba (XAMPP Control Panel), procederemos a iniciar Apache y MySQL con los botones start.

Después de iniciar estos servicios, necesitaremos acceder a phpMyAdmin en el local host http://localhost/phpmyadmin/

O bien puede acceder fácilmente desde el Panel de control de XAMPP presionando el botón Admin de MySQL y éste abrirá el navegador (Google Chrome en mi caso) el phpAdmin en el localhost.

Paso 4.1 .- Crear una nueva base de datos

Procedemos a crear una base de datos en XAMPP.

• Presionar el botón +Nueva y le habilitará la opción de crear base de datos, tal como se ve en la imagen de abajo.
  

  El nombre de la base de datos en este ejemplo es myblogdb

• Finalmente le damos click en el botón Crear.
  Listo, con esto hemos creado la base de datos en XAMPP de una manera muy sencilla.

Paso 5.- Conexión a la base de datos de XAMPP con Laravel

El siguiente paso es conectar la base de datos que acabamos de crear con XAMPP a nuestra aplicación en Laravel.
Este es muy simple de realizarlo.

• Dirigirse en el archivo .env ylocalizar la parte de DB_DATABASE y poner ahí el nombre de nuestra base de datos myblogdb.

  DB_CONNECTION=mysql
  DB_HOST=127.0.0.1
  DB_PORT=3306
  DB_DATABASE=myblogdb
  DB_USERNAME=root
  DB_PASSWORD=
                      

  Nota: El DB_PORT 3306 puede que sea diferente para usted, Si usted tiene una contraseña para el usuario root deberá de ponerlo en el apartado de DB_PASSWORD.

Paso 6.- Instalación de paquetes

composer require laravel/passport

Laravel Passport es el módulo oficial de Laravel que nos ayuda a la implementación de servicios de autenticación haciendo uso del protocolo OAuth2. El protocolo OAuth2 es lo que usaremos para el inicio de sesión del usuario.

Para saber más sobre Passport, puede consultarlo en la documentación oficial de Laravel https://laravel.com/docs/8.x/passport

Paso 7.- Migraciones

Al crear el proyecto, le genera de manera automática los archivos de migración del usuario, puede verlo en database/migrations.
Los archivos de migración deben de verse algo similar a la imagen de abajo.

Bien antes de realizar el migrate necesitamos definir los campos del usuario (username, first_name, last_name, …) en el archivo migrations/2014_10_12_000000_create_users_table.php

                
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('username');
            $table->string('first_name');
            $table->string('last_name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('users');
    }
}
                
            

Listo, ahora podemos hacer el migrate sin problemas.

php artisan migrate

Verá la siguiente salida en su consola de comando.

$ php artisan migrate
Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table (607.80ms)
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table (541.70ms)
Migrating: 2016_06_01_000001_create_oauth_auth_codes_table
Migrated:  2016_06_01_000001_create_oauth_auth_codes_table (1,869.04ms)
Migrating: 2016_06_01_000002_create_oauth_access_tokens_table
Migrated:  2016_06_01_000002_create_oauth_access_tokens_table (1,488.44ms)
Migrating: 2016_06_01_000003_create_oauth_refresh_tokens_table
Migrated:  2016_06_01_000003_create_oauth_refresh_tokens_table (1,996.52ms)
Migrating: 2016_06_01_000004_create_oauth_clients_table
Migrated:  2016_06_01_000004_create_oauth_clients_table (999.64ms)
Migrating: 2016_06_01_000005_create_oauth_personal_access_clients_table
Migrated:  2016_06_01_000005_create_oauth_personal_access_clients_table (1,429.81ms)
Migrating: 2019_08_19_000000_create_failed_jobs_table
Migrated:  2019_08_19_000000_create_failed_jobs_table (671.25ms)
Migrating: 2019_12_14_000001_create_personal_access_tokens_table
Migrated:  2019_12_14_000001_create_personal_access_tokens_table (933.22ms)
            

En su phpMyAdmin puede ver el resultado de la migración.

Para saber más sobre el tema de migraciones, puede consultarlo en la documentación oficial de Laravel https://laravel.com/docs/8.x/migrations

Nota: Se debe de realizar la migración después de la instalación de Passport, ya que Passport creará tablas que la aplicación necesita para almacenar clientes OAuth2 y tokens de acceso.

Paso 8.- Generación de la llave

Crear las claves de cifrado necesarias para generar tokens de acceso seguro.
Además, el comando passport:install creará clientes de "acceso personal" y "concesión de contraseña" que se utilizarán para generar tokens de acceso.

php artisan passport:install

Tendrá una salida similar a esto en su consola de comando.

$ php artisan passport:install
Encryption keys generated successfully.
Personal access client created successfully.
Client ID: 1
Client secret: r6AcqZ29dAslg23rO8VIw1q3NNjDEBMDpGGtij5r
Password grant client created successfully.
Client ID: 2
Client secret: HvUUx33HgyfXvtRRy7CplQwByy46fJOts8otkdEG
            

Después de generar las llaves es necesario publicar el archivo de configuración de Passport para la carga de claves desde el entorno.

php artisan vendor:publish --tag=passport-config

Tendrá una salida similar a esto en su consola de comando.

$ php artisan vendor:publish --tag=passport-config
Copied File [\vendor\laravel\passport\config\passport.php] To [\config\passport.php]
Publishing complete.
            

Nota: Si no realiza el paso anterior no podrá generar los tokens de seguridad.

Paso 9.- Configuración de Passport

Paso 9.1.- User.php

Después de ejecutar el comando passport: install del paso 8, agregue el trait Laravel\Passport\HasApiTokens a su modelo App\Models\User.
Este trait proporcionará algunos métodos auxiliares a su modelo que le permitirán inspeccionar el token y los alcances del usuario autenticado.

Lo que debe de agregar es lo que está marcado en negritas.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Passport\HasApiTokens;  //Import HasApiTokens

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
}
            

Paso 9.2.- AuthServiceProvider.php

Para que Passport funcione correctamente debe habilitar las rutas.
Debe llamar al método Passport::routes dentro del método boot de su App\Providers\ AuthServiceProvider

Lo que debe de agregar es lo que está marcado en negritas.

<?php

namespace App\Providers;

use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Gate;
use Laravel\Passport\Passport; //Import Passport

class AuthServiceProvider extends ServiceProvider
{
    /**
     * The policy mappings for the application.
     *
     * @var array
     */
    protected $policies = [
        'App\Models\Model' => 'App\Policies\ModelPolicy',
    ];

    /**
     * Register any authentication / authorization services.
     *
     * @return void
     */
    public function boot()
    {
        $this->registerPolicies();
        Passport::routes();  //Add passport routes
    }
}
            

Paso 9.3.- auth.php

En el archivo de configuración config\auth.php de su aplicación, debe configurar la opción del controlador de la protección de autenticación de api en Passport.

Lo que debe de agregar es lo que está marcado en negritas.

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    //  Option of the api authentication guard to passport
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
    //
],

            

Paso 9.4.- app.php

Finalmente, en el archivo config\app.php de su aplicación agregamos PassportServiceProvider en el apartado providers.

Lo que debe de agregar es lo que está marcado en negritas.

'providers' => [
   /*
    * Application Service Providers...
   */

    Laravel\Passport\PassportServiceProvider::class, //Add the passport services
],
            

¡Listo!

Con esto terminamos con la configuración del uso de Passport

A continuación, crearemos el CRUD de usuario, login y logout de una manera muy práctica de hacerlo.

10.- CRUD de usuario

Paso 10.1.- User.php

Para este proceso, necesitaremos definir los campos para el usuario (username, email, …), en nuestro modelo App\Models\User.php

//Add the required fields
protected $fillable = [
    'username',
    'first_name',
    'last_name',
    'email',
    'password',
];
            

Este archivo User.php finalmente quedaría de esta manera.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Passport\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */

   //Add the required fields
    protected $fillable = [
        'username',
        'first_name',
        'last_name',
        'email',
        'password',
    ];


    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * The attributes that should be cast to native types.
     *
     * @var array
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];
}

Paso 10.2.- UserController.php

Crearemos un controlador llamado UserController en este controlador definiremos los métodos Create, Read, Update, Delete (CRUD) y así mismo el login y logout.

Este controlador lo crearemos con la siguiente línea de comando.

php artisan make:controller UserController
            

Este comando, le creará el archivo UserController.php en App\Http\Controllers\UserController.php

Dentro de este archivo UserController.php copia y pega el siguiente código.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Auth;
use App\Models\User;  //This is the user model/Models/Use

class UserController extends Controller
{
    /**
     * User CRUD section
     */
    public function user_create(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'username' => 'required|string|max:50',
            'first_name' => 'required|string|max:50',
            'last_name' => 'required|string|max:50',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|between:8,50|confirmed'
        ]);

        //Check if the data entered is valid
        if ($validator->fails()) {
            return response(['errors' => $validator->errors()->all()], 422);
        }

        //To hash the password
        $request['password'] = Hash::make($request['password']);

        $user = new User();
        $user->username = $request->username;
        $user->first_name = $request->first_name;
        $user->last_name = $request->last_name;
        $user->email = $request->email;
        $user->password = $request->password;

        $user->save();
        $response = 'Successfully created user';
        return response($response, 200);
    }

    public function user_update(Request $request, $id)
    {
        $user = User::find($request->id);

        $validator = Validator::make($request->all(), [
            'username' => 'required|string|max:50',
            'first_name' => 'required|string|max:50',
            'last_name' => 'required|string|max:50',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|between:8,50|confirmed'
        ]);
        //Check if the data entered is valid
        if ($validator->fails()) {
            return response(['errors' => $validator->errors()->all()], 422);
        }

        $request['password'] = Hash::make($request['password']);

        $user->username = $request->username;
        $user->first_name = $request->first_name;
        $user->last_name = $request->last_name;
        $user->email = $request->email;
        $user->password = $request->password;

        $user->update();
        return $user;
    }

    public function user_delete(Request $request)
    {
        $user = User::find($request->id);
        $user->delete();

        $response = 'Successfully removed!';
        return response($response, 200);
    }

    public function user_index()
    {
        //get all user list
        return User::all();
    }

    /**
     * Login secction
     */

    // Log in user
    public function login(Request $request)
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required']
        ]);

        $credentials = request(['email', 'password']);

        //Check if the user has the credentials
        if (!Auth::attempt($credentials)) {
            return response()->json([
                'message' => 'Unauthorized'
            ], 401);
        }

        $user = $request->user();
        $accessToken = $user->createToken('authToken')->accessToken;

        return response(['user' => Auth::user(), 'access_token' => $accessToken]);
    }

    //Logout user
    public function logout(Request $request)
    {
        $token = $request->user()->token();
        $token->revoke();

        $response = 'You have been succesfully logged out!';
        return response($response, 200);
    }
}
            

Para saber más sobre el tema de Controllers, puede verlo en la documentación de Laravel en el siguiente enlace https://laravel.com/docs/8.x/controllers

Paso 11.- Definir las rutas principales para la API

Para este procedimiento de enrutamiento necesitaremos definirlo en el archivo routes\api.php

En este archivo estaremos llamando y usando los métodos declarados en el archivo UserController.php

<?php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\UserController; 

/**
 * Routes for signup & login
 */

Route::group([
    'prefix' => 'users'
], function () {
    //Public access routes
    Route::post('signup', [UserController::class, 'user_create']);
    Route::post('login', [UserController::class, 'login']);
    //

    // Access only for logged in users
    Route::group([
      'middleware' => 'auth:api'
    ], function() {
        Route::put('user-update/{id}', [UserController::class, 'user_update']);
        Route::delete('user-delete/{id}', [UserController::class, 'user_delete']);
        Route::get('index', [UserController::class, 'user_index']);
        Route::post('logout', [UserController::class, 'logout']);
    });
});
            

Explicación de las rutas

Las rutas de signup y login son de acceso público y lo que tiene el 'middleware' => 'auth:api' indica que se necesita iniciar sesión para acceder a ellas, es decir que no es de acceso público.

Para saber más sobre el tema de rutas, puede consultarlo en la documentación de laravel https://laravel.com/docs/8.x/routing

¡Listo hemos terminado!

Fue un proceso un poco largo.

Antes de continuar puede ver el código en el siguiente enlace de github.

Ahora es momento de probar nuestra aplicación y ver si funciona adecudamente.

Paso 12.- Consumir la API con Postman

POST: http://127.0.0.1:8000/api/users/signup

Nos debe de retornar un resultado de success HTTP 200

POST: http://127.0.0.1:8000/api/users/login

El login debe devolver un token, ese token debe de copiar y pegar en los headers en Authorization

GET: http://127.0.0.1:8000/api/users/index

En caso de que le marque un error como la imagen de abajo, indica que está intentando realizar una consulta sin haber iniciado sesión o que el token que intenta pasar no es válido.

Nota: No olvide pasar el token en el Headers -> Authorization

PUT: http://127.0.0.1:8000/api/users/user-update/1

Nota: No olvide pasar el token en el Headers -> Authorization y pasarle como encabezado el ID del usuario

DELETE : http://127.0.0.1:8000/api/users/user-delete/2

Nota: No olvide pasar el token en el Headers -> Authorization pasamos como encabezado el ID del usuario, en este ejemplo, anteriormente he registrado otro usuario que tiene el id 2.

Por último, cerramos la sesión del usuario.

POST : http://127.0.0.1:8000/api/users/logout

Para generar otro token, deberá de iniciar sesión de nuevo.

Con esto terminamos con el tutorial del CRUD de usuario usando Laravel 8.

Puede ver el código fuente en github