O ecossistema Node vem com uma ampla variedade de ferramentas que têm evoluído ao longo dos anos. Essas ferramentas são entregues via pacotes NPM e são executadas no prompt de comando, tornando-as acessíveis a qualquer desenvolvedor (não é necessário um IDE sofisticado para realizar o trabalho).

Exploraremos ferramentas Node para aprender este ano: TypeScript, ES Modules, ESLint, o plugin ESLint SpellCheck e Mocha. Todos eles são executados via prompt de comando e podem ajudar a aumentar sua produtividade ao trabalhar em projetos Node.

TypeScript para seu Projeto Node.js

Tenho certeza de que já ouviu isso muitas vezes, mas se você ainda não experimentou o TypeScript em um projeto, realmente precisa. O TypeScript adiciona segurança de tipos aos seus projetos e facilita a captura de erros no código.

Para começar, certifique-se de criar um arquivo package.json se você ainda não tiver um via npm init. Em seguida, adicione a dependência do TypeScript.

npm i typescript --save-dev

Neste ponto, é possível adicionar o comando tsc como um script de build no arquivo package.json. Se você tiver vários arquivos JavaScript existentes, qualquer arquivo que seja renomeado com uma extensão .ts se torna um arquivo TypeScript, e o compilador faz o restante do trabalho.

A maioria dos fluxos de trabalho de desenvolvimento exige algum ajuste da configuração do compilador. A forma de fazer isso é via o inicializador.

npx tsc --init

Isso cria um arquivo tsconfig.json com a configuração padrão. Cada configuração é bem documentada dentro deste arquivo, para que você possa ajustar a ferramenta às suas necessidades.

Enquanto você estiver no arquivo de configuração, altere a configuração do TypeScript para que possamos falar sobre a próxima ferramenta disponível.

"compilerOptions": {
  "module": "esnext",
  "target": "esnext"
}

Agora é possível declarar interfaces e classes fortemente tipadas.

ES Modules no Node.js e no Navegador

Tanto o Node quanto o navegador alcançaram a igualdade via export/import. Este sistema de módulos permite que você importe facilmente código de diferentes arquivos e funciona de forma nativa sem transpiladores.

No Node, altere o arquivo package.json para um módulo.

"type": "module"

Isso instrui o Node a começar a usar ES Modules de forma nativa, sem o transpilador TypeScript.

Com isso conseguimos duas coisas:

• O TypeScript não destrói o código de export/import
• O navegador pode usar este mesmo sistema de módulos para lidar com dependências

Uma pegadinha aqui é que há uma pequena divergência entre o TypeScript e o navegador. A especificação diz que os módulos importados devem declarar uma extensão de arquivo, enquanto o TypeScript faz a resolução mesmo sem uma extensão como .js.

Para lidar com este problema, basta declarar todas as dependências como arquivos JavaScript em seu código TypeScript. O compilador é inteligente o suficiente para saber que você pretende declarar a importação como um arquivo JavaScript.

ESLint com TypeScript para sua aplicação Node.js

A ferramenta linter ESLint analisa estaticamente o código, suporta a maioria dos editores de texto e pode ser executada na linha de comando. Ele adiciona verificações de código, verificações para possíveis erros e até ajuda a estilizar o código de maneira consistente. Recomendamos ativar todas as funcionalidades oferecidas pelo ESLint.

Para começar, inicialize o pacote de configuração:

npm init @eslint/config

Este ferramenta CLI irá guiá-lo automaticamente através de uma série de opções, onde você pode personalizar a configuração. Certifique-se de escolher todas as três opções: verificar sintaxe, encontrar problemas e impor estilo de código. Escolha o guia de estilo mais popular e padrão, ESM, como sistema de módulo e TypeScript.

O arquivo de configuração vem em três versões: JavaScript, JSON e YAML. Escolha JavaScript, pois precisaremos abordar o próximo detalhe.

Para o ESLint funcionar com o compilador TypeScript, é necessário adicionar os parserOptions no arquivo de configuração. Além disso, como estamos usando o sistema de módulos ES em package.json, precisamos renomear o arquivo de configuração para .eslintrc.cjs.

Em .eslintrc.cjs, certifique-se de definir as parserOptions:

"parserOptions": {
  "project": ["tsconfig.json"],
  "tsconfigRootDir": __dirname,
  "ecmaVersion": "latest"
}

Note o uso de __dirname - isso permite que o linter encontre o arquivo tsconfig.json a partir de qualquer local na estrutura de pastas do projeto. Essa técnica só é possível através do arquivo de configuração JavaScript.

Agora, faça uma análise léxica em um arquivo na pasta src, exemplo:

npx eslint example.ts

ESLint Plugin — SpellCheck

ESLint é extensível por meio de plugins. Como nada é mais irritante do que erros de digitação no código, vamos instalar o plugin de correção ortográfica.

npm i eslint-plugin-spellcheck --save-dev

Para habilitar o corretor ortográfico no ESLint, edite o arquivo .eslintrc.cjs:

"plugins": ["spellcheck"],
"rules": {
  "spellcheck/spell-checker": [
    "warn", {
      "skipWords": ["rect", "keydown"]
    }
  ]
}

Isso dispara alertas no ESLint quando ele encontra um erro de ortografia. Se você tiver palavras válidas que não forem encontradas no dicionário, basta adicioná-las à lista em skipWords.

Com o ESLint, a maioria dos problemas detectados gera um erro e o build falhará até que o problema seja resolvido. Isso torna a ferramenta CLI ideal tanto para o desenvolvimento local quanto para a integração contínua em um servidor de build.

Para habilitar essas verificações automaticamente, adicione o ESLint ao script prebuild em package.json.

"scripts": {
  "prebuild": "eslint ."
}

Mocha para Testes no Node.js

Se você ainda não praticou o desenvolvimento orientado a testes (TDD), agora é a sua chance. O Mocha se integra perfeitamente a todas as ferramentas que abordamos até agora e pode executar centenas de testes de unidade em menos de um segundo.

Para começar a usar o Mocha, instale as seguintes dependências:

npm i @types/mocha jsdom jsdom-global ts-node mocha --save-dev

Como falamos de TypeScript, o ts-node é uma engine de execução que executa diretamente o TypeScript no Node sem precisar compilá-lo antes. Essas duas dependências são úteis para rodar testes unitários no Mocha.

Para habilitar essas ferramentas no Mocha, crie um arquivo .mocharc.json com a seguinte configuração:

{
  "require": ["jsdom-global/register"],
  "loader": "ts-node/esm",
  "extensions": ["ts"],
  "spec": ["tests/**/*.test.ts"]
}

Essa configuração fala para o Mocha habilitar três coisas: jsdom, ts-node com ES Modules e as extensões do TypeScript. As configurações especificam onde os testes irão.

Por último, certifique-se de incluir o Mocha em package.json:

"scripts": {
  "test": "mocha"
}

O arquivo de configuração .mocharc.json já diz ao Mocha como executar os testes. Essa técnica mantém o arquivo package.json livre de bagunça.

Uma coisa a se atentar é que o Mocha não suporta ESM no modo watch. Espera-se que essa limitação seja abordada em futuros lançamentos.

Lembre-se, o linter e compilador são separados da execução de testes unitários em sua pipeline de integração contínua. O motor de execução no ts-node não é um compilador e não faz verificações de código. Portanto, uma boa técnica é executar tanto o ESLint quanto o compilador do TypeScript primeiro e, em seguida, executar os testes unitários por último no servidor de build.

Resumo

Exploramos ferramentas do Node para aprender este ano: TypeScript, ES Modules, ESLint, o plugin SpellCheck do ESLint e, por fim, Mocha para execução de testes.

Estas ferramentas do Node oferecem a possibilidade de lidar com mudanças no código sem uma IDE. As ferramentas são acessíveis e não empurram IDEs ou editores de texto específicos para os desenvolvedores. Eles são fáceis de automatizar e podem ser incluídos na integração contínua, de modo que toda a equipe possa se beneficolar.