CRUD con APIs REST en Slim Framework: Paso a Paso

Slim Framework es una excelente opción para construir aplicaciones web livianas y rápidas. Si necesitas desarrollar un sistema para administrar datos a través de una APIs REST (Crear, Leer, Actualizar, Eliminar), Slim puede ser tu elección ideal. En este artículo, te guiaré a través de los pasos para crear un CRUD con APIs REST en Slim Framework.

Paso 1: Configuración del Entorno

Antes de comenzar, asegúrate de tener Slim Framework instalado. Puedes instalarlo fácilmente a través de Composer con el siguiente comando:

composer require slim/slim

Paso 2: Creación del Proyecto

Crea un nuevo proyecto Slim ejecutando el siguiente comando en tu línea de comandos:

composer create-project slim/slim NOMBRE_DE_TU_PROYECTO

Paso 3: Configuración de las Rutas

Slim utiliza un enrutamiento sencillo pero potente. Define las rutas en tu archivo index.php para manejar las solicitudes HTTP. Por ejemplo:

use Slim\Http\Request;
use Slim\Http\Response;

$app->get('/recurso', function (Request $request, Response $response) {
    // Lógica para obtener recursos
});

$app->post('/recurso', function (Request $request, Response $response) {
    // Lógica para crear recursos
});

// Define rutas adicionales para Actualizar y Eliminar

Aquí tienes un ejemplo de cómo configurar las rutas para un CRUD con APIs REST en Slim Framework:

<?php
use Slim\Routing\RouteCollectorProxy;

// Definir un grupo de rutas para la API
$app->group('/api', function (RouteCollectorProxy $group) {
    
    // Ruta para obtener todos los coches
    $group->get('/coches', 'App\Controllers\CocheController:getCoches');

    // Ruta para obtener un coche por su ID
    $group->get('/coches/{id}', 'App\Controllers\CocheController:getCoche');

    // Ruta para crear un nuevo coche
    $group->post('/coches', 'App\Controllers\CocheController:createCoche');

    // Ruta para actualizar un coche por su ID
    $group->put('/coches/{id}', 'App\Controllers\CocheController:updateCoche');

    // Ruta para eliminar un coche por su ID
    $group->delete('/coches/{id}', 'App\Controllers\CocheController:deleteCoche');
});

En este ejemplo, hemos configurado un grupo de rutas /api para todas las operaciones relacionadas con los coches. Dentro de este grupo, hemos definido rutas para:

Obtener todos los coches.
Obtener un coche por su ID.
Crear un nuevo coche.
Actualizar un coche por su ID.
Eliminar un coche por su ID.

Asegúrate de ajustar las rutas y los controladores según las necesidades específicas de tu aplicación. Además, deberás definir los métodos correspondientes en tus controladores para manejar estas rutas.

Paso 4: Creación de Controladores

Es una buena práctica utilizar controladores para separar la lógica de enrutamiento de la lógica de la aplicación. Crea controladores para cada acción CRUD (Crear, Leer, Actualizar, Eliminar).

Aquí tienes un ejemplo de cómo crear un controlador para un CRUD con APIs REST en Slim Framework:

<?php
namespace App\Controllers;

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;

class CocheController
{
    protected $container;

    public function __construct($container)
    {
        $this->container = $container;
    }

    public function getCoches(Request $request, Response $response, $args)
    {
        // Ejemplo genérico: Obtener todos los coches desde una base de datos
        $coches = [
            ['id' => 1, 'marca' => 'Toyota', 'modelo' => 'Camry'],
            ['id' => 2, 'marca' => 'Honda', 'modelo' => 'Civic'],
            ['id' => 3, 'marca' => 'Ford', 'modelo' => 'Focus'],
        ];

        // Devolver la respuesta como JSON
        return $response->withJson($coches);
    }

    public function getCoche(Request $request, Response $response, $args)
    {
        $cocheId = $args['id'];

        // Ejemplo genérico: Obtener un coche por su ID desde una base de datos
        $coche = ['id' => $cocheId, 'marca' => 'Toyota', 'modelo' => 'Camry'];

        // Devolver la respuesta como JSON
        return $response->withJson($coche);
    }

    public function createCoche(Request $request, Response $response, $args)
    {
        // Ejemplo genérico: Crear un nuevo coche a partir de los datos en la solicitud
        $nuevoCoche = $request->getParsedBody();

        // Realizar operaciones de creación en la base de datos

        // Devolver la respuesta como JSON
        return $response->withJson($nuevoCoche, 201); // Código de respuesta 201 para "Created"
    }

    public function updateCoche(Request $request, Response $response, $args)
    {
        $cocheId = $args['id'];

        // Ejemplo genérico: Actualizar un coche por su ID con los datos en la solicitud
        $datosActualizados = $request->getParsedBody();

        // Realizar operaciones de actualización en la base de datos

        // Devolver la respuesta como JSON
        return $response->withJson($datosActualizados);
    }

    public function deleteCoche(Request $request, Response $response, $args)
    {
        $cocheId = $args['id'];

        // Ejemplo genérico: Eliminar un coche por su ID desde la base de datos
        // Realizar operaciones de eliminación en la base de datos

        // Devolver una respuesta de éxito (sin contenido)
        return $response->withStatus(204); // Código de respuesta 204 para "No Content"
    }
}

En este ejemplo, hemos creado un controlador llamado CocheController con cinco métodos correspondientes a las operaciones CRUD en la API REST:

getCoches: Recupera todos los coches.
getCoche: Recupera un coche por su ID.
createCoche: Crea un nuevo coche.
updateCoche: Actualiza un coche por su ID.
deleteCoche: Elimina un coche por su ID.

Cada método toma una solicitud (Request) y una respuesta (Response) como parámetros y contiene la lógica necesaria para llevar a cabo la operación correspondiente.

Asegúrate de ajustar la lógica de estos métodos según tus necesidades específicas y conecta tu controlador con las rutas definidas en Slim Framework.

Paso 5: Conexión a la Base de Datos

Si tu aplicación requiere una base de datos, configura la conexión a la base de datos utilizando una biblioteca como Eloquent o Doctrine. Asegúrate de manejar las credenciales de conexión de forma segura.

Para conectar a una base de datos en una aplicación Slim Framework, puedes utilizar una biblioteca de ORM (Mapeo Objeto-Relacional) como Eloquent o implementar la conexión directamente. A continuación, te proporcionaré un ejemplo de cómo conectar Slim Framework a una base de datos MySQL utilizando el componente PDO:

<?php
use Slim\App;

require 'vendor/autoload.php';

// Configuración de la base de datos
$settings = [
    'settings' => [
        'displayErrorDetails' => true,
        'db' => [
            'host' => 'localhost',
            'user' => 'tu_usuario',
            'pass' => 'tu_contraseña',
            'dbname' => 'nombre_de_la_base_de_datos'
        ]
    ],
];

$app = new App($settings);

// Obtén el contenedor de Slim
$container = $app->getContainer();

// Configuración de la base de datos en el contenedor
$container['db'] = function ($c) {
    $dbSettings = $c['settings']['db'];
    $pdo = new PDO("mysql:host=" . $dbSettings['host'] . ";dbname=" . $dbSettings['dbname'],
                   $dbSettings['user'], $dbSettings['pass']);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
    return $pdo;
};

// Rutas de la API REST y controladores
// Aquí configurarías tus rutas y controladores

$app->run();

En este ejemplo:

Importamos las bibliotecas necesarias.
Configuramos los ajustes de la base de datos en el arreglo $settings.
Creamos una instancia de la aplicación Slim.
Accedemos al contenedor de Slim para configurar la base de datos.
Configuramos una conexión PDO con los parámetros de la base de datos y la almacenamos en el contenedor con la clave 'db'.

Luego, puedes utilizar la conexión a la base de datos en tus controladores para realizar operaciones de lectura y escritura en la base de datos. Asegúrate de adaptar esta configuración a tu entorno y necesidades específicas, como el tipo de base de datos que estás utilizando y las credenciales de conexión.

Paso 6: Implementación de las Acciones CRUD

En los controladores, implementa las acciones CRUD como métodos. Utiliza Eloquent, Doctrine u otra biblioteca de ORM para interactuar con la base de datos.

La implementación de acciones para un CRUD con APIs REST en Slim Framework se basa en la definición de rutas y controladores correspondientes. A continuación, te proporcionaré un ejemplo de cómo implementar acciones para un CRUD de recursos «Coche» utilizando Slim Framework:

<?php
use Slim\App;

require 'vendor/autoload.php';

// Configuración de la base de datos (como se mostró en la respuesta anterior)

$app = new App($settings);

// Obtén el contenedor de Slim
$container = $app->getContainer();

// Definición de rutas y controladores para el CRUD de Coches

// Listar todos los Coches
$app->get('/coches', function ($request, $response) {
    $db = $this->get('db');
    $query = $db->query('SELECT * FROM coches');
    $coches = $query->fetchAll();
    return $response->withJson($coches);
});

// Obtener un Coche por su ID
$app->get('/coches/{id}', function ($request, $response, $args) {
    $db = $this->get('db');
    $query = $db->prepare('SELECT * FROM coches WHERE id = :id');
    $query->bindParam('id', $args['id']);
    $query->execute();
    $coche = $query->fetch();
    return $response->withJson($coche);
});

// Crear un nuevo Coche
$app->post('/coches', function ($request, $response) {
    $data = $request->getParsedBody();
    $db = $this->get('db');
    $query = $db->prepare('INSERT INTO coches (marca, modelo) VALUES (:marca, :modelo)');
    $query->bindParam('marca', $data['marca']);
    $query->bindParam('modelo', $data['modelo']);
    $query->execute();
    return $response->withJson(['message' => 'Coche creado']);
});

// Actualizar un Coche por su ID
$app->put('/coches/{id}', function ($request, $response, $args) {
    $data = $request->getParsedBody();
    $db = $this->get('db');
    $query = $db->prepare('UPDATE coches SET marca = :marca, modelo = :modelo WHERE id = :id');
    $query->bindParam('marca', $data['marca']);
    $query->bindParam('modelo', $data['modelo']);
    $query->bindParam('id', $args['id']);
    $query->execute();
    return $response->withJson(['message' => 'Coche actualizado']);
});

// Eliminar un Coche por su ID
$app->delete('/coches/{id}', function ($request, $response, $args) {
    $db = $this->get('db');
    $query = $db->prepare('DELETE FROM coches WHERE id = :id');
    $query->bindParam('id', $args['id']);
    $query->execute();
    return $response->withJson(['message' => 'Coche eliminado']);
});

$app->run();

En este ejemplo, hemos definido las rutas y las acciones correspondientes para las operaciones CRUD de «Coches». Puedes adaptar este código para tus necesidades específicas, incluyendo la validación de datos y la gestión de errores según sea necesario. Asegúrate de configurar correctamente la conexión a la base de datos y las rutas para tu aplicación.

Paso 7: Validación de Datos

Asegúrate de validar los datos de entrada en tus acciones CRUD para garantizar la integridad de los datos y la seguridad de la aplicación. Puedes usar bibliotecas de validación como Respect\Validation.

La validación de datos es una parte importante de cualquier API REST. En Slim Framework, puedes utilizar la librería Respect\Validation para realizar la validación de datos. A continuación, te proporciono un ejemplo de cómo realizar la validación de datos para la creación de un nuevo recurso «Coche» en un CRUD utilizando Slim Framework:

Primero, asegúrate de que has incluido la librería Respect\Validation en tu proyecto. Puedes instalarla utilizando Composer:

composer require respect/validation

Luego, puedes utilizarla en tu aplicación Slim. Aquí tienes un ejemplo de cómo realizar la validación de datos para la creación de un nuevo Coche:

use Respect\Validation\Validator as v;

// ...

// Crear un nuevo Coche
$app->post('/coches', function ($request, $response) {
    $data = $request->getParsedBody();

    // Define las reglas de validación
    $rules = [
        'marca' => v::stringType()->notEmpty(),
        'modelo' => v::stringType()->notEmpty(),
    ];

    // Realiza la validación
    $validation = v::key($rules)->validate($data);

    if ($validation) {
        // Los datos son válidos, procede a crear el Coche en la base de datos
        $db = $this->get('db');
        $query = $db->prepare('INSERT INTO coches (marca, modelo) VALUES (:marca, :modelo)');
        $query->bindParam('marca', $data['marca']);
        $query->bindParam('modelo', $data['modelo']);
        $query->execute();

        return $response->withJson(['message' => 'Coche creado']);
    } else {
        // Los datos no son válidos, devuelve un mensaje de error
        return $response->withJson(['error' => 'Datos de entrada no válidos'], 400);
    }
});

En este ejemplo, hemos definido las reglas de validación utilizando la librería Respect\Validation. Si los datos no cumplen con las reglas de validación, se devolverá una respuesta de error con el código 400. Si los datos son válidos, se procederá a crear el Coche en la base de datos.

Puedes personalizar las reglas de validación según tus necesidades y agregar más validaciones, como comprobaciones de longitud, formato, etc. Este es solo un ejemplo básico para mostrarte cómo implementar la validación de datos en Slim Framework.

Paso 8: Pruebas

Realiza pruebas exhaustivas para asegurarte de que tu API REST funcione correctamente. Puedes utilizar herramientas de pruebas como PHPUnit o Postman para probar tus rutas y asegurarte de que respondan adecuadamente.

Para realizar pruebas con la herramienta Postman en un CRUD con APIs REST en Slim Framework, primero debes asegurarte de tener tu aplicación Slim configurada y en funcionamiento. Luego, puedes usar Postman para enviar solicitudes HTTP a tu API y verificar las respuestas. Aquí tienes un ejemplo de cómo realizar pruebas con Postman para un CRUD de la entidad «Coche»:

Supongamos que deseas realizar pruebas para las siguientes rutas de tu API de Slim:

Crear un nuevo coche (POST): http://tu-aplicacion/api/coches
Obtener todos los coches (GET): http://tu-aplicacion/api/coches
Obtener un coche por su ID (GET): http://tu-aplicacion/api/coches/{id}
Actualizar un coche por su ID (PUT): http://tu-aplicacion/api/coches/{id}
Eliminar un coche por su ID (DELETE): http://tu-aplicacion/api/coches/{id}

Para realizar pruebas de estas rutas en Postman, sigue estos pasos:

Paso 1: Crear una colección en Postman

Abre Postman y crea una nueva colección para tu proyecto. Puedes nombrarla como «API Coches» o similar.

Paso 2: Agregar solicitudes a la colección

Para cada ruta mencionada anteriormente, agrega una solicitud correspondiente a tu colección. Por ejemplo, para la creación de un coche, crea una solicitud POST con la URL http://tu-aplicacion/api/coches.

Paso 3: Configurar encabezados y cuerpo

En cada solicitud, configura los encabezados según sea necesario. Por ejemplo, asegúrate de incluir encabezados Content-Type con el valor application/json si estás enviando datos JSON en el cuerpo.
Configura el cuerpo de la solicitud con los datos que deseas enviar. Por ejemplo, para una solicitud POST para crear un coche, puedes proporcionar un objeto JSON con los detalles del coche.

Paso 4: Enviar solicitudes y verificar respuestas

Una vez que hayas configurado las solicitudes, simplemente haz clic en «Enviar» para enviar la solicitud a tu API.
Postman mostrará la respuesta de tu API. Verifica que la respuesta sea la esperada y que los datos se creen, obtengan, actualicen o eliminen correctamente.

Paso 5: Guardar y organizar tus pruebas

Puedes guardar tus solicitudes y respuestas en Postman para futuras pruebas. Organiza tus pruebas en carpetas dentro de tu colección.

Este es solo un ejemplo básico de cómo puedes realizar pruebas con Postman en una API CRUD construida con Slim Framework. Puedes personalizar y extender estas pruebas según las necesidades específicas de tu aplicación. Postman es una herramienta poderosa que te permite automatizar pruebas, ejecutar colecciones de pruebas y mucho más para garantizar el buen funcionamiento de tu API.

Conclusión

Con estos pasos, habrás creado un CRUD con APIs REST en Slim Framework. Slim es especialmente adecuado para aplicaciones livianas y rápidas, y te permite implementar rápidamente servicios web eficientes.

Siempre ten en cuenta la seguridad y la escalabilidad en tu desarrollo. Asegúrate de validar y sanear los datos, proteger tus rutas y considerar prácticas como la paginación y la autenticación. ¡Buena codificación!