Domänenmodellierung – Aggregate, Invarianten und Services
Modellieren Sie Aggregate wie Cart mit markierten IDs und erzwingen Sie Invarianten mithilfe von Factories und Services.
Domänenmodellierung – Aggregate, Invarianten und Services ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Einführung
Ziel: Modellieren Sie ein Cart-Aggregat mit gebrandeten IDs und stellen Sie sicher, dass Regeln wie qty > 0 in Factorys und Services durchgesetzt werden.
- Gebrandete IDs unterscheiden Entitätsgrenzen
- Factorys geben Result-Unionen zurück
- Servicefunktionen vermeiden ungültige Zustandsübergänge
Entitäten und Brands
Gebrandete IDs machen CartId und ProductId inkompatibel, obwohl beide Strings sind. Das verhindert Verwechslungen.
type Brand<Tag extends string, T> = T & { readonly __brand: Tag }
type CartId = Brand<"CartId", string>
type ProductId = Brand<"ProductId", string>
type Result<T> = { ok: true; value: T } | { ok: false; error: string }
const cartId = (s: string): CartId => s as CartId
const productId = (s: string): ProductId => s as ProductIdAggregat und Invariante
Factorys validieren Regeln: qty muss > 0 sein. Nur gültige Line-Objekte können erstellt werden.
type Money = number & { readonly __brand: "Money" }
const money = (n: number): Money => n as Money
interface Line { productId: ProductId; qty: number; price: Money }
interface Cart { id: CartId; lines: Line[]; total: Money }
function makeLine(productId: ProductId, qty: number, price: Money): Result<Line> {
if (!Number.isInteger(qty) || qty <= 0) return { ok: false, error: "qty must be > 0" }
return { ok: true, value: { productId, qty, price } }
}
function makeCart(id: CartId): Cart { return { id, lines: [], total: money(0) } }Service: Element hinzufügen
Servicefunktionen führen sichere Zustandsübergänge durch und berechnen Summen neu. Wenn Summen ungültig sind, gibt die Funktion einen Fehler zurück, statt den Zustand zu beschädigen.
function addItem(cart: Cart, line: Line): Result<Cart> {
const lines = [...cart.lines, line]
const totalNum = lines.reduce((s, x) => s + (x.qty * (x.price as number)), 0)
if (!Number.isFinite(totalNum) || totalNum < 0) return { ok: false, error: "invalid total" }
return { ok: true, value: { ...cart, lines, total: (totalNum as unknown) as Money } }
}
// Usage
const c0 = makeCart(cartId("c1"))
const l = makeLine(productId("p1"), 2, money(10))
const c1 = l.ok ? addItem(c0, l.value) : { ok: false, error: "bad line" }Abbildung an den Grenzen
An Systemgrenzen (z. B. APIs) wandeln Sie in DTOs um und validieren Sie die Daten beim Zurückparsen. Factorys stellen sicher, dass die Daten korrekt sind.
type CartDTO = { id: string; lines: { productId: string; qty: number; price: number }[]; total: number }
function serialize(c: Cart): CartDTO {
return {
id: c.id as unknown as string,
lines: c.lines.map(x => ({ productId: x.productId as unknown as string, qty: x.qty, price: x.price as unknown as number })),
total: c.total as unknown as number
}
}
function parse(dto: CartDTO): Result<Cart> {
const id = cartId(dto.id)
const lines: Line[] = []
for (const raw of dto.lines) {
const l = makeLine(productId(raw.productId), raw.qty, money(raw.price))
if (!l.ok) return { ok: false, error: l.error }
lines.push(l.value)
}
const totalNum = lines.reduce((s, x) => s + (x.qty * (x.price as number)), 0)
return { ok: true, value: { id, lines, total: money(totalNum) } }
}Tipps
Bewährte Vorgehensweisen:
- Zentralisieren Sie die Validierung in Factorys.
- Halten Sie Servicefunktionen rein und deterministisch.
- Führen Sie Brand-Konvertierungen nur an Systemgrenzen durch.
Invarianten prüfen
Schnelltest: Wie sollten Sie eine Invariante wie qty > 0 durchsetzen?
Zusammenfassung
Zusammenfassung: Gebrandete IDs setzen zusammen mit Factorys und Services Invarianten durch. Ungültige Zustände können nicht erstellt werden, weil alle Einstiegspunkte die Eingaben validieren.
Häufig gestellte Fragen
Ist die Lektion „Domänenmodellierung – Aggregate, Invarianten und Services“ kostenlos?
Ja — der vollständige Text von „Domänenmodellierung – Aggregate, Invarianten und Services“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Domänenmodellierung – Aggregate, Invarianten und Services“?
Modellieren Sie Aggregate wie Cart mit markierten IDs und erzwingen Sie Invarianten mithilfe von Factories und Services. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um TypeScript Academy zu starten?
Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.
Wie lange dauert die Lektion „Domänenmodellierung – Aggregate, Invarianten und Services“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Branding-/Opaque-Typen zur Vermeidung von Einheitenverwechslungen
- Markierte IDs und Muster zur Domänenmodellierung
- Domänenmodellierung – Aggregate, Invarianten und Services