TypeScript Academy · Lezione

Relazioni e join con i tipi

Modelli le relazioni affinché i risultati dei join siano tipizzati correttamente.

Relazioni e join con i tipi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Relazioni tipizzate e risultati annidati

Gli schemi reali hanno relazioni: un utente ha molti post e un post appartiene a un utente. Un ORM type-safe consente di dichiarare queste relazioni e restituisce poi risultati correttamente annidati e tipizzati dalle query relazionali.

Dichiarare le relazioni

Accanto alle tabelle, definisca un oggetto delle relazioni che descriva i collegamenti tra loro. Questi metadati alimentano sia la generazione dell'SQL sia il tipo del risultato.

import { relations } from "drizzle-orm";

export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));

export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
}));

Una query relazionale

L'API delle query consente di richiedere le righe correlate con with. Il risultato annida i dati correlati sotto il nome della relazione.

const result = await db.query.users.findMany({
  with: { posts: true },
});
// result: (User & { posts: Post[] })[]

one e many determinano la forma del tipo

Una relazione many restituisce un array; una relazione one restituisce un singolo oggetto (oppure null). Il tipo annidato corrisponde alla cardinalità dichiarata.

const r = await db.query.posts.findMany({
  with: { author: true },
});
// r: (Post & { author: User })[]   // author is a single object

Selezionare colonne all'interno delle relazioni

È possibile restringere sia le righe principali sia quelle annidate. Il tipo del risultato si restringe in modo indipendente a ogni livello.

const r = await db.query.users.findMany({
  columns: { id: true, name: true },
  with: {
    posts: { columns: { title: true } },
  },
});
// r: { id: number; name: string; posts: { title: string }[] }[]

Join manuali con colonne tipizzate

Anche le join di livello inferiore mantengono i tipi. Il predicato della join utilizza riferimenti tipizzati alle colonne e la select determina la forma piatta del risultato.

const rows = await db
  .select({ author: users.name, title: posts.title })
  .from(posts)
  .innerJoin(users, eq(users.id, posts.authorId));
// rows: { author: string; title: string }[]

left join introduce la nullabilità

Una LEFT JOIN può produrre righe mancanti sul lato destro, quindi le colonne collegate diventano nullable nel tipo del risultato. L'ORM lo riflette automaticamente.

const rows = await db
  .select({ name: users.name, title: posts.title })
  .from(users)
  .leftJoin(posts, eq(posts.authorId, users.id));
// rows: { name: string; title: string | null }[]

Risultati annidati e piatti

Le query relazionali (findMany + with) restituiscono oggetti annidati; le join manuali restituiscono righe piatte. Scelga i risultati annidati quando desidera grafi di oggetti e quelli piatti quando desidera proiezioni tabellari.

Come viene tipizzato l'annidamento

I metadati delle relazioni vengono letti a livello di tipo. Il tipo della query interseca la riga di base con un oggetto le cui chiavi sono le relazioni richieste, ciascuna mappata a un tipo array o singolo in base alla propria cardinalità.

type WithPosts = User & { posts: Post[] };
// "many" -> Post[], "one" -> User (or User | null for optional)

Relazioni profondamente annidate

Le relazioni sono componibili. È possibile richiedere una relazione di una relazione e il tipo si anniderà allo stesso livello di profondità, con inferenza completa.

await db.query.users.findMany({
  with: { posts: { with: { comments: true } } },
});
// User & { posts: (Post & { comments: Comment[] })[] }

Perché è importante

Tipizzare manualmente i risultati di join annidate è soggetto a errori e porta a divergenze rispetto allo schema. Derivarli dalle relazioni dichiarate mantiene sincronizzati il tipo del grafo di oggetti e l'SQL, quindi la rinomina di una relazione diventa un errore di compilazione, non una sorpresa in produzione.

Verifica rapida

Verifichi la Sua comprensione delle relazioni tipizzate e delle join.

Riepilogo

Ha dichiarato le relazioni e ha lasciato che l'ORM producesse risultati tipizzati e annidati: many restituisce array, one restituisce singoli oggetti, le select parziali restringono ogni livello, le LEFT JOIN introducono la nullabilità e le relazioni profondamente annidate sono componibili. I metadati delle relazioni guidano sia l'SQL sia i tipi dei risultati, mantenendoli sincronizzati.

Domande Frequenti

La lezione «Relazioni e join con i tipi» è gratuita?

Sì — il testo completo di «Relazioni e join con i tipi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Relazioni e join con i tipi»?

Modelli le relazioni affinché i risultati dei join siano tipizzati correttamente. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Relazioni e join con i tipi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Mappatura da schema a tipo
Costruzione di query type-safe
Inferire la forma dei risultati delle query
Relazioni e join con i tipi

← Torna a TypeScript Academy