Ejercicio: Escritura de datos

5 minutos

Tailwind Traders está impresionado con las API, que devuelven productos existentes. Ahora debe crear una API que pueda insertar y actualizar productos. Los datos se almacenan normalmente en una base de datos y contienen millones de registros. Por ese motivo, debe usar técnicas que limiten la cantidad de datos que se pasan a la API y se devuelven desde la API.

Implementación de compatibilidad para escribir datos

Implemente la API CRUD en el recurso products:

Este proyecto inicial en nodejs-route\exercise-express-routing\reading-writing contiene los archivos de producto y algo de código de aplicación de inicio. Lo único que hay que hacer es rellenar las partes que faltan.

Haga clic con el botón derecho en el nombre de la carpeta reading-writing y seleccione Abrir en el terminal integrado.
Ejecute el comando siguiente en el terminal para instalarlo:
```
npm install
```

Abra app.js para inspeccionarlo. El archivo debería tener este aspecto:

 const express = require('express');
 const app = express();
 const port = 3000;

 app.use(express.json());

 let products = [];

 app.post('/products', function (req, res) {
   // implement
 });

 app.put('/products', function (req, res) {
   // implement
 });

 app.delete('/products/:id', function (req, res) {
   // implement
 });

 app.get('/products', (req, res) => {
   // implement
 });

 app.listen(port, () =>
   console.log(`Example app listening at http://localhost:${port}`),
 );

El archivo app.js muestra el esqueleto de un programa. El trabajo siguiente consiste en implementar las rutas.

Implementación de la ruta para leer datos

Para implementar rutas, el proceso consiste en agregar un poco de código y después probarlo. Continúe agregando cada método de ruta hasta que tenga una API totalmente funcional. Realice los cambios en el archivo app.js en el directorio de lectura y escritura . Todos los archivos que comienzan por client son aplicaciones cliente que puede usar para probar la API.

Para admitir la lectura desde la API, busque la parte del código que tiene el siguiente aspecto:
```
app.get('/products', (req, res) => {
  // implement
})
```
Reemplácelo por este código:
```
app.get('/products', (req, res) => {
  res.json(products);
})
```
Para comprobar que el código funciona, inicie la aplicación Node ejecutando este comando:
```
node app.js
```
En un terminal independiente para la misma carpeta, reading-writing, ejecute el siguiente comando. Es importante tener dos terminales abiertos porque necesita ejecutar el servidor y el cliente al mismo tiempo.
```
node client-get.js
```
Debería obtener la siguiente salida:
```
Received data []
Connection closed
```
La API responde con una matriz vacía porque todavía no hemos escrito datos en ella. Vamos a cambiar eso a continuación.
En el primer terminal, seleccione Ctrl+C para detener la aplicación.

Implementación de la ruta para escribir datos

Para implementar la escritura de datos en la base de datos en memoria, busque este código:
```
app.post('/products', function (req, res) {
   // implement
});
```
Reemplácelo por este código:
```
app.post('/products', function(req, res) {
  const newProduct = { ...req.body, id: products.length + 1 }
  products = [ ...products, newProduct]
  res.json(newProduct);
});
```
El nuevo código lee los datos entrantes de req.body y los usa para crear un objeto de JavaScript. A continuación, se agrega a la matriz products de base de datos en memoria. Por último, el nuevo producto se devuelve al usuario.
Para probar el código, ejecute el programa de servidor ejecutando este comando:
```
node app.js
```
En un terminal independiente para la misma carpeta, reading-writing, ejecute el siguiente comando. Es importante tener dos terminales abiertos porque necesita ejecutar el servidor y el cliente al mismo tiempo.
```
node client-post.js
```
La salida debe ser parecida a la siguiente:
```
response {"name":"product","id":1}
Closed connection
```
Para comprobar que los datos se escriben en la API, ejecute el comando siguiente:
```
node client-get.js
```
Debería ver la siguiente salida:
```
Received data [{"name":"product","id":1}]
Connection closed
```
Sus solicitudes hasta ahora:
- client-post.js: la respuesta le indica que, cuando se ha ejecutado client-post.js, se han escrito datos en la API.
- client-get.js: ha ejecutado client-get.js para consultar los datos de la API. La API ha respondido con los datos que acaba de escribir en ella.
En el primer terminal, seleccione Ctrl+C para detener la aplicación.

Implementación de la ruta para actualizar datos

Para implementar la capacidad de actualizar los datos, busque este código:

app.put('/products', function (req, res) {
  // implement
});

Reemplácelo por este código:

app.put('/products', function(req, res) {
  let updatedProduct;
  products = products.map(p => {
    if (p.id === req.body.id) {
      updatedProduct = { ...p, ...req.body };
      return updatedProduct;
    }
    return p;
  })
  res.json(updatedProduct);
});

El nuevo código busca el registro en la matriz products de base de datos en memoria que coincide con la propiedad id y actualiza ese registro.

Para probar el código, inicie la aplicación de servidor:
```
node app.js
```
En el otro terminal, ejecute este comando para crear un registro:
```
node client-post.js
```
Ejecute este comando para actualizar el registro recién creado:
```
node client-put.js
```
Debería aparecer la siguiente actualización en el terminal:
```
response {"name":"product-updated","id":1}
Closed connection
```
Para comprobar que la actualización funciona, ejecute este comando:
```
node client-get.js
```
Debería ver esta actualización:
```
Received data [{"name":"product-updated","id":1}]
Connection closed
```
En el primer terminal, seleccione Ctrl+C para detener la aplicación.

Implementación de la ruta para eliminar datos

Para implementar la eliminación, busque un código similar a este:

app.delete('/products/:id', function (req, res) {
  // implement
});

Reemplácelo por este código:

app.delete('/products/:id', function(req, res) {
  const deletedProduct = products.find(p => p.id === +req.params.id);
  products = products.filter(p => p.id !== +req.params.id);
  res.json(deletedProduct);
});

El nuevo código busca el producto que se va a eliminar. A continuación, filtra ese elemento de la matriz products de base de datos en memoria y devuelve el producto eliminado.

Para probar el código, inicie la aplicación de servidor:
```
node app.js
```
En un terminal aparte, ejecute este comando para crear un registro:
```
node client-post.js
```
Ejecute este comando para quitar el registro:
```
node client-delete.js
```
Debería ver la salida siguiente:
```
response {"name":"product","id":1}
Closed connection
```
Para comprobar el código, ejecute este comando:
```
node client-get.js
```
Debe proporcionar esta salida:
```
Received data []
Connection closed
```
Felicidades. Ha implementado un recurso products mediante un CRUD completo (crear, leer, actualizar, eliminar acciones).
En el primer terminal, seleccione Ctrl+C para detener la aplicación.

Limpiar contenedor de desarrollo

Después de completar el proyecto, puede que desee limpiar el entorno de desarrollo o devolverlo a su estado típico.

Desarrollo remoto (explorador)
Desarrollo local (Docker)

La eliminación del entorno de GitHub Codespaces garantiza que puede maximizar la cantidad de derechos de horas gratuitas de núcleos que obtiene para su cuenta.

Importante

Para obtener más información sobre los derechos de la cuenta de GitHub, consulte Almacenamiento y horas de núcleo incluidas mensualmente en GitHub Codespaces.

Inicie sesión en el panel de GitHub Codespaces (https://github.com/codespaces).
Busque los espacios de código que se ejecutan actualmente procedentes del repositorio de GitHub MicrosoftDocs/node-essentials.
Abra el menú contextual delcodespace y seleccione Eliminar.

Continuar