← Alle Projekte

Eigenes Projekt, allein entwickelt

Expenseapp

Einnahmen und Ausgaben im Griff, mit Kategorien, Diagrammen und eigenem Admin-Bereich.

Rolle
Allein entwickelt
Stack
React, TanStack Query, Express, Prisma, PostgreSQL
Screenshot: Expenseapp

Ausgangslage & Ziel

Nach dem Praktikum wollte ich eine Anwendung komplett allein bauen, von der Datenbank bis zum Deployment, um Backend-Architektur wirklich zu verstehen.

Meine Rolle

Planung, Datenmodell, Backend, Frontend und Deployment habe ich selbst umgesetzt. Es gab keine Vorlage aus einem Kurs.

Features

  • Registrierung, Login und geschützte Routen
  • Einnahmen und Ausgaben anlegen, bearbeiten, löschen, suchen und filtern
  • Globale Kategorien vom Admin und persönliche Kategorien pro Nutzer
  • Dashboard mit Summen, letzten Buchungen und Diagrammen (Chart.js)
  • Admin-Bereich, nur für die Rolle ADMIN

Architektur

  1. React + TanStack Query
  2. Express API
  3. Services
  4. Prisma
  5. PostgreSQL

Herausforderung & Lösung

Die Datenbank musste wachsen: erst Kategorien mit Icon und Farbe, dann Rollen und globale Kategorien. Bestehende Daten durften dabei nicht verloren gehen.

Jede Änderung am Schema ist eine eigene Prisma-Migration. So ist nachvollziehbar, wie sich die Datenbank entwickelt hat, und jede Umgebung lässt sich gleich aufsetzen.

Code-Einblicke

backend/src/validators/transactionValidator.js
const transactionType = z.preprocess(
  (value) => (typeof value === "string" ? value.toUpperCase() : value),
  z.enum(["INCOME", "EXPENSE"])
);

export const createTransactionSchema = z.object({
  title: z.string().min(2, "Title must be at least 2 characters"),
  amount: z.number().positive("Amount must be greater than 0"),
  type: transactionType,
  description: z.string().optional(),
  date: z.string().datetime("Invalid date format"),
  categoryId: z.string().uuid("Invalid category id"),
});

Jede Anfrage wird geprüft, bevor sie die Datenbank erreicht: falscher Betrag oder ungültige Kategorie werden sofort abgelehnt.

backend/src/middlewares/authMiddleware.js
function authMiddleware(req, res, next) {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith("Bearer ")) {
    return res.status(401).json({ message: "Not authorized, no token" });
  }

  const token = authHeader.split(" ")[1];

  try {
    req.user = jwt.verify(token, process.env.JWT_SECRET);
    next();
  } catch (error) {
    return res.status(401).json({ message: "Not authorized, invalid token" });
  }
}

Geschützte Routen laufen durch eine Middleware, die das JWT prüft und den Nutzer an die Anfrage hängt.

backend/prisma/schema.prisma
model Transaction {
  id          String          @id @default(uuid())
  title       String
  amount      Decimal         @db.Decimal(10, 2)
  type        TransactionType
  date        DateTime
  category    Category        @relation(fields: [categoryId], references: [id])
  user        User            @relation(fields: [userId], references: [id])

  @@index([categoryId])
  @@index([userId])
}

Beträge als Decimal statt Float, damit keine Rundungsfehler entstehen. Indizes beschleunigen die Abfragen pro Nutzer.

Was ich gelernt habe

  • Backend sauber in Schichten aufbauen
  • Datenbanken mit Migrationen weiterentwickeln
  • Eingaben serverseitig validieren statt dem Frontend zu vertrauen
  • Rollen und Berechtigungen im Backend durchsetzen

Nächste Schritte

  • Wiederkehrende Einnahmen: Gehalt einmal festlegen, die App bucht es jeden Monat automatisch.