4. Kapitel 3 - Der [NestJS]-Server für die Anwendung [RdvMedecins]
Dieses Kapitel beschreibt Datei für Datei den Inhalt des diesem Dokument beiliegenden Ordners [rdvmedecins-nestjs-server]. Es folgt demselben Aufbau, der im gesamten Kurs verwendet wird: der Quellcode, Zeile für Zeile nummeriert, gefolgt von einem Abschnitt mit dem Titel „Kommentieren wir diesen Code“, der die Zeilen erläutert, die einer näheren Erklärung bedürfen. Jeder Projektordner enthält außerdem eine eigene Datei README.md mit einer verdichteten Fassung dieser Erläuterungen.
4.1. Die Datenbank
Die Datenbank [dbrdvmedecins] entspricht in ihrer Struktur der des ursprünglichen Dokuments (2014, Spring 4 / [MySQL] 5): dieselben Tabellen – [doctors], [clients], [slots], [appointments] –, dieselben Fremdschlüssel, dieselbe Eindeutigkeitsbedingung. Die einzige Neuerung, die der Schritt „Authentifizierung“ dieser Portierung mit sich bringt, ist die Tabelle [users].
4.1.1. [database/dbrdvmedecins.sql]
Kommentieren wir diesen Code:
- Zeilen 20–24: [DROP TABLE IF EXISTS …] – das Skript beginnt bei jeder Ausführung mit einer leeren Datenbank, in umgekehrter Reihenfolge der Abhängigkeiten (beginnend mit `appointments`, das auf `[slots]` und `clients` verweist, bis hinunter zu `users`, auf das niemand verweist): [MySQL] würde sich weigern, eine Tabelle zu löschen, auf die noch ein Fremdschlüssel verweist;
- Zeile 48: [doctor_id INT NOT NULL], dann Zeile 53: [CONSTRAINT fk_slots_doctor FOREIGN KEY …] – ein Zeitfenster gehört immer zu einem Arzt;
- Zeile 64: [CONSTRAINT unq1_appointments UNIQUE (day, slot_id)] – die zentrale Geschäftsregel der Anwendung: Dasselbe Zeitfenster am selben Tag kann nur einmal gebucht werden. Diese Bedingung, und nur sie, verhindert einen doppelten Termin – weder der Validator noch die Geschäftslogik prüfen sie ausdrücklich erneut (siehe unten, addAppointment);
- Zeilen 67–74: [CREATE TABLE users (…)] – die in diesem Schritt hinzugefügte Tabelle. `login` ist UNIQUE (zwei Benutzer können nicht dieselbe Anmeldekennung haben); `password` speichert ein mit bcrypt gehashtes Passwort (niemals im Klartext); role ist entweder 'ADMIN' oder 'USER' – eine einfache Textspalte, während das ursprüngliche Dokument drei Tabellen verwendete (users, roles, users_roles), um mehrere Rollen pro Benutzer zu ermöglichen. Da diese Anwendung nur zwei sich gegenseitig ausschließende Rollen benötigt, wäre die ursprüngliche Many-to-many-Beziehung überdimensioniert gewesen;
- Zeilen 91–93: [INSERT INTO users …] – zwei Demokonten, admin/admin (Rolle ADMIN) und user/user (Rolle USER), mit bereits per bcrypt gehashten Passwörtern (10 Salting-Runden) – niemals im Klartext, auch nicht in diesem Demoskript.
4.2. Schichtenorganisation
Der Server folgt der Schichtenstruktur des ursprünglichen Projekts:

Jede Schicht kommuniziert nur mit der Schicht unmittelbar rechts von ihr, [5-8]: So kommuniziert der Controller [5] zum Beispiel nie direkt mit der Schicht [7]. Dies folgt demselben Entwurfsprinzip wie das ursprüngliche Spring-Projekt und macht jede Schicht unabhängig von den anderen austauschbar.
4.3. Die [TypeORM]-Entitäten (src/entities/)
Entitäten sind die Klassen, die Zeilen von Datenbanktabellen als TypeScript-Objekte darstellen – das direkte Äquivalent der JPA-Entitäten des ursprünglichen Projekts (Paket rdvmedecins.entities).
4.3.1. src/entities/abstract.entity.ts

Kommentieren wir diesen Code:
- Zeile 4: [@PrimaryGeneratedColumn()] – deklariert einen automatisch hochzählenden Primärschlüssel über das DBMS – das exakte Äquivalent von @Id + @GeneratedValue(strategy = GenerationType.AUTO) in JPA;
- Zeile 7: [@VersionColumn()] – der [TypeORM]-eigene Mechanismus für das optimistische Sperren: [TypeORM] erhöht diese Spalte bei jeder Änderung automatisch und löst einen Fehler aus, wenn Sie versuchen, eine Entität zu speichern, deren Version nicht mehr mit der in der Datenbank übereinstimmt (jemand anderes hat sie in der Zwischenzeit geändert) – das exakte Äquivalent von @Version in JPA/Hibernate;
- Zeile 3: [export abstract class AbstractEntity {] – diese Klasse ist nicht mit [@Entity] dekoriert: Sie entspricht für sich genommen keiner Tabelle. [TypeORM] bezeichnet diese Technik als „Concrete Table Inheritance“: Jede mit [@Entity] dekorierte Unterklasse erhält eine eigene Tabelle mit allen geerbten Spalten – das exakte Äquivalent von @MappedSuperclass in JPA.
4.3.2. src/entities/person.entity.ts
Kommentieren wir diesen Code:
- Zeile 4: [export abstract class Person extends AbstractEntity {] – enthält die Felder, die Arzt und Patient gemeinsam haben (Anrede, Nachname, Vorname) und erbt zugleich id/version ([AbstractEntity]). Wie ihre Elternklasse ist sie nicht mit [@Entity] dekoriert: Sie ist das [TypeORM]-Gegenstück zur Klasse [Personne] des ursprünglichen Projekts, die ebenfalls @MappedSuperclass ist;
- Zeilen 5, 8, 11: [@Column({ length: N })], [@Column({ name: '...', length: N })] – drei Textspalten begrenzter Länge (die Option name gibt den tatsächlichen Spaltennamen in snake_case an: last_name, first_name), entspricht [@Column](length = N) private String ... in JPA.
4.3.3. src/entities/doctor.entity.ts
Kommentieren wir diesen Code:
- Zeile 5: [@Entity({ name: 'doctors' })] – deklariert die Klasse als [TypeORM]-Entität, die in der Tabelle [doctors] persistiert wird – das exakte Äquivalent von [@Entity] + @Table(name = "[doctors]") in JPA;
- Zeile 6: [export class Doctor extends Person {] — erbt title/lastName/firstName (von [Person]) sowie id/version (von [AbstractEntity]), ohne sie erneut deklarieren zu müssen;
- Zeile 7: [@OneToMany(() => Slot, (slot) => slot.doctor)] – deklariert die inverse Beziehung „ein Arzt hat mehrere Zeitfenster“: eine Komfortfunktion zur Navigation, die im ursprünglichen Projekt fehlte (dort nur in der Gegenrichtung auf der Seite von [Creneau] deklariert), sich mit TypeORM aber leicht ergänzen lässt.
4.3.4. src/entities/client.entity.ts
Kommentieren wir diesen Code:
- Zeilen 4–5: [@Entity({ name: 'clients' }) export class Client extends Person {}] – genau dasselbe Prinzip wie bei [Doctor], ohne zusätzliche Beziehungen: eine Tabelle [clients] mit denselben drei von Person geerbten Spalten. Erinnerung an die Begrifflichkeit: [Client] bezeichnet hier einen Patienten der Arztpraxis (Begriff aus der ursprünglichen Fachdomäne) und ist nicht mit dem „HTTP-Client“ zu verwechseln.
4.3.5. src/entities/slot.entity.ts
Zerlegen wir diesen Code:
- Zeilen 7–10: [@Column({ name: 'start_hour' }) startHour: number; …] – die vier Zeitgrenzen des Terminzeitfensters (Beginn und Ende als Stunde/Minute), vier einfache ganze Zahlen, jeweils auf ihre Spalte in snake_case abgebildet (start_hour, start_minute, end_hour, end_minute);
- Zeile 12: [@ManyToOne(() => Doctor, (doctor) => doctor.slots)] – mehrere Zeitfenster gehören zu demselben Arzt. Standardmäßig lädt [TypeORM] die Beziehung „doctor“ beim Lesen eines Zeitfensters nicht (standardmäßiges „Lazy“-Verhalten): Sie müssen sie ausdrücklich anfordern (Beziehungsoption: [...] in einer Abfrage) – genauso wie FetchType.LAZY auf der JPA-Seite ein explizites `left join fetch` in der JPQL-Abfrage erforderte, um den Arzt abzurufen;
- Zeile 13: [@JoinColumn({ name: 'doctor_id' })] – legt den Namen der Fremdschlüsselspalte in der Tabelle [slots] fest;
- Zeile 16: [@RelationId((slot: Slot) => slot.doctor)] – das exakte und idiomatische Äquivalent auf der [TypeORM]-Seite zum schreibgeschützten Feld idMedecin des ursprünglichen Projekts ([@Column](name = "id_medecin", insertable = false, updatable = false)): Es stellt den Wert des Fremdschlüssels direkt bereit, ohne die gesamte Entität [Doctor] laden zu müssen – nützlich, um schlanke JSON-Antworten zu erstellen (siehe unten, die Web-Schicht).
Hinweis: Ein Feld [@RelationId] ist eine virtuelle Spalte, die nachträglich von [TypeORM] berechnet wird – es ist keine echte SQL-Spalte, die sich in einer WHERE-Klausel eines „Query Builders“ verwenden ließe (siehe unten, [SlotRepository]). Es dient ausschließlich dazu, den Wert des Fremdschlüssels auszulesen, sobald die Entität geladen ist.
4.3.6. src/entities/appointment.entity.ts
Kommentieren wir diesen Code:
- Zeile 7: [@Unique('unq1_appointments', ['day', 'slot'])] – bezieht sich auf der [TypeORM]-Seite auf die SQL-Bedingung im Datenbankskript. Beachten Sie: Hier verweisen wir auf den Namen der Beziehung („slot“), nicht auf das Feld [@RelationId] („slotId“) – Letzteres ist eine virtuelle Spalte, die [TypeORM] in einer @Unique-Bedingung nicht akzeptiert. [TypeORM] bildet 'slot' selbst auf die tatsächliche Fremdschlüsselspalte (slot_id) ab;
- Zeile 9: [@Column({ type: 'date' })] – Typ 'date' (nicht 'datetime'): Nur der Tag wird gespeichert, nicht die Uhrzeit – genau wie TemporalType.DATE auf der JPA-Seite festlegte;
- Zeilen 12–18: [@ManyToOne(...) / @JoinColumn(...)] – zwei Beziehungen, zu [Client] und zu [Slot], nach demselben Prinzip wie in [slot.entity.ts];
- Zeilen 20–24: [@RelationId(...)] – die schreibgeschützten Entsprechungen der Felder idClient/idCreneau des ursprünglichen Projekts (derselbe Mechanismus wie bei Slot.doctorId; siehe oben).
4.3.7. src/entities/user.entity.ts
Kommentieren wir diesen Code:
- Zeile 4: [export type Role = ‘ADMIN’ | ‘USER’;] – eine einfache Vereinigung zweier Zeichenketten in TypeScript: die einzigen beiden Rollen, die die Anwendung verwaltet. Dieser Typ wird überall dort wiederverwendet, wo eine Rolle behandelt wird (roles.decorator.ts, jwt.strategy.ts, der Client [Vue.js] …);
- Zeile 6: [@Entity({ name: 'users' })] – wie die anderen Entitäten eine eigene Tabelle;
- Zeile 12: [password: string;] – speichert ein gehashtes (bcrypt) Passwort, niemals im Klartext – siehe auth.service.ts;
- Zeile 18: [role: Role;] – eine einzige Spalte statt der Many-to-many-Beziehung (users/roles/users_roles) des ursprünglichen Spring-Projekts. Diese Anwendung kennt nur zwei sich gegenseitig ausschließende Rollen (ein Benutzer ist entweder ADMIN oder USER, nie beides): Die ursprüngliche Beziehung nachzubauen, hätte Komplexität ohne echten Nutzen hinzugefügt. Dies ist eine bewusste Vereinfachung zu didaktischen Zwecken, genau wie die Enumeration `[ResponseStatus]` , der wir weiter oben in diesem Kapitel begegnet sind.
4.4. Fachobjekte (src/domain/)

Diese Klassen entsprechen keiner Datenbanktabelle: Sie werden zur Laufzeit aus mehreren Entitäten zusammengesetzt, um ein für die Anwendung nützliches Konzept darzustellen („der Terminkalender von Dr. Pelissier für den 13.09.2026“), das aber nicht in dieser Form gespeichert werden muss. Entspricht dem gleichnamigen Unterordner „domain“ (bzw. Paket) im ursprünglichen Projekt.
4.4.1. src/domain/doctor-day-slot.ts
Kommentieren wir diesen Code:
- Zeile 4: [export class DoctorDaySlot {] – verknüpft ein Zeitfenster mit dem Termin, der in diesem Zeitfenster gegebenenfalls für einen bestimmten Tag vereinbart wurde;
- Zeilen 5–8: [constructor(public slot: Slot, public appointment: Appointment | null) {}] – die Syntax [public] direkt in den Parametern des Konstruktors ist eine Abkürzung in TypeScript: Sie deklariert UND initialisiert beide Eigenschaften in jeweils einer Zeile, ohne dass man [this.slot = slot] gesondert schreiben müsste. [appointment] ist null, wenn das Zeitfenster frei ist.
4.4.2. src/domain/doctor-day-schedule.ts
Kommentieren wir diesen Code:
- Zeile 4: [export class DoctorDaySchedule {] – der vollständige Terminkalender eines Arztes für einen bestimmten Tag: der betreffende Arzt, der Tag und die Liste seiner Zeitfenster (jeweils als frei oder gebucht markiert; siehe [DoctorDaySlot] oben);
- Zeile 8: [public doctorDaySlots: DoctorDaySlot[],] – berechnet von [BusinessService.getDoctorDaySchedule] (siehe unten); diese Liste wandelt der Controller für den Client [Vue.js] in JSON um.
4.5. Die DAO-Schicht (src/repositories/)
Die DAO-Schicht (Data Access Object) ist der einzige Teil des Projekts, der direkt mit TypeORM/MySQL kommuniziert – das Äquivalent der Spring-Data-Schnittstellen des ursprünglichen Projekts (Paket rdvmedecins.repositories).

Der wichtigste Unterschied zwischen Spring Data und [TypeORM]: Bei Spring Data genügte es, eine Schnittstelle (extends CrudRepository<...>) zu deklarieren, um automatisch die grundlegenden Methoden (findAll, findOne, save, delete usw.) zu erhalten – Spring selbst erzeugte beim Start eine Klasse, die sie implementierte. Bei [TypeORM] gibt es keine automatische Erzeugung einer Implementierung aus einer Schnittstelle: Wir injizieren direkt das von [TypeORM] bereitgestellte generische Repository<Entity> (über [@InjectRepository]) und schreiben die Methoden, die wir anbieten möchten, selbst, indem wir auf den vordefinierten Methoden dieses Repository aufbauen oder für spezifischere Abfragen den Query Builder verwenden.
4.5.1. src/repositories/doctor.repository.ts
Kommentieren wir diesen Code:
- Zeile 9: [@InjectRepository(Doctor)] – fordert [NestJS] auf, das von [TypeORM] für die Entität Doctor automatisch erzeugte Repository<[Doctor]> bereitzustellen. Das entspricht der automatischen Injektion (@Autowired) der von Spring Data erzeugten Implementierung;
- Zeile 14: [return this.repository.find();] – entspricht medecinRepository.findAll(), geerbt von CrudRepository;
- Zeile 18: [return this.repository.findOneBy({ id });] – entspricht medecinRepository.findOne(id); gibt null zurück, wenn kein Arzt diese ID hat (wie findOne in Spring Data, statt eine Ausnahme auszulösen).
4.5.2. src/repositories/client.repository.ts
Diese Datei entspricht im Prinzip genau [DoctorRepository] (siehe die Erläuterung oben), ist aber auf die Entität [Client] (einen Patienten) angewandt.
4.5.3. src/repositories/slot.repository.ts
Kommentieren wir diesen Code:
- Zeilen 13–19: [findAll() / findById(id)] – identisch mit dem Prinzip, das wir bereits in [DoctorRepository] gesehen haben;
- Zeile 21: [getAllSlots(doctorId: number): Promise<Slot[]> {] – eine „benutzerdefinierte“ Abfrage, die der ursprünglichen JPQL-Abfrage select c from [Creneau] c where c.medecin.[id]=?1 entspricht;
- Zeile 23: [.createQueryBuilder(‘s’)] — der SQL-Alias s wird benannt, genauso wie [Creneau] c in JPQL benannt wird;
- Zeile 24: [.where(‘s.doctor = :doctorId’, { doctorId })] – hier vergleichen wir die Beziehung selbst (s.doctor), nicht das Feld [@RelationId] (s.doctorId): Wie oben (slot.entity.ts) erwähnt, ist Letzteres keine Spalte, die sich in einem WHERE verwenden ließe. Indem die Beziehung mit einer Zahl verglichen wird, [TypeORM] erkennt es, dass ihr Fremdschlüssel gemeint ist, und erzeugt das richtige SQL, ohne einen Join;
- Zeilen 25–26: [.orderBy(‘s.startHour’, ‘ASC’).addOrderBy(‘s.startMinute’, ‘ASC’)] – sortiert die Zeitfenster in chronologischer Reihenfolge, eine nützliche Ergänzung, die in der ursprünglichen Spring-Version nicht ausdrücklich existierte.
4.5.4. src/repositories/appointment.repository.ts
Kommentieren wir diesen Code:
- Zeilen 13–18: [findById(id) { … relations: [‘client’, ‘slot’] }] – relations: [...] weist [TypeORM] ausdrücklich an, auch den zugehörigen Client und das zugehörige Zeitfenster zu laden (zur Erinnerung: Diese Beziehungen sind standardmäßig im „Lazy“-Modus; siehe slot.entity.ts) – nützlich, um die JSON-Antwort zu erstellen (siehe unten, getMapForAppointment);
- Zeile 21: [return this.repository.save(appointment);] – entspricht rvRepository.save(new Rv(jour, client, creneau));
- Zeile 25: [await this.repository.delete(id);] – entspricht rvRepository.delete(rv.getId());
- Zeile 28: [getDoctorDayAppointments(doctorId: number, day: string): Promise<Appointment[]> {] – entspricht der ursprünglichen JPQL-Abfrage SELECT rv FROM Rv rv LEFT JOIN FETCH rv.client c LEFT JOIN FETCH rv.creneau cr WHERE cr.medecin.[id]=?1 and rv.[jour]=?2 ;
- Zeilen 31–32: [.leftJoinAndSelect(‘appointment.client’, ‘client’) / .leftJoinAndSelect(‘appointment.slot’, ‘slot’)] – das Äquivalent zum LEFT JOIN FETCH des ursprünglichen JPQL: ruft in einer einzigen SQL-Abfrage den Client und das Zeitfenster ab, die zu jedem Termin gehören;
- Zeile 33: [.where(‘slot.doctor = :doctorId’, { doctorId })] – Bedingung für den Arzt, ermittelt über einen Join auf das Zeitfenster (rv.creneau.medecin.[id]=?1 in JPQL) – auch hier vergleichen wir die Beziehung „doctor“, nicht das entsprechende [@RelationId]-Feld.
4.5.5. src/repositories/user.repository.ts
Kommentieren wir diesen Code:
- Zeile 13: [findByLogin(login: string): Promise<User | null> {] – die einzige hier benötigte Suchmethode, die bei der Anmeldung verwendet wird (siehe auth.service.ts): Sie ersetzt die rollenbasierte Suche über drei Tabellen im ursprünglichen Projekt, die durch die Vereinfachung auf eine einzige Spalte [role] überflüssig geworden ist (siehe user.entity.ts).
4.6. Die Geschäftsschicht (src/business/)
Hier und nur hier liegen die Geschäftsregeln der Anwendung – das Äquivalent zum Paket rdvmedecins.metier des ursprünglichen Projekts.
4.6.1. src/business/business.interface.ts
Kommentieren wir diesen Code:
- Zeile 7: [export interface IBusiness {] – der Vertrag der Geschäftsschicht, unabhängig von seiner Implementierung – das exakte Äquivalent der Java-Schnittstelle [IMetier] des ursprünglichen Projekts;
- Zeilen 8–18: elf Methoden, eine für jede Anforderung der Anwendung (Listen, Suchen nach ID, Hinzufügen/Löschen von Terminen, Berechnung des Terminkalenders);
- Zeile 21: [export const BUSINESS_TOKEN = ‘IBusiness’;] – wir definieren ein Injektions-„Token“ (InjectionToken), um diese Schnittstelle in den Controller injizieren zu können, genau wie Spring die Referenz auf die Geschäftsschicht [IMetier] injizierte, ohne ihre konkrete Implementierungsklasse [Metier] zu kennen. In TypeScript werden Schnittstellen beim Kompilieren entfernt: Sie können daher nicht direkt als Injektions-Token verwendet werden ([NestJS]); dieser Umweg ist notwendig (siehe seine Verwendung in app.module.ts und application-model.service.ts).
4.6.2. src/business/business.service.ts
Kommentieren wir diesen Code:
- Zeile 10: [export class BusinessService implements IBusiness {] – [@Injectable]() entspricht @Service("métier"): Diese Klasse wird zu einem „Provider“ ([NestJS]), den [NestJS] erzeugen und dort injizieren kann, wo er benötigt wird;
- Zeilen 11–16: [constructor(private readonly doctorRepository: …, …) {}] – Injektion der vier DAO-Instanzen, entspricht den vier @Autowired-Feldern des ursprünglichen Projekts. [NestJS] setzt hier auf Konstruktorinjektion statt auf Feldinjektion (wie @Autowired sie auf einem Java-Feld vornimmt): Das ist in TypeScript der empfohlene Ansatz; er macht die Abhängigkeiten explizit und erleichtert das Testen;
- Zeilen 18–23: Die meisten Methoden delegieren einfach an die DAO-Schicht – keine eigene Geschäftslogik;
- Zeilen 25–31: [addAppointment(…) { const appointment = new Appointment(); … }] – erzeugt eine neue Entität Appointment und speichert sie; es ist die SQL-Bedingung unq1_appointments (siehe oben, das Datenbankskript), und nur sie, die eine doppelte Reservierung verhindert – hier wird keine ausdrückliche Prüfung durchgeführt; ein Versuch, einen Termin doppelt zu buchen, löst eine SQL-Ausnahme aus, die von der DAO-Schicht weitergereicht wird;
- Zeile 37: [async getDoctorDaySchedule(doctorId: number, day: string): Promise<DoctorDaySchedule | null> {] – die einzige Methode der Geschäftsschicht, die echte Geschäftslogik ausführt (die anderen delegieren lediglich): Sie berechnet den vollständigen Terminkalender eines Arztes für einen bestimmten Tag. Der Algorithmus wird genau wie im ursprünglichen Dokument in drei Schritten wiedergegeben;
- Zeile 42: [const timeSlots = await this.getAllSlots(doctorId);] – 1. alle Zeitfenster des Arztes abrufen;
- Zeile 43: [const bookings = await this.getDoctorDayAppointments(doctorId, day);] – 2. alle Termine des Arztes für den angeforderten Tag abrufen;
- Zeilen 45–48: [const hBookings = new Map<number, Appointment>(); …] – diese Termine werden in einem Dictionary abgelegt, das über die ID des Zeitfensters indiziert ist, damit sie im nächsten Schritt schnell abgerufen werden können – entspricht der `Map<Long, Rv> hReservations` im ursprünglichen Code;
- Zeilen 50–53: [const doctorDaySlots = timeSlots.map((slot) => { … })] – 3. Für jedes Zeitfenster prüfen wir, ob es zu einer der gefundenen Reservierungen passt: Wenn ja, ist es „belegt“ (wir ordnen ihm den gefundenen Termin zu); andernfalls ist es „frei“ (appointment = null).
4.7. Die Web-Schicht (src/web/)
Dies ist der HTTP-Einstiegspunkt der Anwendung – das Äquivalent zum Paket [rdvmedecins.web] des ursprünglichen Projekts.

4.7.1. src/web/models/response.model.ts
Kommentieren wir diesen Code:
- Zeilen 1–6: [export enum ResponseStatus { … }] – das ursprüngliche Spring-Projekt verwendete „ad hoc“ vergebene Zahlen (0, 1, 2, 3, 4 …), deren Bedeutung von einer Controller-Methode zur anderen variierte. Diese Portierung nutzt die Gelegenheit, alle möglichen Codes in einer einzigen Enumeration zusammenzufassen, die sich leichter erlernen und warten lässt: Das für den Client beobachtbare Verhalten (0 = Erfolg, alles andere = Fehler) bleibt strikt dasselbe;
- Zeile 8: [export class ServerResponse<T = unknown> {] – der gemeinsame Antwort-Body für alle JSON-Antworten des Webservices: { "status": 0, "data": ... }. Neu gegenüber dem Original: Diese Klasse ist dank TypeScript generisch ([ServerResponse]<T>), sodass der Datentyp zur Kompilierzeit bekannt ist (z. B. [ServerResponse]<[Doctor][]>) – Die Sprache Java des ursprünglichen Projekts erlaubte dies mit einem Typ `Object` nicht so einfach;
- Zeilen 17–19: [static ok<T>(data: T): ServerResponse<T> {] – eine kleine statische „Factory“-Methode, um den Controller-Code lesbarer zu schreiben (ServerResponse.ok([doctors]) statt new [ServerResponse](ResponseStatus.OK, [doctors]));
- Zeilen 21–23: [static error<T = unknown>(status: ResponseStatus, data: T | null = null): ServerResponse<T> {] – ihr Gegenstück für Fehlerantworten.
4.7.2. src/web/models/post-add-appointment.dto.ts
Kommentieren wir diesen Code:
- Zeile 3: [export class PostAddAppointmentDto {] – beschreibt das Format des JSON-Bodys, den die Route /addAppointment erwartet ({ day, clientId, slotId }) – ein „DTO“ (Data Transfer Object), eine Klasse, deren einziger Zweck darin besteht, das Format der ausgetauschten Daten zu beschreiben, ohne jede Logik;
- Zeile 4: [@IsDateString()] – überprüft, dass die empfangene Zeichenkette tatsächlich ein gültiges Datum im ISO-Format ist. Ist dies nicht der Fall, [NestJS] gibt automatisch einen HTTP-Fehler 400 zurück (Bad [Request]) bevor der Controller ausgeführt wird – dank der globalen Variable [ValidationPipe] , die in [main.ts] deklariert ist (siehe unten);
- Zeilen 7, 10: [@IsInt()] – überprüft, dass der empfangene Wert tatsächlich eine ganze Zahl ist. Diese Dekoratoren sind zusammen mit [ValidationPipe] das [NestJS]-Äquivalent der automatischen Typkonvertierungen, die Spring MVC mit @RequestBody vornahm.
4.7.3. src/web/models/post-delete-appointment.dto.ts
Dasselbe Prinzip wie bei [PostAddAppointmentDto] oben, für den JSON-Body, den /deleteAppointment erwartet ({ appointmentId }).
4.7.4. src/web/helpers/static.helper.ts
Kommentieren wir diesen Code:
- Zeile 4: [export function getErrorsForException(exception: unknown): string[] {] – entspricht Static.getErreursForException (Exception exception). Java konnte Ausnahmen verketten (exception.getCause()), um das „Warum“ einer Ausnahme zu erklären; im modernen JavaScript/TypeScript (ES2022) besitzen Fehler ebenfalls eine Kette von Ursachen, über die Eigenschaft `cause`;
- Zeilen 6–10: [while (cause instanceof Error) { … cause = cause.cause; }] – dies wird genauso behandelt wie im ursprünglichen Java-Code, indem jede angetroffene Meldung aufgestapelt wird;
- Zeilen 17–19: [export interface SlotJson { … }] – die Entität [Slot] wird nicht unverändert als JSON zurückgegeben: Sie enthält eine Beziehung zu „doctor“, die, falls geladen, Informationen duplizieren würde, die dem Client bereits bekannt sind (der Client weiß bereits, um welchen Arzt es geht; siehe den Parameter {doctorId} in der URL). Wir konstruieren daher ein „maßgeschneidertes“ Objekt, das nur die für die Anzeige nötigen Felder enthält;
- Zeile 21: [export function getMapForSlot(slot: Slot | null | undefined): SlotJson | null {] – entspricht Static.getMapForCreneau ([Creneau] Zeitfenster): wandelt eine Entität in ein schlankes JSON-Objekt um;
- Zeile 29: [export function getListMapForSlots(slots: Slot[]): SlotJson[] {] – ihr Gegenstück für eine ganze Liste (entspricht Static.getListMapForCreneaux);
- Zeilen 33–38, 40–50, 52–54: [AppointmentJson / getMapForAppointment / getListMapForAppointments] – dasselbe Prinzip, angewandt auf Termine: Auch der eingebettete Client (appointment.client) wird auf die für die Anzeige nötigen Felder reduziert.
4.7.5. src/web/application-model.service.ts
Kommentieren wir diesen Code:
- Zeile 6: [export class ApplicationModelService implements IBusiness, OnModuleInit {] – entspricht der Klasse ApplicationModel des ursprünglichen Projekts: ein Cache, der einmal beim Start des Servers aufgebaut wird und die Liste der Ärzte und Clients im Speicher hält (kurze Listen, die sich selten ändern, sodass man sie nicht bei jeder Anfrage aus der Datenbank abfragen muss). Diese Klasse erfüllt, genau wie das Original, zwei Aufgaben: Sie fungiert einerseits als Cache und andererseits als einziger Zugang des Controllers zur Geschäftsschicht – wenn die Caching-Strategie einmal geändert wird, muss nur diese Datei angepasst werden;
- Zeile 11: [constructor(@Inject(BUSINESS_TOKEN) private readonly business: IBusiness) {}] – hier wird die Schnittstelle [IBusiness] injiziert (über das Token [BUSINESS_TOKEN], siehe app.module.ts), nicht die konkrete Klasse [BusinessService] – genau wie der ursprüngliche Java-Code @Autowired private [IMetier] métier; schrieb, ohne die Klasse Metier je zu erwähnen;
- Zeile 13: [async onModuleInit(): Promise<void> {] – [OnModuleInit] ist die „Lifecycle“-Schnittstelle von [NestJS], die genau dieselbe Rolle spielt wie @PostConstruct in Spring: onModuleInit() wird von [NestJS] automatisch aufgerufen, unmittelbar nachdem alle Abhängigkeiten dieser Klasse injiziert wurden;
- Zeilen 17–18: [catch (ex) { this.messages = getErrorsForException(ex); }] – wenn die Datenbank beim Start nicht verfügbar ist, wird der Fehler abgefangen und in `messages` gespeichert, statt den Absturz des Servers zu verursachen – exakt das Verhalten des ursprünglichen Projekts;
- Zeile 26: [async getAllClients(): Promise<Client[]> { return this.clients; }] – die Listen der Ärzte und Clients stammen aus dem Cache; alles Übrige (ab Zeile 29) wird einfach an die Geschäftsschicht delegiert.
4.7.6. src/web/rdvmedecins.controller.ts
RdvMedecinsController deklariert die elf Routen der Anwendung, die bewusst, ins Englische übersetzt, die des ursprünglichen Dokuments widerspiegeln (/getAllDoctors für /getAllMedecins, /addAppointment für /ajouterRv …) und nicht im REST-Stil „modernisiert“ wurden (/doctors, /clients/:id …) – Ziel dieses Dokuments ist es, die beiden Implementierungen zu vergleichen, nicht die API zu modernisieren.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | |
Kommentieren wir diesen Code:
- Zeile 12: [@UseGuards(JwtAuthGuard)] – auf die Klasse angewandt, schützt es alle elf Routen dieses Controllers auf einmal: Keine ist ohne ein gültiges JWT-Token erreichbar (siehe unten das Kapitel „Authentifizierung“). Das entspricht der ursprünglichen Spring-Security-Regel .antMatchers("/**").hasRole("ADMIN"), mit dem Unterschied, dass hier lediglich verlangt wird, authentifiziert zu sein (jede Rolle) – die Beschränkung auf die Rolle ADMIN gilt nur für die beiden Routen, die Daten ändern (Zeilen 75–76 und 95–96);
- Zeile 13: [@Controller()] — kein Präfix: Die Routen lauten daher genau /getAllDoctors, /getAllClients usw. Das entspricht @RestController in Spring: Jeder von einer Methode zurückgegebene Wert wird automatisch als JSON serialisiert;
- Zeile 15: [constructor(private readonly application: ApplicationModelService) {}] — Injektion des Caches/der Fassade, entspricht @Autowired private ApplicationModel application; ;
- Zeilen 19–22: [const messages = this.application.getMessages(); if (messages !== null) { … }] — zunächst prüfen wir, ob die Anwendung korrekt initialisiert wurde (siehe ApplicationModelService.onModuleInit); entspricht `if (messages != null) { return new [Reponse](-1, messages); }`;
- Zeile 33: [async getAllSlots(@Param('doctorId') doctorId: string) {] — [@Param]('doctorId') ruft das Segment {doctorId} aus der URL ab, und zwar als String (ähnlich wie @PathVariable(String) in Spring); wir wandeln es selbst in eine Zahl um (Zeile 34), während Spring dies bei einem als `long` deklarierten Parameter automatisch erledigt hätte;
- Zeilen 35–38: [const doctor = await this.application.getDoctorById(id); if (doctor === null) { … }] — wir rufen zunächst den Arzt ab, um zu prüfen, ob er existiert, bevor wir fortfahren (entspricht der privaten Methode getMedecin(id) im ursprünglichen Controller);
- Zeile 41: [return ServerResponse.ok(getListMapForSlots(slots));] — wandelt die Liste der Entitäten [Slot] in eine Liste „leichtgewichtiger“ JavaScript-Objekte um (siehe static.helper.ts);
- Zeile 59: [return ServerResponse.ok({ doctor: …, day: …, slots: … });] — der Terminkalender wird für JSON im „leichten“ Modus formatiert, nach denselben Prinzipien wie getMapForSlot/getMapForAppointment;
- Zeile 75: [@UseGuards(RolesGuard)], dann Zeile 76: [@Roles('ADMIN')] — Man muss hier nicht nur authentifiziert sein (das verlangt bereits [@UseGuards]([JwtAuthGuard]) für die Klasse), sondern auch die Rolle ADMIN besitzen – die Rolle USER erhält eine Antwort 403 Forbidden (siehe roles.guard.ts). [RolesGuard] liest request.user (von JwtAuthGuard/JwtStrategy bereitgestellt): Er muss daher nach [JwtAuthGuard] ausgeführt werden ([NestJS] wendet zuerst die Guards der Klasse an, dann die der Methode, jeweils in der Reihenfolge ihrer Angabe);
- Zeilen 87–92: [try { const appointment = await this.application.addAppointment(…); … } catch (e) { … }] — an dieser Stelle hat class-validator (siehe [PostAddAppointmentDto]) bereits geprüft, dass post.[day] ist ein gültiges Datum und dass post.clientId/post.slotId tatsächlich ganze Zahlen sind. Die SQL-Constraint unq1_appointments (day, slot_id) verhindert, dass derselbe Zeitslot am selben Tag zweimal reserviert wird: Ein doppelter Versuch löst eine Exception aus, die hier abgefangen wird, genau wie die SQLException des ursprünglichen JDBC-Treibers;
- Zeile 95: gleiche Einschränkung wie in Zeile 75, für deleteAppointment: Nur die Rolle ADMIN kann einen Termin stornieren;
- Zeile 112: [function isValidDate(day: string): boolean {] — eine kleine lokale Hilfsfunktion, die dem Paar SimpleDateFormat("yyyy-MM-dd") + setLenient(false) aus dem ursprünglichen Code entspricht, das zum Beispiel „2026-13-40“ (ungültiger Monat und Tag) abgelehnt hat: Date.toISOString() rekonstruiert das Datum aus der empfangenen Zeichenkette – weicht es von der Eingabe ab, existierte das Datum nicht.
4.8. Authentifizierung (src/auth/)

Dieser Abschnitt dokumentiert die Ergänzung der tokenbasierten Authentifizierung (JWT) und der rollenbasierten Zugriffskontrolle (ADMIN/USER) an dieser Stelle des Kurses – das funktionale Pendant zur Spring-Security-Schicht des ursprünglichen Dokuments, neu geschrieben mit Standardwerkzeugen des [NestJS]-Ökosystems: [@nestjs/passport] und @nestjs/jwt.
Zwei bewusste Unterschiede zum ursprünglichen Projekt, die hier ein für alle Mal festgehalten werden:
- JWT statt HTTP Basic. Das ursprüngliche Spring-Projekt sendete bei jeder Anfrage den Header Authorization: Basic <login:password in Base64>: Das Passwort (kodiert, nicht verschlüsselt) wurde also bei jedem Aufruf über das Netzwerk übertragen. Diese Portierung verwendet stattdessen ein Token: JWT (JSON Web Token). Das Passwort wird nur einmal beim Login übermittelt (POST /login); der Server liefert dann ein signiertes Token zurück, das der Client anschließend in jede weitere Anfrage einfügt (Header Authorization: Bearer <token>). Dies ist die heute übliche Praxis für diese Art von API, wie bereits im Fazit des vorherigen Kapitels erwähnt.
- Eine Rolle pro Benutzer, eine einzige Datenbankspalte statt der Many-to-many-Beziehung (users/roles/users_roles) im ursprünglichen Projekt – siehe user.entity.ts weiter oben.
Ein architektonischer Punkt, den Sie vor dem Lesen des folgenden Codes verstehen sollten: Wenn ein Guard eine Anfrage ablehnt (401 Unauthorized, 403 Forbidden), durchläuft die Antwort niemals den üblichen [ServerResponse]<T>-Umschlag ({ status, data }): [NestJS] antwortet direkt in seinem nativen JSON-Format { statusCode, message, error }. Das ist eine bewusste Entscheidung: Sicherheitsfehler werden vor dem Eintritt in den Controller (durch einen Guard) behandelt, während [ServerResponse]<T> vom Controller für fachliche Fehler erzeugt wird (Ressource nicht gefunden, ungültiges Datum usw.). Der [Vue.js]-Client muss daher zwischen diesen beiden Arten von Fehlerantworten unterscheiden (siehe das folgende Kapitel, auth.interceptor.ts).
4.8.1. src/auth/dto/login.dto.ts
Kommentieren wir diesen Code:
- Zeile 3: [export class LoginDto {] — beschreibt das Format des JSON-Bodys, den POST /login erwartet ({ login, password }); es ist derselbe Mechanismus wie beim DTO, dem wir bereits in src/web/models begegnet sind;
- Zeilen 4–5, 8–9: [@IsString() @IsNotEmpty()] — prüft, dass beide Felder nicht leere Zeichenketten sind.
Dieses DTO dient hier einem rein informativen Zweck: Tatsächlich liest [LocalStrategy] (siehe unten) {login, password} aus dem Request-Body, nicht ein Parameter [@Body]([LoginDto]) des Controllers – dennoch [LoginDto] zeigt dem Leser das genaue Format, das diese Route erwartet.
4.8.2. src/auth/login-result.model.ts
Kommentieren wir diesen Code:
- Zeile 3: [export interface LoginResult {] — das Format der Daten, die POST /login bei Erfolg zurückgibt, im standardmäßigen [ServerResponse]<T>-Umschlag: { "status": 0, "data": { accessToken, login, name, role } } ;
- Zeile 4: [accessToken: string;] — das JWT-Token, das in jede weitere Anfrage einzufügen ist;
- Zeile 7: [role: Role;] — die Rolle des angemeldeten Benutzers, damit der [Vue.js]-Client seine Oberfläche anpassen kann (siehe nächstes Kapitel, Ausblenden der Schaltflächen „Book“/„Cancel“ für die Rolle USER).
4.8.3. src/auth/local.strategy.ts
Eine Passport-„Strategie“ beschreibt, wie eine Anfrage zu authentifizieren ist. [LocalStrategy] kann ein Paar {login, password} aus dem Body einer POST-Anfrage lesen und die Überprüfung an AuthService delegieren. Sie wird nur einmal verwendet, nämlich von der Route POST /login (über [LocalAuthGuard]): Alle anderen geschützten Routen verwenden dann [JwtStrategy] (siehe unten) und nicht diese.
Zerlegen wir diesen Code:
- Zeile 8: [export class LocalStrategy extends PassportStrategy(Strategy) {] — konzeptionell gleichwertig mit der Klasse AppUserDetailsService des ursprünglichen Spring-Security-Projekts: „Sag mir anhand dieser Anmeldedaten, wer dieser Benutzer ist“;
- Zeile 10: [super({ usernameField: ‘login’, passwordField: ‘password’ });] — standardmäßig erwartet passport-local im Request-Body Felder mit den Namen „username“ und „password“; wir benennen sie hier um, damit sie zu unserem DTO passen ([LoginDto]), das „login“ statt „username“ verwendet;
- Zeile 13: [async validate(login: string, password: string): Promise<User> {] — wird von Passport automatisch mit den beiden aus der Anfrage extrahierten Feldern aufgerufen. Was zurückgegeben wird, wird im Controller zu request.user (siehe auth.controller.ts);
- Zeile 16: [throw new UnauthorizedException(‘incorrect login or password’);] — Passport wandelt diese Exception automatisch in eine HTTP-Antwort 401 Unauthorized um, bevor sie überhaupt den Controller erreicht.
4.8.4. src/auth/jwt.strategy.ts
Die zweite Passport-Strategie: Sie kann ein JWT-Token aus dem HTTP-Header Authorization: Bearer <token> jeder Anfrage lesen, seine Signatur überprüfen und die Identität des Benutzers extrahieren – ohne jemals die Datenbank abzufragen (das Token enthält bereits alles Nötige). Dies ist der Mechanismus, der die elf Routen von RdvMedecinsController schützt.
Kommentieren wir diesen Code:
- Zeilen 5–9: [export interface JwtPayload { sub: number; login: string; role: … }] — das Format der Informationen, die wir beim Erzeugen des JWT-Tokens darin speichern (siehe auth.service.ts); sub („subject“) ist in JWT der übliche Name für das Feld, das die Kennung des Benutzers enthält;
- Zeilen 11–15: [export interface ConnectedUser { … }] — was request.user in den Controllern enthalten wird, sobald das Token überprüft wurde;
- Zeile 18: [export class JwtStrategy extends PassportStrategy(Strategy, ‘jwt’) {] — das zweite Argument 'jwt' benennt diese Strategie (anders als [LocalStrategy], die keinen Namen angegeben hat): Mit diesem Namen sagt [JwtAuthGuard] ([AuthGuard]('jwt'), siehe unten) „verwende diese Strategie“;
- Zeile 21: [jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),] — das Token wird im Header Authorization: Bearer xxx erwartet;
- Zeile 22: [ignoreExpiration: false,] — ist das Token abgelaufen, lehnt Passport es ab (401), noch bevor validate() aufgerufen wird;
- Zeile 23: [secretOrKey: process.env.JWT_SECRET ?? ‘…’] — der geheime Schlüssel, mit dem die Signatur des Tokens überprüft wird – derselbe, mit dem es signiert wurde (siehe auth.module.ts, das ihn aus derselben Umgebungsvariable JWT_SECRET liest);
- Zeile 27: [validate(payload: JwtPayload): ConnectedUser {] — wird von Passport automatisch aufgerufen, sobald die Signatur des Tokens überprüft wurde; wandelt den Inhalt des Tokens in request.user um.
4.8.5. src/auth/local-auth.guard.ts
Zerlegen wir diesen Code:
- Zeile 5: [export class LocalAuthGuard extends AuthGuard(‘local’) {}] — ein „Guard“ ([NestJS]) bestimmt, bevor eine Controller-Methode ausgeführt wird, ob die Anfrage darauf zugreifen darf. [AuthGuard]('local') ist eine Factory von [@nestjs/passport] , die einen Guard auf Basis der Passport-Strategie mit dem Namen 'local' erzeugt (implizit [LocalStrategy], der in ihrem eigenen Konstruktor kein expliziter Name gegeben wurde). Dieser Guard wird nur von der Route POST /login verwendet (siehe auth.controller.ts).
4.8.6. src/auth/jwt-auth.guard.ts
Kommentieren wir diesen Code:
- Zeile 5: [export class JwtAuthGuard extends AuthGuard(‘jwt’) {}] — der Guard, der die elf Routen von RdvMedecinsController schützt: Er verlangt ein gültiges JWT-Token („jwt“ verweist auf [JwtStrategy]; siehe oben). Ohne Token oder mit einem ungültigen oder abgelaufenen Token [NestJS] antwortet automatisch mit dem Fehler 401 Unauthorized – noch bevor der Controller erreicht wird.
4.8.7. src/auth/roles.decorator.ts
Kommentieren wir diesen Code:
- Zeile 5: [export const Roles = (…roles: Role[]) => SetMetadata(ROLES_KEY, roles);] — [@Roles]('ADMIN') ist ein eigener Dekorator (wir schreiben ihn selbst, anders als @Get, @Post und @Injectable, die von [NestJS] bereitgestellt werden): Er hängt lediglich Metadaten („diese Methode erfordert diese oder jene Rolle“) an die Methode an, die er dekoriert, ohne selbst eine Prüfung durchzuführen – erst [RolesGuard] (weiter unten) liest diese Metadaten und führt die Prüfung durch. [SetMetadata](key, value) ist die Low-Level-Funktion von [NestJS] , mit der Sie Ihre „eigenen“ Dekoratoren dieser Art schreiben können.
4.8.8. src/auth/roles.guard.ts
Zweite Validierungsstufe, im Anschluss an [JwtAuthGuard]: Dieser prüft lediglich, dass der Benutzer ordnungsgemäß authentifiziert ist (gültiges JWT-Token); [RolesGuard] prüft zusätzlich, dass die Rolle des angemeldeten Benutzers zu den Rollen gehört, die von [@Roles](...) an der Zielmethode verlangt werden.
Kommentieren wir diesen Code:
- Zeile 8: [export class RolesGuard implements CanActivate {] — konzeptionell gleichwertig mit der Spring-Security-Regel http.authorizeRequests().antMatchers(...).hasRole("ADMIN"), hier jedoch Methode für Methode statt URL für URL angewendet, dank des Dekorator-Paars ([@Roles]) + [Reflector] (der die von einem Dekorator gesetzten Metadaten erneut lesen kann);
- Zeile 12: [const requiredRoles = this.reflector.getAllAndOverride<Role[]>(ROLES_KEY, […])] — die von [@Roles](...) gesetzten Metadaten werden an der Zielmethode wieder ausgelesen – getAllAndOverride durchsucht zuerst die Methode (Zeile 13), dann die Klasse (Zeile 14);
- Zeilen 17–19: [if (!requiredRoles || requiredRoles.length === 0) { return true; }] — keine [@Roles](...)-Metadaten für diese Methode: keine zusätzlichen Rollenbeschränkungen ([JwtAuthGuard] dagegen hat bereits eine gültige Authentifizierung verlangt, unabhängig von der Rolle);
- Zeile 21: [const request = context.switchToHttp().getRequest<{ user: ConnectedUser }>();] — request.user wurde von JwtStrategy.validate() bereitgestellt: [RolesGuard] wird daher immer nach [JwtAuthGuard] ausgeführt (siehe ihre Reihenfolge in [@UseGuards](...), rdvmedecins.controller.ts);
- Zeilen 24–28: [if (!requiredRoles.includes(user.role)) { throw new ForbiddenException(…); }] — gehört die Rolle des angemeldeten Benutzers nicht zu den verlangten, wird eine Exception 403 Forbidden ausgelöst, mit einer Meldung, die die erhaltene und die erwartete Rolle nennt.
4.8.9. src/auth/auth.service.ts
Der Service, der die gesamte Authentifizierungslogik übernimmt: die Überprüfung eines Paars aus Benutzername und Passwort sowie die Erzeugung des JWT-Tokens, das an den Client zurückgesendet wird, sobald der Benutzer validiert ist.
Kommentieren wir diesen Code:
- Zeile 10: [export class AuthService {] — konzeptionell gleichwertig mit der Klasse AppUserDetailsService des ursprünglichen Spring-Security-Projekts, hier kombiniert mit der Token-Erzeugung;
- Zeile 16: [async validateUser(login: string, password: string): Promise<User | null> {] — prüft, dass ein Benutzer mit diesem Login existiert und dass das angegebene Passwort übereinstimmt; gibt den Benutzer zurück, wenn alles korrekt ist, andernfalls null;
- Zeile 21: [const passwordCorrect = await bcrypt.compare(password, user.password);] — bcrypt.compare() hasht das Passwort mit dem gleichen Salt, der in user.[password] gespeichert ist, und vergleicht dann die beiden Ergebnisse – das gespeicherte Passwort wird nie entschlüsselt (der Hash ist nicht umkehrbar);
- Zeile 25: [login(user: User): LoginResult {] — erzeugt das JWT-Token für einen bereits authentifizierten Benutzer (aufgerufen von [AuthController], nachdem LocalAuthGuard/LocalStrategy erfolgreich durchlaufen wurden);
- Zeile 28: [accessToken: this.jwtService.sign(payload),] — jwtService.sign() signiert den Payload mit dem geheimen Schlüssel und der Gültigkeitsdauer, die in auth.module.ts (JwtModule.register) konfiguriert sind.
4.8.10. src/auth/auth.controller.ts
Eine einzige Route: POST /login. Sie ist die einzige Route der gesamten Anwendung, die kein JWT-Token voraussetzt (denn genau diese Route stellt es aus).
Kommentieren wir diesen Code:
- Zeile 12: [@UseGuards(LocalAuthGuard)] — setzt diesen Guard vor die Methode: Er löst LocalStrategy.validate() aus, das das Paar aus Login und Passwort überprüft. Schlägt die Überprüfung fehl, [NestJS] gibt eine Antwort 401 Unauthorized zurück, noch bevor der Rumpf dieser Methode ausgeführt wird;
- Zeile 14: [login(@Request() req: { user: User }): ServerResponse<LoginResult> {] — wenn wir diesen Punkt erreichen, war [LocalAuthGuard] erfolgreich: req.user enthält den von LocalStrategy.validate() zurückgegebenen Benutzer. Beachten Sie, dass es keinen Parameter [@Body]([LoginDto]) gibt: Der Guard und nicht diese Methode hat {login, password} aus dem Request-Body gelesen;
- Zeile 15: [return ServerResponse.ok<LoginResult>(this.authService.login(req.user));] — erzeugt das JWT-Token und verpackt es in die standardmäßige [ServerResponse]<T>-Antwort – anders als die Antworten 401/403 der Guards (siehe oben) läuft eine erfolgreiche Anmeldung über diesen Umschlag.
4.8.11. src/auth/auth.module.ts
Das Modul, das alles rund um die Authentifizierung übernimmt. Es wird nur einmal von AppModule importiert.
Kommentieren wir diesen Code:
- Zeile 14: [TypeOrmModule.forFeature([User]),] — macht Repository<[User]> injizierbar (siehe repositories/user.repository.ts);
- Zeile 15: [PassportModule,] — deklariert 'jwt' als Standardstrategie für [AuthGuard]() ohne Argumente; unsere Guards geben weiterhin explizit [AuthGuard]('local')/AuthGuard('jwt') an, damit sie lesbar bleiben;
- Zeilen 16–19: [JwtModule.register({ secret: …, signOptions: { expiresIn: … } }),] — konfiguriert die Erzeugung und Überprüfung der Token: den geheimen Signaturschlüssel (JWT_SECRET, siehe .env) und ihre Gültigkeitsdauer (JWT_EXPIRES_IN, z. B. "2h");
- Zeilen 25–26: [LocalStrategy, JwtStrategy,] — registrieren die Strategien 'local' bzw. 'jwt' bei Passport; ohne diese Deklaration in `providers` [NestJS] könnte diese beiden Klassen nicht konstruieren.
4.9. Konfiguration und Start
4.9.1. package.json
Kommentieren wir diesen Code:
- Zeilen 7–13: [“scripts”: { … }] — die verfügbaren Befehle `npm run <name>`. start:dev (in diesem Dokument durchgehend verwendet) kompiliert den Server automatisch neu und startet ihn neu, sobald eine .ts-Datei geändert wird (die Option --watch der CLI von [NestJS], entspricht den devtools von Spring Boot). start:prod startet direkt das vorkompilierte JavaScript (dist/main.js), ohne die CLI und ohne erneutes Kompilieren – dieser Modus würde in der Produktion verwendet;
- Zeilen 14–31: [“dependencies”: { … }]— die Pakete, die zum Ausführen des Servers erforderlich sind. Sie enthält den Kern von [NestJS] ([@nestjs/common], [@nestjs/core], [@nestjs/platform-express]), das Integrationspaket für [TypeORM] ([@nestjs/typeorm], typeorm, mysql2 – der von [TypeORM] verwendete Treiber für [MySQL]), die Validierung per DTO (class-validator, class-transformer), das Lesen der .env-Datei (dotenv) und – durch die Authentifizierung hinzugekommen (siehe nächstes Kapitel) – [@nestjs/jwt] und [@nestjs/passport] (die [NestJS]-Integration von Passport.js), passport-jwt/passport-local (die beiden verwendeten Passport-Strategien) und bcryptjs (Passwort-Hashing);
- Zeilen 32–39: [“devDependencies”: { … }] — Pakete, die nur während der Entwicklung benötigt werden (Kompilierung, Typisierung) und nie in dist/ landen: die CLI von [NestJS] selbst ([@nestjs/cli]), der TypeScript-Compiler und die Typdefinitionen (@types/...) für JavaScript-Pakete, die diese nicht nativ mitbringen (bcryptjs, passport-jwt, passport-local).
Wie beim [Vue.js]-Client (siehe nächstes Kapitel) ist dies die Datei, die [npm install] liest (Kapitel 1), um zu bestimmen, was in node_modules/ heruntergeladen werden soll – das Äquivalent der pom.xml des ursprünglichen Spring-Projekts im Node/TypeScript-Ökosystem.
4.9.2. [tsconfig.json]
Kommentieren wir diesen Code:
- Zeile 3: [“module”: “commonjs”,] — das Format der durch die Kompilierung erzeugten JavaScript-Module; commonjs (require/module.exports) bleibt das von Node.js für diese Art von serverseitigem Projekt erwartete Format, im Gegensatz zum ESM-Format (natives import/export) auf der Client-Seite ([Vue.js]);
- Zeilen 6–7: [“emitDecoratorMetadata”: true, “experimentalDecorators”: true,] — die beiden unverzichtbaren Optionen für [NestJS] (und [TypeORM]): Sie aktivieren die Unterstützung für Dekoratoren ([@Controller](), [@Injectable](), [@Entity]() usw.) und stellen vor allem sicher, dass der Compiler zur Laufzeit den TYP jedes Konstruktorparameters erhält – diese Information liest [NestJS] , um selbst zu bestimmen, was zu injizieren ist (siehe Kapitel 2, Abschnitt über Dependency Injection). Ohne diese beiden Zeilen würde die Konstruktorinjektion schlicht nicht funktionieren;
- Zeile 9: [“target”: “ES2022”,]— die Version von JavaScript, die bei der Kompilierung erzeugt wird; ES2022 wird von den in diesem Kurs verwendeten Node.js-Versionen (20+) weitgehend unterstützt und erlaubt es, moderne JavaScript-Funktionen direkt im Quellcode zu verwenden (private Klassenfelder #x, Array.at() …);
- Zeile 16: [“strictNullChecks”: true,] — verlangt die explizite Behandlung von null-/undefined-Werten (mit ?, ??, einer if-Anweisung …) – eine der Optionen des Strict-Modus von TypeScript, die hier einzeln statt des vollständigen Strict-Modus aktiviert ist (Zeile 17: noImplicitAny bleibt auf false und ist damit permissiver): ein didaktischer Kompromiss, der den Kern der Typsicherheit bewahrt, ohne für jede Variable eine Typannotation zu verlangen.
4.9.3. nest-cli.json
Kommentieren wir diesen Code:
- Zeile 3: [“collection”: “@nestjs/schematics”,] — der Codegenerator, den die Befehle `nest generate ...` verwenden (in diesem Dokument nicht benutzt, da alle Dateien von Hand geschrieben wurden, aber für den weiteren Verlauf des Kurses verfügbar);
- Zeile 4: [“sourceRoot”: “src”,] — teilt der CLI von [NestJS] mit, wo sich der zu kompilierende Quellcode befindet – dadurch weiß sie zum Beispiel, dass der Einstiegspunkt [src/main.ts] ist;
- Zeile 6: [“deleteOutDir”: true] — Vor jeder Kompilierung wird der Ordner dist/ (Eintrag outDir in [tsconfig.json]) vollständig geleert: So bleibt eine aus einer inzwischen gelöschten .ts-Datei kompilierte .js-Datei nicht dauerhaft in dist/ liegen.
Diese Datei ist spezifisch für das [NestJS]-Ökosystem: Sie hat kein direktes Äquivalent in [Vue.js]-Projekten (siehe nächstes Kapitel), in denen vite.config.ts eine recht ähnliche Rolle spielt.
4.9.4. src/config/database.config.ts

Kommentieren wir diesen Code:
- Zeile 8: [export function getDatabaseConfig(): TypeOrmModuleOptions {] — entspricht der Klasse DomainAndPersitenceConfig des ursprünglichen Spring-Projekts, die einen DataSource definierte (Block @Bean). Hier gibt es keine Klasse: nur eine einfache Funktion, die ein Konfigurationsobjekt zurückgibt, das aus den Umgebungsvariablen gelesen wird (die Datei .env; siehe unten);
- Zeile 16: [entities: [Doctor, Client, Slot, Appointment, User],] — die Liste der Entitäten, die [TypeORM] verwalten muss – entspricht dem automatischen „Scan“ der [@Entity]-Klassen durch Spring Boot. [User] wurde mit der Einführung der Authentifizierung zu dieser Liste hinzugefügt: Würde man sie weglassen, käme es beim Start zu einem Fehler „no metadata found for [User]“;
- Zeile 17: [synchronize: false,] — in diesem Kurs immer vorhanden: Wäre `synchronize` auf `true` gesetzt, [TypeORM] würde das Datenbankschema automatisch anhand der Entitäten ändern – nützlich für einen Wegwerf-Prototyp, aber gefährlich, sobald echte Daten im Spiel sind (Gefahr von Datenverlust). Die Kontrolle über das Schema behalten wir über das Skript [database/dbrdvmedecins.sql];
- Zeile 18: [logging: process.env.NODE_ENV !== ‘production’,] — zeigt die von [TypeORM] erzeugten SQL-Abfragen in der Konsole an, genau wie die Hibernate-Logs im ursprünglichen Spring-Projekt.
4.9.5. [src/main.ts]

Kommentieren wir diesen Code:
- Zeile 1: [import ‘dotenv/config’;] — muss der allererste Import in dieser Datei sein: Sein einziger Zweck ist es, die Datei .env zu lesen und ihren Inhalt nach process.env zu kopieren, bevor irgendetwas anderes ausgewertet wird – insbesondere bevor app.module.ts (in Zeile 5 importiert) seinerseits database.config.ts und auth/auth.module.ts lädt, die beide process.env lesen, sobald sie geladen werden (DB_HOST, JWT_SECRET …). Ohne diese Zeile an genau dieser Stelle wäre eine auf der Festplatte vorhandene .env-Datei nutzlos: Die Variablen würden in process.env schlicht nicht existieren, wenn diese Module sie brauchen;
- Zeile 8: [const app = await NestFactory.create(AppModule);] — erstellt die Anwendung aus dem Wurzelmodul – das Äquivalent zu SpringApplication.run(Boot.class, args);
- Zeile 9: [app.enableCors();] — erlaubt dem [Vue.js]-Client (der auf einem anderen Port läuft), diesen Server aufzurufen. Ohne dies würde der Browser die Anfragen aus Sicherheitsgründen blockieren;
- Zeilen 10–15: [app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));] — prüft bei jeder eingehenden Anfrage automatisch, ob der JSON-Body dem erwarteten Format entspricht (siehe die mit class-validator dekorierten Klassen); `transform: true` wandelt Typen automatisch um (z. B. String "3" → Zahl 3), und `whitelist: true` entfernt aus den empfangenen Daten die Felder, die im `DTO` nicht deklariert sind;
- Zeile 16: [const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 8080;] — der Standardport 8080 ist derselbe wie beim ursprünglichen Spring-Boot-Server.
4.9.6. src/app.module.ts
Kommentieren wir diesen Code:
- Zeile 9: [TypeOrmModule.forRoot(getDatabaseConfig()),] — konfiguriert die globale Datenbankverbindung – entspricht dem @Bean DataSource im ursprünglichen Spring-Projekt;
- Zeile 10: [TypeOrmModule.forFeature([Doctor, Client, Slot, Appointment]),] — deklariert die in diesem Modul verwendeten Entitäten und macht ihre Repository<T> injizierbar (über [@InjectRepository]) in die Klassen in src/repositories/. [User] ist dort nicht aufgeführt: [AuthModule] (Zeile 11) deklariert sein eigenes TypeOrmModule.forFeature([User]) (siehe auth/auth.module.ts);
- Zeile 11: [AuthModule,] — bringt seine eigene Route (POST /login) und seine eigenen Provider (Passport-Strategien, JWT-Token …) mit – ein vollständiges [NestJS]-Modul statt direkt zu [AppModule] hinzugefügter Dateien, damit die Authentifizierung isoliert bleibt und sich leicht entfernen oder ersetzen lässt;
- Zeile 21: [{ provide: BUSINESS_TOKEN, useClass: BusinessService },] — [BusinessService] wird unter dem Token [BUSINESS_TOKEN] registriert, sodass jede Klasse, die [IBusiness] anfordert (über [@Inject]([BUSINESS_TOKEN])), eine Instanz von [BusinessService] erhält – ganz im Sinne der Schnittstelleninjektion von Spring (@Autowired [IBusiness] business).
4.9.7. .env.example
Kommentieren wir diesen Code:
- Zeile 1: [PORT=8080] — verwendet den Port des ursprünglichen Spring-Boot-Servers;
- Zeilen 11–12: [JWT_SECRET=… / JWT_EXPIRES_IN=2h] — die beiden neuen Variablen, die mit der Authentifizierung eingeführt wurden: der geheime Signaturschlüssel der Token (muss in der Produktion geändert werden – eine lange Zufallszeichenfolge, nie in die Versionsverwaltung eingecheckt) und ihre Gültigkeitsdauer.
Diese Datei ist nur ein Beispiel: Kopieren Sie sie nach .env (nie einchecken, da sie Geheimnisse enthalten kann) und passen Sie dann die Werte an Ihren Rechner an.
4.10. Durchgängige Überprüfung
Dieser Schritt wurde anhand von etwa zehn curl-Szenarien gegen eine Testkopie des Servers überprüft (In-Memory-Datenbank, vorab befüllt mit den beiden Konten admin/admin und user/user):
- POST /login mit den korrekten Zugangsdaten liefert korrekt { "status": 0, "data": { "accessToken": "...", "login": "admin", "name": "Administrator", "role": "ADMIN" } } zurück;
- POST /login mit einem falschen Passwort liefert 401 Unauthorized (natives JSON-Format von [NestJS], nicht der [ServerResponse]<T>-Umschlag);
- GET /getAllDoctors ohne Header Authorization liefert eine Antwort 401 Unauthorized;
- GET /getAllDoctors mit einem gültigen JWT-Token (admin oder user) liefert wie üblich die Liste der Ärzte im gewohnten [ServerResponse]<T>-Umschlag;
- POST /addAppointment mit dem Token von admin reserviert normal einen freien Zeitslot;
- POST /addAppointment mit dem Token von user liefert einen Fehler 403 Forbidden, mit der Meldung, dass die Rolle [USER] diese Aktion nicht erlaubt (erforderliche Rolle: ADMIN);
- POST /deleteAppointment verhält sich je nach Rolle des übergebenen Tokens symmetrisch zu /addAppointment.