Skip to content

4. Kapitel 3 - Der [NestJS]-Server für die Anwendung [RdvMedecins]

Dieses Kapitel beschreibt Datei für Datei den Inhalt des Ordners [rdvmedecins-nestjs-server], der diesem Dokument beiliegt. Es folgt dem in diesem Kurs durchgängig verwendeten Aufbau: dem 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 Struktur der Datenbank [dbrdvmedecins] entspricht der des ursprünglichen Dokuments (2014, Spring 4 / [MySQL] 5): dieselben Tabellen – [doctors], [clients], [slots], [appointments] –, dieselben Fremdschlüssel und dieselbe Eindeutigkeitsbedingung. Die einzige Neuerung, eingeführt durch den Schritt „Authentifizierung“ dieser Portierung: die Tabelle [users].

4.1.1. [database/dbrdvmedecins.sql]

  -- =========================================================================
-- Datenbank [dbrdvmedecins] - MySQL 8
  --
-- Dieses Skript bildet das relationale Schema des ursprünglichen Dokuments EXAKT nach
-- (2014, Spring 4 / Spring Data / MySQL 5): gleiche Tabellen, gleiche Spalten,
-- gleiche Fremdschlüssel, gleiche Eindeutigkeitsbedingung. Nur die Datenbank-Engine
-- ändert ihren Namen (MySQL 5 -> MySQL 8), nicht die Struktur.
  --
-- Die Tabelle [users] kommt jetzt hinzu (Schritt „Authentifizierung" dieser
-- Portierung). Das ursprüngliche Dokument verwendete DREI Tabellen (users, roles,
-- users_roles), damit ein Benutzer MEHRERE Rollen haben kann.
-- Da diese Anwendung nur zwei sich gegenseitig ausschließende Rollen kennt
-- (ADMIN, USER), vereinfachen wir hier auf eine einzelne Spalte [role]
-- in der Tabelle [users], statt die ursprüngliche Many-to-Many-
-- Beziehung nachzubauen - eine bewusste didaktische Vereinfachung, dokumentiert
-- im Kapitel „Authentifizierung" des Kurses.
 -- =========================================================================

-- bei jedem Ausführen des Skripts beginnen wir mit einer leeren Datenbank (praktisch in der Entwicklung)
 DROP TABLE IF EXISTS appointments;
 DROP TABLE IF EXISTS slots;
 DROP TABLE IF EXISTS clients;
 DROP TABLE IF EXISTS doctors;
 DROP TABLE IF EXISTS users;

 CREATE DATABASE IF NOT EXISTS dbrdvmedecins CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 USE dbrdvmedecins;

 CREATE TABLE doctors (
   id         INT AUTO_INCREMENT PRIMARY KEY,
   version    INT NOT NULL DEFAULT 0,
   title      VARCHAR(5)  NOT NULL,
   last_name  VARCHAR(20) NOT NULL,
   first_name VARCHAR(20) NOT NULL
 );

 CREATE TABLE clients (
   id         INT AUTO_INCREMENT PRIMARY KEY,
   version    INT NOT NULL DEFAULT 0,
   title      VARCHAR(5)  NOT NULL,
   last_name  VARCHAR(20) NOT NULL,
   first_name VARCHAR(20) NOT NULL
 );

 CREATE TABLE slots (
   id           INT AUTO_INCREMENT PRIMARY KEY,
   version      INT NOT NULL DEFAULT 0,
   doctor_id    INT NOT NULL,
   start_hour   INT NOT NULL,
   start_minute INT NOT NULL,
   end_hour     INT NOT NULL,
   end_minute   INT NOT NULL,
   CONSTRAINT fk_slots_doctor FOREIGN KEY (doctor_id) REFERENCES doctors(id)
 );

 CREATE TABLE appointments (
   id         INT AUTO_INCREMENT PRIMARY KEY,
   version    INT NOT NULL DEFAULT 0,
   day        DATE NOT NULL,
   slot_id    INT NOT NULL,
   client_id  INT NOT NULL,
   CONSTRAINT fk_appointments_slot   FOREIGN KEY (slot_id)   REFERENCES slots(id),
   CONSTRAINT fk_appointments_client FOREIGN KEY (client_id) REFERENCES clients(id),
   CONSTRAINT unq1_appointments UNIQUE (day, slot_id)
 );

 CREATE TABLE users (
   id       INT AUTO_INCREMENT PRIMARY KEY,
   version  INT NOT NULL DEFAULT 0,
   login    VARCHAR(30) NOT NULL UNIQUE,
   password VARCHAR(100) NOT NULL,
   name     VARCHAR(40) NOT NULL,
   role     VARCHAR(10) NOT NULL
 );

 INSERT INTO doctors (title, last_name, first_name) VALUES
   ('Mme', 'PELISSIER', 'Marie'), ('Mr', 'TATOU', 'Paul'), ('Melle','DUPONT', 'Sophie');

 INSERT INTO clients (title, last_name, first_name) VALUES
   ('Mr', 'MARTIN', 'Jean'), ('Mme', 'DURAND', 'Alice'),
   ('Melle','BISTROU', 'Brigitte'), ('Mr', 'GERMAN', 'Luc');

 INSERT INTO slots (doctor_id, start_hour, start_minute, end_hour, end_minute) VALUES
   (1, 8, 0, 8, 20), (1, 8, 20, 8, 40), /* ... */ (1, 11, 40, 12, 0);

 INSERT INTO slots (doctor_id, start_hour, start_minute, end_hour, end_minute) VALUES
   (2, 14, 0, 14, 20), (2, 14, 20, 14, 40), /* ... */ (2, 17, 40, 18, 0);

 INSERT INTO appointments (day, slot_id, client_id) VALUES (CURDATE(), 2, 3);

 INSERT INTO users (login, password, name, role) VALUES
   ('admin', '$2b$10$YSNBJXXHX9mp13nPZb6YGu8M1jR6uvPwO1s2X73z0QAqBR7TOQjoq', 'Administrator', 'ADMIN'),
   ('user',  '$2b$10$6Cvoion7AgJkpYHw5N0jMuWPf8T90J28En56kWBL9PT0bXt7lwW7.', 'User',          'USER');

Kommentieren wir diesen Code:

  • Zeilen 20–24: [DROP TABLE IF EXISTS …] – Das Skript beginnt bei jeder Ausführung mit einer leeren Datenbank, und zwar in umgekehrter Reihenfolge der Abhängigkeiten (beginnend mit `appointments`, das `[slots]` und `clients` referenziert, bis hin zu `users`, auf das niemand verweist): [MySQL] würde sich weigern, eine Tabelle zu löschen, die noch von einem Fremdschlüssel referenziert wird;
  • 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. Allein diese Einschränkung 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 Login-ID 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 (users, roles, users_roles) verwendete, 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 mehr als nötig gewesen;
  • Zeilen 91–93: [INSERT INTO users …] – zwei Demokonten, admin/admin (Rolle ADMIN) und user/user (Rolle USER), deren Passwörter bereits mit bcrypt gehasht sind (10 Salt-Runden) – niemals im Klartext, auch nicht in diesem Demo-Skript.

4.2. Schichtenorganisation

Der Server folgt der Schichtenstruktur des ursprünglichen Projekts:

Image

Jede Schicht kommuniziert nur mit der unmittelbar rechts neben ihr liegenden Schicht, [5-8]: So kommuniziert der Controller [5] zum Beispiel nie direkt mit 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

Image

1
2
3
4
5
6
7
8
9
  import { [PrimaryGeneratedColumn], [VersionColumn] } from 'typeorm';

  export abstract class AbstractEntity {
    @PrimaryGeneratedColumn()
    id: number;

    @VersionColumn()
    version: number;
  }

Kommentieren wir diesen Code:

  • Zeile 4: [@PrimaryGeneratedColumn()] – deklariert einen vom DBMS automatisch hochgezählten Primärschlüssel – das exakte Äquivalent von @Id + @GeneratedValue(strategy = GenerationType.AUTO) in JPA;
  • Zeile 7: [@VersionColumn()] – der [TypeORM]-eigene Mechanismus für optimistisches 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 zwischenzeitlich geändert) – das exakte Äquivalent von @Version in JPA/Hibernate;
  • Zeile 3: [export abstract class AbstractEntity {] – diese Klasse wird 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 ihre eigene Tabelle mit allen geerbten Spalten – das exakte Äquivalent von @MappedSuperclass in JPA.

4.3.2. src/entities/person.entity.ts

  import { [Column] } from 'typeorm';
  import { AbstractEntity } from './abstract.entity';

  export abstract class Person extends AbstractEntity {
    @Column({ length: 5 })
    title: string;

    @Column({ name: 'last_name', length: 20 })
    lastName: string;

   @Column({ name: 'first_name', length: 20 })
   firstName: string;
 }

Kommentieren wir diesen Code:

  • Zeile 4: [export abstract class Person extends AbstractEntity {] – fasst die Felder zusammen, die Arzt und Patient gemeinsam haben (Anrede, Nachname, Vorname), und erbt id/version ([AbstractEntity]). Wie ihre Elternklasse wird sie nicht mit [@Entity] dekoriert: Sie ist das Gegenstück ([TypeORM]) zur Klasse [Personne] – die ebenfalls @MappedSuperclass ist – aus dem ursprünglichen Projekt;
  • Zeilen 5, 8, 11: [@Column({ length: N })] / [@Column({ name: '...', length: N })] – drei Textspalten fester Länge (bei den letzten beiden mit einem expliziten Spaltennamen in snake_case, last_name / first_name), entsprechend [@Column](length = N) private String ... in JPA.

4.3.3. src/entities/doctor.entity.ts

1
2
3
4
5
6
7
8
9
  import { [Entity], [OneToMany] } from 'typeorm';
  import { Person } from './person.entity';
  import { Slot } from './slot.entity';

  @Entity({ name: 'doctors' })
  export class Doctor extends Person {
    @OneToMany(() => Slot, (slot) => slot.doctor)
    slots: Slot[];
  }

Kommentieren wir diesen Code:

  • Zeile 5: [@Entity({ name: 'doctors' })] – deklariert die Klasse als [TypeORM]-Entität, die in der Tabelle [doctors] gespeichert wird – das exakte Äquivalent von [@Entity] + @Table(name = "[doctors]") in JPA;
  • Zeile 6: [export class Doctor extends Person {] – erbt title/lastName/firstName (von [Person]) und id/version (von [AbstractEntity]), ohne sie neu deklarieren zu müssen;
  • Zeile 7: [@OneToMany(() => Slot, (slot) => slot.doctor)] – deklariert die inverse Beziehung „ein Arzt hat mehrere Zeitfenster“: eine Komfortfunktion für die Navigation, die im ursprünglichen Projekt fehlte (das sie nur in der anderen Richtung deklarierte, auf der Seite von [Creneau]), sich mit TypeORM aber leicht hinzufügen lässt.

4.3.4. src/entities/client.entity.ts

1
2
3
4
5
  import { [Entity] } from 'typeorm';
  import { Person } from './person.entity';

  @Entity({ name: 'clients' })
  export class Client extends Person {}

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. Zur Erinnerung an das Vokabular: [Client] bezeichnet hier einen Patienten der Arztpraxis (Vokabular aus der ursprünglichen Fachdomäne), nicht zu verwechseln mit dem „HTTP-Client“.

4.3.5. src/entities/slot.entity.ts

  import { [Column], [Entity], [JoinColumn], [ManyToOne], [RelationId] } from 'typeorm';
  import { AbstractEntity } from './abstract.entity';
  import { Doctor } from './doctor.entity';

  @Entity({ name: 'slots' })
  export class Slot extends AbstractEntity {
    @Column({ name: 'start_hour' }) startHour: number;
    @Column({ name: 'start_minute' }) startMinute: number;
    @Column({ name: 'end_hour' }) endHour: number;
   @Column({ name: 'end_minute' }) endMinute: number;

   @ManyToOne(() => Doctor, (doctor) => doctor.slots)
   @JoinColumn({ name: 'doctor_id' })
   doctor: Doctor;

   @RelationId((slot: Slot) => slot.doctor)
   doctorId: number;
 }

Gehen wir diesen Code im Einzelnen durch:

  • Zeilen 7–10: [@Column({ name: 'start_hour' }) startHour: number; …] – die vier zeitlichen Grenzen des Terminzeitfensters (Beginn und Ende nach Stunde/Minute), vier einfache Ganzzahlen, jeweils auf ihre snake_case-Spalte abgebildet (start_hour, start_minute, end_hour, end_minute);
  • Zeile 12: [@ManyToOne(() => Doctor, (doctor) => doctor.slots)] – mehrere Zeitfenster gehören zum selben Arzt. Standardmäßig lädt [TypeORM] die Beziehung „doctor“ beim Lesen eines Zeitfensters nicht (Standardverhalten „lazy“): Sie müssen sie ausdrücklich anfordern (Option relations: ['doctor'] in einer Abfrage) – genau 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 im ursprünglichen Projekt ([@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 zum Aufbau schlanker JSON-Antworten (siehe unten, die Web-Schicht).

Hinweis: Ein [@RelationId]-Feld ist eine virtuelle Spalte, die nachträglich von [TypeORM] berechnet wird – es ist keine echte SQL-Spalte, die in einer WHERE-Klausel eines „Query Builders“ verwendet werden kann (siehe unten, [SlotRepository]). Es dient ausschließlich dazu, den Wert des Fremdschlüssels abzurufen, sobald die Entität geladen wurde.

4.3.6. src/entities/appointment.entity.ts

  import { [Column], [Entity], [JoinColumn], [ManyToOne], [RelationId], [Unique] } from 'typeorm';
  import { AbstractEntity } from './abstract.entity';
  import { Client } from './client.entity';
  import { Slot } from './slot.entity';

  @Entity({ name: 'appointments' })
  @Unique('unq1_appointments', ['day', 'slot'])
  export class Appointment extends AbstractEntity {
    @Column({ type: 'date' })
   day: string;

   @ManyToOne(() => Client)
   @JoinColumn({ name: 'client_id' })
   client: Client;

   @ManyToOne(() => Slot)
   @JoinColumn({ name: 'slot_id' })
   slot: Slot;

   @RelationId((appointment: Appointment) => appointment.client)
   clientId: number;

   @RelationId((appointment: Appointment) => appointment.slot)
   slotId: number;
 }

Kommentieren wir diesen Code:

  • Zeile 7: [@Unique('unq1_appointments', ['day', 'slot'])] – greift auf der [TypeORM]-Seite die SQL-Einschränkung aus dem Datenbankskript auf. Beachten Sie: Hier wird der Name der Beziehung („slot“) referenziert, nicht das Feld [@RelationId] („slotId“) – Letzteres ist eine virtuelle Spalte, die [TypeORM] in einer @Unique-Einschränkung nicht akzeptiert. [TypeORM] bildet 'slot' selbst auf die tatsächliche Fremdschlüsselspalte (slot_id) ab;
  • Zeile 9: [@Column({ type: 'date' })] – Typ 'date' (nicht 'datetime'): Es wird nur der Tag gespeichert, nicht die Uhrzeit – genau wie TemporalType.DATE es 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 Äquivalente der Felder idClient/idCreneau des ursprünglichen Projekts (derselbe Mechanismus wie bei Slot.doctorId, siehe oben).

4.3.7. src/entities/user.entity.ts

  import { [Column], [Entity] } from 'typeorm';
  import { AbstractEntity } from './abstract.entity';

  export type Role = 'ADMIN' | 'USER';

  @Entity({ name: 'users' })
  export class User extends AbstractEntity {
    @Column()
    login: string;

   @Column()
   password: string;

   @Column()
   name: string;

   @Column()
   role: Role;
 }

Kommentieren wir diesen Code:

  • Zeile 4: [export type Role = ‘ADMIN’ | ‘USER’;] – eine einfache Union 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 [React] …);
  • Zeile 6: [@Entity({ name: 'users' })] – wie bei den anderen Entitäten eine eigene Tabelle;
  • Zeile 12: [password: string;] – speichert ein gehashtes Passwort (bcrypt), 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 bereits weiter oben in diesem Kapitel begegnet sind.

4.4. Geschäftsobjekte (src/domain/)

Image

Diese Klassen entsprechen keiner Datenbanktabelle: Sie werden zur Laufzeit aus der Kombination mehrerer Entitäten aufgebaut, um ein für die Anwendung nützliches Konzept darzustellen („der Terminkalender von Dr. Pelissier für den 13.09.2026“), das aber nicht als solches gespeichert werden muss. Entspricht demselben Unterordner (bzw. Paket) „domain“ im ursprünglichen Projekt.

4.4.1. src/domain/doctor-day-slot.ts

1
2
3
4
5
6
7
8
9
  import { [Slot] } from '[../entities/slot.entity]';
  import { Appointment } from '../entities/appointment.entity';

  export class DoctorDaySlot {
    constructor(
      public slot: Slot,
      public appointment: Appointment | null, // null, wenn der Zeitslot an diesem Tag frei ist
    ) {}
  }

Kommentieren wir diesen Code:

  • Zeile 4: [export class DoctorDaySlot {] – verknüpft ein Zeitfenster mit dem Termin, der in diesem Zeitfenster für einen bestimmten Tag möglicherweise vereinbart wurde;
  • Zeilen 5–8: [constructor(public slot: Slot, public appointment: Appointment | null) {}] – die Syntax [public] direkt in den Parametern des Konstruktors ist eine TypeScript-Abkürzung: Sie deklariert und initialisiert beide Eigenschaften jeweils in einer einzigen Zeile, ohne [this.slot = slot] separat schreiben zu müssen. [appointment] ist null, wenn das Zeitfenster frei ist.

4.4.2. src/domain/doctor-day-schedule.ts

  import { [Doctor] } from '[../entities/doctor.entity]';
  import { DoctorDaySlot } from './doctor-day-slot';

  export class DoctorDaySchedule {
    constructor(
      public doctor: Doctor,
      public day: string, // Format "yyyy-MM-dd"
      public doctorDaySlots: DoctorDaySlot[],
    ) {}
 }

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 in JSON für den [React]-Client 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-Interfaces des ursprünglichen Projekts (Paket rdvmedecins.repositories).

Image

Der wichtigste Unterschied zwischen Spring Data und [TypeORM]: Bei Spring Data genügte es, ein Interface zu deklarieren (extends CrudRepository<...>), um automatisch die grundlegenden Methoden zu erhalten (findAll, findOne, save, delete usw.) – Spring selbst generierte beim Start eine Klasse, die es implementierte. Mit [TypeORM] gibt es keine automatische Generierung einer Implementierung aus einem Interface: Wir injizieren direkt das generische Repository<Entity>, das von [TypeORM] bereitgestellt wird (über [@InjectRepository]), und schreiben die Methoden, die wir bereitstellen möchten, selbst – aufbauend auf den vordefinierten Methoden dieses Repository oder mit dem Query Builder für spezifischere Abfragen.

4.5.1. src/repositories/doctor.repository.ts

  import { Injectable } from '@nestjs/common';
  import { InjectRepository } from '@nestjs/typeorm';
  import { Repository } from 'typeorm';
  import { Doctor } from '../entities/doctor.entity';

  @Injectable()
  export class DoctorRepository {
    constructor(
      @InjectRepository(Doctor)
     private readonly repository: Repository<Doctor>,
   ) {}

   findAll(): Promise<Doctor[]> {
     return this.repository.find();
   }

   findById(id: number): Promise<Doctor | null> {
     return this.repository.findOneBy({ id });
   }
 }

Kommentieren wir diesen Code:

  • Zeile 9: [@InjectRepository(Doctor)] – weist [NestJS] an, das Repository<[Doctor]> bereitzustellen, das [TypeORM] für die Entität Doctor automatisch erzeugt hat. 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

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Client } from '../entities/client.entity';

@Injectable()
export class ClientRepository {
  constructor(
    @InjectRepository(Client)
    private readonly repository: Repository<Client>,
  ) {}

  findAll(): Promise<Client[]> {
    return this.repository.find();
  }

  findById(id: number): Promise<Client | null> {
    return this.repository.findOneBy({ id });
  }
}

Diese Datei entspricht im Prinzip genau dem [DoctorRepository] (siehe die Erläuterung oben), ist aber auf die Entität [Client] (einen Patienten) angewendet.

4.5.3. src/repositories/slot.repository.ts

  import { Injectable } from '@nestjs/common';
  import { InjectRepository } from '@nestjs/typeorm';
  import { Repository } from 'typeorm';
  import { Slot } from '../entities/slot.entity';

  @Injectable()
  export class SlotRepository {
    constructor(
      @InjectRepository(Slot)
     private readonly repository: Repository<Slot>,
   ) {}

   findAll(): Promise<Slot[]> {
     return this.repository.find();
   }

   findById(id: number): Promise<Slot | null> {
     return this.repository.findOneBy({ id });
   }

   getAllSlots(doctorId: number): Promise<Slot[]> {
     return this.repository
       .createQueryBuilder('s')
       .where('s.doctor = :doctorId', { doctorId })
       .orderBy('s.startHour', 'ASC')
       .addOrderBy('s.startMinute', 'ASC')
       .getMany();
   }
 }

Kommentieren wir diesen Code:

  • Zeilen 13–19: [findAll() / findById(id)] – identisch mit dem bereits in [DoctorRepository] gezeigten Prinzip;
  • Zeile 21: [getAllSlots(doctorId: number): Promise<Slot[]> {] – eine „benutzerdefinierte“ Abfrage, entsprechend der ursprünglichen JPQL-Abfrage select c from [Creneau] c where c.medecin.[id]=?1;
  • Zeile 23: [.createQueryBuilder(‘s’)] – der SQL-Alias s wird festgelegt, genau 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 angemerkt (slot.entity.ts), ist Letzteres keine Spalte, die in einem WHERE verwendet werden kann. Wenn die Beziehung mit einer Zahl verglichen wird, erkennt [TypeORM] , dass ihr Fremdschlüssel gemeint ist, und erzeugt das korrekte SQL ohne 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 vorhanden war.

4.5.4. src/repositories/appointment.repository.ts

  import { Injectable } from '@nestjs/common';
  import { InjectRepository } from '@nestjs/typeorm';
  import { Repository } from 'typeorm';
  import { Appointment } from '../entities/appointment.entity';

  @Injectable()
  export class AppointmentRepository {
    constructor(
      @InjectRepository(Appointment)
     private readonly repository: Repository<Appointment>,
   ) {}

   findById(id: number): Promise<Appointment | null> {
     return this.repository.findOne({
       where: { id },
       relations: ['client', 'slot'],
     });
   }

   save(appointment: Appointment): Promise<Appointment> {
     return this.repository.save(appointment);
   }

   async deleteById(id: number): Promise<void> {
     await this.repository.delete(id);
   }

   getDoctorDayAppointments(doctorId: number, day: string): Promise<Appointment[]> {
     return this.repository
       .createQueryBuilder('appointment')
       .leftJoinAndSelect('appointment.client', 'client')
       .leftJoinAndSelect('appointment.slot', 'slot')
       .where('slot.doctor = :doctorId', { doctorId })
       .andWhere('appointment.day = :day', { day })
       .getMany();
   }
 }

Kommentieren wir diesen Code:

  • Zeilen 13–18: [findById(id) { … relations: [‘client’, ‘slot’] }] – Beziehungen: [...] weist [TypeORM] ausdrücklich an, auch den zugehörigen Client und das Zeitfenster zu laden (zur Erinnerung: Diese Beziehungen sind standardmäßig im Modus „lazy“; siehe slot.entity.ts) – nützlich zum Aufbau der JSON-Antwort (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 des LEFT JOIN FETCH der ursprünglichen JPQL: Es ruft in einer einzigen SQL-Abfrage den zu jedem Termin gehörenden Client und das Zeitfenster ab;
  • Zeile 33: [.where(‘slot.doctor = :doctorId’, { doctorId })] – Bedingung für den Arzt, die über einen Join auf das Zeitfenster erreicht wird (rv.creneau.medecin.[id]=?1 in JPQL) – auch hier vergleichen wir die Beziehung „doctor“ und nicht das entsprechende [@RelationId]-Feld.

4.5.5. src/repositories/user.repository.ts

  import { Injectable } from '@nestjs/common';
  import { InjectRepository } from '@nestjs/typeorm';
  import { Repository } from 'typeorm';
  import { User } from '../entities/user.entity';

  @Injectable()
  export class UserRepository {
    constructor(
      @InjectRepository(User)
     private readonly repository: Repository<User>,
   ) {}

   findByLogin(login: string): Promise<User | null> {
     return this.repository.findOneBy({ login });
   }
 }

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 befinden sich die Geschäftsregeln der Anwendung – das Äquivalent des Pakets rdvmedecins.metier im ursprünglichen Projekt.

4.6.1. src/business/business.interface.ts

  import { Client } from '../entities/client.entity';
  import { Slot } from '../entities/slot.entity';
  import { Doctor } from '../entities/doctor.entity';
  import { Appointment } from '../entities/appointment.entity';
  import { DoctorDaySchedule } from '../domain/doctor-day-schedule';

  export interface IBusiness {
    getAllClients(): Promise<Client[]>;
    getAllDoctors(): Promise<Doctor[]>;
   getAllSlots(doctorId: number): Promise<Slot[]>;
   getDoctorDayAppointments(doctorId: number, day: string): Promise<Appointment[]>;
   getClientById(id: number): Promise<Client | null>;
   getDoctorById(id: number): Promise<Doctor | null>;
   getAppointmentById(id: number): Promise<Appointment | null>;
   getSlotById(id: number): Promise<Slot | null>;
   addAppointment(day: string, slot: Slot, client: Client): Promise<Appointment>;
   deleteAppointment(appointment: Appointment): Promise<void>;
   getDoctorDaySchedule(doctorId: number, day: string): Promise<DoctorDaySchedule | null>;
 }

 export const BUSINESS_TOKEN = 'IBusiness';

Kommentieren wir diesen Code:

  • Zeile 7: [export interface IBusiness {] – der Vertrag der Geschäftsschicht, unabhängig von ihrer Implementierung – das exakte Äquivalent des Java-Interfaces [IMetier] des ursprünglichen Projekts;
  • Zeilen 8–18: elf Methoden, jeweils eine pro 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 dieses Interface 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 Interfaces 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

  import { Injectable } from '@nestjs/common';
  import { IBusiness } from './business.interface';
  import { DoctorRepository } from '../repositories/doctor.repository';
  import { ClientRepository } from '../repositories/client.repository';
  import { SlotRepository } from '../repositories/slot.repository';
  import { AppointmentRepository } from '../repositories/appointment.repository';
  // ... Entitäten und importierte Geschäftsobjekte (siehe oben)

  @Injectable()
 export class BusinessService implements IBusiness {
   constructor(
     private readonly doctorRepository: DoctorRepository,
     private readonly clientRepository: ClientRepository,
     private readonly slotRepository: SlotRepository,
     private readonly appointmentRepository: AppointmentRepository,
   ) {}

   getAllClients(): Promise<Client[]> { return this.clientRepository.findAll(); }
   getAllDoctors(): Promise<Doctor[]> { return this.doctorRepository.findAll(); }
   getAllSlots(doctorId: number): Promise<Slot[]> {
     return this.slotRepository.getAllSlots(doctorId);
   }
   // ... 5 weitere einfache Delegationsmethoden (gleiches Prinzip)

   addAppointment(day: string, slot: Slot, client: Client): Promise<Appointment> {
     const appointment = new Appointment();
     appointment.day = day;
     appointment.slot = slot;
     appointment.client = client;
     return this.appointmentRepository.save(appointment);
   }

   async deleteAppointment(appointment: Appointment): Promise<void> {
     await this.appointmentRepository.deleteById(appointment.id);
   }

   async getDoctorDaySchedule(doctorId: number, day: string): Promise<DoctorDaySchedule | null> {
     const doctor = await this.getDoctorById(doctorId);
     if (doctor === null) {
       return null;
     }
     const timeSlots = await this.getAllSlots(doctorId);
     const bookings = await this.getDoctorDayAppointments(doctorId, day);

     const hBookings = new Map<number, Appointment>();
     for (const booking of bookings) {
       hBookings.set(booking.slotId, booking);
     }

     const doctorDaySlots = timeSlots.map((slot) => {
       const appointment = hBookings.get(slot.id) ?? null;
       return new DoctorDaySlot(slot, appointment);
     });

     return new DoctorDaySchedule(doctor, day, doctorDaySlots);
   }
 }

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 bei Bedarf injizieren kann;
  • Zeilen 11–16: [constructor(private readonly doctorRepository: …, …) {}] – Injektion der vier DAO-Instanzen, entsprechend den vier @Autowired-Feldern im ursprünglichen Projekt. [NestJS] wählt hier die Konstruktorinjektion statt der Feldinjektion (wie @Autowired sie bei einem Java-Feld vornimmt): Dies ist der empfohlene Ansatz in TypeScript; er macht 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; allein die SQL-Einschränkung unq1_appointments (siehe oben, das Datenbankskript) verhindert eine doppelte Buchung – hier wird keine ausdrückliche Prüfung durchgeführt; ein Duplikatversuch 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 tatsächliche Geschäftslogik ausführt (die anderen delegieren nur): Sie berechnet den vollständigen Terminkalender eines Arztes für einen bestimmten Tag. Der Algorithmus wird in drei Schritten exakt wie im ursprünglichen Dokument wiedergegeben;
  • Zeile 42: [const timeSlots = await this.getAllSlots(doctorId);] – 1. alle verfügbaren 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 nach der ID des Zeitfensters indizierten Dictionary abgelegt, 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 des Pakets [rdvmedecins.web] im ursprünglichen Projekt.

Image

4.7.1. src/web/models/response.model.ts

  export enum ResponseStatus {
    OK = 0,
    RESOURCE_NOT_FOUND = 1,
    INVALID_DATE = 2,
    SERVER_ERROR = 3,
  }

  export class ServerResponse<T = unknown> {
    status: ResponseStatus;
   data: T | null;

   constructor(status: ResponseStatus, data: T | null) {
     this.status = status;
     this.data = data;
   }

   static ok<T>(data: T): ServerResponse<T> {
     return new ServerResponse<T>(ResponseStatus.OK, data);
   }

   static error<T = unknown>(status: ResponseStatus, data: T | null = null): ServerResponse<T> {
     return new ServerResponse<T>(status, data);
   }
 }

Kommentieren wir diesen Code:

  • Zeilen 1–6: [export enum ResponseStatus { … }] – das ursprüngliche Spring-Projekt verwendete „Ad-hoc“-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 leichter zu erlernen und zu pflegen ist: 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 Webdienstes: { "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 `Object`-Typ nicht so einfach;
  • Zeilen 17–19: [static ok(data: T): ServerResponse {] – eine kleine statische „Factory“-Methode für besser lesbaren Controller-Code (ServerResponse.ok([doctors]) statt new [ServerResponse](ResponseStatus.OK, [doctors]));
  • Zeilen 21–23: [static error<T = unknown>(status: ResponseStatus, data: T | null = null): ServerResponse {] – ihr Gegenstück für Fehlerantworten.

4.7.2. src/web/models/post-add-appointment.dto.ts

  import { IsDateString, IsInt } from 'class-validator';

  export class PostAddAppointmentDto {
    @IsDateString()
    day: string;

    @IsInt()
    clientId: number;

   @IsInt()
   slotId: number;
 }

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 es ist, das Format der ausgetauschten Daten zu beschreiben, ohne jede Logik;
  • Zeile 4: [@IsDateString()] – prüft, ob die empfangene Zeichenkette tatsächlich ein gültiges Datum im ISO-Format ist. Ist dies nicht der Fall, gibt [NestJS] automatisch einen HTTP-400-Fehler (Bad [Request]) zurück, bevor der Controller ausgeführt wird – dank der globalen Pipe [ValidationPipe] , die in [main.ts] deklariert ist (siehe unten);
  • Zeilen 7, 10: [@IsInt()] – prüft, ob der empfangene Wert tatsächlich eine Ganzzahl ist. Diese Dekoratoren sind in Kombination 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

1
2
3
4
5
6
import { IsInt } from 'class-validator';

export class PostDeleteAppointmentDto {
  @IsInt()
  appointmentId: number;
}

Dasselbe Prinzip wie bei [PostAddAppointmentDto] oben, für den JSON-Body, den /deleteAppointment erwartet ({ appointmentId }).

4.7.4. src/web/helpers/static.helper.ts

  import { Slot } from '../../entities/slot.entity';
  import { Appointment } from '../../entities/appointment.entity';

  export function getErrorsForException(exception: unknown): string[] {
    const errors: string[] = [];
    let cause: unknown = exception;
    while (cause instanceof Error) {
      errors.push(cause.message);
      cause = cause.cause;
   }
   if (errors.length === 0) {
     errors.push(String(exception));
   }
   return errors;
 }

 export interface SlotJson {
   id: number; startHour: number; startMinute: number; endHour: number; endMinute: number;
 }

 export function getMapForSlot(slot: Slot | null | undefined): SlotJson | null {
   if (!slot) { return null; }
   return {
     id: slot.id, startHour: slot.startHour, startMinute: slot.startMinute,
     endHour: slot.endHour, endMinute: slot.endMinute,
   };
 }

 export function getListMapForSlots(slots: Slot[]): SlotJson[] {
   return slots.map((slot) => getMapForSlot(slot) as SlotJson);
 }

 export interface AppointmentJson {
   id: number;
   day: string;
   client: { id: number; title: string; lastName: string; firstName: string } | null;
   slot: SlotJson | null;
 }

 export function getMapForAppointment(appointment: Appointment | null | undefined): AppointmentJson | null {
   if (!appointment) { return null; }
   return {
     id: appointment.id,
     day: appointment.day,
     client: appointment.client
       ? { id: appointment.client.id, title: appointment.client.title, lastName: appointment.client.lastName, firstName: appointment.client.firstName }
       : null,
     slot: getMapForSlot(appointment.slot),
   };
 }

 export function getListMapForAppointments(appointments: Appointment[]): AppointmentJson[] {
   return appointments.map((appointment) => getMapForAppointment(appointment) as AppointmentJson);
 }

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) haben Fehler ebenfalls eine Kette von Ursachen, über die Eigenschaft `cause`;
  • Zeilen 6–10: [while (cause instanceof Error) { … cause = cause.cause; }] – dies wird auf dieselbe Weise wie im ursprünglichen Java-Code verarbeitet, 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, wenn sie geladen wird, 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 „benutzerdefiniertes“ Objekt, das nur die für die Anzeige benötigten Felder enthält;
  • Zeile 21: [export function getMapForSlot(slot: Slot | null | undefined): SlotJson | null {] – entspricht Static.getMapForCreneau([Creneau] creneau): wandelt eine Entität in ein schlankes JSON-Objekt um;
  • Zeile 29: [export function getListMapForSlots(slots: Slot[]): SlotJson[] {] – das Gegenstück für eine ganze Liste (entspricht Static.getListMapForCreneaux);
  • Zeilen 33–38, 40–50, 52–54: [AppointmentJson / getMapForAppointment / getListMapForAppointments] – dasselbe Prinzip, angewendet auf Termine: Auch der eingebettete Client (appointment.client) wird auf die für die Anzeige benötigten Felder reduziert.

4.7.5. src/web/application-model.service.ts

  import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
  import { IBusiness, BUSINESS_TOKEN } from '../business/business.interface';
  // ... Entitäten, DoctorDaySchedule, getErrorsForException (siehe oben)

  @Injectable()
  export class ApplicationModelService implements IBusiness, OnModuleInit {
    private doctors: Doctor[] = [];
    private clients: Client[] = [];
    private messages: string[] | null = null;

   constructor(@Inject(BUSINESS_TOKEN) private readonly business: IBusiness) {}

   async onModuleInit(): Promise<void> {
     try {
       this.doctors = await this.business.getAllDoctors();
       this.clients = await this.business.getAllClients();
     } catch (ex) {
       this.messages = getErrorsForException(ex);
     }
   }

   getMessages(): string[] | null {
     return this.messages;
   }

   async getAllClients(): Promise<Client[]> { return this.clients; }
   async getAllDoctors(): Promise<Doctor[]> { return this.doctors; }

   getAllSlots(doctorId: number): Promise<Slot[]> {
     return this.business.getAllSlots(doctorId);
   }
   // ... 6 weitere Methoden, einfache Delegation an this.business
 }

Kommentieren wir diesen Code:

  • Zeile 6: [export class ApplicationModelService implements IBusiness, OnModuleInit {] – entspricht der Klasse ApplicationModel im ursprünglichen Projekt: ein Cache, der einmalig beim Start des Servers aufgebaut wird und die Liste der Ärzte und Clients im Speicher hält (kurze Listen, die sich selten ändern, sodass sie nicht bei jeder Anfrage aus der Datenbank abgefragt werden müssen). Diese Klasse erfüllt wie das Original zwei Aufgaben: einerseits ein Cache und andererseits ein einziger Einstiegspunkt vom Controller in die Geschäftsschicht – wenn die Caching-Strategie jemals geändert wird, muss nur diese Datei angepasst werden;
  • Zeile 11: [constructor(@Inject(BUSINESS_TOKEN) private readonly business: IBusiness) {}] – hier wird das Interface [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 das „Lifecycle“-Interface von [NestJS], das exakt 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 Server abstürzen zu lassen – 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 andere (Zeile 29 und folgende) wird einfach an die Geschäftsschicht delegiert.

4.7.6. src/web/rdvmedecins.controller.ts

RdvMedecinsController deklariert die elf Routen der Anwendung, die bewusst denen des ursprünglichen Dokuments entsprechen (/getAllDoctors, /addAppointment … , englische Entsprechungen von /getAllMedecins, /ajouterRv …) und nicht im REST-Stil „modernisiert“ wurden (/doctors, /clients/:id …) – Zweck dieses Dokuments ist es, die beiden Implementierungen zu vergleichen, nicht die API zu modernisieren.

  import { Body, Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
  import { ApplicationModelService } from './application-model.service';
  import { ServerResponse, ResponseStatus } from './models/response.model';
  import { PostAddAppointmentDto } from './models/post-add-appointment.dto';
  import { PostDeleteAppointmentDto } from './models/post-delete-appointment.dto';
  import { getErrorsForException, getListMapForSlots, getListMapForAppointments, getMapForAppointment } from './helpers/static.helper';
  // ... Entitäten
  import { JwtAuthGuard } from '../auth/jwt-auth.guard';
  import { RolesGuard } from '../auth/roles.guard';
 import { Roles } from '../auth/roles.decorator';

 @UseGuards(JwtAuthGuard)
 @Controller()
 export class RdvMedecinsController {
   constructor(private readonly application: ApplicationModelService) {}

   @Get('getAllDoctors')
   async getAllDoctors(): Promise<ServerResponse<Doctor[]>> {
     const messages = this.application.getMessages();
     if (messages !== null) {
       return new ServerResponse(ResponseStatus.SERVER_ERROR, messages as unknown as Doctor[]);
     }
     try {
       return ServerResponse.ok(await this.application.getAllDoctors());
     } catch (e) {
       return ServerResponse.error(ResponseStatus.SERVER_ERROR, getErrorsForException(e) as unknown as Doctor[]);
     }
   }

   // ... getAllClients: gleiches Prinzip, auf Client

   @Get('getAllSlots/:doctorId')
   async getAllSlots(@Param('doctorId') doctorId: string) {
     const id = Number(doctorId);
     const doctor = await this.application.getDoctorById(id);
     if (doctor === null) {
       return ServerResponse.error(ResponseStatus.RESOURCE_NOT_FOUND);
     }
     try {
       const slots = await this.application.getAllSlots(doctor.id);
       return ServerResponse.ok(getListMapForSlots(slots));
     } catch (e) {
       return ServerResponse.error(ResponseStatus.SERVER_ERROR, getErrorsForException(e));
     }
   }

   // ... getDoctorAppointmentsOfDay/:doctorId/:day: prüft isValidDate(day), danach gleiches Prinzip

   @Get('getDoctorScheduleOfDay/:doctorId/:day')
   async getDoctorScheduleOfDay(@Param('doctorId') doctorId: string, @Param('day') day: string) {
     if (!isValidDate(day)) {
       return ServerResponse.error(ResponseStatus.INVALID_DATE);
     }
     try {
       const schedule = await this.application.getDoctorDaySchedule(Number(doctorId), day);
       if (schedule === null) {
         return ServerResponse.error(ResponseStatus.RESOURCE_NOT_FOUND);
       }
       return ServerResponse.ok({
         doctor: schedule.doctor,
         day: schedule.day,
         slots: schedule.doctorDaySlots.map((s) => ({
           slot: { id: s.slot.id, startHour: s.slot.startHour, startMinute: s.slot.startMinute, endHour: s.slot.endHour, endMinute: s.slot.endMinute },
           appointment: getMapForAppointment(s.appointment),
         })),
       });
     } catch (e) {
       return ServerResponse.error(ResponseStatus.SERVER_ERROR, getErrorsForException(e));
     }
   }

   // ... getDoctorById/:id, getClientById/:id, getSlotById/:id, getAppointmentById/:id:
   // vier ähnliche Methoden, die eine Entität anhand der ID suchen, andernfalls RESOURCE_NOT_FOUND

   @UseGuards(RolesGuard)
   @Roles('ADMIN')
   @Post('addAppointment')
   async addAppointment(@Body() post: PostAddAppointmentDto) {
     const client = await this.application.getClientById(post.clientId);
     if (client === null) {
       return ServerResponse.error(ResponseStatus.RESOURCE_NOT_FOUND);
     }
     const slot = await this.application.getSlotById(post.slotId);
     if (slot === null) {
       return ServerResponse.error(ResponseStatus.RESOURCE_NOT_FOUND);
     }
     try {
       const appointment = await this.application.addAppointment(post.day, slot, client);
       return ServerResponse.ok(getMapForAppointment(appointment));
     } catch (e) {
       return ServerResponse.error(ResponseStatus.SERVER_ERROR, getErrorsForException(e));
     }
   }

   @UseGuards(RolesGuard)
   @Roles('ADMIN')
   @Post('deleteAppointment')
   async deleteAppointment(@Body() post: PostDeleteAppointmentDto) {
     const appointment = await this.application.getAppointmentById(post.appointmentId);
    if (appointment === null) {
      return ServerResponse.error(ResponseStatus.RESOURCE_NOT_FOUND);
    }
    try {
      await this.application.deleteAppointment(appointment);
      return ServerResponse.ok(null);
    } catch (e) {
      return ServerResponse.error(ResponseStatus.SERVER_ERROR, getErrorsForException(e));
    }
  }
 }

 function isValidDate(day: string): boolean {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) {
     return false;
   }
   const date = new Date(`${day}T00:00:00Z`);
   return date.toISOString().slice(0, 10) === day;
 }

Kommentieren wir diesen Code:

  • Zeile 12: [@UseGuards(JwtAuthGuard)] – auf die Klasse angewendet, schützt es alle elf Routen dieses Controllers auf einmal: Ohne ein gültiges JWT-Token ist keine davon zugänglich (siehe unten das Kapitel „Authentifizierung“). Das entspricht der ursprünglichen Spring-Security-Regel .antMatchers("/**").hasRole("ADMIN"), nur dass hier lediglich verlangt wird, authentifiziert zu sein (beliebige 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 von Cache/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') liest das Segment {doctorId} aus der URL als String aus (ähnlich wie @PathVariable(String) in Spring); wir wandeln es selbst in eine Zahl um (Zeile 34), während Spring dies für einen als `long` deklarierten Parameter automatisch erledigt hätte;
  • Zeilen 35–38: [const doctor = await this.application.getDoctorById(id); if (doctor === null) { … }] — wir rufen zuerst 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')] — zusätzlich zur Authentifizierung (die bereits durch [@UseGuards]([JwtAuthGuard]) für die Klasse verlangt wird) benötigen Sie hier die Rolle ADMIN – 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] ein gültiges Datum ist und dass post.clientId/post.slotId tatsächlich ganze Zahlen sind. Die SQL-Constraint unq1_appointments (day, slot_id) verhindert, dass für dasselbe Zeitfenster am selben Tag zwei Reservierungen vorgenommen werden: Ein doppelter Versuch löst eine Exception aus, die hier abgefangen wird, genau wie die SQLException des ursprünglichen JDBC-Treibers;
  • Zeile 95: dieselbe 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, entsprechend dem Paar SimpleDateFormat("yyyy-MM-dd") + setLenient(false) aus dem ursprünglichen Code, das zum Beispiel „2026-13-40“ (ungültiger Monat und Tag) zurückwies: Date.toISOString() rekonstruiert das Datum aus dem empfangenen String – weicht es von der Eingabe ab, hat das Datum nicht existiert.

4.8. Authentifizierung (src/auth/)

Image

Dieser Abschnitt dokumentiert die Ergänzung der tokenbasierten Authentifizierung (JWT) und der rollenbasierten Zugriffskontrolle (ADMIN/USER) in dieser Phase des Kurses – das funktionale Äquivalent der Spring-Security-Schicht des ursprünglichen Dokuments, neu umgesetzt mit Standardwerkzeugen des [NestJS]-Ökosystems: [@nestjs/passport] und @nestjs/jwt.

Zwei bewusste Unterschiede zum ursprünglichen Projekt, die hier ein für alle Mal dokumentiert werden:

  1. 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. Dieser Port verwendet stattdessen einen Token: JWT (JSON Web Token). Das Passwort wird nur einmal übermittelt, nämlich beim Login (POST /login); der Server liefert dann einen signierten Token zurück, den 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 in der Schlussfolgerung des vorherigen Kapitels erwähnt.
  2. Eine Rolle pro Benutzer, eine einzige Datenbankspalte, statt der Many-to-many-Beziehung (users/roles/users_roles) des ursprünglichen Projekts – 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 behandelt (durch einen Guard), während [ServerResponse]<T> vom Controller für fachliche Fehler erzeugt wird (Ressource nicht gefunden, ungültiges Datum usw.). Der [React]-Client muss daher zwischen diesen beiden Arten von Fehlerantworten unterscheiden (siehe nächstes Kapitel, auth.interceptor.ts).

4.8.1. src/auth/dto/login.dto.ts

import { IsNotEmpty, IsString } from 'class-validator';

export class LoginDto {
  @IsString()
  @IsNotEmpty()
  login: string;

  @IsString()
  @IsNotEmpty()
  password: string;
}

Kommentieren wir diesen Code:

  • Zeile 3: [export class LoginDto {] — beschreibt das Format des JSON-Bodys, den POST /login erwartet ({ login, password }); 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 Strings sind.

Dieses DTO dient hier einem rein informativen Zweck: Tatsächlich liest [LocalStrategy] (siehe unten) {login, password} aus dem Request-Body, nicht ein [@Body]-Parameter ([LoginDto]) des Controllers. Dennoch [LoginDto] zeigt dem Leser das genaue Format, das diese Route erwartet.

4.8.2. src/auth/login-result.model.ts

1
2
3
4
5
6
7
8
  import { Role } from '../entities/user.entity';

  export interface LoginResult {
    accessToken: string;
    login: string;
    name: string;
    role: Role;
  }

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;] — der JWT-Token, der in jede weitere Anfrage eingefügt werden muss;
  • Zeile 7: [role: Role;] — die Rolle des angemeldeten Benutzers, damit der [React]-Client seine Oberfläche anpassen kann (siehe nächstes Kapitel: Die Schaltflächen „Reservieren“/„Stornieren“ werden für die Rolle USER ausgeblendet).

4.8.3. src/auth/local.strategy.ts

Eine Passport-„Strategie“ beschreibt, wie eine Anfrage authentifiziert wird. [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 danach [JwtStrategy] (siehe unten), nicht diese.

  import { Injectable, UnauthorizedException } from '@nestjs/common';
  import { PassportStrategy } from '@nestjs/passport';
  import { Strategy } from 'passport-local';
  import { AuthService } from './auth.service';
  import { User } from '../entities/user.entity';

  @Injectable()
  export class LocalStrategy extends PassportStrategy(Strategy) {
    constructor(private readonly authService: AuthService) {
     super({ usernameField: 'login', passwordField: 'password' });
   }

   async validate(login: string, password: string): Promise<User> {
     const user = await this.authService.validateUser(login, password);
     if (user === null) {
       throw new UnauthorizedException('incorrect login or password');
     }
     return user;
   }
 }

Gehen wir diesen Code im Einzelnen durch:

  • Zeile 8: [export class LocalStrategy extends PassportStrategy(Strategy) {] — konzeptionell äquivalent zur Klasse AppUserDetailsService des ursprünglichen Spring-Security-Projekts: „Gegeben sind Anmeldedaten; sag mir, wer dieser Benutzer ist“;
  • Zeile 10: [super({ usernameField: ‘login’, passwordField: ‘password’ });] — standardmäßig erwartet passport-local Felder mit den Namen „username“ und „password“ im Request-Body; hier benennen wir sie passend zu unserem DTO um ([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 einen JWT-Token aus dem HTTP-Header Authorization: Bearer <token> jeder Anfrage lesen, seine Signatur prüfen und die Identität des Benutzers extrahieren – ohne jemals die Datenbank abzufragen (der Token enthält bereits alles Nötige). Dies ist der Mechanismus, der die elf Routen von RdvMedecinsController schützt.

  import { Injectable } from '@nestjs/common';
  import { PassportStrategy } from '@nestjs/passport';
  import { ExtractJwt, Strategy } from 'passport-jwt';

  export interface JwtPayload {
    sub: number;
    login: string;
    role: 'ADMIN' | 'USER';
  }

 export interface ConnectedUser {
   userId: number;
   login: string;
   role: 'ADMIN' | 'USER';
 }

 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
   constructor() {
     super({
       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
       ignoreExpiration: false,
       secretOrKey: process.env.JWT_SECRET ?? 'dev-secret-to-change-in-production',
     });
   }

   validate(payload: JwtPayload): ConnectedUser {
     return { userId: payload.sub, login: payload.login, role: payload.role };
   }
 }

Kommentieren wir diesen Code:

  • Zeilen 5–9: [export interface JwtPayload { sub: number; login: string; role: … }] — das Format der Informationen, die wir im JWT-Token bei dessen Erzeugung ablegen (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 { … }] — das, was request.user in den Handlern enthält, sobald der Token geprüft wurde;
  • Zeile 18: [export class JwtStrategy extends PassportStrategy(Strategy, ‘jwt’) {] — das zweite Argument 'jwt' benennt diese Strategie (anders als [LocalStrategy], die keinen Namen angab): Dies ist der Name, über den [JwtAuthGuard] ([AuthGuard]('jwt'), siehe unten) angibt: „Verwende diese Strategie“;
  • Zeile 21: [jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),] — der Token wird im Header Authorization: Bearer xxx erwartet;
  • Zeile 22: [ignoreExpiration: false,] — ist der Token abgelaufen, lehnt Passport ihn ab (401), noch bevor validate() aufgerufen wird;
  • Zeile 23: [secretOrKey: process.env.JWT_SECRET ?? ‘…’] — der geheime Schlüssel, mit dem die Signatur des Tokens geprüft wird – derselbe, mit dem er signiert wurde (siehe auth.module.ts, das ihn aus derselben Umgebungsvariablen JWT_SECRET liest);
  • Zeile 27: [validate(payload: JwtPayload): ConnectedUser {] — wird von Passport automatisch aufgerufen, sobald die Signatur des Tokens geprüft wurde; wandelt den Inhalt des Tokens in request.user um.

4.8.5. src/auth/local-auth.guard.ts

1
2
3
4
5
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {}

Gehen wir diesen Code im Einzelnen durch:

  • 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], die in ihrem eigenen Konstruktor keinen expliziten Namen erhalten hat). Dieser Guard wird nur von der Route POST /login verwendet (siehe auth.controller.ts).

4.8.6. src/auth/jwt-auth.guard.ts

1
2
3
4
5
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

Kommentieren wir diesen Code:

  • Zeile 5: [export class JwtAuthGuard extends AuthGuard(‘jwt’) {}] — der Guard, der die elf Routen von RdvMedecinsController schützt: Er verlangt einen gültigen 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

1
2
3
4
5
import { SetMetadata } from '@nestjs/common';
import { Role } from '../entities/user.entity';

export const ROLES_KEY = 'roles';
export const Roles = (...roles: Role[]) => SetMetadata(ROLES_KEY, roles);

Kommentieren wir diesen Code:

  • Zeile 5: [export const Roles = (…roles: Role[]) => SetMetadata(ROLES_KEY, roles);] — [@Roles]('ADMIN') ist ein benutzerdefinierter Dekorator (wir schreiben ihn selbst, im Gegensatz zu @Get, @Post und @Injectable, die von [NestJS] bereitgestellt werden): Er hängt lediglich Metadaten („diese Methode erfordert die und die Rolle“) an die Methode an, die er dekoriert, ohne selbst eine Prüfung durchzuführen – [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 nur, ob der Benutzer ordnungsgemäß authentifiziert ist (gültiger JWT-Token); [RolesGuard] prüft zusätzlich, ob die Rolle des angemeldeten Benutzers zu den Rollen gehört, die [@Roles](...) an der Zielmethode verlangt.

  import { CanActivate, ExecutionContext, ForbiddenException, Injectable } from '@nestjs/common';
  import { Reflector } from '@nestjs/core';
  import { ROLES_KEY } from './roles.decorator';
  import { Role } from '../entities/user.entity';
  import { ConnectedUser } from './jwt.strategy';

  @Injectable()
  export class RolesGuard implements CanActivate {
    constructor(private readonly reflector: Reflector) {}

   canActivate(context: ExecutionContext): boolean {
     const requiredRoles = this.reflector.getAllAndOverride<Role[]>(ROLES_KEY, [
       context.getHandler(),
       context.getClass(),
     ]);

     if (!requiredRoles || requiredRoles.length === 0) {
       return true;
     }

     const request = context.switchToHttp().getRequest<{ user: ConnectedUser }>();
     const user = request.user;

     if (!requiredRoles.includes(user.role)) {
       throw new ForbiddenException(
         `role [${user.role}] does not allow this action (required role: ${requiredRoles.join(', ')})`,
       );
     }
     return true;
   }
 }

Kommentieren wir diesen Code:

  • Zeile 8: [export class RolesGuard implements CanActivate {] — konzeptionell äquivalent zur Spring-Security-Regel http.authorizeRequests().antMatchers(...).hasRole("ADMIN"), die hier jedoch Methode für Methode statt URL für URL angewendet wird, dank des Dekoratorpaars ([@Roles]) + [Reflector] (der die von einem Dekorator gesetzten Metadaten wieder auslesen 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] hingegen 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 Rollen, 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: das Prüfen eines Paars aus Benutzername und Passwort sowie das Erzeugen des JWT-Tokens, der an den Client zurückgesendet wird, sobald der Benutzer validiert ist.

  import { Injectable } from '@nestjs/common';
  import { JwtService } from '@nestjs/jwt';
  import * as bcrypt from 'bcryptjs';
  import { UserRepository } from '../repositories/user.repository';
  import { User } from '../entities/user.entity';
  import { LoginResult } from './login-result.model';
  import { JwtPayload } from './jwt.strategy';

  @Injectable()
 export class AuthService {
   constructor(
     private readonly userRepository: UserRepository,
     private readonly jwtService: JwtService,
   ) {}

   async validateUser(login: string, password: string): Promise<User | null> {
     const user = await this.userRepository.findByLogin(login);
     if (user === null) {
       return null;
     }
     const passwordCorrect = await bcrypt.compare(password, user.password);
     return passwordCorrect ? user : null;
   }

   login(user: User): LoginResult {
     const payload: JwtPayload = { sub: user.id, login: user.login, role: user.role };
     return {
       accessToken: this.jwtService.sign(payload),
       login: user.login,
       name: user.name,
       role: user.role,
     };
   }
 }

Kommentieren wir diesen Code:

  • Zeile 10: [export class AuthService {] — konzeptionell äquivalent zur 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, ob ein Benutzer mit diesem Login existiert und ob 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 demselben 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 den JWT-Token für einen bereits authentifizierten Benutzer (aufgerufen von [AuthController], sobald LocalAuthGuard und 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. Dies ist die einzige Route der gesamten Anwendung, die nicht bereits einen JWT-Token verlangt (denn genau diese Route stellt ihn aus).

  import { Controller, Post, Request, UseGuards } from '@nestjs/common';
  import { LocalAuthGuard } from './local-auth.guard';
  import { AuthService } from './auth.service';
  import { ServerResponse } from '../web/models/response.model';
  import { LoginResult } from './login-result.model';
  import { User } from '../entities/user.entity';

  @Controller()
  export class AuthController {
   constructor(private readonly authService: AuthService) {}

   @UseGuards(LocalAuthGuard)
   @Post('login')
   login(@Request() req: { user: User }): ServerResponse<LoginResult> {
     return ServerResponse.ok<LoginResult>(this.authService.login(req.user));
   }
 }

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 prüft. Schlägt die Prü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 diese Stelle erreichen, war [LocalAuthGuard] erfolgreich: req.user enthält den von LocalStrategy.validate() zurückgegebenen Benutzer. Beachten Sie das Fehlen eines [@Body]-Parameters ([LoginDto]): Es war der Guard, nicht diese Methode, der {login, password} aus dem Request-Body gelesen hat;
  • Zeile 15: [return ServerResponse.ok(this.authService.login(req.user));] — erzeugt den JWT-Token und verpackt ihn in die standardmäßige [ServerResponse]<T>-Antwort – anders als die Antworten 401/403 der Guards (siehe oben) läuft eine erfolgreiche Anmeldung durch 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.

  import { Module } from '@nestjs/common';
  import { JwtModule } from '@nestjs/jwt';
  import { PassportModule } from '@nestjs/passport';
  import { TypeOrmModule } from '@nestjs/typeorm';
  import { User } from '../entities/user.entity';
  import { UserRepository } from '../repositories/user.repository';
  import { AuthService } from './auth.service';
  import { AuthController } from './auth.controller';
  import { LocalStrategy } from './local.strategy';
 import { JwtStrategy } from './jwt.strategy';

 @Module({
   imports: [
     TypeOrmModule.forFeature([User]),
     PassportModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET ?? 'dev-secret-to-change-in-production',
       signOptions: { expiresIn: process.env.JWT_EXPIRES_IN ?? '2h' },
     }),
   ],
   controllers: [AuthController],
   providers: [
     AuthService,
     UserRepository,
     LocalStrategy,
     JwtStrategy,
   ],
 })
 export class AuthModule {}

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 dennoch weiterhin explizit [AuthGuard]('local')/AuthGuard('jwt') an, damit sie lesbar bleiben;
  • Zeilen 16–19: [JwtModule.register({ secret: …, signOptions: { expiresIn: … } }),] — konfiguriert die Erzeugung und Prüfung von Tokens: 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 erzeugen.

4.9. Konfiguration und Start

4.9.1. package.json

{
  "name": "rdvmedecins-nestjs-server",
  "version": "1.0.0",
  "description": "NestJS server of the medical appointment booking application [RdvMedecins] - port of the original Spring 4 / Spring Data server",
  "private": true,
  "license": "UNLICENSED",
  "scripts": {
    "build": "nest build",
    "start": "nest start",
    "start:dev": "nest start --watch",
    "start:debug": "nest start --debug --watch",
    "start:prod": "node dist/main"
  },
  "dependencies": {
    "@nestjs/common": "^10.4.0",
    "@nestjs/core": "^10.4.0",
    "@nestjs/jwt": "^10.2.0",
    "@nestjs/passport": "^10.0.3",
    "@nestjs/platform-express": "^10.4.0",
    "@nestjs/typeorm": "^10.0.2",
    "bcryptjs": "^3.0.3",
    "class-transformer": "^0.5.1",
    "class-validator": "^0.14.1",
    "dotenv": "^17.4.2",
    "mysql2": "^3.11.0",
    "passport-jwt": "^4.0.1",
    "passport-local": "^1.0.0",
    "reflect-metadata": "^0.2.2",
    "rxjs": "^7.8.1",
    "typeorm": "^0.3.20"
  },
  "devDependencies": {
    "@nestjs/cli": "^10.4.5",
    "@types/bcryptjs": "^2.4.6",
    "@types/node": "^20.14.0",
    "@types/passport-jwt": "^4.0.1",
    "@types/passport-local": "^1.0.38",
    "typescript": "^5.5.0"
  }
}

Kommentieren wir diesen Code:

  • Zeilen 7–13: [“scripts”: { … }] — die verfügbaren Befehle `npm run <name>`. start:dev (in diesem gesamten Dokument verwendet) kompiliert den Server automatisch neu und startet ihn neu, sobald eine .ts-Datei geändert wird (die Option --watch der CLI von [NestJS], vergleichbar mit den Devtools von Spring Boot). start:prod startet direkt das vorkompilierte JavaScript (dist/main.js), ohne die CLI zu durchlaufen oder neu zu kompilieren – dies ist der Modus, der in der Produktion verwendet würde;
  • Zeilen 14–31: [“dependencies”: { … }]— die Pakete, die zum Ausführen des Servers erforderlich sind. Es enthält den Kern von [NestJS] ([@nestjs/common], [@nestjs/core], [@nestjs/platform-express]), das Integrationspaket für [TypeORM] ([@nestjs/typeorm], typeorm, mysql2 – der von [MySQL] verwendete Treiber [TypeORM]), die Validierung per DTO (class-validator, class-transformer), das Lesen der Datei .env (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/ enthalten sind: die CLI von [NestJS] selbst ([@nestjs/cli]), der TypeScript-Compiler und die Typdefinitionen (@types/...) für JavaScript-Pakete, die diese nicht nativ mitliefern (bcryptjs, passport-jwt, passport-local).

Wie beim [React]-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]

{
  "compilerOptions": {
    "module": "commonjs",
    "declaration": false,
    "removeComments": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "allowSyntheticDefaultImports": true,
    "target": "ES2022",
    "lib": ["ES2022"],
    "sourceMap": true,
    "outDir": "./dist",
    "baseUrl": "./",
    "incremental": true,
    "skipLibCheck": true,
    "strictNullChecks": true,
    "noImplicitAny": false,
    "strictBindCallApply": false,
    "forceConsistentCasingInFileNames": true,
    "noFallthroughCasesInSwitch": false
  }
}

Kommentieren wir diesen Code:

  • Zeile 3: [“module”: “commonjs”,] — das Format der JavaScript-Module, die bei der Kompilierung erzeugt werden; 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 ([React]);
  • Zeilen 6–7: [“emitDecoratorMetadata”: true, “experimentalDecorators”: true,] — die zwei unverzichtbaren Optionen damit [NestJS] (und [TypeORM]) funktionieren: 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 beibehält – diese Information liest [NestJS] , um selbstständig zu bestimmen, was injiziert werden soll (siehe Kapitel 2, Abschnitt über Dependency Injection). Ohne diese beiden Zeilen würde die Konstruktorinjektion schlicht nicht funktionieren;
  • Zeile 9: [“target”: “ES2022”,]— die Version des JavaScripts, das bei der Kompilierung erzeugt wird; ES2022 wird von den in diesem Kurs verwendeten Node.js-Versionen (20+) weitgehend unterstützt und erlaubt es, aktuelle 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 wird (Zeile 17: noImplicitAny bleibt auf false, was toleranter ist): ein didaktischer Kompromiss, um den Kern der Typsicherheit zu bewahren, ohne für jede Variable eine Typannotation zu verlangen.

4.9.3. nest-cli.json

1
2
3
4
5
6
7
8
{
  "$schema": "https://json.schemastore.org/nest-cli",
  "collection": "@nestjs/schematics",
  "sourceRoot": "src",
  "compilerOptions": {
    "deleteOutDir": true
  }
}

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, im weiteren Kursverlauf aber 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/ (Zeile outDir von [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 [React]-Projekten (siehe nächstes Kapitel), in denen vite.config.ts eine recht ähnliche Rolle spielt.

4.9.4. src/config/database.config.ts

Image

  import { TypeOrmModuleOptions } from '@nestjs/typeorm';
  import { Doctor } from '../entities/doctor.entity';
  import { Client } from '../entities/client.entity';
  import { Slot } from '../entities/slot.entity';
  import { Appointment } from '../entities/appointment.entity';
  import { User } from '../entities/user.entity';

  export function getDatabaseConfig(): TypeOrmModuleOptions {
    return {
     type: 'mysql',
     host: process.env.DB_HOST ?? 'localhost',
     port: process.env.DB_PORT ? parseInt(process.env.DB_PORT, 10) : 3306,
     username: process.env.DB_USERNAME ?? 'root',
     password: process.env.DB_PASSWORD ?? '',
     database: process.env.DB_DATABASE ?? 'dbrdvmedecins',
     entities: [Doctor, Client, Slot, Appointment, User],
     synchronize: false,
     logging: process.env.NODE_ENV !== 'production',
   };
 }

Kommentieren wir diesen Code:

  • Zeile 8: [export function getDatabaseConfig(): TypeOrmModuleOptions {] — entspricht der Klasse DomainAndPersitenceConfig des ursprünglichen Spring-Projekts, die eine DataSource definierte (@Bean-Block). Hier gibt es keine Klasse: nur eine einfache Funktion, die ein Konfigurationsobjekt zurückgibt, das aus den Umgebungsvariablen gelesen wird (der 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 dieser Liste mit der Einführung der Authentifizierung hinzugefügt: Fehlt sie, führt dies beim Start zum Fehler „no metadata found for [User]“;
  • Zeile 17: [synchronize: false,] — in diesem Kurs immer gesetzt: 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). Wir behalten die Kontrolle über das Schema mithilfe des Skripts [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]

Image

  import 'dotenv/config';
  import 'reflect-metadata';
  import { NestFactory } from '@nestjs/core';
  import { ValidationPipe } from '@nestjs/common';
  import { AppModule } from './app.module';

  async function bootstrap() {
    const app = await NestFactory.create(AppModule);
    app.enableCors();
   app.useGlobalPipes(
     new ValidationPipe({
       transform: true,
       whitelist: true,
     }),
   );
   const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 8080;
   await app.listen(port);
   console.log(`[RdvMedecins] NestJS server started on http://localhost:${port}`);
 }

 bootstrap();

Kommentieren wir diesen Code:

  • Zeile 1: [import ‘dotenv/config’;] — muss der allererste Import in dieser Datei sein: Sein einziger Zweck besteht darin, 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 Datei .env nutzlos: Die Variablen würden in process.env schlicht nicht existieren, wenn diese Module sie benötigen;
  • Zeile 8: [const app = await NestFactory.create(AppModule);] — erstellt die Anwendung aus dem Root-Modul – das Äquivalent zu SpringApplication.run(Boot.class, args);
  • Zeile 9: [app.enableCors();] — erlaubt dem [React]-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 für jede eingehende Anfrage automatisch, dass 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

  import { Module } from '@nestjs/common';
  import { TypeOrmModule } from '@nestjs/typeorm';
  import { getDatabaseConfig } from './config/database.config';
  // ... Entitäten, Repositories, BUSINESS_TOKEN/BusinessService, ApplicationModelService, RdvMedecinsController
  import { AuthModule } from './auth/auth.module';

  @Module({
    imports: [
      TypeOrmModule.forRoot(getDatabaseConfig()),
     TypeOrmModule.forFeature([Doctor, Client, Slot, Appointment]),
     AuthModule,
   ],
   controllers: [
     RdvMedecinsController,
   ],
   providers: [
     DoctorRepository,
     ClientRepository,
     SlotRepository,
     AppointmentRepository,
     { provide: BUSINESS_TOKEN, useClass: BusinessService },
     ApplicationModelService,
   ],
 })
 export class AppModule {}

Kommentieren wir diesen Code:

  • Zeile 9: [TypeOrmModule.forRoot(getDatabaseConfig()),] — konfiguriert die globale Datenbankverbindung – entspricht der @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,] — liefert seine eigene Route (POST /login) und seine eigenen Provider (Passport-Strategien, JWT-Guard …) – ein vollständiges [NestJS]-Modul statt direkt zu [AppModule] hinzugefügter Dateien, damit die Authentifizierung isoliert und leicht entfernbar oder austauschbar bleibt;
  • 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 Interface-Injektion von Spring (@Autowired [IMetier] métier).

4.9.7. .env.example

  PORT=8080

  DB_HOST=localhost
  DB_PORT=3306
  DB_USERNAME=root
  DB_PASSWORD=
  DB_DATABASE=dbrdvmedecins

  DB_SYNCHRONIZE=false

 JWT_SECRET=change-me-to-a-long-random-string
 JWT_EXPIRES_IN=2h

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 durch die Authentifizierung neu eingeführten Variablen: der geheime Signaturschlüssel der Tokens (muss in der Produktion geändert werden – eine lange Zufallszeichenfolge, nie committen) und ihre Gültigkeitsdauer.

Diese Datei ist nur ein Beispiel: Kopieren Sie sie nach .env (nie committen, da sie Geheimnisse enthalten kann) und passen Sie dann die Werte an Ihren Rechner an.

4.10. End-to-End-Ü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 erwartungsgemäß { "status": 0, "data": { "accessToken": "...", "login": "admin", "name": "Administrator", "role": "ADMIN" } };
  • 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 die Antwort 401 Unauthorized;
  • GET /getAllDoctors mit einem gültigen JWT-Token (admin oder user) liefert normal die Liste der Ärzte im üblichen [ServerResponse]<T>-Umschlag;
  • POST /addAppointment mit dem Admin-Token reserviert normal ein freies Zeitfenster;
  • POST /addAppointment mit dem User-Token liefert den 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.