Node.js 22 Promovido a LTS - require(ESM) e Resumo das Novas Funcionalidades

Visão Geral do Node.js 22 LTS

O Node.js 22 foi promovido a LTS (Suporte de Longo Prazo) em outubro de 2024. Com o codinome “Jod”, receberá suporte ativo até abril de 2027.

Recomendação: Use versões LTS em ambientes de produção

Suporte a ESM com require()

O grande destaque do Node.js 22 é a capacidade de carregar módulos ES a partir do CommonJS usando require().

// Pacote ESM (package.json: "type": "module")
// lib.mjs
export const greeting = 'Hello';
export function sayHello(name) {
  return `${greeting}, ${name}!`;
}
export default { greeting, sayHello };

// Agora carregável do CommonJS
// app.cjs
const { greeting, sayHello } = require('./lib.mjs');
console.log(sayHello('World')); // Hello, World!

// Exportação padrão também disponível
const lib = require('./lib.mjs');
console.log(lib.default.greeting); // Hello

Promoção de Flag Experimental

# Node.js 22 e anteriores (funcionalidade experimental)
node --experimental-require-module app.js

# Node.js 22.12.0 em diante (habilitado por padrão)
node app.js

# Para desabilitar
node --no-experimental-require-module app.js

Observações

// ESM contendo top-level await não pode ser requerido
// async-lib.mjs
const data = await fetch('https://api.example.com/data');
export const config = await data.json();

// Isso resultará em erro
try {
  require('./async-lib.mjs'); // ERR_REQUIRE_ASYNC_MODULE
} catch (e) {
  console.error('Módulos contendo top-level await não podem ser requeridos');
}

Cliente WebSocket (Integrado)

// Node.js 22 em diante, WebSocket disponível sem bibliotecas externas
const ws = new WebSocket('wss://echo.websocket.org');

ws.addEventListener('open', () => {
  console.log('Conexão estabelecida');
  ws.send('Hello, WebSocket!');
});

ws.addEventListener('message', (event) => {
  console.log('Recebido:', event.data);
});

ws.addEventListener('close', () => {
  console.log('Desconectado');
});

ws.addEventListener('error', (error) => {
  console.error('Erro:', error);
});

Integração com Servidor HTTP

import { createServer } from 'http';
import { WebSocketServer } from 'ws';

const server = createServer();
const wss = new WebSocketServer({ server });

wss.on('connection', (ws, request) => {
  console.log('Nova conexão:', request.url);

  ws.on('message', (message) => {
    // Broadcast
    wss.clients.forEach((client) => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(message.toString());
      }
    });
  });
});

server.listen(8080, () => {
  console.log('Servidor WebSocket rodando em ws://localhost:8080');
});

Motor V8 12.4

O Node.js 22 inclui o V8 12.4, disponibilizando as últimas funcionalidades JavaScript.

Array.fromAsync

// Criar array a partir de iterável assíncrono
async function* asyncGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const arr = await Array.fromAsync(asyncGenerator());
console.log(arr); // [1, 2, 3]

// Também processa arrays de Promises
const promises = [
  fetch('/api/user/1'),
  fetch('/api/user/2'),
  fetch('/api/user/3'),
];

const responses = await Array.fromAsync(promises, (p) => p.then((r) => r.json()));

Novos Métodos de Set

const a = new Set([1, 2, 3, 4]);
const b = new Set([3, 4, 5, 6]);

// União
console.log(a.union(b)); // Set {1, 2, 3, 4, 5, 6}

// Interseção
console.log(a.intersection(b)); // Set {3, 4}

// Diferença
console.log(a.difference(b)); // Set {1, 2}

// Diferença simétrica
console.log(a.symmetricDifference(b)); // Set {1, 2, 5, 6}

// Verificação de subconjunto
console.log(new Set([1, 2]).isSubsetOf(a)); // true
console.log(a.isSupersetOf(new Set([1, 2]))); // true

// Verificação de conjuntos disjuntos
console.log(a.isDisjointFrom(new Set([7, 8]))); // true

Iterator Helpers

// Operações de transformação em iteradores
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

// map, filter, take etc. disponíveis
const result = numbers()
  .filter((n) => n % 2 === 0)
  .map((n) => n * 2)
  .take(2)
  .toArray();

console.log(result); // [4, 8]

// drop: pular início
const skipped = numbers().drop(2).toArray();
console.log(skipped); // [3, 4, 5]

// flatMap
function* nested() {
  yield [1, 2];
  yield [3, 4];
}
const flat = nested()
  .flatMap((arr) => arr)
  .toArray();
console.log(flat); // [1, 2, 3, 4]

// find
const found = numbers().find((n) => n > 3);
console.log(found); // 4

// some / every
console.log(numbers().some((n) => n > 3)); // true
console.log(numbers().every((n) => n > 0)); // true

SQLite Integrado (Experimental)

import { DatabaseSync } from 'node:sqlite';

// Banco de dados em memória
const db = new DatabaseSync(':memory:');

// Criar tabela
db.exec(`
  CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE
  )
`);

// Inserir dados
const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
insert.run('Alice', 'alice@example.com');
insert.run('Bob', 'bob@example.com');

// Executar query
const select = db.prepare('SELECT * FROM users WHERE name = ?');
const user = select.get('Alice');
console.log(user); // { id: 1, name: 'Alice', email: 'alice@example.com' }

// Buscar todos
const all = db.prepare('SELECT * FROM users').all();
console.log(all);

// Transação
const transfer = db.transaction((from, to, amount) => {
  db.prepare('UPDATE accounts SET balance = balance - ? WHERE id = ?').run(amount, from);
  db.prepare('UPDATE accounts SET balance = balance + ? WHERE id = ?').run(amount, to);
});

transfer(1, 2, 100);

Melhorias de Desempenho

Estabilização do Watch Mode

# Monitorar alterações de arquivo e reiniciar automaticamente
node --watch server.js

# Monitorar apenas caminhos específicos
node --watch-path=./src --watch-path=./config server.js

# Excluir do monitoramento
node --watch --watch-preserve-output server.js

// Verificar estado de monitoramento programaticamente
import { watch } from 'node:fs/promises';

const ac = new AbortController();
const { signal } = ac;

(async () => {
  const watcher = watch('./src', { recursive: true, signal });
  for await (const event of watcher) {
    console.log(`${event.eventType}: ${event.filename}`);
  }
})();

// Parar monitoramento
// ac.abort();

Suporte Nativo a Padrões Glob

import { glob, globSync } from 'node:fs';

// API assíncrona
const files = await glob('**/*.js', {
  cwd: './src',
  ignore: ['node_modules/**'],
});
console.log(files);

// API síncrona
const syncFiles = globSync('**/*.{ts,tsx}');
console.log(syncFiles);

// Também disponível via módulo fs
import { promises as fs } from 'node:fs';
const matches = await fs.glob('src/**/*.test.ts');

Carregamento de Arquivos de Variáveis de Ambiente

# Carregar arquivo .env automaticamente
node --env-file=.env app.js

# Suporte a múltiplos arquivos
node --env-file=.env --env-file=.env.local app.js

# .env
DATABASE_URL=postgresql://localhost:5432/mydb
API_KEY=secret-key
NODE_ENV=development

// Acessar variáveis de ambiente
console.log(process.env.DATABASE_URL);
console.log(process.env.API_KEY);

Melhorias no Test Runner

// test/user.test.js
import { describe, it, before, after, mock } from 'node:test';
import assert from 'node:assert/strict';

describe('User Service', () => {
  let mockDb;

  before(() => {
    mockDb = mock.fn(() => ({ id: 1, name: 'Test User' }));
  });

  after(() => {
    mock.reset();
  });

  it('should create a user', async () => {
    const user = await createUser({ name: 'Test User' });
    assert.strictEqual(user.name, 'Test User');
  });

  it('should validate email', () => {
    assert.throws(() => createUser({ email: 'invalid' }), /Invalid email/);
  });

  // Teste de snapshot
  it('should match snapshot', async (t) => {
    const user = await getUser(1);
    t.assert.snapshot(user);
  });
});

# Executar testes
node --test

# Com cobertura
node --test --experimental-test-coverage

# Apenas arquivo específico
node --test test/user.test.js

Guia de Migração

# Verificar versão
node --version

# Usando nvm
nvm install 22
nvm use 22
nvm alias default 22

# Verificar compatibilidade de dependências
npx npm-check-updates --target minor

# Especificação de engine no package.json
# "engines": { "node": ">=22" }

Links de Referência

• Notas de Lançamento do Node.js 22
• Explicação do require(esm)
• Breaking Changes do Node.js 22
• Notas de Lançamento do V8 12.4