Prisma com TypeScript: Guia Completo 2026

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

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

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String
  role      Role     @default(USER)
  posts     Post[]
  profile   Profile?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Post {
  id        String   @id @default(cuid())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  String
  tags      Tag[]
  createdAt DateTime @default(now())
}

model Profile {
  id     String  @id @default(cuid())
  bio    String?
  avatar String?
  user   User    @relation(fields: [userId], references: [id])
  userId String  @unique
}

model Tag {
  id    String @id @default(cuid())
  name  String @unique
  posts Post[]
}

enum Role {
  USER
  ADMIN
  EDITOR
}

// src/lib/prisma.ts
import { PrismaClient } from '@prisma/client';

// Evita múltiplas instâncias em desenvolvimento (hot reload)
const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined;
};

export const prisma =
  globalForPrisma.prisma ??
  new PrismaClient({
    log: ['query', 'error', 'warn'],
  });

if (process.env.NODE_ENV !== 'production') {
  globalForPrisma.prisma = prisma;
}

import { prisma } from './lib/prisma';
import { User, Post, Prisma } from '@prisma/client';

// CREATE - tipos gerados garantem campos corretos
async function createUser(data: Prisma.UserCreateInput): Promise<User> {
  return prisma.user.create({ data });
  // data precisa ter: email (string), name (string)
  // data pode ter: role (Role), posts, profile
}

// Usando:
await createUser({
  email: 'maria@email.com',
  name: 'Maria Silva',
  role: 'ADMIN', // autocomplete mostra: USER, ADMIN, EDITOR
});

// READ - com filtros tipados
async function findUsers(where?: Prisma.UserWhereInput): Promise<User[]> {
  return prisma.user.findMany({
    where,
    orderBy: { createdAt: 'desc' },
  });
}

// Filtros com autocomplete:
await findUsers({
  role: 'ADMIN',
  email: { contains: '@empresa.com' },
  createdAt: { gte: new Date('2025-01-01') },
});

// UPDATE - só campos do modelo
async function updateUser(
  id: string,
  data: Prisma.UserUpdateInput
): Promise<User> {
  return prisma.user.update({ where: { id }, data });
}

// DELETE
async function deleteUser(id: string): Promise<User> {
  return prisma.user.delete({ where: { id } });
}

// Include traz dados de relações com tipos corretos
async function getUserWithPosts(id: string) {
  const user = await prisma.user.findUnique({
    where: { id },
    include: {
      posts: {
        where: { published: true },
        orderBy: { createdAt: 'desc' },
        include: { tags: true },
      },
      profile: true,
    },
  });

  // user.posts é Post[] (com tags: Tag[])
  // user.profile é Profile | null
  return user;
}

// Select pra trazer só campos específicos
async function getUserEmails() {
  const users = await prisma.user.findMany({
    select: {
      id: true,
      email: true,
      name: true,
      // posts: false -- nao precisa explicitar
    },
  });

  // Tipo retornado: { id: string; email: string; name: string }[]
  // Sem campos extras. Tipo exato do que você pediu.
  return users;
}

// Criar com relação
async function createPostWithTags() {
  return prisma.post.create({
    data: {
      title: 'Meu Post',
      content: 'Conteudo aqui',
      author: { connect: { email: 'maria@email.com' } },
      tags: {
        connectOrCreate: [
          { where: { name: 'TypeScript' }, create: { name: 'TypeScript' } },
          { where: { name: 'Prisma' }, create: { name: 'Prisma' } },
        ],
      },
    },
    include: { author: true, tags: true },
  });
}

import { Prisma, User, Post, Role } from '@prisma/client';

// Prisma gera tipos pra tudo:
// - User, Post, Profile, Tag = tipos dos modelos
// - Role = enum
// - Prisma.UserCreateInput = tipo do data pra create
// - Prisma.UserUpdateInput = tipo do data pra update
// - Prisma.UserWhereInput = tipo dos filtros
// - Prisma.UserSelect = tipo do select
// - Prisma.UserInclude = tipo do include

// Tipo de User com relações incluídas
type UserWithPosts = Prisma.UserGetPayload<{
  include: { posts: true; profile: true };
}>;

function renderUserProfile(user: UserWithPosts) {
  console.log(user.name);
  console.log(user.posts.length); // posts é Post[]
  console.log(user.profile?.bio); // profile é Profile | null
}

// Tipo derivado com select específico
type UserSummary = Prisma.UserGetPayload<{
  select: { id: true; name: true; email: true };
}>;

function renderUserCard(user: UserSummary) {
  // Só tem id, name, email. Nada mais.
  console.log(`${user.name} - ${user.email}`);
}