TypeScript Academy · Leçon

Relations et jointures avec les types

Modéliser les relations afin que les résultats des jointures soient correctement typés.

Relations et jointures avec les types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Relations typées et résultats imbriqués

Les schémas réels comportent des relations : un utilisateur possède des posts et un post appartient à un utilisateur. Un ORM sûr du point de vue des types vous permet de déclarer ces relations, puis de renvoyer des résultats correctement imbriqués et typés à partir de requêtes relationnelles.

Déclarer des relations

En plus des tables, vous définissez un objet de relations qui décrit leurs liens. Ces métadonnées alimentent à la fois la génération du SQL et le type de résultat.

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],
  }),
}));

Une requête relationnelle

L’API de requête vous permet de demander les lignes associées avec with. Le résultat imbrique les données associées sous le nom de la relation.

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

one et many façonnent le type

Une relation many produit un tableau ; une relation one produit un objet unique (ou null). Le type imbriqué correspond à la cardinalité que vous avez déclarée.

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

Sélectionner des colonnes dans les relations

Vous pouvez réduire à la fois les lignes parentes et les lignes imbriquées. Le type de résultat est réduit indépendamment à chaque niveau.

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 }[] }[]

Jointures manuelles avec des colonnes typées

Les jointures de niveau inférieur restent elles aussi typées. Le prédicat de jointure utilise des références de colonnes typées et la sélection détermine la forme plate du résultat.

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 }[]

La jointure gauche introduit la nullabilité

Une LEFT JOIN peut produire des lignes manquantes du côté droit : les colonnes jointes deviennent donc nullables dans le type de résultat. L’ORM le reflète automatiquement.

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 }[]

Résultats imbriqués ou plats

Les requêtes relationnelles (findMany + with) produisent des objets imbriqués ; les jointures manuelles produisent des lignes plates. Choisissez les résultats imbriqués pour obtenir des graphes d’objets, et les résultats plats pour obtenir des projections tabulaires.

Typage de l’imbrication

Les métadonnées des relations sont lues au niveau des types. Le type de requête intersecte la ligne de base avec un objet dont les clés sont les relations demandées, chacune étant mappée vers un tableau ou un type unique selon sa cardinalité.

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

Relations profondément imbriquées

Les relations se composent. Vous pouvez demander une relation d’une relation, et le type s’imbrique avec la même profondeur, le tout étant inféré.

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

Pourquoi est-ce important

Écrire manuellement les types de résultats de jointures imbriquées est source d’erreurs et finit par diverger du schéma. Les dériver des relations déclarées maintient le type du graphe d’objets et le SQL parfaitement synchronisés : renommer une relation devient une erreur de compilation, et non une surprise en production.

Vérification rapide

Testez votre compréhension des relations et des jointures typées.

Récapitulatif

Vous avez déclaré des relations, puis laissé l’ORM produire des résultats typés et imbriqués : many produit des tableaux, one produit des objets uniques, les sélections partielles réduisent chaque niveau, les LEFT JOIN introduisent la nullabilité et les relations profondément imbriquées se composent. Les métadonnées des relations pilotent à la fois le SQL et les types de résultats, ce qui les maintient synchronisés.

Questions Fréquemment Posées

La leçon « Relations et jointures avec les types » est-elle gratuite ?

Oui — le texte complet de « Relations et jointures avec les types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Relations et jointures avec les types » ?

Modéliser les relations afin que les résultats des jointures soient correctement typés. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Relations et jointures avec les types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Correspondance entre schéma et type
Construction de requêtes sûre du point de vue du typage
Inférer la structure des résultats de requêtes
Relations et jointures avec les types

← Retour à TypeScript Academy