Creación de rutas para modificar y borrar los registros (5ª parte de creación de una API REST con Express y TypeScript)

En la publicación anterior se han visto los pasos para crear dos rutas mediante las cuales se pueden consultar y agregar los usuarios de la API. Esto es, se han implementado los métodos GET y POST respectivamente. Ahora, para tener implementado todas las operaciones CRUD es necesario crear dos métodos para modificar y borrar los registros. Veamos en esta ocasión como se puede implementar un verbo PUT para modificar los registros y otro DELETE para eliminarlos.

Método PUT para modificar los registros

Tal como se ha visto para la creación de un método PUT solamente hay que implementar esta operación en la ruta. Para lo que se usa el método router.put(). En este caso la función debería modificar el registro, esto es, para un registro que exista, por lo que es necesario indicar un id válido, se deben modificar los datos. Una posible implementación de esto sería la función que se muestra a continuación.

router.put('/', (req: Request, res: Response) => {
  if (req.query.id) {
    datasource
      .getRepository(User)
      .findOneByOrFail({ id: Number(req.query.id) })
      .then((user) => {
        if (req.body.firstName) {
          user.firstName = String(req.body.firstName);
        }
        if (req.body.lastName) {
          user.lastName = String(req.body.lastName);
        }

        datasource
          .getRepository(User)
          .save(user)
          .then((user) => res.send(user))
          .catch((error) => res.status(500).send({ message: error.message }));
      })
      .catch((error) => res.status(500).send({ message: error.message }));
  } else {
    res
      .status(400)
      .send({ message: `It is necessary to indicate the id of a user` });
  }
});

En este caso lo que se hace es comprobar que se ha indicado un parámetro id en la URL. Si no es así el método emitirá un error 400 indicando que la petición no es válida. Cuando se indica un id se busca en la base de datos con el método findOneByOrFail(). Este método busca solamente un registro que cumpla las condiciones indicadas, si existe devolverá el registros, en caso contrario saldrá por catch() emitiendo un error de registro no encontrado.

Una vez el método de TypeORM devuelva un registro no es necesario comprobar que este no esté vacío, ya que si llega al método then() es que existe. Una ventaja del método findOneByOrFail() ya que siempre obtiene un registro o produce un error. En el método then() solamente hay que coger el registro, modificarlo con lo que venga en el cuerpo y guardarlo en la base de datos.

Al igual que en el caso del método POST, en esta ocasión se devuelve el registro modificado.

Método DELETE para eliminar los registros

La última operación que se necesita implementar para tener todas las operaciones CRUD es DELETE, con el que se eliminarán los registros de la base de datos. De forma análoga a lo que se ha visto en ocasiones anteriores solamente hay que usar el método router.delete() para su implementación. Al igual que antes, esta operación necesita un id para saber el registro que se desea eliminar. Una posible implementación de este método puede ser el que se muestra a continuación

router.delete('/', (req: Request, res: Response) => {
  if (req.query.id) {
    datasource
      .getRepository(User)
      .delete({ id: Number(req.query.id) })
      .then((user) => res.send(user))
      .catch((error) => res.status(500).send({ message: error.message }));
  } else {
    res
      .status(400)
      .send({ message: `It is necessary to indicate the id of a user` });
  }
});

En esta ocasión, al igual que en para el método POST lo primero que se hace es comprobar si se ha indicado o no un valor para id del registro que se desea eliminar. Si no existe este valor se indicará mediante un error 400 que la operación no es válida. Por otro lado cuando se indica un valor se usa el método delete() del repositorio para eliminar el registro que cumpla la condición. En este caso, tanto si existe como si no existe un registro con el id indicado la operación saldrá por el método then(), indicando el número de registros que se han eliminado.

Comprendiendo las rutas

Hasta ahora, cuando se ha creado un método HTTP el primer parámetro ha sido la cadena '/'. Con esto lo que se indicaba es que el método se ejecuta en la raíz de la ruta http://localhost:3000/. Pero, dado que en una API lo normal es tener más de un método es necesario dar un nombre diferente a cada uno de ellos. Lo que se hace con el primer parámetro de los diferentes métodos de la ruta. Así, si se desea llamar a esta API en, por ejemplo, user, una forma de conseguirlo sería cambiar router.get('/', ...) por router.get('/user', ...). Aunque existe otra opción, mantener el código tal como está actualmente y guardarlo en un archivo llamado users.ts. Ahora estos métodos se pueden importar en una ruta con el método router.use('/users', users); indicando el nombre que tomará la ruta.

Esto es, ahora se tiene un archivo routes\users.ts tal como se muestra a continuación

import { Router, Request, Response } from 'express';

import datasource from '../datasource';
import { User } from '../entities/user';

const router = Router();

router.post('/', (req: Request, res: Response) => {
  if (
    (req.query.firstName & req.query.lastName) ||
    (req.body.firstName & req.body.lastName)
  ) {
    const user = new User();

    if (req.query.firstName & req.query.lastName) {
      user.firstName = String(req.query.firstName);
      user.lastName = String(req.query.lastName);
    } else {
      user.firstName = String(req.body.firstName);
      user.lastName = String(req.body.lastName);
    }

    datasource
      .getRepository(User)
      .save(user)
      .then((user) => res.send(user))
      .catch((error) => res.status(500).send({ message: error.message }));
  } else {
    res.status(400).send({
      message: `It is necessary to indicate the parameters 'firstName' and 'lastName' for the creation of a user`,
    });
  }
});

router.get('/', (req: Request, res: Response) => {
  const skip = Number(req.query.from) || 0;
  const take = Number(req.query.take) || 10;

  datasource
    .getRepository(User)
    .find({ skip, take })
    .then((users) => res.send(users))
    .catch((error) => res.status(500).send({ message: error.message }));
});

router.put('/', (req: Request, res: Response) => {
  if (req.query.id) {
    datasource
      .getRepository(User)
      .findOneByOrFail({ id: Number(req.query.id) })
      .then((user) => {
        if (req.body.firstName) {
          user.firstName = String(req.body.firstName);
        }
        if (req.body.lastName) {
          user.lastName = String(req.body.lastName);
        }

        datasource
          .getRepository(User)
          .save(user)
          .then((user) => res.send(user))
          .catch((error) => res.status(500).send({ message: error.message }));
      })
      .catch((error) => res.status(500).send({ message: error.message }));
  } else {
    res
      .status(400)
      .send({ message: `It is necessary to indicate the id of a user` });
  }
});

router.delete('/', (req: Request, res: Response) => {
  if (req.query.id) {
    datasource
      .getRepository(User)
      .delete({ id: Number(req.query.id) })
      .then((user) => res.send(user))
      .catch((error) => res.status(500).send({ message: error.message }));
  } else {
    res
      .status(400)
      .send({ message: `It is necessary to indicate the id of a user` });
  }
});

export default router;

El archivo routes\index.ts será simplemente el siguiente.

import { Router } from 'express';

import users from './users';

const router = Router();

router.use('/users', users);

export default router;

Por lo que ahora el API se encuentra en http://localhost:3000/users

Versiones de la API

En muchas API es habitual encontrarse con prefijos como /v0 o /v1. Un método para separar las versiones de las API. Así si en un momento se desea cambiar el API solamente se debe indicar que ahora se debe consultar la versión /v1 en lugar de la /v0, pudiendo mantener las dos durante un tiempo para que los clientes se adapten. Esto es algo que se pude hacer en Express fácilmente con el método routes.use() creando una carpeta en las rutas v0 y guardando la ruta actual en esta (será necesario actualizar las rutas a las importaciones, aunque esto es algo que puede hacer automáticamente las herramienta de refactorización) y creando un nuevo archivo index.ts como el que se muestra a continuación.

Ahora los métodos implementados se deberán consultar en http://localhost:3000/v0/users. Esta será la forma en la que se trabajará a partir de ahora.

Conclusiones

En esta ocasión se ha visto cómo se pueden crear rutas para modificar y borrar los registros con Express. Aunque prácticamente todas las novedades presentadas son de TypeORM. Además de ver cómo se puede organizar las rutas para que sea fácil mantener el código. En la próxima entrega se mostrará cómo incluir los en la aplicación.

Imagen de Tayeb MEZAHDIA en Pixabay