Gerir atualizações de dependência no seu projeto Node.js

  • 10 minutos

Como desenvolvedor na Tailwind Traders, é importante manter nossos pacotes atualizados. Isso ajuda a garantir que estamos usando os recursos e correções mais recentes. Também nos ajuda a evitar vulnerabilidades de segurança. Nesta unidade, você aprenderá a gerenciar dependências em um projeto .js nó. Você aprenderá a atualizar pacotes, usar o controle de versão semântico e gerenciar problemas de segurança.

Considerações antes de atualizar um pacote

Antes de atualizar um pacote, considere:

  • Tipo de atualização: entenda se é uma pequena correção, um novo recurso ou uma grande alteração que pode quebrar seu código. O controle de versão semântico pode ajudar a identificar isso.
  • Configuração do projeto: Certifique-se de que seu projeto esteja configurado para receber apenas as atualizações desejadas para evitar alterações inesperadas.
  • Segurança: Mantenha-se atento a potenciais vulnerabilidades. Use o recurso de auditoria do npm para identificar e atualizar pacotes problemáticos.
  • Teste: Certifique-se de que seus testes sejam aprovados após a atualização. Se você não tiver testes, considere adicioná-los. Seu aplicativo pode se comportar de forma diferente após uma atualização e os testes validam o comportamento correto .

Controle de versão semântico para definir o comportamento de atualização

O versionamento semântico é um padrão fundamental no desenvolvimento de software. É essencial tanto para publicar quanto para usar pacotes npm. Ele ajuda a gerenciar os riscos de atualização, indicando o tipo de alterações em uma nova versão. Um número de versão tem seções específicas para refletir essas alterações:

Tipo de versão Position Sintaxe O que acontece Abordagem de atualização
Major: 1º x.0.0 ou * Alterações de 1.0.0 para 2.0.0 indicam alterações de rutura. Podem ser necessários ajustamentos de código. Confortável com atualizações imediatas para a versão principal mais recente, reconhecendo possíveis alterações de código.
Menor 2º 1.x.1 ou ^ Alterações de 1.2.9 para 1.3.0 introduzir novas funcionalidades. O código existente ainda deve funcionar. As atualizações são normalmente seguras. Aberto a novos recursos, mas sem alterações de rutura.
Patch 3º 1.1.x ou ~ Alterações de 1.0.7 para 1.0. 8 correções de bugs médios. As atualizações devem ser seguras. Aceitação de correções de bugs.

Para projetos .js nós pequenos, você pode atualizar livremente para as versões mais recentes. Mas para projetos maiores, as atualizações precisam ser cuidadosamente pensadas e nem sempre são automáticas. Geralmente, atualizar dependências menores, com menos dependências próprias, facilita o processo.

Antes de atualizar uma ou mais dependências, você deve configurar o arquivo para obter um comportamento previsível ao executar o package.json npm update <name of dependency> comando. Node.js usa um conjunto de símbolos que permite definir como deseja que seus pacotes sejam atualizados.

Atualizar um pacote com a CLI npm

Você pode instalar um pacote usando o install comando ou update no npm. Estes comandos são agora maioritariamente intercambiáveis. Para atualizar um pacote, você normalmente usa:

  • Última versão: npm update <package name>@latest.
  • Versão específica: npm update <package name>@<optional version number>.

O processo de atualização depende de dois fatores:

  • Argumento da versão: Se um número de versão for especificado no comando, o npm update npm buscará e instalará essa versão específica.
  • Entrada de arquivo de manifesto: O package.json arquivo contém regras para atualizar dependências. Por exemplo, "dependencyName": "1.1.x" significa que npm buscará a versão que corresponde a esse padrão.

Compreender o controle de versão

Três arquivos controlam o controle de versão das dependências:

  • package.json: Este arquivo define a versão do pacote que você deseja usar. É o arquivo de manifesto para o seu projeto. Ele contém os metadados para seu projeto, incluindo as dependências.
  • package-lock.json: Este arquivo descreve a árvore exata que foi gerada, de modo que as instalações subsequentes sejam capazes de gerar árvores idênticas, independentemente das atualizações de dependência intermediárias. Este ficheiro destina-se a ser confirmado em repositórios de origem.
  • shrinkwrap.json: Este arquivo é criado pelo npm shrinkwrap comando CLI e é semelhante ao package-lock.json. A principal diferença entre os comandos é que as versões do pacote especificadas em npm-shrinkwrap.json não podem ser substituídas pelos usuários. Além disso, o npm-shrinkwrap.json arquivo é compatível com versões mais antigas do npm (versões 2-4), enquanto package-lock.json é compatível com npm versão 5 e posterior. Portanto, você pode encontrar npm-shrinkwrap.json ao manter bases de código herdadas. A maioria dos desenvolvedores usará package-lock.json em vez de npm-shrinkwrap.json. Uma exceção em que npm-shrinkwrap.json é preferível é para instalações globais de daemons e ferramentas de linha de comando onde os desenvolvedores desejam garantir que as versões exatas dos pacotes especificados sejam instaladas.

Exemplo de determinação da versão do pacote

Considere um cenário em que você está usando a versão 1.2 em seu código e, em seguida, a versão 1.4 é lançada, quebrando seu código. Se alguém instalar seu aplicativo neste momento, receberá um aplicativo que não funciona. Mas, se houver um package-lock.json arquivo especificando a versão 1.2, essa versão será instalada.

Aqui está um exemplo de como determinar qual versão de um pacote está instalada:

  • Se os package.json arquivos e package-lock.json concordarem com uma regra de versão, não haverá conflito. Por exemplo, se package.json especificar e package-lock.json especificar 1.x a versão 1.4, a versão 1.4 será instalada.
  • Se package.json especificar uma versão mais específica, como 1.8.x, ele substituirá o package-lock.json arquivo, que indica a versão mais antiga do 1.4. Neste caso, a versão 1.8.0 ou uma versão posterior do patch será instalada, se disponível.

Encontre e atualize pacotes desatualizados com npm desatualizado

O npm outdated comando é usado para identificar pacotes que têm versões mais recentes disponíveis. Quando executado, ele fornece uma lista desses pacotes desatualizados:

Package       Current    Wanted   Latest     Location     Depended by
lodash        1.0.0      1.0.0    4.17.19    lock-test    main-code-file
node-fetch    1.2.0      1.2.0    2.6.0      lock-test    function-code-file

As colunas na saída incluem:

Column Description
Pacote O pacote desatualizado.
Atual A versão instalada atual do pacote.
Procura-se A versão mais recente que corresponde ao padrão semântico package.json especificado no arquivo.
Mais Recente A versão mais recente do pacote.
Localização O local da dependência do pacote. O outdated comando rastreia todos os pacotes instalados nas várias node_modules pastas.
Dependido por O pacote que tem a dependência.

Gerencie problemas de segurança com a auditoria npm

Toda vez que você instala ou atualiza um pacote, você recebe uma resposta de log que informa qual versão foi instalada e se há vulnerabilidades. O log lista vulnerabilidades. Se você tiver alguma vulnerabilidade crítica ou alta, você deve atualizar o pacote.

Um exemplo de uma resposta de log é:

+ lodash@1.3.1
added 1 package from 4 contributors and audited 1 package in 0.949s
found 3 vulnerabilities (1 low, 2 high)
  run `npm audit fix` to fix them, or `npm audit` for details

Para corrigir um problema e aplicar uma atualização, você pode executar o npm audit comando. Este comando lista cada vulnerabilidade.

O npm audit fix comando tenta resolver vulnerabilidades atualizando para uma versão secundária onde o problema não existe. No entanto, isso pode não estar disponível se a correção estiver realmente na próxima versão principal.

Nesses casos, você pode precisar usar npm audit fix --forceo , que pode introduzir alterações de quebra atualizando para a versão principal. Executar este comando é uma decisão que você deve tomar com cuidado. Você deve estar ciente das alterações de quebra e usar npm update para atualizar seu código, incluindo vulnerabilidades.

Uma vulnerabilidade é uma falha de código que pode ser explorada por atacantes para executar ações maliciosas, comprometendo potencialmente os seus dados e sistemas. É crucial abordar essas vulnerabilidades prontamente.

Dada a descoberta frequente de vulnerabilidades, o GitHub tem um recurso que verifica repositórios e cria automaticamente PRs sugerindo atualizações para versões mais seguras. A execução npm audit regular é uma boa prática para identificar e corrigir vulnerabilidades, contribuindo para a segurança geral do seu projeto.

O fluxo de trabalho recomendado para atualizações é:

  1. npm run test: Verifique se os testes existentes passam antes de iniciar este processo de atualização.
  2. npm audit: para verificar vulnerabilidades na versão atual que você está usando. As informações de npm audit podem recomendar a atualização para uma versão principal. Você deve revisar cuidadosamente as alterações de quebra, se alguma estiver listada.
  3. npm outdated: para listar todos os pacotes desatualizados. Este comando fornece informações nas colunas Procurado, Mais recente e Local .
  4. Atualize com npm update:
    • Para projetos menores (algumas dependências no package.json: você pode tentar npm update atualizar todas as dependências e executar os testes.
    • Para projetos maiores (com muitas dependências no package.json: atualize um único pacote ou família de pacotes (como Next.js e React), execute os testes.
  5. npm audit: verifique se não existem vulnerabilidades críticas ou elevadas. Se ainda existirem vulnerabilidades, use npm update com o nome do pacote e a versão principal recomendada em npm audit.
  6. npm run test novamente.
  7. Faça check-in no seu package.json e package-lock.json.