Creación de Usuarios con Método POST en Node.js

Clase 9 de 30 • Curso de Backend con ExpressJS

Contenido del curso

Introducción a Node.js y Express

CRUD

MIddlewares

DB

JWT

Expres.js

Deploy

Tomar examen

Resumen

La creación de APIs RESTful es una habilidad fundamental para cualquier desarrollador web moderno. En este contenido, exploraremos cómo implementar el método POST para crear nuevos usuarios en nuestra API, un paso esencial para construir aplicaciones que permitan el registro de usuarios. Aprenderás a recibir datos, validarlos y almacenarlos correctamente, sentando las bases para operaciones CRUD completas.

¿Cómo implementar el método POST para crear usuarios en una API?

Cuando desarrollamos una API, necesitamos permitir que los clientes puedan crear nuevos recursos. En este caso, implementaremos un endpoint que utiliza el método HTTP POST para crear nuevos usuarios en nuestra aplicación.

Para comenzar, necesitamos crear un nuevo punto de entrada en nuestra aplicación. Aunque ya teníamos un endpoint para obtener usuarios con GET, ahora crearemos uno que utilice POST para la misma ruta:

app.post('/users', (req, res) => {
  // Código para crear un nuevo usuario
});

Este es un ejemplo claro de cómo una misma ruta puede tener diferentes comportamientos dependiendo del método HTTP que se utilice, uno de los principios fundamentales de las APIs RESTful.

¿Cómo obtener y procesar los datos enviados por el cliente?

Cuando un cliente envía una solicitud POST, generalmente incluye datos en el cuerpo de la solicitud. Gracias a la integración de BodyParser en nuestra aplicación, podemos acceder fácilmente a estos datos:

const newUser = req.body;

Esta simple línea nos permite capturar toda la información que el cliente está enviando. La estructura esperada para un usuario podría ser algo como:

{
  "id": 3,
  "name": "Nuevo Usuario",
  "email": "nuevo@ejemplo.com"
}

¿Cómo validar los datos recibidos?

Antes de guardar un nuevo usuario, es crucial validar que los datos recibidos cumplan con nuestros requisitos. Algunas validaciones comunes incluyen:

Verificar que el nombre tenga al menos 3 caracteres
Comprobar que el email tenga un formato válido
Asegurarse de que el ID sea único

Para implementar estas validaciones, podríamos usar código como el siguiente:

// Validación del nombre
if (!newUser.name || newUser.name.length < 3) {
  return res.status(400).json({ error: "El nombre debe tener al menos 3 caracteres" });
}

// Validación del email con expresión regular
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!newUser.email || !emailRegex.test(newUser.email)) {
  return res.status(400).json({ error: "El email no es válido" });
}

¿Cómo leer y actualizar los datos existentes?

Para guardar un nuevo usuario, primero necesitamos leer los usuarios existentes. Utilizaremos el módulo fs (File System) de Node.js para esto:

const fs = require('fs');

fs.readFile(userFilePath, 'utf-8', (error, data) => {
  if (error) {
    return res.status(500).json({ error: "Error con conexión de datos" });
  }
  
  const users = JSON.parse(data);
  
  // Aquí continuamos con el proceso
});

Una vez que tenemos los usuarios existentes, podemos agregar el nuevo usuario y guardar la información actualizada:

// Agregar el nuevo usuario
users.push(newUser);

// Guardar la información actualizada
fs.writeFile(userFilePath, JSON.stringify(users, null, 2), (error) => {
  if (error) {
    return res.status(500).json({ error: "Error al guardar el usuario" });
  }
  
  // Responder con el usuario creado
  res.status(201).json(newUser);
});

Utilizamos el código de estado HTTP 201 (Created) para indicar que el recurso se ha creado correctamente, siguiendo las mejores prácticas de diseño de APIs RESTful.

¿Cómo probar nuestro endpoint POST?

A diferencia de los endpoints GET, no podemos probar un endpoint POST simplemente visitando una URL en el navegador. Necesitamos una herramienta como Postman:

Crear una nueva solicitud en Postman
Seleccionar el método POST
Ingresar la URL de nuestro endpoint (por ejemplo, http://localhost:3000/users)
En la pestaña "Body", seleccionar "raw" y "JSON"
Ingresar los datos del nuevo usuario en formato JSON
Enviar la solicitud

Si todo funciona correctamente, recibiremos una respuesta con código 201 y los datos del usuario creado. Podemos verificar que el usuario se haya guardado correctamente haciendo una solicitud GET a /users.

¿Qué mejoras podríamos implementar?

Aunque nuestro endpoint funciona, hay varias mejoras que podríamos implementar:

Validación de ID único: Actualmente, no estamos verificando si el ID ya existe, lo que podría causar problemas.
Generación automática de ID: En lugar de requerir que el cliente proporcione un ID, podríamos generarlo automáticamente.
Manejo de errores más robusto: Podríamos implementar un sistema más completo para manejar diferentes tipos de errores.
Encapsulación de código repetido: Notamos que hay código que se repite (como la lectura del archivo) que podría encapsularse en funciones reutilizables.

Estas mejoras nos ayudarían a crear una API más robusta y mantenible, siguiendo los principios de diseño de software como DRY (Don't Repeat Yourself) y la separación de responsabilidades.

La implementación del método POST es solo el comienzo. En próximas lecciones, aprenderemos a utilizar el método PUT para actualizar información existente, completando así más operaciones CRUD en nuestra API.

¿Has implementado validaciones en tus APIs? Comparte en los comentarios cómo manejas la validación de datos en tus proyectos y qué estrategias utilizas para garantizar la integridad de la información.

Jorge Mario Florez Hernández

student•

Por acá mi aporte para la validación del campo name y emailapp.post('/users', (req, res) => { const newUser = req.body; const name = newUser.name; const email = newUser.email; const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; if(!newUser || Object.keys(newUser).length === 0){ return res.status(400).json({error: 'No se recibieron datos'}); } if(name.length < 3){ return res.status(400).json({ error: 'El campo \'name\' debe ser igual o mayor a 3 caracteres'}) } if(!regex.test(email)){ return res.status(400).json({ error: 'El campo \'email\' no cumple con la estructura esperada de un correo'}) }});

app.post('/users', (req, res) => {
    const newUser = req.body;
    const name = newUser.name;
    const email = newUser.email;
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

    if(!newUser || Object.keys(newUser).length === 0){
        return res.status(400).json({error: 'No se recibieron datos'});
    }

    if(name.length < 3){
        return res.status(400).json({ error: 'El campo \'name\' debe ser igual o mayor a 3 caracteres'})
    }

    if(!regex.test(email)){
        return res.status(400).json({ error: 'El campo \'email\' no cumple con la estructura esperada de un correo'})
    }
});

Cristian Ortega

student•


const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
function validateEmail(email) {
    return emailRegex.test(email);
}

app.post('/users', (req, res) => {
    const { name, email } = req.body;
    const errors = [];
    if (!name || !email) {
        return res.status(400).json({ error: 'Los campos name y email son obligatorios'});
    }

    if (name && name.length < 10) {
        errors.push('El campo Nombre debe tener al menos 10 carácteres');
    }

    if (email && !validateEmail(email)) {
        errors.push('El campo Email ingresado no es válido');
    }

    if (errors.length > 0) {
        return res.status(400).json({ errors });
    }

    fs.readFile(usersFilePath, 'utf-8', (error, data) => {
        if(error) {
            return res.status(500).json({ error: 'Error con conexión de datos.'});
        }
        const users = JSON.parse(data);
        const newId = users.length > 0 ? users[users.length - 1].id + 1 : 0
        const newUser = { id: newId, ...req.body };
        users.push(newUser);

        fs.writeFile(usersFilePath, JSON.stringify(users, null, 2), (error ) => {
            if(error) {
                return res.status(500).json({ error: 'Hubo un error la guardar al usuario.'});
            }
            res.status(201).json(newUser)
        });
    });
```app.post('/users', (req, res) => {    const { name, email } = req.body;    const errors = \[];    if (!name || !email) {        return res.status(400).json({ error: 'Los campos name y email son obligatorios'});    }
    if (name && name.length < 10) {        errors.push('El campo Nombre debe tener al menos 10 carácteres');    }
    if (email && !validateEmail(email)) {        errors.push('El campo Email ingresado no es válido');    }
    if (errors.length > 0) {        return res.status(400).json({ errors });    }
    fs.readFile(usersFilePath, 'utf-8', (error, data) => {        if(error) {            return res.status(500).json({ error: 'Error con conexión de datos.'});        }        const users = JSON.parse(data);        const newId = users.length > 0 ? users\[users.length - 1].id + 1 : 0        const newUser = { id: newId, ...req.body };        users.push(newUser);
        fs.writeFile(usersFilePath, JSON.stringify(users, null, 2), (error ) => {            if(error) {                return res.status(500).json({ error: 'Hubo un error la guardar al usuario.'});            }            res.status(201).json(newUser)        });    });

juan camilo mazuera arismendy

student•

Hola, podrian explicarme como funciona esa linea de caracteres especiales que llama regex, nunca habia visto eso. Gracias

Creación de Usuarios con Método POST en Node.js

Introducción a Node.js y Express

Desarrollo de APIs REST con ExpressJS y Node.js

Gestión de Versiones y Configuración de Node.js con NVM

Configuración y uso de variables de entorno en Node.js

Configuración de Body Parser en Express para APIs RESTful

Procesamiento de Formularios y JSON con Body Parser

Creación y Configuración de Workspaces en Postman para API Testing

CRUD

Construcción de una API RESTful con Express.js y métodos HTTP

Lectura y Escritura de Archivos en Node.js con FS y Path