Abschnitt 18 · Lektion 5
Abschlussprojekt
Wer Bücher verleiht, muss bei jeder Anfrage wissen, ob ein Buch gerade da ist. Dasselbe Buch zweimal verleihen geht nicht. Die Ausleihverwaltung in diesem Projekt hat Bücher, Nutzer und Ausleihen, eine öffentliche Suche, eine Anmeldung und eine geschützte Route zum Ausleihen. Bis auf eine Schicht steht sie schon. Es fehlt die Logik, die entscheidet, ob ein Buch verfügbar ist und ob es ausgeliehen werden darf, und die schreibst du.
Was am Ende steht
| Route | Wer darf | Was passiert |
|---|---|---|
GET /api/buecher?q= | jeder | Suche im Bestand, mit Verfügbarkeit je Buch |
GET /api/buecher/:id | jeder | ein Buch, oder 404 |
POST /login | jeder | Anmeldung, Sitzung, 303 |
POST /api/ausleihen | nur angemeldet | leiht aus, oder 401, 404, 409 |
Hinter drei dieser Routen steht deine Logik. Die Suche ruft sucheBuecher auf, das einzelne Buch
holeBuch, das Ausleihen leiheAus. Die Anmeldung gehört dem Server und hat mit der Logik nichts
zu tun.
Was schon da ist
Von den zehn Dateien der Anwendung schreibst du eine, logik/bibliothek.js mit drei Funktionen. Die
anderen kommen aus den Abschnitten davor.
| Datei | Was darin steht | Wie in |
|---|---|---|
daten/db.js | drei Tabellen und der Bestand | Abschnitt 12 |
routen/buecher.js, routen/ausleihen.js | zwei Router, die prüfen und weitergeben | Abschnitt 10 und 11 |
server.js | Anmeldung, Sitzung, Wächter, Kopfzeilen, Fehler-Handler | Abschnitt 13 bis 16 |
passwoerter.js | Passwörter hashen und prüfen | Abschnitt 14 |
fehler.js, logger.js | Fehlerklassen und das Protokoll | Abschnitt 16 |
Dazu kommen die package.json und das Schaltpult in public/index.html. Das Außenherum hast du
schon einmal selbst geschrieben. Ein zweites Mal abgetippt brächte es nichts Neues. In der Logik
steckt dagegen das, was diese Anwendung von jeder anderen unterscheidet. Sie ist kurz, aber an ihr
hängt, ob die Antworten der Routen stimmen.
Das Datenmodell
Die Ausleihverwaltung hat drei Tabellen, buecher, nutzer und ausleihen. Eine Spalte
verfuegbar gibt es mit Absicht nicht. Sie wäre bequem, aber sie wäre eine zweite Wahrheit neben
den Ausleihen. Beim ersten vergessenen Update stünde dort etwas anderes, als die Ausleihen sagen,
und dann glaubt niemand mehr einer von beiden.
Statt in einer Spalte nachzusehen, fragt die Logik, ob es zu einem Buch eine Ausleihe ohne Rückgabedatum gibt. Im Beispiel geht dieselbe Art Frage an eine Tabelle, die in der Aufgabe nicht vorkommt. Gefragt wird dort, ob ein Nutzer eine Mahnung hat, die noch nicht bezahlt ist.
import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec(`CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL UNIQUE)`);
db.exec(`CREATE TABLE mahnungen (
id INTEGER PRIMARY KEY,
nutzer_id INTEGER NOT NULL REFERENCES nutzer(id),
betrag_cent INTEGER NOT NULL,
erstellt_am TEXT NOT NULL,
bezahlt_am TEXT
)`);
db.exec(`INSERT INTO nutzer (email) VALUES ('anna@example.com'), ('test@example.com')`);
db.exec(`INSERT INTO mahnungen (nutzer_id, betrag_cent, erstellt_am) VALUES (1, 250, '2026-09-01')`);
db.exec(`INSERT INTO mahnungen (nutzer_id, betrag_cent, erstellt_am, bezahlt_am) VALUES (2, 400, '2026-08-01', '2026-08-15')`);
// Es gibt keine Spalte "darf_ausleihen", und das ist Absicht: Sie waere
// eine zweite Wahrheit neben den Mahnungen und liefe auseinander,
// sobald irgendwo ein Update fehlt.
const zeilen = db.prepare(`
SELECT n.id, n.email,
(SELECT count(*) FROM mahnungen m WHERE m.nutzer_id = n.id AND m.bezahlt_am IS NULL) AS offen
FROM nutzer n ORDER BY n.id
`).all();
for (const zeile of zeilen) {
console.log(`${zeile.id} ${zeile.email.padEnd(17)} offen: ${zeile.offen} darf ausleihen: ${zeile.offen === 0}`);
} Beantwortet wird das mit einer Unterabfrage, einem SELECT in Klammern, das für jeden Nutzer einmal
zählt. So steht die Antwort für alle Nutzer in einer einzigen Anweisung. Anna hat eine offene
Mahnung und darf nicht ausleihen, die Mahnung von test@example.com ist bezahlt.
Die Logik, die du schreibst
/** Daran erkennst du, dass ein Fehler aus deiner eigenen Anwendung kommt. */
export class AppFehler extends Error {
constructor(meldung, code) {
super(meldung);
this.name = new.target.name;
this.code = code;
}
}
export class NichtGefunden extends AppFehler {
constructor(was) {
super(`${was} gibt es nicht.`, "nicht_gefunden");
}
}
export class Konflikt extends AppFehler {
constructor(meldung) {
super(meldung, "konflikt");
}
} import { DatabaseSync } from "node:sqlite";
import { Konflikt, NichtGefunden } from "./fehler.js";
const HOECHSTENS = 2;
const db = new DatabaseSync(":memory:");
db.exec(`CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL)`);
db.exec(`CREATE TABLE ausleihen (id INTEGER PRIMARY KEY, buch_id INTEGER, nutzer_id INTEGER, zurueck_am TEXT)`);
db.exec(`INSERT INTO nutzer (email) VALUES ('anna@example.com')`);
// Eine andere Regel als in der Aufgabe: Hier zaehlt der Nutzer, nicht das Buch.
function leiheAus(nutzerId, buchId) {
const nutzer = db.prepare("SELECT id FROM nutzer WHERE id = ?").get(nutzerId);
if (!nutzer) throw new NichtGefunden(`Einen Nutzer mit der Kennung ${nutzerId}`);
db.exec("BEGIN");
try {
const offen = db
.prepare("SELECT count(*) AS anzahl FROM ausleihen WHERE nutzer_id = ? AND zurueck_am IS NULL")
.get(nutzerId).anzahl;
if (offen >= HOECHSTENS) throw new Konflikt(`Mehr als ${HOECHSTENS} Bücher gleichzeitig gehen nicht.`);
db.prepare("INSERT INTO ausleihen (buch_id, nutzer_id) VALUES (?, ?)").run(buchId, nutzerId);
db.exec("COMMIT");
return { nutzerId, buchId, offen: offen + 1 };
} catch (fehler) {
db.exec("ROLLBACK");
throw fehler;
}
}
// Kein Server, kein curl, kein Port: Die Logik laesst sich aufrufen.
for (const [nutzer, buch] of [[1, 3], [1, 4], [1, 5], [99, 3]]) {
try {
console.log("geklappt:", JSON.stringify(leiheAus(nutzer, buch)));
} catch (fehler) {
console.log(`${fehler.name} (${fehler.code}):`, fehler.message);
}
} Die Regeln der Anwendung sind schnell aufgezählt. Ein Buch, das es nicht gibt, kann man nicht ausleihen, eins, das schon verliehen ist, auch nicht, und alles andere darf.
Diese drei Regeln gehören in die Logik (Lektion 18.1). Im Beispiel siehst du die Bauart an einer Regel, die in der Aufgabe nicht vorkommt, höchstens zwei Bücher gleichzeitig je Nutzer. Ein Server läuft dabei nicht. Die Funktion wird einfach viermal aufgerufen und antwortet mit einem Wert oder mit einem Fehler. So ließe sie sich auch testen.
Zwei Dinge stecken darin.
- Prüfen und Anlegen stehen in einer Transaktion. In dieser Anwendung kann sich zwischen beide
nichts schieben, denn
DatabaseSyncarbeitet synchron, und Node nimmt die nächste Anfrage erst danach an. Ich setze die Transaktion trotzdem drumherum. Sonst sehen zwei Anfragen beide „ist frei“, sobald zwischen Zählen und Einfügen einawaitsteht oder ein zweiter Prozess dieselbe Datei beschreibt. - Der Fehler trägt einen Code und keinen Statuscode. Ein
Konfliktheißtkonflikt, und welche Zahl daraus wird, entscheidet oben der Fehler-Handler. In der Logik steht damit nichts von HTTP.
Die Routen darüber
import express from "express";
import { UngueltigeEingabe } from "../fehler.js";
import { leiheAus } from "../logik/bibliothek.js";
export const ausleihenRouter = express.Router();
ausleihenRouter.post("/", (req, res) => {
// Pruefen gehoert nach oben: Was von aussen kommt, ist erst einmal
// gar nichts (15.1).
const buchId = Number(req.body?.buchId);
if (!Number.isInteger(buchId) || buchId < 1) {
throw new UngueltigeEingabe([{ feld: "buchId", meldung: "buchId muss eine ganze Zahl ab 1 sein." }]);
}
// Wirft leiheAus, reicht Express den Fehler an den Fehler-Handler weiter.
// Einen Statuscode kennt diese Route nur fuer den Erfolg.
res.status(201).json(leiheAus(req.nutzer.id, buchId));
}); import { AppFehler } from "./fehler.js";
import { logge } from "./logger.js";
// Ganz unten in server.js, mit vier Argumenten. Welcher Code welcher
// Statuscode ist, steht in dieser Tabelle und nirgends sonst (16.3).
const STATUS = {
nicht_gefunden: 404,
ungueltig: 400,
nicht_angemeldet: 401,
konflikt: 409,
};
export function fehlerHandler(fehler, req, res, next) {
const bekannt = fehler instanceof AppFehler && STATUS[fehler.code] !== undefined;
// Kaputtes JSON und ein zu grosser Rumpf kommen von express.json(); http-errors
// kennzeichnet sie mit expose, also duerfen sie als Fehler des Aufrufers durch.
const vomAufrufer = !bekannt && fehler.expose === true && fehler.status < 500;
const status = bekannt ? STATUS[fehler.code] : vomAufrufer ? fehler.status : 500;
// Nach innen die ganze Wahrheit samt Kennung, nach aussen ein Satz.
if (status === 500) {
logge("error", "serverfehler", {
anfrageId: req.anfrageId,
fehler: fehler.message,
stapel: fehler.stack,
});
}
const code = bekannt ? fehler.code : vomAufrufer ? "ungueltig" : "serverfehler";
const meldung = bekannt
? fehler.message
: vomAufrufer
? "Die Anfrage war nicht in Ordnung."
: "Da ist etwas schiefgegangen.";
res.status(status).json({ fehler: { code, meldung, felder: fehler.felder } });
} Oben bleibt wenig zu tun, entgegennehmen, prüfen, weitergeben und antworten. Die Eingabeprüfung gehört hierher, denn hier ist die Systemgrenze (Lektion 15.1). Die Statuscodes 404 und 409 stehen hier nicht, die vergibt der Fehler-Handler.
Der Fehler-Handler ganz unten macht aus jedem Fehler eine einheitliche Antwort. Nach innen geht die
vollständige Meldung, nach außen ein Satz und ein maschinenlesbarer Code. Welcher Code welcher
Statuscode ist, steht in seiner Tabelle, und was dort fehlt, wird ein 500. Ausnahmen sind nur
kaputtes JSON und ein zu großer Rumpf. Die kommen von express.json(), schon als Fehler des
Aufrufers gekennzeichnet, und deshalb bleiben sie 400 und 413.
Was mit Absicht fehlt
Der Anwendung fehlt ein schönes Frontend (die API antwortet mit JSON, und das reicht), sie schickt keine E-Mails (Passwort vergessen, Erinnerung an die Rückgabe), und sie hat kein Deployment. Alle drei wären in einem echten Projekt dran, und alle drei brauchen etwas, das dieser Kurs nicht hat.
Auch die Rückgabe fehlt, und eigene Tests gehören nicht zur Aufgabe. In einem Schritt läuft entweder dein Server oder deine Tests, nicht beides. Geprüft wird hier über echte HTTP-Anfragen gegen den laufenden Server. Rückgabe und Tests sind die beiden naheliegenden Erweiterungen, und beide kommen in der nächsten Lektion noch einmal vor.
Woran du merkst, dass du fertig bist
Dass es läuft, reicht nicht. Fertig ist die Ausleihverwaltung, wenn du für jede der vier Routen sagen kannst, was sie antwortet, wenn etwas schiefgeht, und keine dieser Antworten einen Stacktrace enthält.
Im Reiter Praxis werden davon die 404 und die 409 geprüft, die aus deiner Logik kommen, und nichts, was der gegebene Code beantwortet.
Zum Mitnehmen
Was fachlich gilt, steht in der Logik und kommt als Fehler mit Code heraus. Die Routen prüfen die Eingabe, und der Fehler-Handler macht aus jedem Fehler dieselbe Form von Antwort.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.