Edit Prisma schema files with syntax highlighting, model validation, and relation visualization.
Prisma schemas are hand-written text, and the errors that hurt live in the relations between models, not in the syntax. This tool parses the Prisma Schema Language (PSL), highlights syntax as you type, and validates models the way prisma validate does, flagging broken relations, missing ids, and mismatched field types before you ever run a migration. It also draws the data model as a diagram of model boxes and relation edges. The surprise for most users: every relation must be declared on both models. Listing the foreign key on one model and nothing on the other is a validation error, not an omission the tool will fill in.
A concrete input and expected output from the current implementation.
Input
datasource db {
provider = "postgresql"
url = "postgresql://user:pass@localhost:5432/mydb"
}
model User {
id Int @id @default(autoincrement())
}
model Post {
id Int @id @default(autoincrement())
authorId Int
author User @relation(fields: [authorId], references: [id])
} Expected output
Validation reports an error: "The relation field `author` on model `Post` is missing an opposite relation field on the model `User`." Both models render in the diagram, but the relation edge between them is flagged as invalid rather than drawn as a resolved connection.
Prisma requires every relation to be declared on both participating models: one side carries the foreign key (`author` with `fields: [authorId]`), and the other must declare the matching list field (`posts Post[]`). With only one side declared, the relation cannot be resolved, so validation rejects the schema.
The schema text is parsed into models, fields, and attributes. Validation then walks every `@relation`: it pairs `fields` with `references` element by element, checks that the two arrays have equal length and matching types, verifies an opposite relation field exists on the target model, and confirms every model carries an `@id` or `@@id`. Each error is reported against the specific model or field, mirroring what the `prisma validate` command reports.
Each model becomes a box in the diagram listing its fields; relation fields become edges to other boxes. Cardinality is inferred from the schema: a foreign key without `@unique` is one-to-many, with `@unique` it is one-to-one, and two list fields with no `@relation` attribute form an implicit many-to-many edge whose generated join table the tool renders as part of the relation.
When two models have more than one relation between them, Prisma cannot tell which fields pair with which. Add the same `name` argument to both sides, for example `@relation(name: "AuthorPosts", fields: [authorId], references: [id])`. If the names differ or only one side carries one, validation fails.
No. It parses and validates the schema you paste and renders the diagram from that text alone; nothing connects to a database and no migrations are generated. Anything that touches the real database - `prisma migrate dev`, `prisma db pull`, `prisma generate` - runs through the Prisma CLI, not this tool.
The example and behavioral notes were checked against the browser implementation. Standards and primary references below define the relevant format, formula, or platform behavior.
Format, validate, and beautify JSON with syntax highlighting and error detection.
Encode text or files to Base64 and decode Base64 strings back to their original form.
Format and indent SQL queries for better readability across all major dialects.
Convert HTML markup into clean Markdown syntax with support for tables and lists.
Write Markdown and see the rendered HTML output in real time with live preview.
Visualize unified diffs and patch files with color-coded additions and deletions.