10 funciones modernas del runtime de Node.js que debes empezar a usar en 2024

Escrito por

29 de mayo de 2024

0 minutos de lectura

10 Node.js runtime features you SHOULD be using in 2024

El ecosistema de runtimes de JavaScript del lado del servidor está repleto de innovaciones: Bun avanza con APIs compatibles con Node.js, mientras que el runtime de Node.js ofrece una biblioteca estándar completa y amplias capacidades.

Ahora que comienza 2024, este artículo es una buena oportunidad para mantenerte al día con las últimas funciones y capacidades del runtime de Node.js. Estar al tanto de las novedades no se trata solo de «seguir el ritmo»: también significa aprovechar el poder de las APIs modernas para escribir código más eficiente, rápido y seguro.

En esta publicación exploraremos 10 funciones modernas del runtime de Node.js que todos los desarrolladores deberían empezar a usar en 2024. Veremos desde APIs recién lanzadas hasta las interesantes funciones de las nuevas alternativas, como Bun y Deno.

Requisito previo: versión LTS de Node.js

Antes de explorar estas funciones modernas, asegúrate de usar la versión LTS (soporte a largo plazo) de Node.js. Al momento de escribir este artículo, la versión LTS más reciente de Node.js es la v20.14.0.

Para comprobar tu versión de Node.js, usa este comando:

node --version

Si no estás usando la versión LTS, considera usar un administrador de versiones como fnm o nvm para cambiar fácilmente entre distintas versiones de Node.js.

¿Qué novedades hay en Node.js 20?

En las siguientes secciones, veremos algunas funciones nuevas que se incorporaron en versiones recientes de Node.js. Algunas son estables, otras aún son experimentales y algunas ya contaban con soporte, aunque quizá todavía no las conocías.

Veremos los siguientes temas:

1. El ejecutor de pruebas nativo de Node.js

¿Qué usábamos antes de que Node.js incorporara un ejecutor de pruebas al runtime nativo? Hasta ahora, probablemente usabas una de las opciones populares, como node-tap, jest, mocha o vitest.

Veamos cómo aprovechar el ejecutor de pruebas nativo de Node.js en tu flujo de desarrollo. Para empezar, debes importar el módulo de pruebas de Node.js en tu archivo de pruebas, como se muestra a continuación:

import { test } from 'node:test';

Ahora repasemos los distintos pasos para usar el ejecutor de pruebas de Node.js.

Ejecutar una sola prueba con node:test

Para crear una sola prueba, usa la función test y pasa el nombre de la prueba y una función de callback. En esta función defines la lógica de la prueba.

1import { test } from "node:test";
2import assert from "node:assert";
3import { add } from "../src/math.js";
4
5test("should add two numbers", () => {
6  const result = add(1, 2);
7  assert.strictEqual(result, 3);
8});
9
10test("should fail to add strings", () => {
11  assert.throws(() => {
12    add("1", "2");
13  });
14});

Para ejecutar esta prueba, usa el comando node --test, seguido del nombre del archivo de pruebas:

node --test tests/math.test.js

El ejecutor de pruebas de Node.js puede detectar y ejecutar automáticamente los archivos de pruebas de tu proyecto. Por convención, estos archivos deben terminar en .test.js, aunque no es obligatorio seguir esta convención de nombres.

Si omites el argumento posicional del archivo de pruebas, el ejecutor de pruebas de Node.js aplicará algunas heurísticas y patrones glob para encontrar archivos de pruebas, como todos los archivos de una carpeta test/ o tests/, o los archivos que comienzan con test- o terminan en .test.

Por ejemplo, para buscar archivos de pruebas con patrones glob:

node --test '**/*.test.js'

Usar aserciones de prueba con node:assert

El ejecutor de pruebas de Node.js admite aserciones mediante el módulo integrado assert. Puedes usar distintos métodos, como assert.strictEqual, para verificar tus pruebas.

1import assert from 'node:assert';
2
3test('Test 1', () => {
4  assert.strictEqual(1 + 1, 2);
5});

Suites y hooks de pruebas con el ejecutor nativo de Node.js

La función describe se usa para agrupar pruebas relacionadas en una suite. Esto permite organizar mejor las pruebas y facilita su administración.

1import { test, describe } from "node:test";
2
3describe('My Test Suite', () => {
4  test('Test 1', () => {
5    // Test 1 logic
6  });
7
8  test('Test 2', () => {
9    // Test 2 logic
10  });
11});

Los hooks de pruebas son funciones especiales que se ejecutan antes o después de las pruebas. Son útiles para preparar o limpiar los entornos de prueba.

1test.beforeEach(() => {
2  // Runs before each test
3});
4
5test.afterEach(() => {
6  // Runs after each test
7});

También puedes omitir una prueba con la función test.skip. Esto resulta útil cuando quieres ignorar temporalmente una prueba específica.

1test.skip('My skipped test', () => {
2  // Test logic
3});

Además, el ejecutor de pruebas de Node.js ofrece distintos reporteros que presentan los resultados de varias maneras. Puedes especificar uno con la opción --reporter.

node --test --test-reporter=tap

¿Deberías dejar de usar Jest?

Aunque Jest es un framework de pruebas popular en la comunidad de Node.js, tiene algunos inconvenientes que hacen que el ejecutor de pruebas nativo de Node.js sea una opción más atractiva.

Al instalar Jest, incluso como una simple dependencia de desarrollo, agregas 277 dependencias transitivas con distintas licencias, entre ellas MIT, Apache-2.0, CC-BY-4.0 y una licencia desconocida. ¿Lo sabías?

Gráfico de dependencias transitivas de Jest.

Jest modifica variables globales, lo que puede provocar comportamientos inesperados en tus pruebas.
El operador instanceof no siempre funciona como se espera en Jest.
Jest agrega una gran cantidad de dependencias a tu proyecto, lo que dificulta mantenerlas actualizadas y te obliga a administrar innecesariamente problemas de seguridad y otras cuestiones relacionadas con las dependencias de desarrollo.
Jest puede ser más lento que el ejecutor de pruebas nativo de Node.js debido a la sobrecarga que genera.

Otras funciones destacadas del ejecutor de pruebas nativo de Node.js son la ejecución de subpruebas y de pruebas simultáneas. Las subpruebas permiten que cada callback de test() reciba un argumento context con el que puedes crear pruebas anidadas mediante context.test. Las pruebas simultáneas son una gran función si sabes usarlas y evitar las condiciones de carrera. Solo tienes que pasar un posible objeto concurrency: true como segundo argumento a la suite de pruebas describe().

¿Qué es un ejecutor de pruebas?

Un ejecutor de pruebas es una herramienta de software que permite a los desarrolladores administrar y ejecutar pruebas automatizadas en su código. El ejecutor de pruebas de Node.js es un framework diseñado para funcionar sin problemas con Node.js y ofrecer un entorno completo para escribir y ejecutar pruebas en tus aplicaciones de Node.js.

2. Mocking nativo de Node.js

El mocking es una estrategia que los desarrolladores usan para aislar código durante las pruebas. El runtime de Node.js incorporó funciones de mocking nativas que es importante conocer y usar correctamente.

Probablemente ya usaste funciones de mocking de otros frameworks de pruebas, como jest.spyOn o mockResolvedValueOncel de Jest. Son útiles cuando quieres evitar que se ejecute código real en tus pruebas, como solicitudes HTTP o APIs del sistema de archivos, y reemplazar esas operaciones con stubs y mocks que luego puedes inspeccionar.

A diferencia de otras funciones del runtime de Node.js, como las de watch y cobertura, el mocking no está marcado como experimental. Sin embargo, podría cambiar más, ya que es una función nueva que se incorporó en Node.js 18.

Mocking nativo de Node.js con import { mock } from 'node:test'

Veamos cómo usar la función de mocking nativo de Node.js en un ejemplo práctico. El ejecutor de pruebas y la función de mocking de módulos ya están disponibles como funciones estables en Node.js 20 LTS.

Usaremos un módulo de utilidades propio, dotenv.js, que carga variables de entorno desde un archivo .env. También usaremos un archivo de pruebas, dotenv.test.js, que prueba el módulo dotenv.js.

Este es nuestro propio módulo dotenv:

1// dotenv.js
2import fs from "node:fs/promises";
3
4export async function loadEnv(path = ".env") {
5  const rawDataEnv = await fs.readFile(path, "utf8");
6  const env = {};
7  rawDataEnv.split("\n").forEach((line) => {
8    const [key, value] = line.split("=");
9    env[key] = value;
10  });
11
12  return env;
13}

En el archivo dotenv.js, tenemos una función asíncrona, loadEnv, que lee un archivo mediante el método fs.readFile y divide su contenido en pares clave-valor. Como puedes ver, usa la API nativa del sistema de archivos de Node.js, fs.

Ahora veamos cómo probar esta función con la función de mocking nativo de Node.js.

1// dotenv.test.js
2import { describe, test, mock } from "node:test";
3import assert from "node:assert";
4import fs from "node:fs/promises";
5
6import { loadEnv } from "../src/dotenv.js";
7
8describe("dotenv test suite", () => {
9  test("should load env file", async () => {
10    const mockImplementation = async (path) => {
11      return "PORT=3000\n";
12    };
13    const mockedReadFile = mock.method(fs, "readFile", mockImplementation);
14
15    const env = await loadEnv(".env");
16
17    assert.strictEqual(env.PORT, "3000");
18    assert.strictEqual(mockedReadFile.mock.calls.length, 1);
19  });
20});

En el archivo de pruebas, importamos el método mock de node:test para crear una implementación mock de fs.readFile. En ella, devolvemos la cadena "PORT=3000\n", independientemente de la ruta del archivo que se pase.

Luego llamamos a la función loadEnv y, con el módulo assert, verificamos dos cosas:

El objeto devuelto tiene una propiedad PORT cuyo valor es "3000".
El método fs.readFile se llamó exactamente una vez.

Al usar la función mock nativa de Node.js, podemos aislar eficazmente la función loadEnv del sistema de archivos y probarla por separado. Las capacidades de mocking de Node.js 20 también admiten mocks de temporizadores.

¿Qué es el mocking?

En las pruebas de software, el mocking es un proceso que reemplaza las funcionalidades reales de módulos específicos por otras artificiales. Su objetivo principal es aislar la unidad de código que se está probando de las dependencias externas, para que la prueba verifique únicamente la funcionalidad de esa unidad y no la de sus dependencias. El mocking también te permite simular distintos escenarios, como errores de las dependencias, que podrían ser difíciles de reproducir de manera consistente en un entorno real.

3. Cobertura de pruebas nativa de Node.js

¿Qué es la cobertura de pruebas?

La cobertura de pruebas es una métrica que se usa en las pruebas de software. Ayuda a los desarrolladores a comprender en qué medida se prueba el código fuente de una aplicación. Esto es fundamental porque revela las áreas de la base de código que no se han probado y permite identificar posibles puntos débiles en el software.

¿Por qué es importante la cobertura de pruebas? Porque garantiza la calidad del software al reducir la cantidad de errores y prevenir regresiones. Además, permite conocer la eficacia de tus pruebas y te ayuda a crear una aplicación más sólida, confiable y segura.

Cómo aprovechar la cobertura de pruebas nativa de Node.js

A partir de la versión 20, el runtime de Node.js incluye capacidades nativas de cobertura de pruebas. Sin embargo, es importante tener en cuenta que esta función está marcada actualmente como experimental. Esto significa que, aunque está disponible, podría cambiar en futuras versiones.

Para usar la cobertura de pruebas nativa de Node.js, debes incluir el indicador de línea de comandos --experimental-test-coverage. Aquí tienes un ejemplo de cómo agregar una entrada test:coverage al campo de scripts de tu archivo package.json para ejecutar las pruebas del proyecto:

1{
2  "scripts": {
3    "test": "node --test ./tests",
4    "test:coverage": "node --experimental-test-coverage --test ./tests"
5  }
6}

En el ejemplo anterior, el script test:coverage usa el indicador --experimental-test-coverage para generar datos de cobertura durante la ejecución de las pruebas.

Después de ejecutar npm run test:coverage, deberías ver un resultado similar a este:

ℹ tests 7
ℹ suites 4
ℹ pass 5
ℹ fail 0
ℹ cancelled 0
ℹ skipped 1
ℹ todo 1
ℹ duration_ms 84.018917
ℹ start of coverage report
ℹ ---------------------------------------------------------------------
ℹ file                 | line % | branch % | funcs % | uncovered lines
ℹ ---------------------------------------------------------------------
ℹ src/dotenv.js        | 100.00 |   100.00 |  100.00 | 
ℹ src/math.js          | 100.00 |   100.00 |  100.00 | 
ℹ tests/dotenv.test.js | 100.00 |   100.00 |  100.00 | 
ℹ tests/math.test.js   |  94.64 |   100.00 |   91.67 | 24-26
ℹ ---------------------------------------------------------------------
ℹ all files            |  96.74 |   100.00 |   94.44 |
ℹ ---------------------------------------------------------------------
ℹ end of coverage report

Este reporte muestra el porcentaje de sentencias, ramas, funciones y líneas que cubren las pruebas.

La cobertura de pruebas nativa de Node.js es una herramienta eficaz que puede ayudarte a mejorar la calidad de tus aplicaciones Node.js. Aunque actualmente está marcada como experimental, ofrece información valiosa sobre la cobertura de tus pruebas y puede orientar tus esfuerzos de testing. Si comprendes y aprovechas esta función, podrás asegurarte de que tu código sea sólido, confiable y seguro.

4. Modo watch de Node.js

El modo watch de Node.js es una potente función para desarrolladores que permite hacer un seguimiento en tiempo real de los cambios en tus archivos de Node.js y volver a ejecutar scripts automáticamente.

Antes de explorar las capacidades watch nativas de Node.js, es importante reconocer el aporte de nodemon, una popular utilidad que ayudó a cubrir esta necesidad en versiones anteriores de Node.js. Nodemon es una utilidad de línea de comandos (CLI) que reinicia la aplicación Node.js cuando detecta un cambio en el directorio de archivos.

npm install -g nodemon
nodemon

Esta función es especialmente útil durante el desarrollo. Ahorra tiempo y mejora la productividad al eliminar la necesidad de reiniciar manualmente cada vez que se modifica un archivo.

Snyk Advisor muestra el estado de salud del paquete npm nodemon.

Gracias a los avances del propio Node.js, el lenguaje ahora incluye funciones integradas que permiten lograr los mismos resultados. Así, ya no necesitas instalar dependencias de terceros adicionales en tus proyectos, como nodemon.

Antes de comenzar el tutorial, es importante tener en cuenta que el modo watch nativo de Node.js aún es experimental y podría cambiar. Asegúrate de usar una versión de Node.js compatible con esta función.

Uso de las capacidades watch nativas de Node.js 20

Node.js 20 incorpora capacidades nativas de seguimiento de archivos mediante el indicador de línea de comandos --watch. Esta función es fácil de usar e incluso puede coincidir con patrones glob para satisfacer necesidades de seguimiento de archivos más complejas.

Para usar el comando --watch, agrégalo al script de Node.js en la línea de comandos, como se muestra a continuación:

node --watch app.js

Para usar patrones glob, puedes combinar el indicador --watch con un patrón específico y así supervisar varios archivos o directorios. Esto resulta especialmente útil cuando quieres supervisar un grupo de archivos que coincide con un patrón específico:

node --watch 'lib/**/*.js' app.js

También puedes combinar el indicador --watch con --test para volver a ejecutar las pruebas cada vez que cambien los archivos de pruebas:

node --watch --test '**/*.test.js'

Esta combinación puede acelerar considerablemente tu proceso de desarrollo guiado por pruebas (TDD), ya que ejecuta las pruebas automáticamente cada vez que haces un cambio.

Ten en cuenta que, en Node.js 20, el modo watch todavía está marcado como experimental. Esto significa que, aunque funciona plenamente, quizá no sea tan estable ni esté tan optimizado como otras funciones que no son experimentales.

En la práctica, es posible que encuentres algunos comportamientos inesperados o errores al usar la opción --watch.

5. Corepack de Node.js

Corepack de Node.js es una función interesante que vale la pena explorar. Se presentó en Node.js 16 y todavía está marcada como experimental. Esto hace aún más interesante conocer lo que ofrece y cómo aprovecharla en tus proyectos de JavaScript.

¿Qué es Corepack?

Corepack es un proyecto sin dependencias de runtime que sirve de puente entre los proyectos de Node.js y los administradores de paquetes que deben usar. Una vez instalado, proporciona un programa llamado corepack que puedes usar en tus proyectos para asegurarte de tener el administrador de paquetes correcto sin preocuparte por su instalación global.

¿Por qué usar Corepack?

Como desarrolladores de JavaScript, a menudo trabajamos con varios proyectos, cada uno con su propio administrador de paquetes preferido. Ya sabes cómo es: un proyecto administra sus dependencias con pnpm y otro con yarn, así que terminas teniendo que alternar entre distintas versiones de los administradores de paquetes.

Esto puede generar conflictos e inconsistencias. Corepack resuelve este problema al permitir que cada proyecto especifique y use su administrador de paquetes preferido de forma fluida.

Además, Corepack aísla tu proyecto del sistema global, lo que garantiza que seguirá funcionando aunque se actualicen o eliminen paquetes globales. Esto mejora la consistencia y la confiabilidad de tu proyecto.

Instalar y usar Corepack

Instalar Corepack es bastante sencillo. Como viene incluido con Node.js a partir de la versión 16, solo tienes que instalar o actualizar Node.js a esa versión o a una posterior.

Una vez instalado, puedes definir el administrador de paquetes de tu proyecto en el archivo package.json, así:

{
  "packageManager": "yarn@2.4.1"
}

Luego, puedes usar Corepack en tu proyecto de esta manera:

corepack enable

Si escribes yarn en el directorio del proyecto y no tienes Yarn instalado, Corepack detectará e instalará automáticamente la versión correcta.

Esto garantiza que se use Yarn versión 2.4.1 para instalar las dependencias de tu proyecto, sin importar qué versión global de Yarn esté instalada en el sistema.

Si quieres instalar Yarn globalmente o usar una versión específica, puedes ejecutar:

corepack install --global yarn@stable

Corepack: todavía es una función experimental

Aunque se presentó en Node.js 16, Corepack todavía está marcado como experimental. Esto significa que, si bien se espera que funcione bien, sigue en desarrollo activo y algunos aspectos de su comportamiento podrían cambiar en el futuro.

Dicho esto, Corepack es fácil de instalar y usar, y aporta una capa adicional de confiabilidad a tus proyectos. Sin duda, vale la pena explorar esta función e incorporarla a tu flujo de desarrollo.

6. Cargador .env de Node.js

La configuración de las aplicaciones es fundamental. Como desarrollador de Node.js, seguramente necesitas administrar credenciales de API, números de puerto del servidor o configuraciones de bases de datos.

Como desarrolladores, necesitamos una forma de proporcionar distintas configuraciones para cada entorno sin cambiar el código fuente. Una manera popular de hacerlo en las aplicaciones de Node.js es usar variables de entorno almacenadas en archivos .env.

El paquete dotenv de npm

Antes de que Node.js incorporara compatibilidad nativa para cargar archivos .env, los desarrolladores usaban principalmente el paquete dotenv de npm. El paquete dotenv carga las variables de entorno de un archivo .env en process.env, donde quedan disponibles en toda la aplicación.

Este es un uso típico del paquete dotenv:

require('dotenv').config();

console.log(process.env.MY_VARIABLE);

Esto funcionaba bien, pero requería agregar una dependencia más al proyecto. Con la incorporación del cargador nativo .env, ahora puedes cargar las variables de entorno directamente, sin necesidad de paquetes externos.

Node.js incorpora compatibilidad nativa para cargar archivos .env

A partir de Node.js 20, el runtime incluye una función integrada para cargar variables de entorno desde archivos .env. Esta función sigue en desarrollo activo, pero ya ha cambiado las reglas del juego para los desarrolladores.

Para cargar un archivo .env, podemos usar la opción de CLI --env-file al iniciar nuestra aplicación de Node.js. Esta opción especifica la ruta del archivo .env que se va a cargar.

node --env-file=./.env index.js

Esto cargará en process.env las variables de entorno del archivo .env especificado. Luego, las variables estarán disponibles en la aplicación, como antes.

Cargar varios archivos .env

El cargador .env de Node.js también permite cargar varios archivos .env. Esto es útil cuando tienes distintos conjuntos de variables de entorno para diferentes entornos (por ejemplo, desarrollo, pruebas y producción).

Puedes especificar varias opciones --env-file para cargar varios archivos. Los archivos se cargan en el orden en que se especifican, y las variables de los archivos posteriores reemplazan las de los anteriores.

Este es un ejemplo:

node --env-file=./.env.default --env-file=./.env.development index.js

En este ejemplo, ./.env.default contiene las variables predeterminadas y ./.env.development contiene las variables específicas del entorno de desarrollo. Las variables de ./.env.development que también estén en ./.env.default reemplazarán a las de ./.env.default.

La compatibilidad nativa de Node.js para cargar archivos .env es una mejora importante para los desarrolladores de Node.js. Simplifica la administración de la configuración y elimina la necesidad de agregar otro paquete. Empieza a usar la opción de CLI --env-file en tus aplicaciones de Node.js y comprueba lo práctico que resulta.

7. Compatibilidad de Node.js con import.meta para dirname y file

Si vienes de las convenciones de módulos CommonJS de Node.js, seguramente estás acostumbrado a usar filename y __dirname para obtener el nombre del directorio y la ruta del archivo actual. Sin embargo, hasta hace poco no era fácil acceder a estos valores en ESM, por lo que tenías que escribir el siguiente código para obtener __dirname:

1import url from 'url'
2import path from 'path'
3const dirname = path.dirname(url.fileURLToPath(import.meta.url))

O, si eres fan de Matteo Collina, quizá resolviste el problema usando su paquete npm desm.

Matteo Collina desm, paquete npm que proporciona __dirname y __filename en proyectos ESM mediante los datos del objeto import.meta.

Node.js evoluciona continuamente para ofrecer a los desarrolladores formas más eficientes de trabajar con archivos y rutas. Una mejora importante para los desarrolladores de Node.js llegó en las versiones 20.11.0 y 21.2.0 de Node.js, con la compatibilidad integrada para import.meta.dirname y import.meta.filename.

Uso de import.meta.filename e import.meta.dirname en Node.js

Por suerte, la incorporación de import.meta.filename y import.meta.dirname simplificó mucho este proceso. Veamos un ejemplo de cómo cargar un archivo de configuración con estas nuevas funciones.

Supongamos que hay un archivo de configuración YAML en el mismo directorio que tu archivo JavaScript y que necesitas cargarlo. Puedes hacerlo así:

1import fs from 'fs';
2
3const { dirname: __dirname, filename: __filename } = import.meta;
4const projectSetup = fs.readFileSync(`${__dirname}/setup.yml`, "utf8");
5
6console.log(projectSetup);

En este ejemplo, usamos import.meta.dirname para obtener el nombre del directorio del archivo actual y asignarlo a la variable __dirname, por comodidad y para mantener las convenciones de código de CommonJS.

8. Promesas de temporizadores nativos de Node.js

Node.js, un runtime de JavaScript popular basado en el motor V8 de Chrome, siempre ha buscado facilitarles la vida a los desarrolladores con actualizaciones constantes y nuevas funciones.

Aunque Node.js incorporó compatibilidad para usar temporizadores nativos con sintaxis de promesas desde la versión 15, admito que no los he usado con regularidad.

Temporizadores setTimeout() y setInterval() de JavaScript: breve repaso

Antes de profundizar en las promesas nativas para temporizadores, repasemos brevemente los temporizadores setTimeout() y setInterval() de JavaScript.

La API setTimeout() es una función de JavaScript que ejecuta una función o un fragmento de código especificado cuando se cumple el tiempo indicado.

1setTimeout(function(){ 
2    console.log("Hello World!"); 
3}, 3000);

En el código anterior, se imprimirá «Hello World!» en la consola después de 3 segundos (3000 milisegundos).

Por otro lado, setInterval() ejecuta repetidamente la función especificada, con una pausa entre cada llamada.

1setInterval(function(){ 
2    console.log("Hello again!"); 
3}, 2000);

En el código anterior, se imprimirá «Hello again!» en la consola cada 2 segundos (2000 milisegundos).

La forma anterior: envolver setTimeout() en una promesa

Antes, los desarrolladores solían tener que envolver artificialmente la función setTimeout() en una promesa para usarla de forma asíncrona. Esto permitía usar setTimeout() con async/await.

Así se hacía:

1function sleep(ms) {
2  return new Promise(resolve => setTimeout(resolve, ms));
3}
4
5async function demo() {
6  console.log('Taking a break...');
7  await sleep(2000);
8  console.log('Two seconds later...');
9}
10
11demo();

Esto imprimiría «Taking a break...», esperaría dos segundos y luego imprimiría «Two seconds later...».

Aunque funcionaba, agregaba complejidad innecesaria al código.

Promesas nativas de temporizadores de Node.js: una forma más sencilla

Con las promesas nativas de temporizadores de Node.js, ya no necesitamos envolver setTimeout() en una promesa. En su lugar, podemos usar setTimeout() directamente con async/await. Así, el código queda más limpio, legible y fácil de mantener. Este es un ejemplo de cómo usar las promesas nativas de temporizadores de Node.js:

1const {
2  setTimeout,
3} = require('node:timers/promises');
4
5setTimeout(2000, 'Two seconds later...').then((res) => {
6  console.log(res);  
7});
8
9console.log('Taking a break...');

En el código anterior, se importa setTimeout() desde node:timers/promises. Luego, lo usamos directamente con async/await. El código imprimirá «Taking a break...», esperará dos segundos y luego imprimirá «Two seconds later...».

Esto simplifica mucho la programación asíncrona y facilita leer, escribir y mantener el código.

9. Modelo de permisos de Node.js

Rafael Gonzaga, ahora miembro del TSC de Node.js, retomó el trabajo en el módulo de permisos de Node.js, que, al igual que Deno, ofrece un conjunto de restricciones de recursos configurables a nivel de proceso.

Ante los riesgos de seguridad de la cadena de suministro, los paquetes npm maliciosos y otras amenazas, es cada vez más importante administrar y controlar los recursos a los que pueden acceder tus aplicaciones de Node.js, por motivos de seguridad y cumplimiento.

En este sentido, Node.js incorporó una función experimental llamada módulo de permisos, que permite administrar los permisos de recursos en tus aplicaciones de Node.js. Esta función se habilita con la opción de línea de comandos --experimental-permission.

Modelo de permisos de recursos de Node.js

El modelo de permisos de Node.js ofrece una abstracción para administrar el acceso a distintos recursos, como sistemas de archivos, redes, variables de entorno y subprocesos de trabajo, entre otros. Esta función es especialmente útil cuando quieres limitar los recursos a los que puede acceder una parte determinada de tu aplicación.

Entre las restricciones de recursos que puedes establecer con el modelo de permisos están:

Lectura y escritura del sistema de archivos con --allow-fs-read=* y --allow-fs-write=*. Puedes especificar directorios y rutas de archivos concretas, y agregar varios recursos repitiendo las opciones.
Ejecución de procesos secundarios con --allow-child-process
Ejecución de subprocesos de trabajo con --allow-worker

El modelo de permisos de Node.js también ofrece una API de runtime, process.permission.has(resource, value), que permite consultar permisos de acceso específicos.

Si intentas acceder a recursos no permitidos, por ejemplo, leer el archivo .env, verás un error ERR_ACCESS_DENIED:

1> start:protected
2> node --env-file=.env --experimental-permission server.js
3
4node:internal/modules/cjs/loader:197
5  const result = internalModuleStat(filename);
6                 ^
7
8Error: Access to this API has been restricted
9    at stat (node:internal/modules/cjs/loader:197:18)
10    at Module._findPath (node:internal/modules/cjs/loader:682:16)
11    at resolveMainPath (node:internal/modules/run_main:28:23)
12    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:135:24)
13    at node:internal/main/run_main_module:28:49 {
14  code: 'ERR_ACCESS_DENIED',
15  permission: 'FileSystemRead',
16  resource: '/Users/lirantal/repos/modern-nodejs-runtime-features-2024/server.js'
17}
18
19Node.js v21.6.1

Ejemplo del modelo de permisos de Node.js

Imagina que tienes una aplicación de Node.js que administra la carga de archivos. Quieres restringir esta parte de la aplicación para que solo tenga acceso a un directorio específico donde se almacenan los archivos cargados.

Habilita la función experimental de permisos al iniciar tu aplicación de Node.js con la opción --experimental-permission.

node --experimental-permission ./app.js

También queremos permitir específicamente que la aplicación lea dos archivos de confianza, .env y setup.yml, así que debemos actualizar lo anterior de esta manera:

node --experimental-permission --allow-fs-write=/tmp/uploads --allow-fs-read=.env --allow-fs-read=setup.yml ./app.js

De este modo, si la aplicación intenta escribir en recursos del sistema basados en archivos fuera de la ruta de carga proporcionada, se detendrá y mostrará un error.

Consulta el siguiente ejemplo de código para ver cómo envolver el acceso a un recurso con try/catch y cómo usar la API de runtime de permisos de Node.js como otra forma de comprobar el acceso sin que se genere una excepción de error:

1 const { dirname: __dirname, filename: __filename } = import.meta;
2// @TODO to avoid the Node.js resource permission issue you should update
3// the path to be `setup.yml` in the current directory and not `../setup.yml`.
4// the outside path for setup.yml was only changed in the source code to
5// show you how Node.js resource permission module will halt if trying to access
6// something outside the current directory.
7const filePath = `${__dirname}/../setup.yml`;
8try {
9  const projectSetup = fs.readFileSync(filePath, "utf8");
10  // @TODO do something with projectSetup if you want to
11} catch (error) {
12  console.error(error.code);
13}
14// @TODO or consider using the permissions runtime API check:
15if (!process.permission.has("read", filePath)) {
16  console.error("no permissions to read file at", filePath);
17}

Es importante tener en cuenta que la funcionalidad de permisos de Node.js todavía es experimental y puede cambiar.

Sobre los permisos y las convenciones de seguridad para producción, puedes obtener más información sobre cómo crear aplicaciones seguras de Node.js en estas publicaciones del blog de Snyk:

Estas publicaciones ofrecen una guía completa para crear imágenes de contenedor seguras para aplicaciones web de Node.js, algo fundamental para desarrollar aplicaciones seguras de Node.js.

10. Módulo de políticas de Node.js

El módulo de políticas de Node.js es una función de seguridad diseñada para evitar que se cargue y ejecute código malicioso en una aplicación de Node.js. Aunque no rastrea el origen del código cargado, ofrece un mecanismo de defensa sólido frente a posibles amenazas.

El módulo de políticas usa la marca de CLI --experimental-policy para habilitar la carga de código basada en políticas. Esta marca recibe como argumento un archivo de manifiesto de políticas (en formato JSON). Por ejemplo, --experimental-policy=policy.json.

El archivo de manifiesto de políticas contiene las políticas que Node.js sigue al cargar módulos. Esto ofrece una manera sólida de controlar qué tipo de código se carga en tu aplicación.

Cómo implementar el módulo de políticas de Node.js: guía paso a paso

Veamos un ejemplo sencillo para mostrar cómo usar el módulo de políticas de Node.js:

1. Crea un archivo de políticas. El archivo debe ser un JSON que especifique las políticas de tu aplicación para cargar módulos. Lo llamaremos policy.json.

Por ejemplo:

  {
    "resources": {
      "./moduleA.js": {
        "integrity": "sha384-xxxxx"
      },
      "./moduleB.js": {
        "integrity": "sha384-yyyyy"
      }
    }
  }

Este archivo de políticas especifica que moduleA.js y moduleB.js deben tener valores de integridad específicos para poder cargarse.

Sin embargo, generar el archivo de políticas para todas tus dependencias directas y transitivas no es sencillo. Hace algunos años, Bradley Meck creó el paquete npm node-policy, que ofrece una CLI para automatizar la generación del archivo de políticas.

2. Ejecuta tu aplicación de Node.js con la --experimental-policy marca:

  node --experimental-policy=policy.json app.js

Este comando le indica a Node.js que siga las políticas especificadas en policy.json al cargar los módulos de app.js.

3. Para proteger el archivo de políticas contra alteraciones, puedes proporcionar un valor de integridad para el propio archivo mediante la --policy-integrity marca:

    node --experimental-policy=policy.json --policy-integrity="sha384-zzzzz" app.js

Este comando garantiza que se mantenga la integridad del archivo de políticas, incluso si el archivo cambia en el disco.

Limitaciones de la política de integridad de Node.js

El runtime de Node.js no tiene funciones integradas para generar ni administrar el archivo de políticas. Esto puede generar dificultades, como administrar distintas políticas para los entornos de producción y desarrollo, además de las importaciones dinámicas de módulos.

Otra limitación es que, si ya tienes un paquete npm malicioso en su estado actual, es demasiado tarde para generar un archivo de políticas de integridad de módulos.

Te recomiendo estar al tanto de las novedades en esta área e intentar adoptar esta función de manera gradual.

Para obtener más información sobre el módulo de políticas de Node.js, consulta el artículo Presentamos las políticas experimentales de integridad en Node.js, que ofrece un tutorial paso a paso más detallado sobre cómo trabajar con la integridad de las políticas de Node.js.

Conclusión

Al repasar las funciones modernas del runtime de Node.js que deberías empezar a usar en 2024, queda claro que están diseñadas para agilizar el proceso de desarrollo, mejorar el rendimiento de las aplicaciones y reforzar la seguridad. No son solo una tendencia: tienen un gran potencial para transformar nuestra manera de desarrollar con Node.js.

Refuerza la seguridad de Node.js con Snyk

Aunque estas funciones de Node.js pueden mejorar considerablemente tu proceso de desarrollo y el rendimiento de tus aplicaciones, es fundamental mantenerse alerta ante posibles amenazas de seguridad. Snyk puede ser tu aliado en esta tarea. Esta potente herramienta te ayuda a encontrar y corregir vulnerabilidades conocidas en las dependencias de Node.js y a mantener un ecosistema de desarrollo seguro.

Para aprovechar lo que Snyk ofrece, regístrate aquí gratis y comienza tu camino hacia un desarrollo más seguro con Node.js.