# So beheben Sie, dass KI ungültige Prisma-Beziehungen generiert

> KI-Agenten generieren Prisma-Schema-Beziehungen mit fehlenden Gegenbeziehungen, falschen referenziellen Aktionen oder nicht übereinstimmenden Feldtypen, die bei prisma validate und prisma migrate fehlschlagen.

**Type:** Failure  
**Tools:** Cursor, Claude Code, Codex, Windsurf  
**Stack:** PostgreSQL, TypeScript  
**Updated:** 2026-06-08

---

Der Agent schreibt ein Prisma-Schema mit Beziehungen, die korrekt aussehen, aber bei
`prisma validate` aufgrund fehlender Rückverweise, Typinkonsistenzen oder
mehrdeutigen Multi-Beziehungs-Setups fehlschlagen.

## Das Symptom

Eine Beziehung wird in einem Modell deklariert, ohne dass das erforderliche Gegenstück im
anderen vorhanden ist, oder der Typ des Fremdschlüsselfelds stimmt nicht mit dem referenzierten Feld überein.

```prisma
// schema.prisma — WRONG
model User {
  id    String @id @default(cuid())
  posts Post[]
}

model Post {
  id       String @id @default(cuid())
  authorId Int    // Int, but User.id is String — type mismatch
  // Missing: author User @relation(fields: [authorId], references: [id])
}
```

Die Ausführung von `prisma validate` ergibt:

```
Error: The relation field `posts` on model `User` is missing an opposite
relation field on the model `Post`.
```

## Warum es passiert

Der Agent schreibt oft eine Seite einer Beziehung und vergisst, die andere hinzuzufügen,
insbesondere bei Many-to-Many- oder selbstreferenziellen Fällen. Außerdem kopiert er Feldtypen
aus dem Gedächtnis, ohne zu überprüfen, ob `authorId` exakt dem referenzierten `id`-Typ
entsprechen muss.

## Wie man es erkennt

- `prisma validate` oder `prisma migrate dev` schlägt mit einem Beziehungsfehler fehl.
- Ein Modell hat ein Array-Feld (One-to-Many), aber das referenzierte Modell hat keinen
  skalaren Fremdschlüssel oder kein `@relation`-Attribut.
- Many-to-Many verwendet explizite Join-Tabellen mit nicht übereinstimmenden Typen.
- Selbstreferenzielle Modelle (z. B. Kategoriebäume) haben nur eine Seite des
  `@relation(name: "...")`-Paars.

## Wie man es behebt

Jede Beziehung muss auf beiden Seiten deklariert sein. Die skalaren Fremdschlüsseltypen müssen
genau mit dem referenzierten Feldtyp übereinstimmen.

```prisma
// schema.prisma — CORRECT
model User {
  id    String @id @default(cuid())
  posts Post[] // one-to-many: back-reference
}

model Post {
  id       String @id @default(cuid())
  authorId String                       // String, matches User.id
  author   User   @relation(fields: [authorId], references: [id], onDelete: Cascade)
}
```

Für einen selbstreferenziellen Baum:

```prisma
model Category {
  id       String     @id @default(cuid())
  parentId String?
  parent   Category?  @relation("CategoryTree", fields: [parentId], references: [id])
  children Category[] @relation("CategoryTree")
}
```

```txt
[ ] Run "prisma validate" before "prisma migrate dev" — fix all errors first
[ ] Every @relation on model A has a matching field on model B
[ ] Foreign key scalar type matches the referenced @id type (String/Int/cuid)
[ ] Self-referential relations use a named @relation("name") on both sides
[ ] Explicit many-to-many join tables declare both foreign keys with onDelete
[ ] onDelete referential action is explicit (Cascade, Restrict, SetNull) — not left to default
```

## Korrektur-Prompt

```txt title="Fix Prompt"
This Prisma schema fails prisma validate. Fix every relation error: add the
missing back-reference fields, ensure all foreign key scalar types exactly match
the referenced @id type, give every self-referential relation a unique name on
both sides, and set explicit onDelete actions (Cascade for required relations,
SetNull for optional). Run prisma validate after each change until it passes.
```

## Test

```bash
# Validate schema before attempting migration
npx prisma validate && echo "Schema OK" || echo "FAIL: schema invalid"

# Also check for type mismatches (Int fk -> String id is a common error)
grep -A3 "@relation" prisma/schema.prisma
```