TypeScript Academy · Les

Relaties en joins met typen

Modelleer relaties zodat samengevoegde resultaten correct worden getypeerd

Les 4 van 413 stappen

Relaties en joins met typen is een gratis TypeScript Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.

Getypeerde relaties en geneste resultaten

Realistische schema's hebben relaties: een gebruiker heeft meerdere berichten en een bericht hoort bij een gebruiker. Met een typesafe ORM kun je deze relaties declareren en vervolgens correct geneste, getypeerde resultaten terugkrijgen uit relationele query's.

Relaties declareren

Naast tabellen definieer je een relatieobject dat beschrijft hoe ze met elkaar verbonden zijn. Deze metagegevens sturen zowel het genereren van SQL als het resultaatstype aan.

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

Een relationele query

Via de query-API kun je gerelateerde rijen opvragen met with. Het resultaat nest de gerelateerde gegevens onder de naam van de relatie.

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

one versus many bepaalt de vorm van het type

Een many-relatie levert een array op; een one-relatie levert één object (of null) op. Het geneste type komt overeen met de kardinaliteit die je hebt gedeclareerd.

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

Kolommen binnen relaties selecteren

Je kunt zowel de bovenliggende rijen als de geneste rijen beperken. Het resultaatstype wordt op elk niveau afzonderlijk specifieker.

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

Handmatige joins met getypeerde kolommen

Ook joins op een lager niveau blijven getypeerd. Het join-predicaat gebruikt getypeerde kolomverwijzingen en de selectie bepaalt de vlakke resultaatvorm.

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 introduceert nullbaarheid

Een LEFT JOIN kan ontbrekende rijen aan de rechterkant opleveren, waardoor de gekoppelde kolommen nullable worden in het resultaatstype. De ORM weerspiegelt dit automatisch.

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

Geneste versus vlakke resultaten

Relationele query's (findMany + with) leveren geneste objecten op; handmatige joins leveren vlakke rijen op. Kies geneste resultaten als je objectgrafieken wilt en vlakke resultaten als je tabulaire projecties wilt.

Hoe nesten wordt getypeerd

De relatiemetadata wordt op typeniveau uitgelezen. Het querytype voegt de basisrij samen met een object waarvan de sleutels de opgevraagde relaties zijn. Elke sleutel wordt afhankelijk van de kardinaliteit omgezet naar een arraytype of een type voor één object.

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

Diep geneste relaties

Relaties zijn samenstelbaar. Je kunt een relatie van een relatie opvragen en het type wordt net zo diep genest, volledig afgeleid.

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

Waarom dit belangrijk is

Geneste joinresultaten handmatig typen is foutgevoelig en raakt los van het schema. Door ze af te leiden uit gedeclareerde relaties blijven het type van de objectgrafiek en de SQL exact op elkaar afgestemd, zodat het hernoemen van een relatie een compilatiefout oplevert in plaats van een verrassing in productie.

Snelle controle

Test je begrip van getypeerde relaties en joins.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt relaties gedeclareerd en de ORM vervolgens geneste, getypeerde resultaten laten produceren: many levert arrays op, one levert afzonderlijke objecten op, gedeeltelijke selecties maken elk niveau specifieker, LEFT JOIN's introduceren nullbaarheid en diep geneste relaties zijn samenstelbaar. De relatiemetadata stuurt zowel SQL als resultaattypen aan, zodat ze synchroon blijven.

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 101
Lessen: 352

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Relaties en joins met typen” gratis?

Ja — de volledige tekst van “Relaties en joins met typen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.

Wat leer ik in “Relaties en joins met typen”?

Modelleer relaties zodat samengevoegde resultaten correct worden getypeerd Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met TypeScript Academy te beginnen?

Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Relaties en joins met typen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?

Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar TypeScript Academy