Modellare i tipi di dominio in TypeScript con unioni discriminate

Prompt

Agisci come esperto di TypeScript e di design guidato dai tipi, che privilegia la chiarezza rispetto ai trucchi.

Contesto:
- Dominio: {{dominio}}
- Tipi attuali (se presenti): {{tipi_attuali}}
- Dove si usano: {{uso}}

Se non è chiaro quali transizioni tra stati siano valide o quali campi esistano in ogni stato, chiedimelo prima di progettare.

Consegna:
1. Una diagnosi dei tipi attuali: quali combinazioni impossibili consentono (ad esempio un ordine «spedito» senza data di spedizione) e quali bug possono causare.
2. Il nuovo modello: unioni discriminate da un campo letterale, campi presenti solo nello stato a cui appartengono, `readonly` dove ha senso e tipi brand per gli identificatori da non confondere.
3. Funzioni di transizione tipizzate che accettino solo lo stato di partenza valido.
4. Uno `switch` esaustivo con controllo `never` e un esempio dell'errore di compilazione che compare aggiungendo un nuovo stato non gestito.
5. Validazione ai confini del sistema (API, form, storage) con uno schema da cui derivare il tipo, così tipo e validazione non divergono.
6. Test sui tipi con `@ts-expect-error` o `expectTypeOf` che dimostrino che gli stati impossibili non compilano.
7. Quando questo modello è eccessivo e basterebbe qualcosa di più semplice.

Vincoli:
- Preferisci unioni di letterali agli `enum`, a meno che tu non spieghi perché qui convenga un enum.
- Niente tipi condizionali o generici complessi se non portano un vantaggio chiaro; il codice deve essere leggibile da uno sviluppatore intermedio.
- Non inventare regole di business: segna quelle da confermare con [DA COMPLETARE].

Formato: diagnosi, blocchi di codice con nome del file e una tabella di stati e transizioni.

Come usarlo

Esempio d'uso

Esempio di risultato

export type OrdineId = string & { readonly __brand: 'OrdineId' };

type Base = { readonly id: OrdineId };

export type Ordine =
  | (Base & { stato: 'in_attesa' })
  | (Base & { stato: 'pagato'; pagatoIl: Date })
  | (Base & { stato: 'spedito'; pagatoIl: Date; codiceTracking: string })
  | (Base & { stato: 'consegnato'; pagatoIl: Date; codiceTracking: string })
  | (Base & { stato: 'annullato'; motivoAnnullamento: string });

type InStato<S extends Ordine['stato']> = Extract<Ordine, { stato: S }>;

export function spedisci(ordine: InStato<'pagato'>, codiceTracking: string): InStato<'spedito'> {
  return { ...ordine, stato: 'spedito', codiceTracking };
}

export function etichetta(ordine: Ordine): string {
  switch (ordine.stato) {
    case 'in_attesa': return 'In attesa di pagamento';
    case 'pagato': return 'Pagato';
    case 'spedito': return `Spedito (${ordine.codiceTracking})`;
    case 'consegnato': return 'Consegnato';
    case 'annullato': return `Annullato: ${ordine.motivoAnnullamento}`;
    default: {
      const esaustivo: never = ordine;
      return esaustivo;
    }
  }
}

Dati chiave

Categoria

Programmazione e sviluppo · TypeScript

Tipo di output

Codice

Livello

Avanzato

Pensato per

ChatGPT, Claude, Gemini e Microsoft Copilot

Verificato in

In attesa di verifica editoriale

Variabili

Dominio, Tipi attuali e Dove si usano

Lingua

Italiano

Prezzo

Gratuito, senza registrazione

Aggiornato

07/11/2026

Domande frequenti