TypeScript Academy · Lektion

Relationer och joins med typer

Modellera relationer så att joinade resultat får korrekta typer.

Lektion 4 av 413 steg

Relationer och joins med typer är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Typade relationer och nästlade resultat

Verkliga scheman innehåller relationer: en användare har många inlägg och ett inlägg tillhör en användare. En typsäker ORM låter dig deklarera dessa relationer och returnerar sedan korrekt nästlade, typade resultat från relationella frågor.

Deklarera relationer

Förutom tabeller definierar du ett relationsobjekt som beskriver hur de hänger ihop. Dessa metadata styr både genereringen av SQL och resultattypen.

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

En relationell fråga

Fråge-API:t låter dig begära relaterade rader med with. Resultatet nästlar de relaterade data under relationsnamnet.

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

one och many formar typen

En many-relation ger en array, medan en one-relation ger ett enda objekt eller null. Den nästlade typen motsvarar den kardinalitet du deklarerade.

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

Välja kolumner i relationer

Du kan begränsa både den överordnade raden och de nästlade raderna. Resultattypen begränsas oberoende på varje nivå.

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

Manuella joiner med typade kolumner

Även joiner på lägre nivå förblir typade. Join-predikatet använder typade kolumnreferenser och select avgör den platta resultatformen.

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 inför nullbarhet

En LEFT JOIN kan ge rader som saknas på höger sida, så de anslutna kolumnerna blir nullable i resultattypen. ORM:en återspeglar detta automatiskt.

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

Nästlade kontra platta resultat

Relationella frågor (findMany + with) ger nästlade objekt, medan manuella joiner ger platta rader. Välj nästlat när du vill ha objektgrafer och platt när du vill ha tabellformade projektioner.

Så typas nästling

Relationsmetadata läses på typsnivå. Frågetypen kombinerar basraden med ett objekt vars nycklar är de begärda relationerna, där varje relation mappas till en array eller en enstaka typ beroende på dess kardinalitet.

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

Djupt nästlade relationer

Relationer kan kombineras. Du kan begära en relation till en relation, och typen nästlas lika djupt, helt med inferens.

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

Varför detta är viktigt

Att skriva typer för nästlade joinresultat manuellt är felbenäget, och typerna kan glida isär från schemat. Genom att härleda dem från deklarerade relationer hålls objektgrafens typ och SQL-frågan synkroniserade, så att ett namnbyte på en relation blir ett kompileringsfel i stället för en överraskning i produktion.

Snabb kontroll

Testa hur väl du behärskar typade relationer och joiner.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du deklarerade relationer och lät sedan ORM:en skapa nästlade, typade resultat: many ger arrayer, one ger enstaka objekt, delurval begränsar varje nivå, LEFT JOIN introducerar nullbarhet och djupt nästlade relationer kan kombineras. Relationsmetadata styr både SQL och resultattyper, så att de förblir synkroniserade.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Relationer och joins med typer” gratis?

Ja – hela texten till ”Relationer och joins med typer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Relationer och joins med typer”?

Modellera relationer så att joinade resultat får korrekta typer. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Relationer och joins med typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy