NestJS Schulung für Einsteiger: REST-APIs mit TypeORM

Die Grundlagen von NestJS

• Architektur: Module, Controller, Provider und Lebenszyklus einer Anfrage
• Projekt einrichten mit der NestJS CLI und nest new
• TypeScript-Konfiguration: experimentalDecorators und emitDecoratorMetadata
• Einen Controller von Hand erstellen
• Anwendung starten mit NestFactory.create() und nest start --watch
• Namenskonventionen für Dateien und Klassen
• Routing-Dekoratoren: @Get(), @Post(), @Patch(), @Delete()
• Plattform-Adapter: Express als Standard, Fastify als Alternative
• Schnellere Builds mit dem SWC-Compiler (nest start -b swc)

Projekte mit der NestJS CLI generieren

• App-Struktur nach nest new: main.ts, app.module.ts und Testordner
• Dateien erzeugen mit nest generate module, controller und service
• CRUD-Gerüste mit nest g resource, Optionen --dry-run und --no-spec
• Routing-Logik ergänzen: Routen-Präfixe, Pfad- und Query-Parameter
• Globales Präfix und API-Versionierung mit enableVersioning()
• OpenAPI-Dokumentation und Swagger UI mit @nestjs/swagger erzeugen

Request-Daten mit Pipes validieren

• Zugriff auf Request-Daten mit @Body(), @Param() und @Query()
• ValidationPipe global einrichten: whitelist, forbidNonWhitelisted und transform
• Validierungsregeln in DTOs mit class-validator
• Hinter den Kulissen: class-transformer macht aus JSON eine DTO-Instanz
• Wie Typinformationen zur Laufzeit erhalten bleiben: reflect-metadata
• Eingebaute Pipes: ParseIntPipe, ParseUUIDPipe und DefaultValuePipe
• Eigene Pipes, Schema-Validierung mit Zod als Alternative

Dienste, Dependency Injection und Module

• Aufgabenteilung zwischen Controller, Service und Repository
• Ein Repository implementieren, das in eine JSON-Datei liest und schreibt
• Einen Service implementieren und im Controller verwenden
• Controller manuell testen mit einem API-Client oder .http-Dateien
• Fehler melden mit Ausnahmen wie NotFoundException
• Inversion of Control verstehen
• Dependency Injection: Provider, Injection-Token und IoC-Container
• Refactoring auf Konstruktor-Injektion mit @Injectable()
• Weitere DI-Details: Scopes, useValue, useFactory und useClass
• Eigene Exception-Filter für einheitliche Fehlerantworten
• Projektübersicht: Fachmodule für Benutzer und Berichte schneiden
• Module, Controller und Services gemeinsam erzeugen und registrieren
• DI zwischen Modulen einrichten: exports und imports
• Mehr zu DI zwischen Modulen: globale Module und forwardRef()
• Mehrere Module verwenden, Abhängigkeiten schlank halten
• Dynamische Module mit forRoot() und forRootAsync()

Persistente Daten mit TypeORM

• Datenbankverbindung mit TypeOrmModule.forRoot() einrichten
• Entität und Repository anlegen, @InjectRepository()
• Datenbankinhalt mit einem grafischen DB-Client ansehen
• TypeORM-Dekoratoren: @Entity(), @Column(), @PrimaryGeneratedColumn()
• Repository-API: create() und save(), Entity-Hooks
• Zusätzliche Routen für Lesen, Ändern und Löschen anlegen
• Body-Validierung mit DTOs für Anlegen und Ändern (PartialType)
• Routen manuell testen und Antworten prüfen
• Daten abfragen mit findOneBy() und find()
• Datensätze aktualisieren: laden, Felder zuweisen, speichern
• Datensätze entfernen: remove() gegenüber delete()
• Suchen, Filtern und Paginierung mit where, skip und take
• Transaktionen mit DataSource.transaction() und dem QueryRunner
• Alternativen zu TypeORM: Prisma, Drizzle ORM, MikroORM

Datenserialisierung mit Interceptors

• Antwortfelder wie den Passwort-Hash mit @Exclude() ausschließen
• Lösungswege: ClassSerializerInterceptor oder eigene Antwort-DTOs
• Serialisierung in einem eigenen Interceptor mit dem RxJS-Operator map()
• Das Antwort-DTO des Interceptors konfigurierbar machen
• Den Interceptor in einen eigenen Decorator @Serialize() einhüllen
• Serialisierung für einen ganzen Controller anwenden
• Interceptors für Logging, Zeitmessung und Caching

Authentifizierung und Autorisierung

• Überblick: Registrierung, Anmeldung, Sitzung und Token im Vergleich
• Registrierung: Passwort-Hashing mit Salt über scrypt
• Benutzeranmeldung ohne Hinweis auf vorhandene Konten
• Cookie-Sitzungen einrichten und mit httpOnly und sameSite absichern
• Sitzungsdaten ändern und abrufen, Abmelden
• Vom Interceptor zum Decorator: @CurrentUser() mit createParamDecorator()
• Interceptor mit DI verbinden, um den angemeldeten Benutzer zu laden
• Global wirksame Interceptors über APP_INTERCEPTOR registrieren
• Zugriff verhindern mit Authentication Guards und CanActivate
• Token-basierte Anmeldung mit @nestjs/jwt und Passport-Strategien
• Rollen und Berechtigungen: eigener Decorator, Reflector und Rollen-Guard
• Helmet, CORS und Rate Limiting mit @nestjs/throttler

Unit-Tests mit Jest

• Teststrategie: Unit-, Integrations- und End-to-End-Tests in NestJS
• Test-Setup mit Test.createTestingModule()
• TypeScript als Hilfe bei Mocks: typisierte Fakes
• Testdateien sinnvoll ablegen und das Datei-Layout verbessern
• Mock-Implementierungen je Testfall ändern
• Intelligente Mocks mit In-Memory-Zustand
• Unit-Test eines Controllers
• Provider ersetzen mit overrideProvider() und jest.fn()
• Testabdeckung messen und Tests in die CI-Pipeline einbinden

Integrations- und End-to-End-Tests

• Erste Schritte mit End-to-End-Tests: Supertest und INestApplication
• Einen End-to-End-Test für Registrierung und Anmeldung schreiben
• Setup-Probleme in Spec-Dateien: Setup aus main.ts ins AppModule
• Eine global wirksame Pipe über APP_PIPE anwenden
• Global wirksame Middleware mit configure() und MiddlewareConsumer anwenden
• Wiederholte Testläufe: Testdatenbank vor jedem Lauf zurücksetzen
• Getrennte Datenbanken für Tests und Entwicklung
• Integrationstests gegen ein echtes PostgreSQL mit Testcontainers

App-Konfiguration verwalten

• Umgebungsvariablen und .env-Dateien verstehen
• ConfigModule und ConfigService aus @nestjs/config anwenden
• Laufzeitumgebung über NODE_ENV angeben
• Konfiguration beim Start gegen ein Schema validieren (Joi oder Zod)
• Typisierte Konfiguration mit registerAs() und Namensräumen

Beziehungen und Query Builder mit TypeORM

• Assoziationen erstellen: Benutzer und Fahrzeugberichte verknüpfen
• Arten von Beziehungen: 1:1, 1:n und n:m
• Die Dekoratoren @ManyToOne() und @OneToMany()
• Die Beziehung einrichten und beim Speichern setzen
• Eigenschaften im DTO transformieren mit @Transform()
• Relationen laden: relations, Eager Loading und das N+1-Problem
• Einen Query Builder mit createQueryBuilder() erstellen
• Abfrage für die Preisschätzung mit Filter, Sortierung und Mittelwert
• Die Logik der Schätzung testen

Bereitstellung für die Produktion

• Der Weg zur Produktion: Build, Konfiguration, Datenbank und Betrieb
• Das synchronize-Flag verstehen
• Die Gefahren von synchronize in Produktion
• Theorie der Migrationen: up() und down()
• TypeORM-Optionen aus @nestjs/config über forRootAsync()
• Datenbank je Umgebung: SQLite lokal, PostgreSQL in Produktion
• TypeORM-CLI mit einer eigenen DataSource-Datei einrichten
• Migrationen generieren und ausführen, auch kompiliert im Build
• Migrationen vor End-to-End-Tests automatisch ausführen
• DB-Konfiguration für die Produktion: Verbindungs-URL und SSL
• Die App bereitstellen: Docker-Image mit Multi-Stage-Build
• Health Checks mit @nestjs/terminus, Graceful Shutdown
• Zeitgesteuerte Aufgaben mit @nestjs/schedule

NestJS-Projekte mit Coding-Agenten

• Neue Ressourcen über nest g resource anlegen lassen, damit der Agent die Projektstruktur übernimmt
• Vollständigkeitsregel für NestJS-Endpunkte: DTO mit class-validator, Service, Guard und E2E-Test
• Geänderte Entitäten nur per migration:generate umsetzen; Migration vor migration:run lesen
• Im Review gezielt suchen: Routen ohne Guard, fehlendes @Exclude(), synchronize: true
• Jest- und Supertest-Läufe als Feedbackschleife nach jeder Änderung an einem Modul

Praxisprojekt: API zur Preisschätzung für Gebrauchtwagen

• Benutzerkonten mit Registrierung, Sitzung und Admin-Rolle zur Freigabe von Verkaufsberichten
• Verkaufsberichte erfassen und per Query Builder einen Marktpreis schätzen
• Unit- und End-to-End-Tests, Migrationen für PostgreSQL und OpenAPI-Dokumentation
• Auslieferung als Docker-Container mit Health-Check-Endpunkt

Lernziele

• Sie gliedern ein NestJS-Backend in Module mit Controllern und Providern und verbinden sie über Dependency Injection
• Sie validieren eingehende Daten mit DTOs, class-validator und der ValidationPipe
• Sie modellieren Entitäten und Beziehungen mit TypeORM und schreiben Abfragen mit dem Query Builder
• Sie bauen Registrierung, Anmeldung und rollenbasierten Zugriff mit Sitzungen, JWT und Guards
• Sie verhindern mit Interceptors und @Exclude(), dass sensible Felder in API-Antworten gelangen
• Sie schreiben Unit-Tests mit Jest und End-to-End-Tests mit Supertest gegen eine eigene Testdatenbank
• Sie bringen die Anwendung mit Migrationen, umgebungsspezifischer Konfiguration und Docker in Produktion

Zielgruppe

• JavaScript- und TypeScript-Entwickler:innen, die strukturierte Backends mit Node.js bauen wollen
• Teams, die eine gewachsene Express-Anwendung auf eine wartbare Architektur umstellen möchten
• Angular-Entwickler:innen, die Module, Decorators und Dependency Injection auch im Backend nutzen wollen