Seminar Express.js – TypeScript in professionellen Projekten

TypeScript verbessert Express-Projekte nur dann nachhaltig, wenn statische Typen, Laufzeitdaten und Architektur zusammenpassen. Eine beliebig typisierte Request-Schnittstelle oder pauschale Type Assertions erzeugen dagegen lediglich ein falsches Sicherheitsgefühl. Dieses Seminar zeigt einen konsequenten Ansatz für typisierte HTTP-Anwendungen.

Die Teilnehmer konfigurieren ein modernes Projekt, typisieren Routen und Kontextdaten, verbinden externe Validierung mit internen Fachtypen und strukturieren Module so, dass Compilerfehler tatsächlich auf relevante Vertragsverletzungen hinweisen. Build, Tests und produktiver Start werden von Anfang an mitgedacht.

Seminarziele

Die Teilnehmer können nach dem Seminar Express-Projekte mit TypeScript belastbar aufsetzen und weiterentwickeln. Sie lernen:

• Compiler-, Modul- und Build-Konfiguration für Node.js und Express korrekt festzulegen.
• Pfadparameter, Query, Body, Response und lokale Kontextdaten präzise zu typisieren.
• Unvertrauenswürdige Laufzeitdaten zu validieren und erst danach in Fachtypen zu überführen.
• Fachmodule, Fehler und Abhängigkeiten mit klaren Typgrenzen zu strukturieren.
• Typisierte Anwendungen ohne Umgehung der Typprüfung zu testen und bereitzustellen.

Zielgruppe

Die Schulung richtet sich an JavaScript- und TypeScript-Entwickler, die Express in größeren, länger gepflegten oder teamübergreifenden Projekten einsetzen. Sie ist besonders geeignet, wenn ein bestehendes JavaScript-Backend schrittweise typisiert oder ein neues Backend mit verbindlichen Verträgen aufgebaut werden soll.

Voraussetzungen

Vorausgesetzt werden gute JavaScript- und Express-Grundkenntnisse sowie TypeScript-Grundlagen zu Typen, Interfaces, Union Types und Generics. Die Teilnehmer sollten Module, Promises und async/await sicher einsetzen können.

Inhalte

Die Typisierung wird nicht isoliert betrachtet, sondern mit Validierung, Architektur, Tests und Build zu einem vollständigen Projekt verbunden.

Projekt- und Compilerkonfiguration

• tsconfig-Optionen nach Zielplattform, Strenge und Build-Prozess auswählen.
• ES-Module und CommonJS bewusst konfigurieren und Mischformen vermeiden.
• Entwicklungsstart, Watch-Modus, Source Maps und Produktionsbuild einrichten.
• Typdefinitionen, Abhängigkeiten und Compiler-Versionen kontrolliert verwalten.

Express-Typen sicher verwenden

• Request-Generics für Parameter, Response Body, Request Body und Query einsetzen.
• Response- und Fehlerverträge als wiederverwendbare Typen modellieren.
• res.locals und anfragebezogene Kontextdaten präzise typisieren.
• Überbreite any-Typen und unsichere Type Assertions systematisch vermeiden.

Laufzeitvalidierung und Typgrenzen

• Statische Typprüfung von Laufzeitvalidierung klar unterscheiden.
• Unbekannte Eingaben als unknown behandeln und kontrolliert verfeinern.
• Validierungsschemata mit internen DTO- und Fachtypen abstimmen.
• Fehler aus ungültigen Eingaben konsistent in HTTP-Antworten überführen.

Erweiterung von Request und Kontext

• Declaration Merging und eigene Typdeklarationen gezielt einsetzen.
• Authentifizierten Benutzer, Mandant und Korrelationsdaten typisiert bereitstellen.
• Globale Erweiterungen auf notwendige Felder begrenzen.
• Alternative explizite Kontextobjekte gegen Request-Erweiterung abwägen.

Architektur und Fachmodelle

• Router, Controller, Services und Repositories mit klaren Schnittstellen verbinden.
• DTOs, Persistenzmodelle und Fachobjekte voneinander trennen.
• Discriminated Unions für Ergebnisse und Fehlerfälle nutzen.
• Abhängigkeiten über kleine Interfaces statt über konkrete Bibliotheken kapseln.

Fehler und asynchrone Verarbeitung

• Eigene Fehlerklassen und sichere Fehlerantworten typisieren.
• Promise-Rückgaben und asynchrone Handler ohne versteckte void-Probleme gestalten.
• Exhaustive Checks für fachliche Ergebnisvarianten verwenden.
• Fehler-Middleware mit Unknown-Fehlern und Drittbibliotheksfehlern robust machen.

Tests und Tooling

• Typisierte Testdaten-Factories und Hilfsfunktionen entwickeln.
• Unit- und HTTP-Tests ohne unnötige Typumgehungen schreiben.
• Linting, Formatierung und Typprüfung in lokale Skripte und CI integrieren.
• Compilerfehler, Laufzeitfehler und Vertragsverletzungen getrennt diagnostizieren.

Migration und Bereitstellung

• JavaScript-Dateien schrittweise übernehmen und strenge Regeln kontrolliert erhöhen.
• Grenzen für temporäre Ausnahmen und technische Schulden festlegen.
• Build-Artefakte, Umgebungsvariablen und Startskripte für Produktion vorbereiten.
• Source Maps, Logging und Fehlerdiagnose im kompilierten Betrieb sicherstellen.

Praxis und Methodik

Die Teilnehmer entwickeln eine typisierte API mit mehreren Routern, Validierung, Fachlogik und zentraler Fehlerbehandlung. Sie typisieren Parameter und Responses, ergänzen anfragebezogenen Kontext und prüfen, an welchen Grenzen Laufzeitvalidierung zwingend bleibt.

Ein zweiter Übungsstrang modernisiert ausgewählte JavaScript-Module schrittweise. Dabei werden typische Scheinlösungen wie großzügiges any oder pauschale Assertions entfernt und durch kleine, überprüfbare Typgrenzen ersetzt.