TypeScript Academy · Les

Een fluent query-DSL ontwerpen

Bouw een koppelbare, zichzelf validerende query-API

Les 2 van 413 stappen

Een fluent query-DSL ontwerpen is een gratis TypeScript Academy-les op CoddyKit. Dit is les 2 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.

Een vloeiende query-DSL ontwerpen

We ontwerpen een ketenbare query-DSL waarbij elke stap via retourtypen de toegestane volgende stappen verder verfijnt. Het resultaat leest als SQL en wijst ongeldige volgordes al tijdens het compileren af.

De gewenste grammatica

We willen: eerst from, daarna optioneel where, dat herhaald kan worden, en vervolgens een afsluitende select. Je kunt geen select gebruiken vóór from en je kunt from niet twee keer gebruiken.

Toestandsinterfaces

Modelleer elke fase als een interface die de volgende fase retourneert.

interface Builder {
  from(table: string): FromStage;
}
interface FromStage {
  where(cond: string): FromStage; // repeatable
  select(...cols: string[]): Result;
}
interface Result { sql: string; }

De volgorde afdwingen

Omdat select alleen bestaat op FromStage, veroorzaakt een aanroep ervan op de eerste Builder een compileerfout. De volgorde wordt uitsluitend afgedwongen door de methoden die elke fase beschikbaar stelt.

declare const db: Builder;
db.from("users").select("id"); // ok
db.select("id");               // Error: select missing on Builder

Geselecteerde kolommen bijhouden

Voeg een phantom-generiek type toe om te onthouden welke kolommen zijn geselecteerd, zodat het type van het resultaat precies is.

interface FromStage<T extends string = never> {
  where(c: string): FromStage<T>;
  select<C extends string>(...cols: C[]): Result<C>;
}
interface Result<C extends string> { columns: C[]; }

Bij elke aanroep verfijnen

Elke where kan ook beperkingen in het type opstapelen. Hier houden we het eenvoudig, maar het patroon kan worden uitgebreid om gebonden parameters bij te houden.

const q = db.from("users").where("age > 18").where("active = true");
// still FromStage; select remains available

Herhaald gebruik van <code>from</code> voorkomen

Omdat FromStage geen from beschikbaar stelt, kun je het niet twee keer aanroepen. De grammatica verbiedt dit structureel; een controle tijdens de uitvoering is niet nodig.

db.from("a").from("b"); // Error: from does not exist on FromStage

Een afsluitende stap

select retourneert Result, dat noch where noch from beschikbaar stelt en zo de keten beëindigt. Alleen bewerkingen om het resultaat te lezen blijven over.

const r = db.from("users").select("id", "name");
r.columns; // ("id" | "name")[]
// r.where(...) -> Error: where not on Result

Getypeerde kolombeperkingen

Beperk kolommen met een ander generiek type tot een bekend tabelschema, zodat onbekende kolommen worden afgewezen. Zo combineer je deze DSL met de eerdere ORM-ideeën.

interface Table<Cols extends string> {
  select<C extends Cols>(...cols: C[]): Result<C>;
}
// db.from gives Table<"id" | "name" | "age">

Optionele en verplichte stappen

Maak een stap verplicht door de volgende methode pas daarna beschikbaar te stellen. Dwing bijvoorbeeld minstens één where af door een fase te retourneren waarin select pas verschijnt nadat where is aangeroepen. Dezelfde gekoppelde typen kunnen ook het type van de resultaatrij van de uitgevoerde query afleiden, waardoor de grammatica tijdens het compileren wordt verbonden met gegevens tijdens de uitvoering.

Waarom dit belangrijk is

Een vloeiende DSL die zo is ontworpen, documenteert zichzelf en kan niet verkeerd worden gebruikt: automatische aanvulling toont alleen geldige volgende stappen en ongeldige reeksen worden nooit gecompileerd. Dit vormt de basis van gebruiksvriendelijke builderbibliotheken.

Korte controle

Bevestig je begrip van het ontwerpen van vloeiende DSL's.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt een vloeiende query-DSL ontworpen als een toestandsmachine op typeniveau: elke fase-interface retourneert de volgende en stelt alleen geldige methoden beschikbaar. Phantom-generieke typen houden geselecteerde kolommen bij, afsluitende fasen beëindigen de keten en kolombeperkingen wijzen onbekende namen af. Alles wordt afgedwongen door retourtypen.

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 “Een fluent query-DSL ontwerpen” gratis?

Ja — de volledige tekst van “Een fluent query-DSL ontwerpen” 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 “Een fluent query-DSL ontwerpen”?

Bouw een koppelbare, zichzelf validerende query-API 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 2 van 4.

Hoe lang duurt de les “Een fluent query-DSL ontwerpen”?

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