Mit der hierarchischen Abfragesprache (MQL), dem Domänenmodell und dem Schema der vorigen Kapitel konnten wir komplexe, hierarchische Datenabfragen typsicher formulieren und am Backend gegen MS-SQL-Server mappen. Diesmal generieren wir aus einer MQL-Query und dem Schema das typisierte Datenmodell für den Client.
In den vorangegangenen Kapiteln haben wir TypeScript sowohl als domänenspezifische als auch als Schemabeschreibungssprache und als Grammatik für hierarchische Datenabfragen verwendet. Als letzten Schritt wollen wir in diesem Kapitel die vom Backend gelieferten, hierarchischen JSON-Daten am Client typsicher verwenden. Wie immer gilt auch hier: „Let the Compiler do the dirty Work“. Dank der statischen Typisierung verhindern wir zahlreiche Fehler und verbessern die Wartbarkeit der Datenabfragen enorm.
Was bisher geschah …
Abbildung 4.1 enthält den Ablauf der MQL-Idee, den wir zum besseren Verständnis zusammenfassen (die roten Kästen beschreiben die Aufgaben dieses Kapitels):
- Durch Metadaten (Decorators) erweitern wir TypeScript zu einer domänenspezifischen Sprache, mit der wir ein Domänenmodell aus Kunden, Einkäufen und Tickets erstellen.
- Aus dem Domänenmodell generieren wir automatisiert ein maschinenlesbares Schema.
- Die Schemainformationen und eine in TypeScript geschriebene Querygrammatik bilden die Grundlage für eine hierarchische Datenabfrage nach Kunden, ihren Einkäufen und den Tickets zu diesen Einkäufen (Listing 4.1).
- Die Abfrage mappen wir generisch, aber trotzdem effizient auf eine relationale Datenbank (SQL-Server) und liefern das hierarchische JSON-Ergebnis zum Client.

Abbildung 4.1: Zusammenfassung der MQL-Abfragegenerierung und -verwendung
import { schema } from "../../gen/schema";
import { Query, ROP, MOP, COP } from "../mql/mqlGrammar";
import { Customer, Purchase, SKU, Ticket } from "../../domainModel ";
// Define shortcuts for operators.
const AND = ROP.and;
const OR = ROP.or;
const EQ = COP.eq;
const GT = COP.gt;
const IN = COP.in;
const LIKE = COP.like;
// Get the class descriptors for domain classes and then their named // properties.
const customerProps = schema.classes.Customer.props;
const purchaseProps = schema.classes. Purchase.props;
const skuProps = schema.classes.SKU.props;
const ticketProps = schema.classes.Ticket.props;
...
export const customerQuery: Query = {
name: "Customers-Nadella-or-Gates",
// Query customers
class: "Customer",
// Only return the following properties for the found customers:
select: [customerProps.id, customerProps.firstName, customerProps.lastName],
restrict:
// (
// (firstName == “Satya” AND lastName == “Nadella”) OR
// (firstName == “Bill” AND lastName == “Gates”)
// ) AND (city IN [“Vienna”, “London”])
{op: AND, restrict: [
{op: OR, restrict: [
// firstName == Satya AND lastName == Nadella
{op: AND, restrict:[
{property: customerProps.firstName,
op: EQ , value: "Satya"},
{property: customerProps.lastName,
op: EQ , value: "Nadella"}
]},
// firstName == Bill AND lastName == Gates
{op: AND, restrict:[
{property: customerProps.firstName,
op: EQ , value: "Bill"},
{property: customerProps.lastName,
op: EQ , value: "Gates"}
]}
]},
// city in ["Vienna", "London"]
{property: customerProps.city, op: IN, value:["Vienna", "London"]},
],
// Hierarchical sub-query: purchases of each customer
expand: [
{
name: customerProps.purchases, // customer -> purchases, 1:n
select: [purchaseProps.id,
purchaseProps.date,
purchaseProps.title],
// Hierarchical sub-query: The tickets for each purchase
expand: [
{
name: purchaseProps.tickets, // purchase -> tickets, 1:n
select: [ticketProps .id, ticketProps.title],
}
],
}
],
} ...Listing 4.1: Modul „queries.ts“, Abfrage Customer -> Purchases -> Tickets
Wozu ein Clientdatenmodell generieren?
Mit den vom Backend gesendeten JSON-Daten können wir am Client auf drei Arten verfahren:
- Verwendung „as is“: In einer Single-Page-App mit einer nicht statisch typisierten Templatesprache könnten wir die Daten direkt an das UI binden. In Angular täten wir das z. B. durch ein *ngFor, mit dem wir über die Kunden iterieren und dann die einzelnen Felder beispielsweise mittels {{customer.lastName}} binden. In großen Applikationen führt das im Lauf der Zeit aber zu immer höherem Wartungsaufwand und Fehlerquellen, da z. B. Tippfehler erst zur Laufzeit aufschlagen. Bei Änderungen des Domänenmodells muss man außerdem die UI-Komponenten manuell durchsuchen und die Data Bindings...

