Laravel Eloquent es una forma sencilla de interactuar con tu base de datos. Es un mapeador objeto-relacional (ORM) que simplifica las complejidades de las bases de datos proporcionando un modelo para interactuar con las tablas.

Como tal, Laravel Eloquent tiene excelentes herramientas para crear y probar API que soporten tu desarrollo. En este artículo práctico, verás lo fácil que es crear y probar API utilizando Laravel.

En esta demostración, empezarás creando un modelo que podrás utilizar para construir la API y la tabla de la base de datos. A continuación, verás cómo añadir un controlador como capa lógica de negocio y una ruta para completar la API. A continuación, aprenderás a realizar pruebas de API utilizando Postman antes de centrarte finalmente en la autenticación y la gestión de errores.

Requisitos Previos

Para empezar, necesitarás:

Conceptos Básicos de API

Comienza creando un nuevo proyecto Laravel utilizando <code>compositor</code>:

composer create-project laravel/laravel laravel-api-create-test

Para iniciar el servidor, ejecuta el siguiente comando, que ejecuta el servidor de aplicaciones en el puerto 8000:

cd laravel-api-create-test
php artisan serve

Deberías ver la siguiente pantalla:

The Laravel landing page
Laravel

A continuación, crea un modelo con una bandera -m para la migración utilizando el código siguiente:

php artisan make:model Product -m

Ahora actualiza el archivo de migración para incluir el campo requerido. Añade los campos de título y descripción para el modelo de producto y estos dos campos de tabla dentro del archivo database/migrations/{date_stamp}_create_products_table.php.

$table->string('title');
$table->longText('description');

El siguiente paso es hacer que estos campos se puedan rellenar. Dentro de app/Models/Product.php, haz que los campos title y description sean rellenables.

protected $fillable = ['title', 'description'];

Cómo Crear un Controlador

Ahora, crea un archivo controlador para el producto ejecutando el siguiente comando. Esto creará el archivo app/Http/Controllers/Api/ProductController.php.

php artisan make:controller ApiProductController --model=Product

Ahora, añade la lógica para crear y recuperar los productos. Dentro del método index, añade el siguiente código para recuperar todos los productos:

$products = Product::all();
return response()->json([
    'status' => true,
    'products' => $products
]);

Después, debes añadir una clase StoreProductRequest para almacenar los nuevos productos en la base de datos. Añade la siguiente clase en la parte superior del mismo archivo.

public function store(StoreProductRequest $request)
 {
    $product = Product::create($request->all());

    return response()->json([
        'status' => true,
        'message' => "Product Created successfully!",
        'product' => $product
    ], 200);
 }

Ahora, crearás la solicitud, lo que puedes hacer ejecutando el siguiente comando:

php artisan make:request StoreProductRequest

Si quieres añadir validaciones, puedes utilizar el archivo app/Http/Requests/StoreProductRequest.php. Para este ejemplo, no hay validaciones.

Cómo Crear una Ruta

El último paso antes de probar la API es añadir una ruta. Para ello, añade el siguiente código dentro del archivo routes/api.php. Añade la sentencia use al principio del archivo y la sentencia Route en el cuerpo:

use AppHttpControllersApiProductController;
Route::apiResource('products', ProductController::class);

Antes de empezar a probar la API, asegúrate de que la tabla de productos está en tu base de datos. Si no existe, crea una utilizando un panel de control como XAMPP. Alternativamente, puedes ejecutar el siguiente comando para migrar la base de datos:

php artisan migrate

Cómo Probar una API

Antes de probar la API, asegúrate de que el método <code>authorize</code> dentro de la app/Http/Requests/StoreProductRequest. php está configurado para devolver <code>true</code>.

Ahora, puedes crear un nuevo producto utilizando Postman. Empieza haciendo una petición POST a esta URL: http://127.0.0.1:8000/api/products/. Como se trata de una solicitud a POST para crear un nuevo producto, debes pasar un objeto JSON con un título y una descripción.

{
    "title":"Apple",
    "description":"Best Apples of the world"
}
Creating a new product in Postman
Crear un nuevo producto en Postman

Tras pulsar el botón Enviar, deberías ver lo siguiente:

Postman after clicking Send
Después de hacer clic en Enviar

Ahora, recupera los productos creados utilizando la solicitud GET. La URL es la misma. Los resultados serán como los siguientes:

The products fetched by the GET request.
Los productos obtenidos mediante la solicitud GET.

Cómo Autenticar una API Utilizando Sanctum

La autenticación es crucial a la hora de asegurar una API. Laravel lo facilita proporcionando la funcionalidad del token Sanctum, que puedes utilizar como middleware. Asegura la API utilizando tokens generados cuando el usuario se conecta utilizando las credenciales correctas. Recuerda que los usuarios no pueden acceder a la API segura sin un token.

El primer paso para añadir la autenticación es añadir un paquete Sanctum utilizando el código siguiente:

composer require laravel/sanctum

A continuación, publica el archivo de configuración de Sanctum:

php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"

Después, añade el token de Sanctum como middleware. Dentro del archivo app/Http/Kernel.php, utiliza la siguiente clase y sustituye middlewareGroups por el siguiente código en la API de los grupos de middleware protegidos.

use LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful;
protected $middlewareGroups = [
    'web' => [
        AppHttpMiddlewareEncryptCookies::class,
        IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
        IlluminateSessionMiddlewareStartSession::class,
        // IlluminateSessionMiddlewareAuthenticateSession::class,
        IlluminateViewMiddlewareShareErrorsFromSession::class,
        AppHttpMiddlewareVerifyCsrfToken::class,
        IlluminateRoutingMiddlewareSubstituteBindings::class,
    ],

    'api' => [
        EnsureFrontendRequestsAreStateful::class,
        'throttle:api',
        IlluminateRoutingMiddlewareSubstituteBindings::class,
    ],
];

El siguiente paso es crear un UserController y añadir el código para obtener el token para autenticarse.

php artisan make:controller UserController

Después de crear el UserController, navega hasta el archivo app/Http/Controllers/UserController.php y sustituye el código existente por el siguiente código:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;
use AppModelsUser;
use IlluminateSupportFacadesHash;
class UserController extends Controller
{
    // 

    function index(Request $request)
    {
        $user= User::where('email', $request->email)->first();
        // print_r($data);
            if (!$user || !Hash::check($request->password, $user->password)) {
                return response([
                    'message' => ['These credentials do not match our records.']
                ], 404);
            }
        
             $token = $user->createToken('my-app-token')->plainTextToken;
        
            $response = [
                'user' => $user,
                'token' => $token
            ];
        
             return response($response, 201);
    }
}

Antes de que puedas probar la autenticación, crea un usuario que emplee seeders. El siguiente comando crea un archivo UsersTableSeeder.

php artisan make:seeder UsersTableSeeder

Dentro del archivo database/seeders/UsersTableSeeder.php, sustituye el código existente por el siguiente código para sembrar el usuario:

<?php

namespace DatabaseSeeders;

use IlluminateDatabaseSeeder;
use IlluminateSupportFacadesDB;
use IlluminateSupportFacadesHash;

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        DB::table('users')->insert([
            'name' => 'John Doe',
            'email' => '[email protected]',
            'password' => Hash::make('password')
        ]);
    }
}

Ahora ejecuta el sembrador utilizando este comando

php artisan db:seed --class=UsersTableSeeder

El último paso que queda en el flujo de autenticación es utilizar el middleware creado para proteger la ruta. Navega hasta el archivo routes/api.php y añade la ruta de productos dentro del middleware.

use AppHttpControllersUserController;

Route::group(['middleware' => 'auth:sanctum'], function () {
    Route::apiResource('products', ProductController::class);
});

Route::post("login",[UserController::class,'index']);

Después de añadir una ruta al middleware, obtendrás un error interno del servidor si intentas obtener los productos.

An internal server error after adding a route
Un error interno del servidor después de añadir una ruta

Pero una vez que te conectes, obtengas un token y lo utilices en la cabecera, te autenticará y empezará a funcionar. Puedes enviar una solicitud POST a http://127.0.0.1:8000/api/login con el siguiente cuerpo:

{
    "email":"[email protected]",
    "password":"password"
}
Successful authentication and the Bearer token
Autenticación correcta

Utiliza el token recibido como token de portador y añádelo como cabecera de autorización.

Adding the Bearer token as the Authorization header
Añadir el código de portador como cabecera de autorización

Cómo Gestionar los Errores de la API

Cada vez que envías una solicitud al servidor, éste responde. Con la respuesta, también envía un código de estado según la naturaleza de la respuesta. Por ejemplo, un código de estado 200 indica que la solicitud se ha realizado correctamente, y un 404 sugiere que el servidor no puede encontrar el recurso solicitado.

Sin embargo, un código de estado no es suficiente. Se necesita un mensaje de error legible por humanos. Laravel ofrece muchas formas de gestionar los errores. Puedes utilizar un bloque try-catch, el método fallback o enviar una respuesta personalizada. El siguiente código que has añadido a UserController lo demuestra.

if (!$user || !Hash::check($request->password, $user->password)) {
    return response([
        'message' => ['These credentials do not match our records.']
    ], 404);
}

Resumen

El Modelo Elocuente de Laravel permite crear, validar y probar API sin esfuerzo. Su mapeo objeto-relacional proporciona un enfoque directo para interactuar con la base de datos.

Además, actuando como middleware, el token Sanctum de Laravel puede ayudarte a proteger tus API rápidamente.

Y si necesitas una mayor optimización, la solución de alojamiento de bases de datos de Kinsta simplifica la configuración y gestión de bases de datos para todos tus proyectos web.

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).