Come utilizzare i moduli Node.js con npm e package.json

Introduzione

Grazie alle caratteristiche quali le sue veloci prestazioni di Input/Output (I/O) e la sua nota sintassi JavaScript, Node.js è rapidamente diventato un popolare ambiente di runtime per lo sviluppo web back-end. Man mano che cresce l'interesse, vengono sviluppate applicazioni più grandi e diventa più difficile gestire la complessità della base di codice e le sue dipendenze. Node.js organizza questa complessità usando i moduli, che sono singoli file JavaScript contenenti funzioni o oggetti che possono essere utilizzati da altri programmi o moduli. Una raccolta di uno o più moduli viene comunemente denominata pacchetto e questi pacchetti sono essi stessi organizzati dai gestori dei pacchetti.

Il gestore pacchetti Node.js (npm) è il gestore pacchetti predefinito e più popolare nell'ecosistema Node.js e viene utilizzato principalmente per installare e gestire moduli esterni in un progetto Node.js. Inoltre, viene comunemente utilizzato per installare una vasta gamma di strumenti CLI ed eseguire script di progetto. npm tiene traccia dei moduli installati in un progetto con il file package.json, che risiede nella directory di un progetto e contiene:

• Tutti i moduli necessari per un progetto e le relative versioni installate
• Tutti i metadati per un progetto, come l'autore, la licenza, ecc.
• Script che possono essere eseguiti per automatizzare le attività all'interno del progetto

Man mano che crei progetti Node.js più complessi, la gestione dei metadati e delle dipendenze con il file package.json ti fornirà build più prevedibili, poiché tutte le dipendenze esterne rimangono invariate. Il file terrà automaticamente traccia di queste informazioni; mentre puoi modificare il file direttamente per aggiornare i metadati del tuo progetto, raramente dovrai interagire direttamente con esso per gestire i moduli.

In questo tutorial gestirai i pacchetti con npm. Il primo passo sarà quello di creare e comprendere il file package.json. Lo userete quindi per tenere traccia di tutti i moduli installati nel progetto. Infine, elencherai le dipendenze, aggiornerai, disinstallerai i tuoi pacchetti ed eseguirai un controllo per trovare difetti di sicurezza nei pacchetti.

Prerequisiti

Avrai bisogno di Node.js e NPM installati nel tuo ambiente di sviluppo, segui uno dei seguenti tutorial in base al sistema operativo in uso:

• Come installare Node.js e NPM su CentOS 8 Linux.
• Come installare Node.js e NPM su Ubuntu 18.04.
• Come installare Node.js e NPM su Debian 10.
• Come installare Node.js su Fedora 30
• Come installare Node.js e NPM su Linux Mint 19 Tara
• Come installare Node.js e NPM su Raspberry Pi

Passaggio 1: Creare un file package.json

Iniziamo questo tutorial impostando il progetto di esempio: un modulo di Node.js locator  fittizio che ottiene l'indirizzo IP dell'utente e restituisce il paese di origine. In questo tutorial non codificherai il modulo. Tuttavia, i pacchetti che gestiresti sarebbero rilevanti se lo stessi sviluppando.

Innanzitutto, creerai un file package.json per archiviare metadati utili sul progetto e aiutarti a gestire i moduli Node.js dipendenti dal progetto. Come suggerisce il suffisso, si tratta di un file JSON (JavaScript Object Notation). JSON è un formato standard utilizzato per la condivisione, basato su oggetti JavaScript e costituito da dati memorizzati come coppie chiave-valore.

Poiché un file package.json contiene numerose proprietà, può essere complicato crearlo manualmente, senza copiare e incollare un modello da qualche altra parte. Per semplificare le cose, npm fornisce il comando init. Questo è un comando interattivo che ti pone una serie di domande e crea un file package.json basato sulle tue risposte.

Usando il comando init

Innanzitutto, imposta un progetto in modo da poter esercitarti nella gestione dei moduli. Nella tua shell, crea una nuova cartella chiamata locator con il comando mkdir:

mkdir locator

Quindi spostati nella nuova cartella con il comando cd:

cd locator

Ora, inizializza il prompt interattivo inserendo:

npm init

Nota: se il codice utilizzerà Git per il controllo della versione, creare prima il repository Git, quindi eseguire npm init. Il comando comprende automaticamente che si trova in una cartella abilitata per Git. Se un Git remoto è impostato, riempie automaticamente i campi repository, bugs e homepage per il vostro file package.json. Se hai inizializzato il repository dopo aver creato il file package.json, dovrai aggiungere queste informazioni manualmente.

Riceverai il seguente output:

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)

Prima ti verrà richiesto il name del nuovo progetto. Per impostazione predefinita, il comando presuppone che sia il nome della cartella in cui ci si trova. I valori predefiniti per ciascuna proprietà sono indicati tra parentesi (). Poiché il valore predefinito per name funzionerà per questa esercitazione, premere ENTER per accettarlo.

Il prossimo valore da inserire è version. Insieme a name, questo campo è obbligatorio se il progetto verrà condiviso con altri nel repository dei pacchetti npm.

Nota: i pacchetti Node.js dovrebbero seguire la guida Semantic Versioning (semver). Pertanto, il primo numero sarà il numero di versione MAJOR  che cambia solo quando cambia l'API. Il secondo numero sarà la versione MINOR che cambia quando vengono aggiunte funzionalità. L'ultimo numero sarà la versione PATCH che cambia quando i bug vengono corretti.

Premere ENTER per accettare la versione predefinita.

Il campo successivo è description — una stringa utile per spiegare cosa fa il tuo modulo Node.js. Il nostro progetto fittizio locator otterrebbe l'indirizzo IP dell'utente e restituire il paese di origine. Un adattamento di description sarebbe Finds the country of origin of the incoming request, quindi digitare qualcosa di simile e premere ENTER. Il description è molto utile quando le persone sono alla ricerca per il modulo.

Il seguente prompt ti chiederà l'entry point. Se qualcuno installa e il tuo modulo requires, ciò che hai impostato nell'entry point sarà la prima parte del tuo programma che verrà caricato. Il valore deve essere la posizione relativa di un file JavaScript e verrà aggiunto alla proprietà main del filepackage.json. Premere ENTER per mantenere il valore predefinito.

Nota: la maggior parte dei moduli ha un file index.js come punto di ingresso principale. Questo è il valore predefinito per la proprietà main di package.json, che è il punto di ingresso per i moduli npm. Se non c'è il file package.json, Node.js proverà a caricare index.js per impostazione predefinita.

Successivamente, ti verrà chiesto un test command, uno script eseguibile o un comando per eseguire i test del progetto. In molti moduli Node.js popolari, i test vengono scritti ed eseguiti con Mocha, Jest, Jasmine o altri framework di test. Poiché i test non rientrano nell'ambito di questo articolo, lasciare questa opzione vuota per ora e premere ENTER per proseguire.

Il comando init chiederà quindi il repository GitHub del progetto. In questo esempio non lo utilizzerai, quindi lascialo vuoto.

Dopo il prompt del repository, il comando richiede keywords. Questa proprietà è un array di stringhe con termini utili che le persone possono usare per trovare il tuo repository. È meglio avere un piccolo insieme di parole veramente rilevanti per il tuo progetto, in modo che la ricerca possa essere più mirata. Elencare queste parole chiave come una stringa con virgole che separano ciascun valore. Per questo progetto di esempio, digitare ip,geo,country nel terminale. Al termine, il file package.json avrà tre elementi nell'array keywords.

Il prossimo campo nel prompt è author. Questo è utile per gli utenti che vogliono mettersi in contatto con te. Ad esempio, se qualcuno scopre un exploit nel tuo modulo, può utilizzarlo per segnalare il problema in modo da poterlo risolvere. Il campo author è una stringa. La sintassi è la seguente: "Name \<Email\> (Website)". Ad esempio: "Noviello \<noviello@your_domain\> (https://your_domain)". Email e sito Web sono opzionali. Si potrebbe inserire anche solo un nome. Aggiungi i tuoi dati di contatto come autore e conferma con ENTER.

Infine, ti verrà la license. Ciò determina le autorizzazioni e le limitazioni legali che gli utenti avranno durante l'utilizzo del modulo. Molti moduli Node.js sono open source, quindi npm imposta il valore predefinito su ISC.

A questo punto, ricontrollerai le opzioni di licenza e deciderai cosa è meglio per il tuo progetto. Per ulteriori informazioni sui diversi tipi di licenze open source, consultare questo elenco di licenze dall'Iniziativa Open Source. Se non si desidera fornire una licenza per un repository privato, è possibile digitare UNLICENSED nel prompt. Per questo esempio, utilizzare la licenza ISC predefinita e premere ENTER per completare questo processo.

Il comando init visualizzerà il file package.json appena creato. Sarà simile a questo:

About to write to /home/noviello/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": "Noviello <noviello@your_domain> (https://your_domain)",
  "license": "ISC"
}


Is this OK? (yes)

Una volta che le informazioni corrispondono a ciò che vedi qui, premi ENTER per completare questo processo e creare il file package.json. Con questo file, puoi tenere un registro dei moduli che installi per il tuo progetto.

Ora che hai il tuo file package.json, puoi provare l'installazione dei moduli nel passaggio successivo.

Passaggio 2: Installare dei moduli

È comune nello sviluppo del software utilizzare librerie esterne per eseguire attività accessorie nei progetti. Ciò consente allo sviluppatore di concentrarsi sulla logica aziendale e creare l'applicazione in modo più rapido ed efficiente.

Ad esempio, se il nostro modulo di esempio locator deve effettuare una richiesta API esterna per ottenere dati geografici, potremmo utilizzare una libreria HTTP per semplificare tale attività. Poiché il nostro obiettivo principale è restituire all'utente i dati geografici pertinenti, potremmo installare un pacchetto che ci semplifica le richieste HTTP anziché riscrivere questo codice per noi stessi, un'attività che esula dall'ambito del nostro progetto.

Esaminiamo questo esempio. Nella tua applicazione locator, utilizzerai la libreria axios, che ti aiuterà a fare richieste HTTP. Installalo inserendo quanto segue nella tua shell:

npm install axios --save

Inizia con il comando con npm install, che installerà il pacchetto (per brevità puoi usare npm i). Quindi si elencano i pacchetti che si desidera installare, separati da uno spazio. In questo caso, questo è axios. Infine, si termina il comando con il parametro facoltativo --save , che specifica che axios verrà salvato come dipendenza del progetto.

Quando la libreria è installata, vedrai un output simile al seguente:

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

Ora apri il file package.json usando un editor di testo a tua scelta. Questo tutorial utilizzerà nano:

nano package.json

Vedrai una nuova proprietà, come evidenziato di seguito:

{
  "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"
  }
}

L'opzione --save ha detto a npm di aggiornare il file package.json con il modulo e la versione appena installati. Questo è molto utile, poiché altri sviluppatori che lavorano ai tuoi progetti possono facilmente vedere quali dipendenze esterne sono necessarie.

Nota : potresti aver notato il simbolo ^ prima del numero di versione per la dipendenza axios. Ricordiamo che il versioning semantico è composto da tre cifre: MAJOR , MINOR e PATCH . Il simbolo ^ indica che qualsiasi versione MINOR o PATCH superiore soddisferebbe questo vincolo di versione. Se vedi il simbolo ~ all'inizio di un numero di versione, solo le versioni PATCH più alte soddisfano il vincolo.

Al termine della revisione, chiudere il file package.json.

Dipendenze dello sviluppo

I pacchetti utilizzati per lo sviluppo di un progetto, non per crearlo o eseguirlo, in produzione sono chiamati dipendenze di sviluppo. Non sono necessari per il funzionamento del modulo o dell'applicazione in produzione, ma possono essere utili durante la scrittura del codice.

Ad esempio, è comune per gli sviluppatori utilizzare i code linters per assicurarsi che il loro codice segua le migliori pratiche e per mantenere lo stile coerente. Sebbene ciò sia utile per lo sviluppo, ciò aumenta solo le dimensioni del distribuibile senza fornire un beneficio tangibile quando viene distribuito in produzione.

Installa un linter come dipendenza di sviluppo per il tuo progetto. Prova questo comando nella tua shell:

npm i [email protected] --save-dev

In questo comando hai usato il flag --save-dev. Ciò salverà eslint come dipendenza necessaria solo per lo sviluppo. Nota anche che hai aggiunto anche @6.0.0 al nome della tua dipendenza. Quando i moduli vengono aggiornati, vengono contrassegnati con una versione. Il simbolo @ dice NPM di cercare un tag specifico del modulo che si sta installando. Senza un tag specificato, npm installa l'ultima versione taggata. Apri di nuovo il file package.json :

nano package.json

Questo mostrerà quanto segue:

{
  "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"
  }
}

eslint è stato salvato come un devDependencies, insieme al numero di versione specificato in precedenza. Esci dal filepackage.json.

File generati automaticamente: node_modules e package-lock.json

Quando si installa per la prima volta un pacchetto in un progetto Node.js, npm crea automaticamente la cartella node_modules in cui archiviare i moduli necessari per il progetto e il file package-lock.json esaminato in precedenza.

Conferma che si trovano nella tua directory di lavoro. Nella shell, digitare ls e premere ENTER. Osserverai il seguente output:

node_modules    package.json    package-lock.json

La cartella node_modules contiene tutte le dipendenze installate per il tuo progetto. Nella maggior parte dei casi, è necessario non impegnare (commit) questa cartella nel vostro repository di versione controllato. Man mano che si installano più dipendenze, le dimensioni di questa cartella aumenteranno rapidamente. Inoltre, il file package-lock.json tiene traccia delle versioni esatte installate in un modo più conciso, quindi non è necessario includere node_modules.

Mentre il file package.json elenca le dipendenze che ci dicono le versioni adatte che dovrebbero essere installate per il progetto, il file package-lock.json tiene traccia di tutte le modifiche in package.json o node_modules e ci dice la versione esatta del pacchetto installato. Di solito lo si impegna nel repository di versione controllato anziché in node_modules, poiché è una rappresentazione più pulita di tutte le dipendenze.

Installare da package.json

Con i tuoi file package.json e package-lock.json, puoi impostare rapidamente le stesse dipendenze del progetto prima di iniziare lo sviluppo di un nuovo progetto. Per dimostrarlo, sali di un livello nella tua struttura di directory e crea una nuova cartella denominata cloned_locator nello stesso livello di directory di locator:

cd ..

mkdir cloned_locator

Sposta nella tua nuova directory:

cd cloned_locator

Ora copia i file package.json e package-lock.json da locator a cloned_locator con il comando cp:

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

Per installare i moduli richiesti per questo progetto, digitare:

npm i

npm verificherà la presenza di un file package-lock.json per installare i moduli. Se non è disponibile alcun file di blocco, verrà letto dal file package.json per determinare le installazioni. Di solito è più veloce da installare package-lock.json, poiché il file di blocco contiene la versione esatta dei moduli e le loro dipendenze, il che significa che npm non deve perdere tempo a trovare una versione adatta da installare.

Durante la distribuzione in produzione, è possibile che si desideri saltare le dipendenze di sviluppo. Ricorda che le dipendenze di sviluppo sono archiviate nella sezione devDependencies di package.json e non hanno alcun impatto sul funzionamento della tua app. Quando si installano i moduli come parte del processo CI/CD per distribuire l'applicazione, omettere le dipendenze degli sviluppatori eseguendo:

npm i --production

Il flag --production ignora la sezione devDependencies durante l'installazione. Per ora, segui la tua build di sviluppo.

Prima di passare alla sezione successiva, torna alla cartella locator:

cd ../locator

Installare in modo globale

Finora hai installato i moduli npm per il progetto locator. npm ti consente anche di installare i pacchetti a livello globale. Ciò significa che il pacchetto è disponibile per l'utente nel sistema più ampio, come qualsiasi altro comando shell. Questa capacità è utile per i numerosi moduli Node.js che sono strumenti della CLI.

Ad esempio, potresti voler creare un blog sul progetto locator a cui stai attualmente lavorando. Per fare ciò, è possibile utilizzare una libreria come Hexo per creare e gestire il blog del sito Web statico. Installa la CLI Hexo a livello globale in questo modo:

npm i hexo-cli -g

Per installare un pacchetto a livello globale, aggiungi il flag -g al comando.

Nota : se si verifica un errore di autorizzazione nel tentativo di installare questo pacchetto a livello globale, il sistema potrebbe richiedere privilegi di superutente per eseguire il comando. Riprova con sudo npm i hexo-cli -g.

Verifica che il pacchetto sia stato installato correttamente digitando:

hexo --version

Vedrai un output simile 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

Finora hai imparato come installare i moduli con npm. È possibile installare i pacchetti in un progetto localmente, come dipendenza dalla produzione o dallo sviluppo. Puoi anche installare pacchetti basati su file package.json o package-lock.json preesistenti. Infine, puoi usare il flag -g per installare i pacchetti a livello globale, così puoi accedervi indipendentemente dal fatto che tu sia o meno in un progetto Node.js.

Ora che puoi installare i moduli, nella prossima sezione eserciterai le tecniche per amministrare le tue dipendenze.

Passaggio 3: Gestire i moduli

Un gestore di pacchetti completo può fare molto di più dei moduli di installazione. npm ha a disposizione oltre 20 comandi relativi alla gestione delle dipendenze. In questo passaggio, dovrai:

• Elenca i moduli che hai installato.
• Aggiorna i moduli a una versione più recente.
• Disinstallare i moduli non più necessari.
• Eseguire un controllo di sicurezza sui moduli per trovare e correggere i difetti di sicurezza.

Mentre questi esempi verranno eseguiti nella tua cartella locator, tutti questi comandi possono essere eseguiti a livello globale aggiungendo il flag -g alla fine di essi, esattamente come hai fatto durante l'installazione a livello globale.

Elencare i moduli

Se vuoi sapere quali moduli sono installati in un progetto, sarebbe più semplice usare il comando list o ls invece di leggere direttamente package.json. Per fare ciò, digita da terminale il seguente comando:

npm ls

Vedrai un output in questo modo:

├─┬ [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]
...

Per impostazione predefinita, ls mostra l'intero albero delle dipendenze: i moduli da cui dipende il progetto e i moduli da cui dipendono le dipendenze. Questo può essere un po eccessivo come output se si desidera una panoramica di alto livello di ciò che è installato.

Per stampare solo i moduli installati senza le relative dipendenze, immettere quanto segue nella shell:

npm ls --depth 0

Il tuo output sarà:

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

L'opzione --depth consente di specificare quale livello dell'albero delle dipendenze si desidera visualizzare. Quando è 0, vedi solo le tue dipendenze di livello superiore.

Aggiornamento dei moduli

È buona norma mantenere aggiornati i moduli npm. Ciò migliora la probabilità di ottenere le ultime correzioni di sicurezza per un modulo. Utilizzare il comando outdated per verificare se è possibile aggiornare eventuali moduli:

npm outdated

Otterrai un output come il seguente:

Package  Current  Wanted  Latest  Location
eslint     6.0.0   6.7.1   6.7.1  locator

Questo comando prima elenca Package ciò che è installato e la versione Current. La colonna Wanted mostra quale versione soddisfa il tuo requisito di versione in package.json. La colonna Latest mostra la versione più recente del modulo che è stato pubblicato.

La colonna Location indica dove si trova il pacchetto nell'albero delle dipendenze. Il comando outdated ha il flag --depth simile a ls. Per impostazione predefinita, la profondità è 0.

Sembra che tu possa aggiornare eslint ad una versione più recente. Utilizzare il comando update o up questo modo:

npm up eslint

L'output del comando conterrà la versione installata:

npm WARN [email protected] No repository field.

+ [email protected]
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 si desidera aggiornare tutti i moduli contemporaneamente, è necessario inserire:

npm up

Disinstallare i moduli

Il comando uninstall permette a npm di rimuovere i moduli dai tuoi progetti. Ciò significa che il modulo non verrà più installato nella cartella node_modules, né verrà visualizzato nei tuoi file package.json e package-lock.json.

La rimozione delle dipendenze da un progetto è un'attività normale nel ciclo di vita dello sviluppo del software. Una dipendenza potrebbe non risolvere il problema come o potrebbe non fornire un'esperienza di sviluppo soddisfacente. In questi casi, potrebbe essere meglio disinstallare la dipendenza e creare il proprio modulo.

Immagina che axios non fornisca l'esperienza di sviluppo desiderato per effettuare richieste HTTP. Disinstallare axios con il comando uninstall o un digitando:

npm un axios

Il tuo output sarà simile a:

npm WARN [email protected] No repository field.

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

Non dice esplicitamente che è axios stato rimosso. Per verificare che sia stato disinstallato, elencare nuovamente le dipendenze:

npm ls --depth 0

Ora vediamo solo che eslint è installato:

└── [email protected]

Ciò dimostra che il pacchetto axios è stato disinstallato correttamente.

Controllare i moduli

npm fornisce un comando audit per evidenziare potenziali rischi per la sicurezza nelle dipendenze. Per vedere l'audit in azione, installare una versione obsoleta del modulo request eseguendo quanto segue:

npm i [email protected]

Quando installi questa versione obsoleta di request, noterai un output simile al seguente:

+ [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

npm ti sta dicendo che hai delle vulnerabilità nelle tue dipendenze. Per ottenere maggiori dettagli, controlla l'intero progetto con:

npm audit

Il comando audit mostra le tabelle di output che evidenziano i difetti di sicurezza:

                    === 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                             │
└───────────────┴──────────────────────────────────────────────────────────────┘
...

Puoi vedere il percorso della vulnerabilità e talvolta npm ti offre la possibilità di risolverlo. È possibile eseguire il comando di aggiornamento come suggerito oppure eseguire il sottocomando fix di audit. Nella shell, inserisci:

npm audit fix

Vedrai un output simile 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

npm è stato in grado di aggiornare in modo sicuro due dei pacchetti, riducendo le vulnerabilità dello stesso importo. Tuttavia, hai ancora quattro vulnerabilità nelle tue dipendenze. Il comando audit fix non risolve sempre tutti i problemi.

È possibile utilizzare il parametro --force per assicurarsi che le vulnerabilità scompaiano, in questo modo:

npm audit fix --force

Come accennato in precedenza, questo non è raccomandato a meno che non si sia sicuri che non interromperà la funzionalità.

Conclusione

In questo tutorial, sono state eseguite varie esercitazioni per dimostrare come i moduli Node.js sono organizzati in pacchetti e come questi pacchetti sono gestiti da npm. In un progetto Node.js, hai utilizzato i pacchetti npm come dipendenze creando e gestendo un file package.json, un registro dei metadati del tuo progetto, inclusi i moduli installati. È stato inoltre utilizzato lo strumento CLI npm per installare, aggiornare e rimuovere i moduli, oltre a elencare l'albero delle dipendenze per i progetti e controllare e aggiornare i moduli obsoleti.