Gerador de Prisma model a partir de tabela

Schema Prisma: modelos declarativos, relações e migrations

O schema do Prisma é um único arquivo .prisma escrito em uma DSL declarativa específica. Diferente de ORMs imperativos onde os modelos vivem em classes TypeScript ou objetos JavaScript, o Prisma coloca o formato do banco em um arquivo dedicado e o usa como fonte única da verdade: prisma generate transforma-o em um cliente tipado e prisma migrate converte mudanças no schema em DDL SQL. A contrapartida é aprender uma mini-linguagem nova — o ganho é type safety imbatível e um workflow que escala de projetos solo a times grandes.

Este gerador monta a estrutura básica de um model; o guia abaixo cobre o catálogo completo de atributos, tipos escalares, relações, o pipeline do generator e como o Prisma se compara a TypeORM, Sequelize e Drizzle.

Anatomia de um schema

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  posts     Post[]
  createdAt DateTime @default(now())
}

model Post {
  id       Int    @id @default(autoincrement())
  title    String
  author   User   @relation(fields: [authorId], references: [id])
  authorId Int
}

Três blocos dominam todo schema: datasource (conexão + provider), generator (que artefatos o Prisma emite — tipicamente o client JS) e uma ou mais declarações model. O ? final marca o campo como opcional; arrays denotam relações 1:N do lado do pai.

Atributos de campo, tipos escalares, defaults

Atributos de campo: @id, @unique, @default(...), @updatedAt, @map("col_name") (renomeia no banco), @relation(fields, references) (foreign key). Atributos de bloco: @@id([cols]) para chave primária composta, @@unique, @@index, @@map("table_name"). Tipos escalares: String, Int, BigInt, Float, Decimal, Boolean, DateTime, Json, Bytes, mais enum definidos pelo usuário. Geradores de default: autoincrement(), now(), uuid(), cuid() e dbgenerated("expr") para defaults SQL nativos como sequences ou colunas computadas.

Relações: 1:1, 1:N, N:N

O Prisma suporta as três cardinalidades clássicas. 1:1 exige @relation no lado dono mais uma foreign key com @unique. 1:N é implícito: declare o array no pai e a FK no filho. N:N vem em dois sabores: implícito (o Prisma gerencia uma tabela de junção escondida) ou explícito (você modela a junção, o que permite adicionar colunas a ela).

// N:N implícita
model Article { tags Tag[] }
model Tag     { articles Article[] }

// N:N explícita — quando o join carrega dados
model ArticleTag {
  article    Article @relation(fields: [articleId], references: [id])
  articleId  Int
  tag        Tag     @relation(fields: [tagId], references: [id])
  tagId      Int
  addedAt    DateTime @default(now())
  @@id([articleId, tagId])
}

Generator, migrations, ecossistema

• Pipeline do generator: prisma generate lê o schema e emite um Client tipado em node_modules/@prisma/client. Rode de novo a cada edição do schema.
• Migrations: prisma migrate dev compara o schema com o banco, grava um arquivo SQL de migration e o aplica. O schema é a fonte da verdade — nunca edite o banco diretamente.
• Prisma Studio: GUI embutida (prisma studio) para navegar nos dados — útil para QA sem escrever queries.
• Suporte a bancos: PostgreSQL, MySQL, SQLite, SQL Server, CockroachDB e MongoDB (ainda em amadurecimento). Multi-schema só em PostgreSQL no momento.
• vs TypeORM: Prisma é declarativo e schema-first; TypeORM é imperativo e class-first. A inferência de tipos do Prisma é mais afiada out-of-the-box.
• vs Drizzle: o Drizzle é mais leve e fica mais perto do SQL — sem etapa de generator e sem DSL proprietária. O Prisma oferece abstração mais alta com DX afiada; o Drizzle vence em bundle size e transparência SQL.
• Performance: o histórico query engine em Rust foi reescrito em TypeScript em versões recentes, removendo a dependência de binário.

FAQ

O Prisma substitui ORMs tradicionais? Para a maioria dos projetos TypeScript modernos, sim — cobre schema, migrations e cliente tipado em uma ferramenta. Projetos legados com stored procedures complexas ou SQL específico do vendor ainda podem preferir queries brutas ou a flexibilidade do TypeORM.

O client é totalmente type-safe? Sim. Cada model, campo e relação vira parte dos tipos TypeScript, então campos errados, tipos errados e includes quebrados são pegos em compile time. O autocomplete na IDE acompanha o schema em tempo real.

A curva de aprendizado é alta? Menor que TypeORM ou Sequelize. A DSL do Prisma é pequena e auto-contida; a documentação é boa; e a maioria dos times fica produtiva em um dia. O difícil é desaprender hábitos de ORM imperativo.

E recursos avançados de SQL? O Prisma cobre os casos comuns; para window functions, CTEs recursivas ou extensões do vendor, caia para prisma.$queryRaw (template tag SQL) ou $executeRaw para DDL. A maioria dos projetos usa queries raw em alguns pontos e o cliente tipado no resto.