Base de Conhecimento

Introdução

Devido a esses recursos, como o rápido desempenho de Entrada / Saída (E / S) e a conhecida sintaxe JavaScript, o Node.js rapidamente se tornou um ambiente de tempo de execução popular para o desenvolvimento da Web de back-end. Porém, à medida que o interesse aumenta, aplicativos maiores são criados e o gerenciamento da complexidade da base de código e de suas dependências se torna mais difícil. O Node.js organiza essa complexidade usando módulos , que são quaisquer arquivos JavaScript únicos que contêm funções ou objetos que podem ser usados ​​por outros programas ou módulos. Uma coleção de um ou mais módulos é geralmente chamada de pacote , e esses pacotes são eles próprios organizados pelos gerenciadores de pacotes.

O Node.js Package Manager (npm) é o gerenciador de pacotes padrão e mais popular no ecossistema Node.js. É usado principalmente para instalar e gerenciar módulos externos em um projeto Node.js. Também é comumente usado para instalar uma ampla variedade de ferramentas da CLI e executar scripts de projeto. O npm rastreia os módulos instalados em um projeto com o package.jsonarquivo, que reside no diretório de um projeto e contém:

• Todos os módulos necessários para um projeto e suas versões instaladas
• Todos os metadados de um projeto, como autor, licença, etc.
• Scripts que podem ser executados para automatizar tarefas no projeto

À medida que você cria projetos Node.j mais complexos, o gerenciamento de seus metadados e dependências com o package.jsonarquivo fornece compilações mais previsíveis, pois todas as dependências externas são mantidas iguais. O arquivo acompanhará essas informações automaticamente; embora você possa alterar o arquivo diretamente para atualizar os metadados do seu projeto, raramente precisará interagir com ele diretamente para gerenciar os módulos.

Neste tutorial, você gerenciará pacotes com o npm. O primeiro passo será criar e entender o package.jsonarquivo. Você o usará para acompanhar todos os módulos que instalar em seu projeto. Por fim, você listará as dependências dos pacotes, atualizará os pacotes, desinstalará os pacotes e executará uma auditoria para encontrar falhas de segurança nos pacotes.

Pré-requisitos

Para concluir este tutorial, você precisará de:

• Node.js instalado em sua máquina de desenvolvimento. Este tutorial usa a versão 10.17.0. Para instalar isso no macOS ou no Ubuntu 18.04, siga as etapas em Como instalar o Node.js e criar um ambiente de desenvolvimento local no macOS ou na seção Instalando usando um PPA de Como instalar o Node.js. no Ubuntu 18.04 . Ao ter o Node.js instalado, você também terá o npm instalado; este tutorial usa a versão 6.11.3.

Etapa 1 - Criando um package.jsonarquivo

Começamos este tutorial configurando o projeto de exemplo - um locatormódulo fictício do Node.js. que obtém o endereço IP do usuário e retorna o país de origem. Você não estará codificando o módulo neste tutorial. No entanto, os pacotes que você gerencia seriam relevantes se você o estivesse desenvolvendo.

Primeiro, você criará um package.jsonarquivo para armazenar metadados úteis sobre o projeto e ajudá-lo a gerenciar os módulos Node.js. dependentes do projeto. Como o sufixo sugere, este é um arquivo JSON (JavaScript Object Notation). JSON é um formato padrão usado para compartilhamento, baseado em objetos JavaScript e consistindo em dados armazenados como pares de valores-chave. Se você quiser saber mais sobre o JSON, leia nosso artigo Introdução ao JSON .

Como um package.jsonarquivo contém várias propriedades, pode ser complicado criar manualmente, sem copiar e colar um modelo de outro lugar. Para facilitar as coisas, o npm fornece o initcomando Este é um comando interativo que faz uma série de perguntas e cria um package.jsonarquivo com base em suas respostas.

Usando o initcomando

Primeiro, configure um projeto para praticar o gerenciamento de módulos. No seu shell, crie uma nova pasta chamada locator:

• mkdir locator

Em seguida, vá para a nova pasta:

• cd locator

Agora, inicialize o prompt interativo digitando:

• npm init

Nota : Se o seu código usará o Git para controle de versão, crie o repositório Git primeiro e depois execute npm init. O comando entende automaticamente que está em uma pasta habilitada para Git. Se um Git remoto está definido, ele preenche automaticamente os repository, bugse homepagecampos para o seu package.jsonarquivo. Se você inicializou o repositório após criar o package.jsonarquivo, precisará adicionar essas informações em si mesmo. Para saber mais sobre o controle de versão do Git, consulte nossa série Introdução ao Git: Instalação, Uso e Ramificações .

Você receberá a seguinte saída:

This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (locator)

Primeiro, você será solicitado a fornecer nameseu novo projeto. Por padrão, o comando assume que é o nome da pasta em que você está. Os valores padrão para cada propriedade são mostrados entre parênteses (). Como o valor padrão para namefuncionará neste tutorial, pressione ENTERpara aceitá-lo.

O próximo valor a ser inserido é version. Junto com o name, este campo é obrigatório se o seu projeto for compartilhado com outras pessoas no repositório de pacotes npm.

Nota: Espera-se que os pacotes Node.js sigam o guia Versão Semântica (semver). Portanto, o primeiro número será o MAJORnúmero da versão que muda apenas quando a API é alterada. O segundo número será a MINORversão que muda quando os recursos são adicionados. O último número será a PATCHversão que muda quando os erros são corrigidos.

Pressione ENTERpara que a versão padrão seja aceita.

O próximo campo é description- uma sequência útil para explicar o que o seu módulo Node.js faz. Nosso locatorprojeto fictício obteria o endereço IP do usuário e retornaria o país de origem. Uma montagem descriptionseria Finds the country of origin of the incoming request, então digite algo assim e pressione ENTER. Isso descriptioné muito útil quando as pessoas estão procurando pelo seu módulo.

O prompt a seguir solicitará o entry point. Se alguém instalar e requiresseu módulo, o que você definir entry pointserá a primeira parte do seu programa carregada. O valor precisa ser o local relativo de um arquivo JavaScript e será adicionado à mainpropriedade do package.json. Pressione ENTERpara manter o valor padrão.

Nota : A maioria dos módulos possui um index.jsarquivo como o principal ponto de entrada. Este é o valor padrão para um package.json's mainpropriedade, que é o ponto de entrada para os módulos da NPM. Se não houver package.json, o Node.js tentará carregar index.jspor padrão.

Em seguida, você será solicitado a test command, um script ou comando executável para executar seus testes de projeto. Em muitos módulos populares do Node.js., os testes são gravados e executados com Mocha , Jest , Jasmine ou outras estruturas de teste. Como o teste está além do escopo deste artigo, deixe essa opção em branco por enquanto e pressione ENTERpara continuar.

O initcomando solicitará o Repositório GitHub do projeto . Você não usará isso neste exemplo, então deixe-o vazio também.

Após o prompt do repositório, o comando solicita keywords. Essa propriedade é uma matriz de cadeias com termos úteis que as pessoas podem usar para encontrar seu repositório. É melhor ter um pequeno conjunto de palavras que sejam realmente relevantes para o seu projeto, para que a pesquisa possa ser mais direcionada. Liste essas palavras-chave como uma sequência com vírgulas separando cada valor. Para este projeto de amostra, digite ip,geo,countryno prompt. O final package.jsonterá três itens na matriz para keywords.

O próximo campo no prompt é author. Isso é útil para usuários do seu módulo que desejam entrar em contato com você. Por exemplo, se alguém descobrir uma exploração no seu módulo, poderá usar isso para relatar o problema, para que você possa corrigi-lo. O authorcampo é uma string no seguinte formato: . Por exemplo, é um autor válido. Os dados de email e site são opcionais - um autor válido pode ser apenas um nome. Adicione seus detalhes de contato como autor e confirme com ."Name \<Email\> (Website)""Sammy \<sammy@your_domain\> (https://your_domain)"ENTER

Finalmente, você será solicitado a license. Isso determina as permissões e limitações legais que os usuários terão ao usar seu módulo. Muitos módulos do Node.js são de código aberto, portanto o npm define o padrão como ISC .

Nesse ponto, você revisaria suas opções de licenciamento e decidira o que é melhor para o seu projeto. Para obter mais informações sobre diferentes tipos de licenças de código aberto, consulte esta lista de licenças da Open Source Initiative . Se você não deseja fornecer uma licença para um repositório privado, digite UNLICENSEDno prompt. Para este exemplo, use a licença ISC padrão e pressione ENTERpara concluir este processo.

O initcomando agora exibirá o package.jsonarquivo que será criado. Será semelhante a este:

About to write to /home/sammy/locator/package.json:

{
  "name": "locator",
  "version": "1.0.0",
  "description": "Finds the country of origin of the incoming request",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "ip",
    "geo",
    "country"
  ],
  "author": "Sammy <sammy@your_domain> (https://your_domain)",
  "license": "ISC"
}


Is this OK? (yes)

Depois que as informações corresponderem ao que você vê aqui, pressione ENTERpara concluir este processo e criar o package.jsonarquivo. Com esse arquivo, você pode manter um registro dos módulos que instalar para o seu projeto.

Agora que você possui seu package.jsonarquivo, pode testar a instalação de módulos na próxima etapa.

Etapa 2 - Instalando Módulos

É comum no desenvolvimento de software usar bibliotecas externas para executar tarefas auxiliares em projetos. Isso permite que o desenvolvedor se concentre na lógica de negócios e crie o aplicativo com mais rapidez e eficiência.

Por exemplo, se nosso locatormódulo de amostra precisar fazer uma solicitação de API externa para obter dados geográficos, poderíamos usar uma biblioteca HTTP para facilitar essa tarefa. Como nosso principal objetivo é retornar dados geográficos pertinentes ao usuário, poderíamos instalar um pacote que facilite as solicitações HTTP para nós, em vez de reescrever esse código para nós mesmos, uma tarefa que está além do escopo de nosso projeto.

Vamos percorrer este exemplo. No seu locatoraplicativo, você usará a biblioteca axios , que o ajudará a fazer solicitações HTTP. Instale-o inserindo o seguinte em seu shell:

• npm install axios --save

Você inicia este comando com o npm installqual instalará o pacote (por uma questão de brevidade, você pode usar npm i). Em seguida, você lista os pacotes que deseja instalar, separados por um espaço. Nesse caso, é isso axios. Por fim, você encerra o comando com o --saveparâmetro opcional , que especifica que axiosserá salvo como uma dependência do projeto.

Quando a biblioteca estiver instalada, você verá uma saída semelhante à seguinte:

...
+ [email protected]
added 5 packages from 8 contributors and audited 5 packages in 0.764s
found 0 vulnerabilities

Agora, abra o package.jsonarquivo, usando um editor de texto de sua escolha. Este tutorial usará nano:

• nano package.json

Você verá uma nova propriedade, conforme destacado a seguir:

{
  "name": "locator",
  "version": "1.0.0",
  "description": "Finds the country of origin of the incoming request",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "ip",
    "geo",
    "country"
  ],
  "author": "Sammy sammy@your_domain (https://your_domain)",
  "license": "ISC",
  "dependencies": {
    "axios": "^0.19.0"
  }
}

A --saveopção disse ao npm para atualizar package.jsono módulo e a versão que acabou de instalar. Isso é ótimo, pois outros desenvolvedores que trabalham em seus projetos podem ver facilmente quais dependências externas são necessárias.

Nota : Você pode ter notado o ^número da versão anterior à axiosdependência. Lembre-se de que o controle de versão semântico consiste em três dígitos: MAJOR , MINOR e PATCH . O ^símbolo significa que qualquer versão MINOR ou PATCH superior satisfaria essa restrição de versão. Se você vir ~no início de um número de versão, apenas as versões PATCH superiores satisfarão a restrição.

Quando você terminar de revisar package.json, saia do arquivo.

Dependências de desenvolvimento

Pacotes que são usados ​​para o desenvolvimento de um projeto, mas não para compilar ou executá-lo na produção são chamados de dependências de desenvolvimento . Eles não são necessários para o seu módulo ou aplicativo funcionar na produção, mas podem ser úteis ao escrever o código.

Por exemplo, é comum os desenvolvedores usarem alinhadores de código para garantir que o código siga as práticas recomendadas e manter o estilo consistente. Embora isso seja útil para o desenvolvimento, isso apenas aumenta o tamanho do material de distribuição, sem fornecer um benefício tangível quando implantado na produção.

Instale um linter como uma dependência de desenvolvimento para o seu projeto. Experimente isso no seu shell:

• npm i [email protected] --save-dev

Neste comando, você usou a --save-devbandeira. Isso será salvo eslintcomo uma dependência necessária apenas para o desenvolvimento. Observe também que você adicionou @6.0.0ao seu nome de dependência. Quando os módulos são atualizados, eles são marcados com uma versão. O @comando diz ao npm para procurar uma etiqueta específica do módulo que você está instalando. Sem uma tag especificada, o npm instala a versão mais recente marcada. Abra package.jsonnovamente:

• nano package.json

Isso mostrará o seguinte:

{
  "name": "locator",
  "version": "1.0.0",
  "description": "Finds the country of origin of the incoming request",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "ip",
    "geo",
    "country"
  ],
  "author": "Sammy sammy@your_domain (https://your_domain)",
  "license": "ISC",
  "dependencies": {
    "axios": "^0.19.0"
  },
  "devDependencies": {
    "eslint": "^6.0.0"
  }
}

eslintfoi salvo como um devDependencies, junto com o número da versão que você especificou anteriormente. Sair package.json.

Arquivos gerados automaticamente: node_modulesepackage-lock.json

Quando você instala um pacote pela primeira vez em um projeto Node.js., o npm cria automaticamente a node_modulespasta para armazenar os módulos necessários para o seu projeto e o package-lock.jsonarquivo que você examinou anteriormente.

Confirme se eles estão no seu diretório de trabalho. No seu shell, digite lse pressione ENTER. Você observará a seguinte saída:

node_modules    package.json    package-lock.json

A node_modulespasta contém todas as dependências instaladas para o seu projeto. Na maioria dos casos, você não deve confirmar esta pasta no seu repositório controlado por versão. À medida que você instala mais dependências, o tamanho dessa pasta aumenta rapidamente. Além disso, o package-lock.jsonarquivo mantém um registro das versões exatas instaladas de maneira mais sucinta, portanto, a inclusão node_modulesnão é necessária.

Enquanto o package.jsonarquivo lista dependências que nos informam as versões adequadas que devem ser instaladas para o projeto, o package-lock.jsonarquivo acompanha todas as alterações package.jsonou node_modulesinforma a versão exata do pacote instalado. Você geralmente confirma isso em seu repositório controlado por versão em vez de node_modules, pois é uma representação mais limpa de todas as suas dependências.

Instalando a partir do package.json

Com seus arquivos package.jsone package-lock.json, você pode configurar rapidamente as mesmas dependências do projeto antes de iniciar o desenvolvimento de um novo projeto. Para demonstrar isso, suba um nível na sua árvore de diretórios e crie uma nova pasta nomeada cloned_locatorno mesmo nível de diretório que locator:

• cd ..
• mkdir cloned_locator

Mova para o seu novo diretório:

• cd cloned_locator

Agora copie os arquivos package.jsone package-lock.jsonde locatorpara cloned_locator:

• cp ../locator/package.json ../locator/package-lock.json .

Para instalar os módulos necessários para este projeto, digite:

• npm i

O npm procurará um package-lock.jsonarquivo para instalar os módulos. Se nenhum arquivo de bloqueio estiver disponível, ele será lido no package.jsonarquivo para determinar as instalações. Geralmente é mais rápido instalar a partir package-lock.json, já que o arquivo de bloqueio contém a versão exata dos módulos e suas dependências, o que significa que o npm não precisa gastar tempo tentando descobrir uma versão adequada para instalação.

Ao implantar na produção, você pode ignorar as dependências de desenvolvimento. Lembre-se de que as dependências de desenvolvimento são armazenadas na devDependenciesseção package.jsone não têm impacto na execução do seu aplicativo. Ao instalar módulos como parte do processo de CI / CD para implantar seu aplicativo, omita as dependências de dev executando:

• npm i --production

A --productionbandeira ignora a devDependenciesseção durante a instalação. Por enquanto, fique com a sua construção de desenvolvimento.

Antes de passar para a próxima seção, retorne à locatorpasta:

• cd ../locator

Instalações Globais

Até agora, você instalou os módulos npm para o locatorprojeto. O npm também permite instalar pacotes globalmente . Isso significa que o pacote está disponível para o usuário em um sistema mais amplo, como qualquer outro comando do shell. Essa capacidade é útil para os vários módulos do Node.js. que são ferramentas de CLI.

Por exemplo, você pode querer publicar um blog sobre o locatorprojeto em que está trabalhando atualmente. Para fazer isso, você pode usar uma biblioteca como o Hexo para criar e gerenciar o blog estático do site. Instale a CLI do Hexo globalmente assim:

• npm i hexo-cli -g

Para instalar um pacote globalmente, anexe o -gsinalizador ao comando

Nota : Se você receber um erro de permissão ao tentar instalar este pacote globalmente, seu sistema poderá exigir privilégios de superusuário para executar o comando. Tente novamente com sudo npm i hexo-cli -g.

Teste se o pacote foi instalado com sucesso, digitando:

• hexo --version

Você verá uma saída semelhante a:

hexo-cli: 2.0.0
os: Linux 4.15.0-64-generic linux x64
http_parser: 2.7.1
node: 10.14.0
v8: 7.6.303.29-node.16
uv: 1.31.0
zlib: 1.2.11
ares: 1.15.0
modules: 72
nghttp2: 1.39.2
openssl: 1.1.1c
brotli: 1.0.7
napi: 4
llhttp: 1.1.4
icu: 64.2
unicode: 12.1
cldr: 35.1
tz: 2019a

Até agora, você aprendeu como instalar módulos com o npm. Você pode instalar pacotes em um projeto localmente, como uma dependência de produção ou desenvolvimento. Você também pode instalar pacotes com base em arquivos package.jsonou existentes package-lock.json, permitindo desenvolver com as mesmas dependências que seus pares. Por fim, você pode usar o -gsinalizador para instalar pacotes globalmente, para poder acessá-los, independentemente de estar ou não em um projeto Node.js.

Agora que você pode instalar os módulos, na próxima seção, praticará técnicas para administrar suas dependências.

Etapa 3 - Gerenciando módulos

Um gerenciador de pacotes completo pode fazer muito mais do que instalar módulos. O npm tem mais de 20 comandos relacionados ao gerenciamento de dependências disponíveis. Nesta etapa, você irá:

• Liste os módulos que você instalou.
• Atualize os módulos para uma versão mais recente.
• Desinstale os módulos que você não precisa mais.
• Faça uma auditoria de segurança em seus módulos para encontrar e corrigir falhas de segurança.

Embora esses exemplos sejam feitos em sua locatorpasta, todos esses comandos podem ser executados globalmente, acrescentando o -gsinalizador no final deles, exatamente como você fez ao instalar globalmente.

Módulos de listagem

Se você gostaria de saber quais módulos estão instalados em um projeto, seria mais fácil usar o comando listou em lsvez de ler o package.jsondiretamente. Para fazer isso, digite:

• npm ls

Você verá uma saída como esta:

├─┬ [email protected]
│ ├─┬ [email protected]
│ │ └─┬ [email protected]
│ │   └── [email protected]
│ └── [email protected]
└─┬ [email protected]
  ├─┬ @babel/[email protected]
  │ └─┬ @babel/[email protected]
  │   ├── [email protected] deduped
  │   ├── [email protected] deduped
  │   └── [email protected]
  ├─┬ [email protected]
  │ ├── [email protected]
  │ ├── [email protected]
  │ ├── [email protected]
  │ └─┬ [email protected]
...

Por padrão, lsmostra toda a árvore de dependências - os módulos dos quais seu projeto depende e os módulos dos quais suas dependências dependem. Isso pode ser um pouco complicado se você quiser uma visão geral de alto nível do que está instalado.

Para imprimir apenas os módulos que você instalou sem suas dependências, digite o seguinte no seu shell:

• npm ls --depth 0

Sua saída será:

├── [email protected]
└── [email protected]

A --depthopção permite especificar o nível da árvore de dependência que você deseja ver. Quando é 0, você vê apenas suas dependências de nível superior.

Atualizando módulos

É uma boa prática manter seus módulos npm atualizados. Isso aumenta sua probabilidade de obter as correções de segurança mais recentes de um módulo. Use o outdatedcomando para verificar se algum módulo pode ser atualizado:

• npm outdated

Você obterá a saída da seguinte maneira:

Package  Current  Wanted  Latest  Location
eslint     6.0.0   6.7.1   6.7.1  locator

Este comando primeiro lista o Packageque está instalado e a Currentversão. A Wantedcoluna mostra em qual versão atende aos requisitos de versão package.json. A Latestcoluna mostra a versão mais recente do módulo que foi publicada.

A Locationcoluna indica onde na árvore de dependência o pacote está localizado. O outdatedcomando tem a --depthbandeira como ls. Por padrão, a profundidade é 0.

Parece que você pode atualizar eslintpara uma versão mais recente. Use o comando updateou upcomo este:

• npm up eslint

A saída do comando conterá a versão instalada:

npm WARN [email protected] No repository field.

+ eslint@6.7.1
added 7 packages from 3 contributors, removed 5 packages, updated 19 packages, moved 1 package and audited 184 packages in 5.818s
found 0 vulnerabilities

Se você deseja atualizar todos os módulos de uma só vez, digite:

• npm up

Desinstalando Módulos

O uninstallcomando npm pode remover módulos de seus projetos. Isso significa que o módulo não será mais instalado na node_modulespasta, nem será visto nos arquivos package.jsone package-lock.json.

Remover dependências de um projeto é uma atividade normal no ciclo de vida de desenvolvimento de software. Uma dependência pode não resolver o problema conforme anunciado ou pode não fornecer uma experiência de desenvolvimento satisfatória. Nesses casos, pode ser melhor desinstalar a dependência e criar seu próprio módulo.

Imagine que axiosnão fornece a experiência de desenvolvimento que você gostaria para fazer solicitações HTTP. Desinstale axioscom o comando uninstallou undigitando:

• npm un axios

Sua saída será semelhante a:

npm WARN [email protected] No repository field.

removed 5 packages and audited 176 packages in 1.488s
found 0 vulnerabilities

Não diz explicitamente que axiosfoi removido. Para verificar se foi desinstalado, liste as dependências mais uma vez:

• npm ls --depth 0

Agora, vemos apenas que eslintestá instalado:

└── eslint@6.7.1

Isso mostra que você desinstalou com sucesso o axiospacote.

Módulos de auditoria

O npm fornece um auditcomando para destacar possíveis riscos de segurança em suas dependências. Para ver a auditoria em ação, instale uma versão desatualizada do módulo de solicitação executando o seguinte:

• npm i [email protected]

Ao instalar esta versão desatualizada request, você notará uma saída semelhante à seguinte:

+ [email protected]
added 54 packages from 49 contributors and audited 243 packages in 7.26s
found 6 moderate severity vulnerabilities
  run `npm audit fix` to fix them, or `npm audit` for details

O npm está dizendo que você tem vulnerabilidades em suas dependências. Para obter mais detalhes, faça uma auditoria de todo o seu projeto com:

• npm audit

O auditcomando mostra tabelas de saída destacando falhas de segurança:

                       === npm audit security report ===

# Run  npm install [email protected]  to resolve 1 vulnerability
┌───────────────┬──────────────────────────────────────────────────────────────┐
│ Moderate      │ Memory Exposure                                              │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ Package       │ tunnel-agent                                                 │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ Dependency of │ request                                                      │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ Path          │ request > tunnel-agent                                       │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ More info     │ https://npmjs.com/advisories/598                             │
└───────────────┴──────────────────────────────────────────────────────────────┘

# Run  npm update request --depth 1  to resolve 1 vulnerability
┌───────────────┬──────────────────────────────────────────────────────────────┐
│ Moderate      │ Remote Memory Exposure                                       │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ Package       │ request                                                      │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ Dependency of │ request                                                      │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ Path          │ request                                                      │
├───────────────┼──────────────────────────────────────────────────────────────┤
│ More info     │ https://npmjs.com/advisories/309                             │
└───────────────┴──────────────────────────────────────────────────────────────┘
...

Você pode ver o caminho da vulnerabilidade e, às vezes, o npm oferece maneiras de corrigi-lo. Você pode executar o comando update conforme sugerido ou o fixsubcomando de audit. No seu shell, digite:

• npm audit fix

Você verá resultados semelhantes a:

+ [email protected]
added 19 packages from 24 contributors, removed 32 packages and updated 12 packages in 6.223s
fixed 2 of 6 vulnerabilities in 243 scanned packages
  4 vulnerabilities required manual review and could not be updated

O npm conseguiu atualizar com segurança dois dos pacotes, diminuindo suas vulnerabilidades na mesma quantidade. No entanto, você ainda tem quatro vulnerabilidades em suas dependências. O audit fixcomando nem sempre resolve todos os problemas. Embora uma versão de um módulo possa ter uma vulnerabilidade de segurança, se você a atualizar para uma versão com uma API diferente, poderá quebrar o código mais alto na árvore de dependências.

Você pode usar o --forceparâmetro para garantir que as vulnerabilidades desapareceram, assim:

• npm audit fix --force

Como mencionado anteriormente, isso não é recomendado, a menos que você tenha certeza de que não interromperá a funcionalidade.

Conclusão

Neste tutorial, você passou por vários exercícios para demonstrar como os módulos do Node.js são organizados em pacotes e como esses pacotes são gerenciados pelo npm. Em um projeto Node.js., você utilizava os pacotes npm como dependências, criando e mantendo um package.jsonarquivo - um registro dos metadados do seu projeto, incluindo os módulos que você instalou. Você também usou a ferramenta npm CLI para instalar, atualizar e remover módulos, além de listar a árvore de dependências para seus projetos e verificar e atualizar módulos desatualizados.