Tutorial

Modernizzare un'applicazione Node.js

Impara a usare IBM Bob per la modernizzazione delle applicazioni aggiornando un'API Express Node.js dalla versione 16 alla 22. Prova lo sviluppo assistito da IA con modalità, approvazioni e codifica letteraria in questo tutorial pratico.

Introduzione

Bob è un partner IA SDLC (Software Development Lifecycle) che potenzia i tuoi flussi di lavoro esistenti. In questo tutorial, imparerai alcune delle funzionalità principali di Bob modernizzando un'API Express TypeScript da Node.js 16 a Node.js 22. Non hai bisogno di esperienza in Node.js o TypeScript per completare il tutorial. Imparerai come Bob analizza le dipendenze e modernizza i pattern di codice.

Funzionalità chiave che imparerai

Bob fornisce quattro capacità essenziali che userai durante l'aggiornamento dell'API:

  • Modalità: Personas specializzate che adattano il comportamento di Bob per compiti specifici.
  • Menzioni di contesto: Fai riferimento a elementi specifici del progetto nelle conversazioni con Bob, come file, cartelle o commit Git.
  • Flusso di approvazione: Rivedi ogni strumento che Bob prevede di utilizzare prima che venga eseguito.
  • Codifica letteraria: Scrivi codice con Bob direttamente nel tuo editor. Digita istruzioni in linguaggio naturale proprio dove dovrebbe andare il codice.

Prerequisiti

Questo tutorial utilizza un'API REST Express TypeScript come progetto di esempio. Tuttavia, non hai bisogno di esperienza in Node.js o TypeScript.

Per completare questo tutorial, hai bisogno di quanto segue:

  • Docker installato e in esecuzione sulla tua workstation. Usi Bob per creare un Dockerfile per l'applicazione.
  • Bob IDE installato.
  • Hai completato il tutorial Quickstart per familiarizzarti con l'interfaccia e le funzionalità di Bob.
  • Potresti voler avviare una nuova finestra di contesto per questo tutorial. Fai riferimento al tutorial Crea una nuova finestra di contesto per le istruzioni.

Configura il tuo spazio di lavoro

Avvia IBM Bob e clona il repository di esempio per iniziare a lavorare con l'applicazione Node.js che modernizzerai.

Avvia IBM Bob

Avvia l'applicazione IBM Bob sul tuo computer.

Apri il pannello chat di Bob

Se il pannello chat non è già aperto, aprilo cliccando sull'icona Bob accanto alla barra di navigazione o usa la scorciatoia Option + Command + B (Mac) o Ctrl + Alt + B (Windows).

Pannello chat di Bob aperto in IBM Bob IDE

Clona il repository del tutorial

Clona il repository contenente l'applicazione di esempio cliccando sull'icona dei file situata in alto a sinistra del pannello Bob IDE. Quindi clicca su Clona Repository e incolla il seguente repository GitHub nella barra di ricerca. Bob ti chiederà dove vuoi salvare il repository. Puoi salvarlo dove preferisci.

https://github.com/IBM/bob-demo.git

Clonazione del repository in Bob IDE

Apri il repository

Quando Bob ti chiede se vuoi aprire il repository clonato, clicca su Apri. Se Bob chiede "Ti fidi degli autori dei file in questa cartella?", clicca su Sì, mi fido degli autori.

Nota i file del progetto nell'Explorer e il pannello chat di Bob sul lato.

File del progetto visualizzati nell'Explorer con il pannello chat di Bob

Disabilita l'approvazione automatica

Assicurati che l'approvazione automatica sia disattivata. Puoi trovare questa impostazione in Permessi.

Costruisci l'ambiente containerizzato

Crea un Dockerfile per eseguire l'applicazione in un ambiente containerizzato, eliminando la necessità di installare Node.js o dipendenze localmente.

Passa alla modalità Agent

Passa Bob alla modalità Agent cliccando sul menu a discesa della modalità e selezionando Agent.

Le Modalità sono un modo in cui Bob rispetta il principio del privilegio minimo. Ogni modalità dà a Bob il permesso di proporre un insieme specifico di compiti per tuo conto. La modalità Agent consente a Bob di scrivere, modificare e refactorizzare il codice. Bob chiede comunque il permesso prima di ogni operazione.

Crea il Dockerfile

Inserisci un prompt nell'interfaccia chat di Bob per chiedere a Bob di creare il Dockerfile.

Crea un Dockerfile per questa applicazione Node.js TypeScript. Dovrebbe usare Node 16 per corrispondere alla versione corrente dell'applicazione, compilare il codice TypeScript ed eseguire l'app sulla porta `3000`.

Bob richiede l'accesso in lettura a diversi file per comprendere i requisiti del Dockerfile. Clicca su Approva per concedere a Bob il permesso di leggere quei file.

Bob determina la struttura appropriata del Dockerfile e ti mostra il file proposto. I pulsanti di azione appaiono sopra il campo di input della chat. Clicca su Salva per creare il file. Salva scrive o modifica file nel tuo progetto. Più avanti in questo tutorial, Bob aggiorna il Dockerfile per usare Node 22.

Verifica che l'applicazione legacy si compili

Prima di modernizzare, verifica che il codice legacy si compili ed esegua correttamente. Questa baseline assicura che tu possa identificare eventuali problemi introdotti dalla modernizzazione.

Durante la fase di build, Bob ti dirà che la build è fallita perché il Dockerfile usa npm ci, che richiede un file package-lock.json che non esiste.

Nel pannello chat di Bob, dì a Bob di compilare e testare l'applicazione.

Compila e testa l'applicazione legacy usando Docker per verificare che funzioni correttamente prima della modernizzazione. L'applicazione dovrebbe rispondere alle richieste API a /api/todos con dati di esempio

Dopo il test, pulisci il container.

Bob ti chiede di salvare una modifica al Dockerfile che risolverà il problema package-lock.json con il seguente messaggio:

La build è fallita perché non c'è un file package-lock.json. Devo aggiornare il Dockerfile per usare `npm install` invece di `npm ci`. Lascia che lo sistemi.

La capacità di Bob di rilevare e correggere errori di build è un esempio di come lavora con te per risolvere i problemi durante i deployment.

Una volta che Bob applica la correzione e completa la build, mostra un riepilogo dei risultati di build e test, confermando che l'applicazione legacy funziona correttamente in un ambiente containerizzato. Hai ora una baseline verificata con cui confrontarti dopo aver modernizzato l'applicazione nella sezione successiva.

Tu e Bob avete verificato che l'applicazione legacy funziona correttamente.

Esplora la codebase Node.js con la modalità Ask di Bob

Prima di modernizzare, clicca sul menu a discesa di selezione della modalità e passa alla modalità Ask di Bob. La modalità Ask può solo leggere file, quindi puoi esplorare il codice in sicurezza senza fare modifiche accidentali. Puoi anche digitare /ask nella chat di Bob per passare alla modalità Ask.

Usa le menzioni di contesto @ per rivedere il progetto

Bob supporta le menzioni di contesto @ che ti permettono di fare riferimento a file, cartelle o problemi specifici direttamente nei tuoi prompt. Le menzioni di contesto danno a Bob informazioni precise su ciò di cui vuoi discutere.

Esplora i file package.json, tsconfig.json e Dockerfile dicendo esplicitamente a Bob quali file analizzare usando le menzioni @. Imparare su questi file ti aiuta a comprendere i requisiti di modernizzazione prima di apportare modifiche.

Nel pannello chat di Bob, esegui il seguente prompt:

@package.json Quale versione di Node.js sta usando questo progetto? Quali dipendenze dovrebbero essere aggiornate per Node.js 22? Dammi un breve riepilogo.

Il simbolo @ dice a Bob di includere package.json come contesto. Bob non inizia a rispondere immediatamente; esplora prima la tua codebase, leggendo file, seguendo pattern e analizzando il codice. Non interrompere questa fase di esplorazione.

Bob identifica i seguenti aggiornamenti necessari per Node.js 22:

**Versione corrente di Node.js:** 16.x

**Dipendenze che necessitano aggiornamenti per Node.js 22:**

1. **@types/node**: ^16.18.0 → ^22.x.x (tipi TypeScript per Node.js 22)
2. **typescript**: ^4.9.5 → ^5.x.x (TypeScript 5+ per un migliore supporto di Node.js 22)
3. **ts-node**: ^10.9.1 → ^10.9.2+ (assicurare compatibilità con TS 5 e Node 22)

**Dipendenze già compatibili:**
- **express**: ^4.18.2 ✓ (funziona con Node.js 22)
- **uuid**: ^9.0.0 ✓ (funziona con Node.js 22)
- **@types/express**: ^4.17.17 ✓ (compatibile)
- **@types/uuid**: ^9.0.0 ✓ (compatibile)

**Riepilogo:** Solo le dipendenze di sviluppo specifiche di Node.js necessitano aggiornamenti. Le dipendenze runtime (Express, UUID) sono già compatibili con Node.js 22.

Analizza la configurazione TypeScript

Chiedi a Bob di analizzare la configurazione TypeScript del progetto:

@tsconfig.json Quale sistema di moduli e impostazioni del compilatore sta usando questo progetto TypeScript? Quali dipendenze dovrebbero essere aggiornate per Node.js 22? Dammi un breve riepilogo.

Bob risponde con i seguenti componenti che devi aggiornare per Node.js 22:

**Configurazione TypeScript corrente:**

**Sistema di moduli:** CommonJS (`"module": "commonjs"`)
- Sistema di moduli Node.js tradizionale usando `require()` e `module.exports`
- Output: file `.js` con sintassi CommonJS

**Impostazioni del compilatore:**
- **Target:** ES2020 (compila in JavaScript ES2020)
- **Lib:** ES2020 (usa funzionalità della libreria standard ES2020)
- **Module Resolution:** Node (algoritmo di risoluzione Node.js standard)
- **Strict Mode:** Abilitato (controllo completo dei tipi)

**Aggiornamenti consigliati per Node.js 22:**

1. **target**: ES2020 → **ES2022** o **ESNext** (sfruttare funzionalità JS più recenti)
2. **lib**: ES2020 → **ES2022** (accedere a API più recenti)
3. **module**: Considera la migrazione a **"node16"** o **"nodenext"** per supporto ESM nativo
4. **moduleResolution**: "node" → **"node16"** o **"bundler"** (migliore risoluzione moderna)

**Riepilogo:** Il progetto usa CommonJS legacy con target ES2020. Per Node.js 22, dovresti aggiornare il target/lib a ES2022+ e considerare la migrazione a moduli ESM nativi (anche se CommonJS funziona ancora bene).

Analizza il Dockerfile

Chiedi a Bob di analizzare il Dockerfile del progetto:

@Dockerfile Quale versione di Node.js usa questo Dockerfile? Cosa dovrebbe cambiare per Node.js 22? Dammi un breve riepilogo.

Bob risponde con ciò che deve essere aggiornato per Node.js 22:

**Versione corrente di Node.js del Dockerfile:** Node 16 Alpine (`node:16-alpine`)

**Modifiche necessarie per Node.js 22:**

1. **Immagine base (Riga 2):** `FROM node:16-alpine` → `FROM node:22-alpine`

**Riepilogo:** Richiesta solo una modifica di riga: aggiornare l'immagine base da node:16-alpine a node:22-alpine. Il resto del Dockerfile è compatibile con Node.js 22, anche se la sintassi dei flag npm potrebbe essere modernizzata

Ora comprendi cosa deve essere aggiornato. Nella sezione successiva, passi alla modalità Agent e fai fare le modifiche a Bob.

Modernizza l'API con la modalità Agent di Bob

Bob ha determinato i seguenti requisiti di modernizzazione per package.json, tsconfig.json e Dockerfile:

  • Cambiare Node.js 16 in Node.js 22 in package.json e Dockerfile
  • Aggiornare le impostazioni di target e modulo del compilatore TypeScript
  • Correggere le versioni delle dipendenze obsolete

Per iniziare a modernizzare l'applicazione, torna alla modalità Agent in modo che Bob possa apportare modifiche al codice.

Nel pannello chat di Bob, esegui il seguente prompt di modernizzazione. Nota i riferimenti @ che puntano Bob ai file specifici su cui lavora:

@package.json @tsconfig.json @Dockerfile

Modernizza questa API Express da Node.js 16 a Node.js 22. Mantieni la funzionalità dell'API identica - questo è un aggiornamento di piattaforma, non un cambio di funzionalità. Dammi un breve riepilogo.

Bob ti dà un riepilogo di tutti i componenti che ha aggiornato nella modernizzazione:

Dockerfile — 2 righe modificate

- Entrambe le fasi FROM node:16-alpine → node:22-alpine

package.json — 3 campi modificati

- engines.node: 16.x → 22.x
- @types/node: ^16.18.0 → ^22.0.0
- typescript: ^4.9.5 → ^5.0.0

tsconfig.json — 4 impostazioni modificate

- target: ES2020 → ES2023
- lib: ["ES2020"] → ["ES2023"]
- module: commonjs → node16 (TypeScript 5 richiede che corrisponda a moduleResolution)
- moduleResolution: node → node16

Tu e Bob avete modernizzato l'applicazione.

Segna la modernizzazione come completata

Usa la funzionalità di codifica letteraria di Bob per aggiornare il titolo del todo di esempio, segnando l'app come modernizzata. La codifica letteraria ti permette di scrivere istruzioni in linguaggio naturale direttamente nel tuo editor invece di usare il pannello chat.

Abilita la modalità di codifica letteraria

Nella scheda Explorer sul lato sinistro dello schermo, naviga nella cartella express-todo-api e clicca su src/db.ts per aprirlo nell'editor. Una volta aperto src/db.ts, attiva la modalità di codifica letteraria cliccando sull'icona della bacchetta magica nella barra degli strumenti dell'editor. In alternativa, puoi premere Cmd + I su Mac, o Ctrl + I su Windows e Linux.

Scrivi la tua istruzione

Nel file src/db.ts che è aperto nel tuo editor, incolla la seguente istruzione in cima al file, prima di qualsiasi codice:

// Trova la proprietà title dell'oggetto todo di esempio e cambiala in "Welcome to the Modernized Node.js 22 API"

Bob capisce che questo commento è un'istruzione, piuttosto che codice normale, perché sei in modalità di codifica letteraria. La tua istruzione appare evidenziata nell'editor.

Genera il codice

Clicca su Genera in fondo al documento.

Bob localizza l'oggetto sampleTodo nel costruttore e ti mostra la modifica. Vedrai il cambio del titolo da:

Prima:

title: "Learn Node.js modernization"

Dopo:

title: "Welcome to the Modernized Node.js 22 API"

Accetta le modifiche

Clicca su Accetta tutto in fondo al documento dove hai cliccato Genera per applicare la modifica al file.

Esci dalla modalità di codifica letteraria

Clicca su Esci sotto la bacchetta magica letteraria in cima al file per uscire dalla modalità di codifica letteraria.

Hai aggiornato l'API usando la codifica letteraria. Quando testerai l'API nella sezione successiva, vedrai questo nuovo titolo nella risposta dell'API.

Verifica l'applicazione modernizzata con Docker

Verifica la modernizzazione del codice e la tua modifica di codice letterario ricostruendo e testando il container Docker.

Torna alla modalità Agent e descrivi cosa vuoi che Bob verifichi:

Verifica che l'applicazione Node.js 22 modernizzata funzioni compilandola e testandola con Docker. Controlla che l'API risponda a /api/todos e mostri il titolo del todo aggiornato. Pulisci quando hai finito. Dammi un breve riepilogo. Voglio anche vedere la validazione del nuovo titolo.

Una volta che Bob ha verificato che l'applicazione è stata modernizzata, ti dà il seguente riepilogo:

✅ **Verifica completata - Modernizzazione Node.js 22 riuscita**

**Risultati di build e test:**
- Immagine Docker compilata con successo con Node.js 22
- Compilazione TypeScript completata senza errori
- Applicazione avviata e ha risposto correttamente

**Validazione API:**
{
  "id": "72459851-7953-4a9c-94d3-4f8f1c656d21",
  "title": "Welcome to the Modernized Node.js 22 API",
  "completed": false,
  "createdAt": "2026-02-16T16:35:49.132Z"
}

**Confermato:**
- ✅ Titolo del todo aggiornato visualizzato correttamente: "Welcome to the Modernized Node.js 22 API"
- ✅ Endpoint API /api/todos risponde con successo
- ✅ Tutte le funzionalità funzionano su Node.js 22
- ✅ Pulizia completata (container e immagine rimossi)

**Riepilogo:** L'API TODO Express modernizzata è completamente funzionale su Node.js 22 con i dati di esempio aggiornati che mostrano il nuovo titolo confermando che la modernizzazione è completa.

L'API funziona correttamente, e il titolo è stato aggiornato a "Welcome to the Modernized Node.js 22 API", confermando che Bob ha preservato il comportamento esistente mentre modernizzava la versione di Node.js e le dipendenze.

Prossimi passi

In questo tutorial, hai imparato come modernizzare un'API Express da Node.js 16 a Node.js 22 usando Bob. Bob ha analizzato le tue dipendenze, aggiornato i file di configurazione e modernizzato la configurazione Docker preservando tutte le funzionalità.

  • Scopri la funzionalità di revisione del codice di Bob /review per individuare potenziali problemi prima di fare commit del tuo lavoro.
  • Scopri le modalità, che sono personas specializzate che adattano il comportamento di Bob per i tuoi compiti specifici.
  • Scopri come usare l'interfaccia chat di Bob che è il modo principale per interagire con Bob.

Quindi, lavora attraverso la serie di tutorial Inizia con IBM Bob per saperne di più sulle funzionalità e capacità di Bob.

Come valuti questo argomento?