Claude Code Express: REST-APIs mit Express.js schneller bauen

Express.js ist das meistgenutzte Web-Framework für Node.js — minimalistisch, middleware-basiert, und seit über einem Jahrzehnt das Rückgrat von REST-APIs. Gleichzeitig ist Express eines der Frameworks, bei dem Boilerplate schnell ausufert: Routing-Dateien, Controller, Services, Error-Handler, Auth-Middleware — alles von Hand aufgebaut, bevor die eigentliche Logik beginnt.

Genau hier greift Claude Code Express: nicht als Zauberwort, sondern als präzise Arbeitsweise. Claude Code liest bestehende Express-Projekte, generiert saubere Boilerplate, erklärt Middleware-Ketten und refactort Routen auf MVC-Struktur — ohne dass man jedes Mal von vorne anfangen muss.

1. Was ist Express.js?

Express.js ist ein minimalistisches Web-Framework für Node.js. Es ergänzt den eingebauten http-Modul von Node mit Routing, Middleware-Unterstützung und einem einfachen Request-Response-Zyklus — ohne die Entscheidungen eines Full-Stack-Frameworks wie NestJS oder Fastify vorzuschreiben.

Das macht Express flexibel und schnell lernbar, aber auch anfällig für inkonsistente Strukturen: Jedes Projekt sieht anders aus, weil Express selbst keine Meinung hat. Claude Code füllt diese Lücke: Es kennt etablierte Muster und setzt sie konsistent um, egal ob das Projekt von Grund auf neu ist oder ein gewachsenes Altsystem.

2. Routing: Routen sauber strukturieren

Express kennt die klassischen HTTP-Methoden direkt als Methoden auf dem App-Objekt: app.get(), app.post(), app.put(), app.delete(). Für größere Projekte werden Router-Objekte verwendet, die Routen nach Ressource gruppieren.

// routes/users.js
const router = require('express').Router();

// Parameter-Route: /users/:id
router.get('/:id', async (req, res, next) => {
  try {
    const user = await UserService.findById(req.params.id);
    if (!user) return res.status(404).json({ error: 'Not found' });
    res.json(user);
  } catch (err) {
    next(err);
  }
});

// Query-String: /users?role=admin&page=2
router.get('/', async (req, res, next) => {
  try {
    const { role, page = 1, limit = 20 } = req.query;
    const users = await UserService.list({ role, page, limit });
    res.json(users);
  } catch (err) {
    next(err);
  }
});

module.exports = router;

Claude Code baut diese Router-Struktur auf Befehl komplett auf — inklusive Parameter-Validierung, Query-String-Parsing und konsistentem Error-Handling. Der Prompt ist direkt:

claude "Erstelle einen Express-Router für die Users-Ressource:
GET /users (Liste mit Pagination), GET /users/:id, POST /users,
PUT /users/:id, DELETE /users/:id. MVC-Struktur, async/await, try-catch."

3. Middleware: Die Schaltzentrale von Express

Middleware ist das Herzstück von Express. Jede Funktion mit der Signatur (req, res, next) ist eine Middleware — sie kann die Anfrage verändern, eine Antwort senden oder die Kontrolle weitergeben.

Eingebaute Middleware

const express = require('express');
const app = express();

// JSON-Body parsen
app.use(express.json());

// URL-encoded Forms parsen
app.use(express.urlencoded({ extended: true }));

// Statische Dateien ausliefern
app.use(express.static('public'));

Eigene Middleware

Eigene Middleware folgt demselben Muster. Ein Request-Logger als Beispiel:

// middleware/logger.js
const logger = (req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
  });
  next();
};

module.exports = logger;

Claude Code erklärt Middleware-Ketten auf Anfrage vollständig — einschließlich der Reihenfolge (die in Express kritisch ist) und der Frage, wann next() versus next(err) aufgerufen werden soll.

Error-Handler als letztes Glied

// middleware/errorHandler.js
const errorHandler = (err, req, res, next) => {
  const status = err.status || err.statusCode || 500;
  const message = err.message || 'Internal Server Error';

  // Im Development: Stack-Trace mitgeben
  const response = { error: message };
  if (process.env.NODE_ENV === 'development') {
    response.stack = err.stack;
  }

  res.status(status).json(response);
};

module.exports = errorHandler;

4. REST-API mit MVC-Struktur aufbauen

Gut strukturierte Express-Projekte folgen dem MVC-Muster: Routes delegieren an Controller, Controller nutzen Services, Services kapseln die Datenbanklogik. Claude Code generiert diese Struktur auf einen einzigen Prompt:

// controllers/userController.js
const UserService = require('../services/userService');

exports.getUser = async (req, res, next) => {
  try {
    const user = await UserService.findById(req.params.id);
    if (!user) return res.status(404).json({ error: 'User not found' });
    res.json(user);
  } catch (err) {
    next(err);
  }
};

exports.createUser = async (req, res, next) => {
  try {
    const user = await UserService.create(req.body);
    res.status(201).json(user);
  } catch (err) {
    next(err);
  }
};

Der Service-Layer hält die Controller schlank und testbar: Controller kümmern sich nur um HTTP-Kontext (Status-Codes, Request/Response), Services um Geschäftslogik. Claude Code kennt dieses Muster und hält es konsequent ein, wenn man es einmal explizit fordert.

5. Authentication: JWT und Passport.js

JWT-basierte Authentication ist in Express-APIs Standard. Die Bibliothek jsonwebtoken liefert sign() und verify(), eine Auth-Middleware schützt geschützte Routen:

// middleware/auth.js
const jwt = require('jsonwebtoken');

const authenticate = (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Missing token' });
  }

  const token = authHeader.split(' ')[1];
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    req.user = payload;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Invalid or expired token' });
  }
};

module.exports = authenticate;

Für komplexere Auth-Szenarien — OAuth2, lokale Strategie mit Passwort-Hash, Sessions — bietet Passport.js ein Strategy-Muster, das sich nahtlos in die Express-Middleware-Kette einfügt. Claude Code erklärt auf Anfrage beide Ansätze und zeigt, wann JWT ausreicht und wann Passport sinnvoll ist.

"JWT ist stateless und skaliert horizontal ohne Shared-State. Passport ist sinnvoll, wenn du mehrere Strategien (Google, GitHub, lokal) unter einer einheitlichen API zusammenfassen willst."

6. Error Handling: Async-Wrapper und globaler Handler

Der häufigste Fehler in Express-APIs: vergessenes try-catch in async Route-Handlern. Unbehandelte Promise-Rejections crashen den Prozess oder hängen die Anfrage — kein Timeout, keine Fehlermeldung. Ein Async-Wrapper löst das systemisch:

// utils/asyncWrapper.js
const asyncWrapper = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

module.exports = asyncWrapper;

// Verwendung in Routen:
const asyncWrapper = require('../utils/asyncWrapper');

router.get('/:id', asyncWrapper(async (req, res) => {
  const user = await UserService.findById(req.params.id);
  if (!user) return res.status(404).json({ error: 'Not found' });
  res.json(user);
}));

Mit diesem Wrapper braucht kein Route-Handler mehr ein eigenes try-catch — alle Fehler landen automatisch im globalen Error-Handler. Claude Code schreibt diesen Wrapper und refactort bestehende Routen darauf, wenn man es mit dem bestehenden Code und einem klaren Auftrag füttert.

7. Claude Code Express-Tipps für den Alltag

Drei Einsatzszenarien, die in der Praxis den größten Zeitgewinn bringen:

REST-API-Boilerplate generieren

Statt Dateien von Hand zu erstellen, beschreibt man das gewünschte Ergebnis:

claude "Erstelle eine vollständige Express-REST-API-Struktur für ein Blog-System:
Ressourcen: posts, comments, users. MVC-Struktur, JWT-Auth,
express-validator für Input-Validierung, globaler Error-Handler,
async-Wrapper. Zeige die Verzeichnisstruktur und alle Hauptdateien."

Claude Code generiert Verzeichnisstruktur, Hauptdateien und verbindet alles in app.js — in der Zeit, die man sonst für die ersten drei Dateien braucht.

Middleware-Ketten erklären lassen

Bestehende Projekte haben oft Middleware-Ketten, deren Reihenfolge nicht dokumentiert ist. Claude Code liest app.js und erklärt, in welcher Reihenfolge Middleware greift und warum — inklusive möglicher Fallstricke:

claude "Erklär die Middleware-Reihenfolge in app.js. Gibt es potenzielle
Probleme mit der aktuellen Reihenfolge? Besonders: CORS vor Auth?"

Routen refactorn

Gewachsene Codebases haben häufig Route-Handler, die Controller-Logik, Service-Calls und Datenbankzugriffe mischen. Claude Code trennt das sauber auf:

claude "Refactor routes/posts.js auf MVC: Controller in controllers/postController.js,
Datenbanklogik in services/postService.js. Behalte das bestehende Verhalten exakt bei."

• Boilerplate: Vollständige API-Struktur in Minuten statt Stunden
• Middleware-Analyse: Reihenfolge und Fallstricke auf einen Blick
• Refactoring: MVC-Trennung ohne Verhaltensänderung
• Auth: JWT-Middleware und Passport-Strategien konsistent eingebaut
• Error Handling: Async-Wrapper und globaler Handler systemisch, nicht Datei für Datei

Der Schlüssel ist Kontext: Claude Code liefert dann die besten Ergebnisse, wenn man es aus dem Root-Verzeichnis des Projekts startet und den Auftrag präzise formuliert — Ressource, Muster, Bibliotheken. Vage Aufträge führen zu generischen Antworten; präzise Aufträge zu produktionsreifem Code.

Verwandte Artikel:

• Claude Code Debugging — Bugs in Express-APIs systematisch finden und beheben
• Claude Code für Unternehmen — Team-Workflows und Deployment auf Unternehmensebene