Skip to content

4. Kapitel 3 - Der [NestJS]-Server der Anwendung [RdvMedecins]

Dieses Kapitel beschreibt Datei für Datei den Inhalt des Ordners [rdvmedecins-nestjs-server], der diesem Dokument beiliegt. Es folgt demselben Format wie im gesamten Kurs: der Quellcode, Zeile für Zeile nummeriert, gefolgt von einem Abschnitt mit dem Titel „Kommentieren wir diesen Code“, der die Zeilen erklärt, die einer näheren Erläuterung 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, die der Schritt „Authentifizierung“ dieser Portierung mit sich bringt: 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 einzige 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 jeder Ausführung 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 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 Constraint, und nur sie, verhindert einen doppelten Termin – weder der Validator noch die Geschäftslogik prüfen dies 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 (users, roles, users_roles) verwendete, um mehrere Rollen pro Benutzer zu ermöglichen. Da diese Anwendung nur zwei einander 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), deren Passwörter bereits mit bcrypt gehasht sind (10 Salting-Runden) – niemals im Klartext, auch nicht in diesem Demoskript.

4.2. Schichtenorganisation

Der Server folgt der Schichtenstruktur des ursprünglichen Projekts:

Image

Jede Schicht kommuniziert nur mit der Schicht unmittelbar rechts von ihr, [5-8]: So kommuniziert der Controller [5] beispielsweise niemals direkt mit der Schicht [7]. Das 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 native Mechanismus von [TypeORM] 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 inzwischen 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 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 ist sie nicht mit [@Entity] dekoriert: Sie ist das [TypeORM]-Gegenstück zur Klasse [Personne] – die im ursprünglichen Projekt ebenfalls @MappedSuperclass ist;
  • Zeilen 5, 8, 11: [@Column({ length: N })] / [@Column({ name: '...', length: N })] – drei Textspalten begrenzter Länge (die letzten beiden explizit auf die Snake-Case-Spalten last_name und first_name abgebildet), äquivalent zu [@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 Anrede/Nachname/Vorname (von [Person]) und 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), mit TypeORM aber leicht zu ergänzen ist.

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. Erinnerung zum Vokabular: [Client] bezeichnet hier einen Patienten der Arztpraxis (Vokabular 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;
 }

Zerlegen wir diesen Code:

  • Zeilen 7–10: [@Column({ name: 'start_hour' }) startHour: number; …] – die vier zeitlichen Grenzen des Zeitfensters (Beginn und Ende, jeweils Stunde/Minute), vier einfache Ganzzahlen, jede explizit 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: [...] 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 für den Aufbau schlanker JSON-Antworten (siehe unten, die Web-Schicht).

Hinweis: Ein Feld [@RelationId] ist eine virtuelle Spalte, die [TypeORM] nachträglich berechnet – 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 ist.

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'])] – verweist auf der [TypeORM]-Seite auf die SQL-Constraint des Datenbankskripts. 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-Constraint 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 Ä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 Verknüpfung zweier Zeichenfolgen, 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 [Angular] …);
  • Zeile 6: [@Entity({ name: 'users' })] – wie die anderen Entitäten eine eigene Tabelle;
  • Zeile 11: [password: string;] – speichert ein gehashtes Passwort (bcrypt), niemals im Klartext – siehe auth.service.ts;
  • Zeile 17: [role: Role;] – eine einzige Spalte anstelle der Many-to-many-Beziehung (users/roles/users_roles) des ursprünglichen Spring-Projekts. Diese Anwendung kennt nur zwei einander ausschließende Rollen (ein Benutzer ist entweder ADMIN oder USER, nie beides): Den ursprünglichen Aufbau nachzubauen, hätte die Komplexität ohne echten Nutzen erhöht. Das ist eine bewusste Vereinfachung zu Lehrzwecken, ebenso wie die Enumeration `[ResponseStatus]`, der Sie weiter oben in diesem Kapitel begegnet sind.

4.4. Fachobjekte (src/domain/)

Image

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 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
    ) {}
  }

Zerlegen wir diesen Code:

  • Zeile 4: [export class DoctorDaySlot {] – verknüpft ein Zeitfenster mit dem Termin, der in diesem Zeitfenster für einen bestimmten Tag vereinbart sein kann;
  • 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 [this.slot = slot] separat geschrieben werden muss. [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 oben [DoctorDaySlot]);
  • Zeile 8: [public doctorDaySlots: DoctorDaySlot[],] – berechnet von [BusinessService.getDoctorDaySchedule] (siehe unten); diese Liste wandelt der Controller für den Angular-Client 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).

Image

Der wichtigste Unterschied zwischen Spring Data und [TypeORM]: Bei Spring Data genügte es, eine Schnittstelle zu deklarieren (extends CrudRepository<...>), um automatisch die Basismethoden (findAll, findOne, save, delete …) 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 bereitstellen möchten, selbst, indem wir auf den vordefinierten Methoden dieses Repository aufbauen oder für speziellere Abfragen den Query Builder verwenden.

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)] – 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, anstatt eine Exception 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 ist im Prinzip genau dieselbe wie [DoctorRepository] (siehe die obige Erläuterung), bezieht sich aber auf die Entität [Client] (einen Patienten).

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, äquivalent zur ursprünglichen JPQL-Abfrage select c from [Creneau] c where c.medecin.[id]=?1;
  • Zeile 23: [.createQueryBuilder(‘s’)] – der SQL-Alias heißt s, so wie [Creneau] in JPQL c heißt;
  • 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. Indem die Beziehung mit einer Zahl verglichen wird, erkennt [TypeORM], dass auf ihren Fremdschlüssel abgezielt wird, 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’] }] – 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 Modus „lazy“; siehe slot.entity.ts) – nützlich für den 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 aus der 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 auf den Arzt, die über den Join mit dem Zeitfenster erreicht wird (rv.creneau.medecin.[id]=?1 in JPQL) – auch hier vergleichen wir die Beziehung „doctor“, nicht das entsprechende Feld [@RelationId].

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 vom Login verwendet wird (siehe auth.service.ts): Sie ersetzt die rollenbasierte Suche über drei Tabellen im ursprünglichen Projekt, die mit der Vereinfachung auf eine einzige Spalte [role] überflüssig geworden ist (siehe user.entity.ts).

4.6. Die Geschäftsschicht (src/business/)

Hier und nirgendwo sonst liegen 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 der Java-Schnittstelle [IMetier] des ursprünglichen Projekts;
  • Zeilen 8–18: elf Methoden, je 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 diese Schnittstelle in den Controller injizieren zu können, genau wie Spring die Geschäftsreferenz [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

  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';
  // ... importierte Entitäten und 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("business"): 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, äquivalent zu den vier @Autowired-Feldern im ursprünglichen Projekt. [NestJS] setzt hier auf Konstruktorinjektion statt auf Feldinjektion (wie @Autowired sie bei einem Java-Feld vornimmt): Das ist der in TypeScript 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-Constraint unq1_appointments (siehe oben, das Datenbankskript), und nur sie, die eine doppelte Buchung verhindert – hier erfolgt keine ausdrückliche Prüfung; ein Versuch einer Doppelbuchung löst eine SQL-Exception 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 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 angefragten Tag abrufen;
  • Zeilen 45–48: [const hBookings = new Map<number, Appointment>(); …] – diese Termine werden in einem Dictionary abgelegt, das nach der ID des Zeitfensters indiziert ist, damit sie im nächsten Schritt schnell gefunden werden – äquivalent zur `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 Buchungen 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“ 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 lernen und pflegen lässt: Das für den Client beobachtbare Verhalten (0 = Erfolg, alles andere = Fehlschlag) bleibt strikt dasselbe;
  • Zeile 8: [export class ServerResponse<T = unknown> {] – der gemeinsame Umschlag 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 lesbareren Controller-Code 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> {] – das 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 darin besteht, das Format der ausgetauschten Daten zu beschreiben, ohne jede Logik;
  • Zeile 4: [@IsDateString()] – prüft, ob die empfangene Zeichenfolge tatsächlich ein gültiges Datum im ISO-Format ist. Ist dies nicht der Fall, gibt [NestJS] automatisch einen HTTP-Fehler 400 (Bad [Request]) zurück, bevor der Controller ausgeführt wird – dank der globalen [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 zu den automatischen Typumwandlungen, 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 Body JSON, 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 Exceptions verketten (exception.getCause()), um zu erklären, „warum“ eine Exception aufgetreten ist; im modernen JavaScript/TypeScript (ES2022) besitzen auch Fehler eine Ursachenkette über die Eigenschaft `cause`;
  • Zeilen 6–10: [while (cause instanceof Error) { … cause = cause.cause; }] – das 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, wenn sie geladen wäre, Informationen doppelt übermitteln 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 erforderlichen 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[] {] – das 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 erforderlichen 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 gelesen werden müssen). Diese Klasse erfüllt wie das Original zwei Aufgaben: einerseits ein Cache, andererseits ein einziger Einstiegspunkt vom Controller in die Geschäftsschicht – falls die Caching-Strategie jemals geändert wird, muss nur diese Datei angepasst werden;
  • Zeile 11: [constructor(@Inject(BUSINESS_TOKEN) private readonly business: IBusiness) {}] – hier injizieren wir die Schnittstelle [IBusiness] (ü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` jemals zu erwähnen;
  • Zeile 13: [async onModuleInit(): Promise<void> {] – [OnModuleInit] ist die „Lifecycle“-Schnittstelle von [NestJS], die 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); }] – ist die Datenbank beim Start nicht verfügbar, wird der Fehler abgefangen und in `messages` gespeichert, anstatt 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 Übrige (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 und lediglich ins Englische übersetzt wurden (/getAllDoctors für /getAllMedecins, /addAppointment für /ajouterRv …) und nicht im Stil von REST „modernisiert“ wurden (/doctors, /clients/:id …) – der 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), dann 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, sonst 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 angewandt, schützt es alle elf Routen dieses Controllers auf einmal: Keine ist ohne ein gültiges JWT-Token zugänglich (siehe das Kapitel „Authentifizierung“ weiter unten). 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, äquivalent zu @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), äquivalent zu `if (messages != null) { return new [Reponse](-1, messages); }`;
  • Zeile 33: [async getAllSlots(@Param('doctorId') doctorId: string) {] – [@Param]('doctorId') liest das Segment {doctorId} der URL als Zeichenfolge aus (ä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 zuerst den Arzt ab, um zu prüfen, ob er existiert, bevor wir fortfahren (äquivalent zur 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 „schlanker“ JavaScript-Objekte um (siehe static.helper.ts);
  • Zeile 59: [return ServerResponse.ok({ doctor: …, day: …, slots: … });] – der Terminkalender wird für JSON im „schlanken“ 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 (bereitgestellt von JwtAuthGuard/JwtStrategy): Er muss daher nach [JwtAuthGuard] ausgeführt werden ([NestJS] wendet zuerst die Guards der Klasse an, dann die der Methode, in der Reihenfolge ihres Auftretens);
  • 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 Ganzzahlen sind. Die SQL-Constraint unq1_appointments (day, slot_id) verhindert, dass für dasselbe Zeitfenster am selben Tag zwei Buchungen vorgenommen werden: Ein Versuch einer Doppelbuchung löst eine Exception aus, die hier abgefangen wird, genau wie die SQLException des ursprünglichen JDBC-Treibers;
  • Zeile 95: dieselbe Beschrä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, äquivalent zum Paar SimpleDateFormat("yyyy-MM-dd") + setLenient(false) des ursprünglichen Codes, das zum Beispiel „2026-13-40“ (ungültiger Monat und Tag) ablehnte: Date.toISOString() konstruiert das Datum aus der empfangenen Zeichenfolge neu – weicht es von der Eingabe ab, hat das Datum nicht existiert.

4.8. Authentifizierung (src/auth/)

Image

Dieser Abschnitt dokumentiert die in diesem Stadium des Kurses ergänzte tokenbasierte Authentifizierung (JWT) und rollenbasierte Zugriffskontrolle (ADMIN/USER) – das funktionale Äquivalent der 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 dokumentiert werden:

  1. JWT statt HTTP Basic. Das ursprüngliche Spring-Projekt sendete den Header Authorization: Basic <login:password in Base64> bei jeder Anfrage: Das Passwort (kodiert, nicht verschlüsselt) wurde somit bei jedem Aufruf über das Netzwerk übertragen. Dieser Port verwendet stattdessen ein Token: JWT (JSON Web Token). Das Passwort wird nur einmal beim Login übermittelt (POST /login); der Server liefert daraufhin ein signiertes Token zurück, das der Client anschließend in jede weitere Anfrage einfügt (Header Authorization: Bearer <token>). Das ist heute die übliche Vorgehensweise für diese Art von API, wie bereits im Fazit des vorigen Kapitels erwähnt.
  2. Eine Rolle pro Benutzer, in einer einzigen Datenbankspalte, statt der Many-to-many-Beziehung (users/roles/users_roles) des ursprünglichen Projekts – siehe user.entity.ts oben.

Ein architektonischer Punkt, den Sie vor dem folgenden Code verstehen sollten: Wenn ein Guard eine Anfrage ablehnt (401 Unauthorized, 403 Forbidden), durchläuft die Antwort nie den üblichen Umschlag [ServerResponse]<T> ({ 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 [Angular]-Client muss daher zwischen diesen beiden Arten von Fehlerantworten unterscheiden (siehe das nächste 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 }), mit demselben Mechanismus wie das 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 hat hier einen rein informativen Zweck: Tatsächlich liest [LocalStrategy] (siehe unten) {login, password} aus dem Body der Anfrage, nicht ein Parameter @Body des Controllers. Dennoch beschreibt [LoginDto] für den 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 im Erfolgsfall zurückgibt, im Standardumschlag [ServerResponse]<T>: { "status": 0, "data": { accessToken, login, name, role } };
  • Zeile 4: [accessToken: string;] – das JWT-Token, das in jede weitere Anfrage eingefügt werden muss;
  • Zeile 7: [role: Role;] – die Rolle des angemeldeten Benutzers, damit der [Angular]-Client seine Oberfläche anpassen kann (siehe das nächste Kapitel: Die Schaltflächen „Buchen“/„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 nutzen anschließend [JwtStrategy] (siehe unten) und 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;
   }
 }

Zerlegen wir diesen Code:

  • Zeile 8: [export class LocalStrategy extends PassportStrategy(Strategy) {] – konzeptionell gleichwertig zur Klasse AppUserDetailsService des ursprünglichen Spring-Security-Projekts: „Sag mir anhand von Zugangsdaten, wer dieser Benutzer ist“;
  • Zeile 10: [super({ usernameField: ‘login’, passwordField: ‘password’ });] – standardmäßig erwartet passport-local im Body der Anfrage Felder mit den Namen „username“ und „password“; wir benennen sie hier um, damit sie zu unserem DTO ([LoginDto]) passen, 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 die Anfrage ü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, dessen 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.

  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 bei der Erzeugung im JWT-Token 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 { … }] – was request.user in den Controllern enthält, 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 angab): 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, weist 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 Umgebungsvariablen 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

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

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

Kommentieren wir diesen Code:

  • Zeile 5: [export class LocalAuthGuard extends AuthGuard(‘local’) {}] – ein „Guard“ in [NestJS] legt vor der Ausführung einer Controller-Methode fest, ob die Anfrage darauf zugreifen darf. [AuthGuard]('local') ist eine von [@nestjs/passport] bereitgestellte Factory, 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

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 ein gültiges JWT-Token („jwt“ verweist auf [JwtStrategy]; siehe oben). Ohne Token oder mit einem ungültigen oder abgelaufenen Token antwortet [NestJS] automatisch mit einem 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, anders als @Get, @Post und @Injectable, die von [NestJS] bereitgestellt werden): Er hängt der dekorierten Methode lediglich Metadaten an („diese Methode erfordert die und die Rolle“), ohne selbst eine Prüfung durchzuführen – erst [RolesGuard] (unten) liest diese Metadaten und führt die Prüfung aus. [SetMetadata](key, value) ist die Low-Level-Funktion von [NestJS], mit der Sie eigene Dekoratoren dieser Art schreiben können.

4.8.8. src/auth/roles.guard.ts

Zweite Validierungsstufe, nach [JwtAuthGuard]: Dieser prüft nur, ob der Benutzer ordnungsgemäß authentifiziert ist (gültiges JWT-Token); [RolesGuard] prüft zusätzlich, ob die Rolle des angemeldeten Benutzers zu den von @Roles an der Zielmethode verlangten gehört.

  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 gleichwertig zur Spring-Security-Regel http.authorizeRequests().antMatchers(...).hasRole("ADMIN"), hier jedoch Methode für Methode statt URL für URL angewandt, dank des Paars aus Dekorator ([@Roles]) und [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 Metadaten [@Roles](...) für diese Methode: keine zusätzliche Rollenbeschränkung ([JwtAuthGuard] hat dagegen 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() geliefert: [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 geworfen, 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 Überprüfen eines Paars aus Benutzername und Passwort sowie das Erzeugen des JWT-Tokens, das 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 gleichwertig 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 übermittelte Passwort übereinstimmt; gibt den Benutzer zurück, wenn alles stimmt, andernfalls null;
  • Zeile 21: [const passwordCorrect = await bcrypt.compare(password, user.password);] – bcrypt.compare() hasht das Passwort mit demselben Salt wie dem in user.[password] gespeicherten 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], sobald 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. Dies ist die einzige Route der gesamten Anwendung, die kein JWT-Token voraussetzt (denn genau diese Route stellt es 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)] – stellt 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, liefert [NestJS] eine Antwort 401 Unauthorized, bevor der Rumpf dieser Methode überhaupt 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 Parameters [@Body]([LoginDto]): Nicht diese Methode, sondern der Guard hat {login, password} aus dem Body der Anfrage gelesen;
  • Zeile 15: [return ServerResponse.ok<LoginResult>(this.authService.login(req.user));] – erzeugt das JWT-Token und verpackt es in die standardmäßige Antwort [ServerResponse]<T> – 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.

  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 [AuthGuard]('local')/AuthGuard('jwt') weiterhin explizit an, um lesbar zu bleiben;
  • Zeilen 16–19: [JwtModule.register({ secret: …, signOptions: { expiresIn: … } }),] – konfiguriert die Erzeugung und Überprüfung der Token: den geheimen Signierschlüssel (JWT_SECRET, siehe .env) und ihre Gültigkeitsdauer (JWT_EXPIRES_IN, z. B. "2h");
  • Zeilen 25–26: [LocalStrategy, JwtStrategy,] – registrieren die Strategie 'local' bzw. die Strategie 'jwt' bei Passport; ohne diese Deklaration in `providers` könnte [NestJS] 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 [NestJS]-CLI, entsprechend den Devtools von Spring Boot). start:prod startet direkt das vorkompilierte JavaScript (dist/main.js), ohne die CLI zu durchlaufen und ohne neu zu kompilieren – das ist der Modus, der in der Produktion verwendet würde;
  • Zeilen 14–31: [“dependencies”: { … }]– die Pakete, die erforderlich sind, um den Server auszuführen. Sie enthalten den Kern von [NestJS] ([@nestjs/common], [@nestjs/core], [@nestjs/platform-express]), das Integrationspaket für [TypeORM] ([@nestjs/typeorm], typeorm, mysql2 – der von [TypeORM] verwendete [MySQL]-Treiber), die Validierung der DTO (class-validator, class-transformer), das Lesen der Datei .env (dotenv) sowie – mit der Authentifizierung eingeführt (siehe das nächste 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 [NestJS]-CLI 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 [Angular]-Client (siehe das nächste Kapitel) ist dies die Datei, die [npm install] liest (Kapitel 1), um zu bestimmen, was in node_modules/ heruntergeladen werden soll – im Node/TypeScript-Ökosystem das Äquivalent zur pom.xml des ursprünglichen Spring-Projekts.

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 serverseitiger Projekte erwartete Format, im Gegensatz zum ESM-Format (natives import/export) auf der Client-Seite ([Angular]);
  • Zeilen 6–7: [“emitDecoratorMetadata”: true, “experimentalDecorators”: true,] – die beiden 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 – das ist die Information, die [NestJS] liest, um selbst herauszufinden, was injiziert werden soll (siehe Kapitel 2, Abschnitt zur 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 Versionen von Node.js (20+) weitgehend unterstützt und erlaubt es, aktuelle JavaScript-Funktionen direkt im Quellcode zu nutzen (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 strikten Modus von TypeScript, die hier isoliert aktiviert ist statt des vollständigen strikten Modus (Zeile 17: noImplicitAny bleibt auf false, was permissiver 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 Code-Generator, 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 [NestJS]-CLI 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 endlos in dist/ liegen.

Diese Datei ist spezifisch für das [NestJS]-Ökosystem: Sie hat kein direktes Äquivalent in [Angular]-Projekten (siehe das nächste Kapitel), wo angular.json eine ziemlich ä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 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 – entsprechend dem automatischen „Scan“ der [@Entity]-Klassen durch Spring Boot. [User] wurde dieser Liste hinzugefügt, als die Authentifizierung implementiert wurde: Würde man sie weglassen, käme es beim Start zum Fehler „no metadata found for [User]“;
  • Zeile 17: [synchronize: false,] – durchgängig in diesem Kurs verwendet: Wäre `synchronize` auf `true` gesetzt, würde [TypeORM] das Datenbankschema automatisch anhand der Entitäten ändern – nützlich für einen Wegwerf-Prototyp, aber gefährlich bei echten Daten (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: Er dient allein dazu, die Datei .env zu lesen und ihren Inhalt in 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 existierten in process.env schlicht nicht, wenn diese Module sie benötigen;
  • Zeile 8: [const app = await NestFactory.create(AppModule);] – erzeugt die Anwendung aus dem Wurzelmodul – das Äquivalent zu SpringApplication.run(Boot.class, args);
  • Zeile 9: [app.enableCors();] – erlaubt dem [Angular]-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, ob der JSON-Body dem erwarteten Format entspricht (siehe die mit `class-validator` dekorierten Klassen); `transform: true` wandelt Typen automatisch um (z. B. Zeichenkette "3" → Zahl 3), und `whitelist: true` entfernt aus den empfangenen Daten Felder, die im Format `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 dem @Bean DataSource im ursprünglichen Spring-Projekt;
  • Zeile 10: [TypeOrmModule.forFeature([Doctor, Client, Slot, Appointment]),] – deklariert die Entitäten, die in diesem Modul verwendet werden, und macht ihre Repository<T> (über [@InjectRepository]) in die Klassen von src/repositories/ injizierbar. [User] ist dort nicht aufgeführt: Es ist [AuthModule] (Zeile 11), das sein eigenes TypeOrmModule.forFeature([User]) deklariert (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 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 [IMetier] business).

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 neuen Variablen, die mit der Authentifizierung eingeführt wurden: der geheime Signierschlüssel der Token (muss in der Produktion geändert werden – eine lange Zufallszeichenfolge, die niemals committet wird) und ihre Gültigkeitsdauer.

Diese Datei ist nur ein Beispiel: Kopieren Sie sie nach .env (niemals 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 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 Umschlag [ServerResponse]<T>);
  • 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 Umschlag [ServerResponse]<T>;
  • POST /addAppointment mit dem Token von admin reserviert wie üblich einen verfügbaren 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 übermittelten Tokens symmetrisch zu /addAppointment.