Ejemplos esenciales de backend con Node.js para desarrolladores en 2024

El desarrollo de backend con Node.js sigue destacándose en 2024 como un entorno de ejecución potente y flexible para crear aplicaciones escalables y eficientes, más aún con el auge de otros entornos como Bun.

En este artículo, quiero ofrecer una introducción breve a ejemplos esenciales de backend con Node.js que muestran cómo aprovechar eficazmente las funciones avanzadas de JavaScript y Node.js. Desde usar el estándar WHATWG Streams y la API Web Streams para manejar datos de forma eficiente, hasta emplear el módulo integrado `crypto` de Node.js para la seguridad, trabajar con Buffers para manipular datos binarios, aprovechar Symbols para encapsular y organizar espacios de nombres, y utilizar literales de plantilla y plantillas etiquetadas para generar HTML y consultas SQL: cada sección ofrece fragmentos de código prácticos del mundo real y consejos.

Estos ejemplos no solo muestran la versatilidad y la capacidad de Node.js para resolver desafíos de backend, sino que también son una referencia valiosa para los desarrolladores que buscan mejorar sus soluciones de backend en 2024.

Capítulos de este artículo:

1. El estándar WHATWG Streams, la API Web Streams y los iterables asíncronos

2. Uso del módulo Crypto para validar firmas de webhook

3. Trabajo con buffers y datos binarios sin procesar en Node.js

4. Uso de JavaScript Symbol para la encapsulación

5. Literales de plantilla y plantillas etiquetadas para generar HTML y consultas SQL

Siempre puedes consultar el código fuente completo de estos ejemplos de backend con Node.js en este repositorio de GitHub.

1. El estándar WHATWG Streams, la API Web Streams y los iterables asíncronos

En 2024, el uso de streams ha aumentado significativamente, sobre todo al trabajar con modelos de lenguaje grandes para la inteligencia artificial generativa (GenAI). El SDK de OpenAI para completar chats es un excelente ejemplo de esta tendencia. Un ejemplo típico de cómo transmitir datos desde la API del SDK de OpenAI sería así:

1const completion = await openai.chat.completions.create(config);
2
3for await (const chunk of completion) {
4  console.log(chunk);
5}

Aquí usamos el concepto de iterables asíncronos, que ha simplificado los flujos de trabajo asíncronos en Node.js para adaptarlos al estilo de programación basado en promesas. La instrucción `for await…` crea un bucle que recorre objetos iterables asíncronos y también iterables síncronos, incluidos String, Array, objetos similares a Array (por ejemplo, arguments o NodeList), TypedArray, Map, Set e iterables asíncronos o síncronos definidos por el usuario.

Incorporación del estándar WHATWG Web Streams en Node.js

Web Streams, parte del estándar WHATWG Streams, se integró en Node.js y ofrece una forma sólida de manejar datos transmitidos en streaming. Este estándar permite a los desarrolladores leer, escribir y transformar datos de manera eficiente con JavaScript.

Veamos un ejemplo completo de cómo usar Web Streams en Node.js.

En el siguiente ejemplo, creamos una función `createReadableStreamFromFile()` que usa la clase `ReadableStream` de la API Web Streams para crear un stream de datos a partir de un archivo. Luego, una segunda función, `consumeStreamWithAsyncIterator()`, consume este stream mediante un iterador asíncrono.

1import { ReadableStream } from "node:stream/web";
2import fs from "fs";
3
4function createReadableStreamFromFile(filePath) {
5  const stream = new ReadableStream({
6    start(controller) {
7      const reader = fs.createReadStream(filePath);
8
9      reader.on("data", (chunk) => {
10        controller.enqueue(chunk);
11        if (reader.readableFlowing === false) {
12          reader.resume();
13        }
14      });
15
16      reader.on("end", () => {
17        controller.close();
18      });
19
20      reader.on("error", (err) => {
21        controller.error(err);
22      });
23    },
24  });
25
26  return stream;
27}
28
29async function consumeStreamWithAsyncIterator(stream) {
30  try {
31    for await (const chunk of stream) {
32      process.stdout.write(chunk);
33    }
34  } catch (err) {
35    console.error("Error occurred while reading the stream:", err);
36  }
37}
38
39const filePath = process.argv[2];
40const stream = createReadableStreamFromFile(filePath);
41consumeStreamWithAsyncIterator(stream);

En este código, usamos la API Web Streams para leer datos de un archivo en streaming. La función `createReadableStreamFromFile()` devuelve un objeto `ReadableStream` a partir de una ruta de archivo determinada. Luego, `consumeStreamWithAsyncIterator()` consume este stream, lee sus fragmentos uno por uno y escribe cada fragmento en la salida estándar. Si se produce un error durante la lectura, se captura y se registra en la consola.

Por cierto, ¿notaste la vulnerabilidad de seguridad en el código anterior?

Si tuvieras instalada la extensión de Snyk para VS Code, verías un error del linter subrayado que te indicaría que el ejemplo de código tiene una vulnerabilidad de recorrido de rutas.

La extensión de Snyk para VS Code te mostraría cómo los datos no seguros pueden llegar a este ejemplo de código de backend con Node.js, en qué consiste esta vulnerabilidad de seguridad y cómo corregirla con sugerencias seleccionadas por IA a partir de proyectos de código abierto activos.

2. Uso del módulo Crypto para validar firmas de webhook

Los webhooks se han convertido en una parte integral del desarrollo moderno de backend, ya que permiten que distintos servicios se comuniquen de manera eficiente y en tiempo real. Sin embargo, el mayor uso de webhooks también exige medidas de seguridad más sólidas, como la validación de las firmas de webhook.

En el contexto de los webhooks, una firma es un hash que se envía junto con la carga útil del webhook y que se calcula con una clave secreta que solo conocen el emisor y el destinatario. Luego, el destinatario puede calcular el hash por su cuenta y compararlo con la firma para verificar la autenticidad del webhook.

El módulo Crypto de Node.js ofrece numerosas funciones criptográficas, incluido un conjunto de envoltorios para las funciones de hash, HMAC, cifrado, descifrado, firma y verificación de OpenSSL. HMAC (código de autenticación de mensajes basado en hash) es especialmente útil para validar firmas de webhook.

Analicemos el fragmento de código para entender cómo funciona:

1const crypto = require("node:crypto");
2
3const secret = process.env.WEBHOOK_SECERT;
4const hmac = crypto.createHmac("sha256", secret);
5const digest = Buffer.from(
6  hmac.update(request.rawBody).digest("hex"),
7  "utf8"
8);
9const signature = Buffer.from(request.headers["x-signature"] || "", "utf8");
10
11if (!crypto.timingSafeEqual(digest, signature)) {
12  throw new Error("Invalid signature.");
13}

En este fragmento, se usa el método `crypto.createHmac` para crear un objeto HMAC. Este método recibe dos parámetros: el algoritmo que se usará (en este caso, `sha256`) y la clave secreta.

Luego, el objeto HMAC se actualiza con el cuerpo sin procesar de la solicitud de webhook mediante el método `hmac.update`. Este método se puede llamar varias veces con datos nuevos a medida que se transmiten.

Luego, se usa el método `digest` para generar el hash. Este método solo se puede llamar una vez en el objeto HMAC y devuelve el hash calculado. El parámetro `hex` indica que el método debe devolver el hash en formato hexadecimal.

Ahora, presentamos el concepto de comparación segura de cadenas. El hash calculado (digest) y la firma recibida en el encabezado de la solicitud de webhook se comparan con el método `crypto.timingSafeEqual`. Este método compara la igualdad de dos buffers de forma segura frente a ataques de temporización, por lo que es ideal para comparar resultados criptográficos.

Los ataques de temporización son un tipo de ataque de canal lateral en el que un atacante intenta comprometer un sistema analizando el tiempo que tardan en ejecutarse los algoritmos criptográficos. Al usar un método seguro frente a ataques de temporización, como `crypto.timingSafeEqual`, nos protegemos contra este tipo de ataques. Si el digest y la firma no coinciden, se genera un error que indica que la solicitud de webhook podría no ser auténtica.

3. Trabajo con buffers y datos binarios sin procesar en Node.js

La API Buffer de Node.js es una herramienta potente que permite a los desarrolladores trabajar directamente con datos binarios. Ya sea que necesites leer un archivo, analizar una imagen o procesar datos sin procesar, la API Buffer ofrece métodos para realizar estas tareas de manera eficiente.

Exploremos algunos métodos comunes de la API Buffer en Node.js, como `.from`, `.alloc` y `.write`, que permiten crear y manipular objetos buffer. El método `.from` crea un buffer nuevo con los datos que se pasan como argumento; `.alloc` crea un buffer nuevo de un tamaño específico, y `.write` permite escribir datos en un buffer. Otro método es `.concat`, que se usa para concatenar una lista de instancias de Buffer.

1let buffer1 = Buffer.from('Hello, ');
2let buffer2 = Buffer.from('World!');
3let buffer3 = Buffer.concat([buffer1, buffer2]);
4
5console.log(buffer3.toString());
6// prints: 'Hello, World!'

Análisis de una imagen con la API de OpenAI mediante la API Buffer de Node.js

En el siguiente ejemplo de código de backend con Node.js, usamos la API Buffer para leer un archivo de imagen y analizarlo mediante la API de OpenAI. Primero, importamos los módulos necesarios y creamos una instancia del cliente de la API de OpenAI:

1import { readFile } from "node:fs/promises";
2import OpenAI from "openai";
3
4const openai = new OpenAI();

A continuación, leemos el archivo de imagen en un buffer:

const imageBuffer = await readFileToBuffer(process.argv[2]);

Luego, validamos el tipo de imagen al comparar la firma del archivo con la firma conocida de una imagen PNG:

1function isImageTypeValid(imageBuffer) {
2  const pngSignature = Buffer.from([
3    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
4  ]);
5  const fileSignature = imageBuffer.slice(0, 8);
6
7  if (pngSignature.equals(fileSignature)) {
8    return true;
9  }
10}

Por último, generamos un texto alternativo descriptivo para la imagen mediante la API de OpenAI:

1async function generateAltTextForImage(imageBuffer) {
2  const imageInBase64 = imageBuffer.toString("base64");
3
4  const response = await openai.chat.completions.create({
5    model: "gpt-4-vision-preview",
6    messages: [
7      {
8        role: "user",
9        content: [
10          {
11            type: "text",
12            text: "What's in this image? generate a simple alt text for an image source in an HTML page",
13          },
14          {
15            type: "image_url",
16            image_url: {
17              url: `data:image/png;base64,${imageInBase64}`,
18            },
19          },
20        ],
21      },
22    ],
23  });
24
25  return response.choices[0];
26}

Consideraciones de seguridad al usar la API Buffer

Al trabajar con la API Buffer, debes tener en cuenta varias consideraciones de seguridad. El manejo incorrecto de datos binarios puede provocar posibles vulnerabilidades de seguridad, como errores de desbordamiento o subdesbordamiento del buffer. Asegúrate siempre de validar las entradas y manejar los errores correctamente.

Además, ten en cuenta posibles vulnerabilidades de seguridad, como el constructor `Buffer`, que ahora está obsoleto y debe evitarse en favor de alternativas más seguras, como `Buffer.from` o `Buffer.alloc`.

4. Uso de JavaScript Symbol para la encapsulación

Los Symbols son un tipo de dato primitivo introducido en ES6 (ECMAScript 2015) que representan identificadores únicos e inmutables. Se crean con la función `Symbol()`, que puede aceptar opcionalmente una descripción (una cadena) para facilitar la depuración, aunque esta no afecta la unicidad del símbolo. Los Symbols se usan principalmente para crear claves de propiedades únicas para objetos que no entren en conflicto con ninguna otra propiedad, incluidas las heredadas. Esto los hace especialmente útiles para definir propiedades privadas o especiales de objetos sin arriesgarse a que los nombres de las propiedades entren en conflicto.

Aquí tienes un ejemplo de código de backend con Node.js que muestra cómo usar Symbols para crear una propiedad privada en una clase y encapsular datos:

1const _privateProperty = Symbol('privateProperty');
2
3class MyClass {
4  constructor(value) {
5    this[_privateProperty] = value;
6  }
7
8  getPrivateProperty() {
9    return this[_privateProperty];
10  }
11}
12
13const instance = new MyClass('secret');
14console.log(instance.getPrivateProperty());
15// Will output 'secret'
16// The _privateProperty cannot be directly accessed from outside the class

Además, los Symbols no son accesibles mediante la enumeración de propiedades de un objeto (como los bucles `for...in` o `Object.keys()`), por lo que, en cierto sentido, pueden usarse para simular propiedades y métodos privados de objetos. Sin embargo, es importante tener en cuenta que no son realmente privados y todavía se puede acceder a ellos con métodos de reflexión como `Object.getOwnPropertySymbols()`.

JavaScript define un conjunto de Symbols conocidos que representan comportamientos internos del lenguaje que los desarrolladores pueden personalizar. Por ejemplo, puedes implementar un iterador para un objeto personalizado mediante `Symbol.iterator`:

1const iterable = {
2  [Symbol.iterator]: function* () {
3    yield 1;
4    yield 2;
5  }
6};
7
8for (const value of iterable) {
9  // Logs 1 and 2
10  console.log(value);
11}

Uso de JavaScript Symbol en Fastify

Veamos un ejemplo más cercano a un caso real con el framework de aplicaciones web Fastify y cómo el proyecto usa Symbols. En concreto, analizaremos un ejemplo de la arquitectura de plugins de Fastify. Uno de los aspectos clave del diseño de Fastify es su función de encapsulación, que permite a los desarrolladores crear contextos de aplicación aislados mediante plugins. Esto es fundamental para crear aplicaciones a gran escala, donde los conflictos entre espacios de nombres pueden convertirse en un problema.

Fastify usa Symbols para identificar de manera única las propiedades y los métodos internos, y así evitar que interfieran con las propiedades definidas por el usuario o con las de otros plugins. Aquí tienes un ejemplo simplificado, basado en el uso real de Symbols en el código fuente de Fastify, para encapsular los metadatos de un plugin:

1const pluginMeta = Symbol('fastify.pluginMeta');
2
3function registerPlugin(instance, plugin, options) {
4  if (!plugin[pluginMeta]) {
5    plugin[pluginMeta] = { options, name: plugin.name };
6  }
7
8  instance.register(plugin, options);
9}
10
11function myPlugin(instance, opts, done) {
12  done();
13}
14
15registerPlugin(fastifyInstance, myPlugin, { prefix: '/api' });

En el ejemplo anterior, `pluginMeta` es un Symbol que Fastify usa para agregar metadatos a las funciones de los plugins. Estos metadatos incluyen las opciones y el nombre del plugin, así como otra información que el framework pueda necesitar internamente. La función `registerPlugin` simplifica el proceso de agregar metadatos a un plugin antes de registrarlo en una instancia de Fastify. Luego, estos metadatos están disponibles dentro del framework Fastify, pero permanecen aislados de la interfaz pública del plugin y del ámbito global de la aplicación.

Usar JavaScript Symbol para metadatos internos como estos ofrece varias ventajas en un framework como Fastify:

• Encapsulación: evita que los detalles internos se filtren al espacio del usuario y mantiene la API pública limpia e intuitiva.

• Seguridad: reduce el riesgo de interferencias accidentales entre plugins o entre un plugin y el framework principal, ya que no se puede acceder a los Symbols mediante la enumeración normal de las propiedades de un objeto.

• Claridad: distingue claramente los mecanismos internos del framework de las API que se exponen a los desarrolladores, lo que facilita el mantenimiento y la ampliación del código de Fastify.

5. Literales de plantilla y plantillas etiquetadas para generar HTML y consultas SQL

Introducidos en ES6, los literales de plantilla ofrecen una sintaxis más legible y concisa para crear cadenas en JavaScript. Es posible que ya los hayas usado para escribir cadenas e integrar expresiones dinámicas, como `hello ${name}`. Se acabó concatenar cadenas.

Cada vez es más común usar literales de plantilla en forma de plantillas etiquetadas para generar HTML y consultas SQL en backends de Node.js. Aquí tienes dos ejemplos reales de código de backend con Node.js y SSR:

Plantillas etiquetadas para generar consultas SQL con la biblioteca PostgreSQL de Vercel

Trabajar con consultas SQL en Node.js suele generar código extenso y propenso a errores, especialmente al insertar valores dinámicamente en las consultas. El paquete PostgreSQL de Vercel (`@vercel/postgres`) ofrece una forma más segura y concisa de dar formato a las consultas SQL mediante literales de plantilla:

1import { sql } from '@vercel/postgres';
2
3const jediName = 'Luke Skywalker';
4const { rows } = await sql`SELECT * FROM jedis WHERE name = ${jediName};`;

La función de literales de plantilla etiquetados con SQL interpola de forma segura la variable `jediName` en la consulta SQL, lo que previene eficazmente los ataques de inyección SQL.

Plantillas etiquetadas para generar HTML en servidores Fastify

Al igual que las consultas SQL, `fastify-html` es un plugin de Fastify que permite a los desarrolladores usar plantillas etiquetadas para generar contenido HTML directamente en los controladores de rutas. Esto puede ser especialmente útil para el renderizado del lado del servidor (SSR) o para generar contenido HTML dinámico (¿alguien dijo htmx?):

1import fastify from 'fastify'
2import fastifyHtml from 'fastify-html'
3
4const app = fastify()
5await app.register(fastifyHtml)
6
7app.get('/', async (req, reply) => {
8  const name = req.query.name || 'World';
9  return reply.html`<h1>Hello ${name}</h1>`;
10});

Para cerrar

Si te gustó este artículo, también puedes consultar las prácticas recomendadas para crear un paquete npm moderno con la seguridad en mente y 10 prácticas recomendadas para implementar aplicaciones web de Node.js en contenedores con Docker.

Y si te interesan las historias de seguridad, asegúrate de estar bien preparado para combatir los ataques a la cadena de suministro en npm con las prácticas de seguridad para desarrolladores que mencioné en el artículo.

Por último, no olvides consultar Snyk con una cuenta gratuita para empezar a proteger tu código de Node.js, tus dependencias y las imágenes de contenedor de Docker.