Aprenda Relacionamentos no Prisma (1-1, 1-m, m-m)

Índice

1. Introdução
2. Relacionamento um-para-um
3. Relacionamento um-para-muitos
4. Relacionamento muitos-para-muitos
5. Relacionamento auto-referenciado
6. Modelagem manual de relacionamentos
7. Modelagem automática de relacionamentos
8. Desafio: Criando um usuário com perfil
9. Desafio: Criando um pedido com usuário
10. Desafio: Criando um produto com categorias
11. Desafio: Criando uma categoria com categoria pai
12. Conclusão

📖 Introdução

Bem-vindo de volta a mais um vídeo, onde vamos explorar os relacionamentos no Prisma. Este vídeo é adequado para iniciantes, então mesmo que você não esteja familiarizado com SQL, Prisma ou relacionamentos de banco de dados, ainda vai ser útil para você. No entanto, se você já conhece o Prisma, também encontrará algumas coisas úteis aqui. Vamos começar com um relacionamento um-para-um, depois um relacionamento um-para-muitos, muitos-para-muitos e finalmente um relacionamento auto-referenciado.

🧩 Relacionamento um-para-um

Começaremos com um relacionamento simples de um-para-um, onde um usuário tem um perfil e um perfil pertence a um usuário. Para modelar isso, criaremos um modelo de usuário e um modelo de perfil. O modelo de usuário terá um ID e um campo de perfil, enquanto o modelo de perfil terá apenas um ID e um campo de nome. Usaremos o Prisma para definir o relacionamento entre eles.

model User {
  id      String   @id @default(cuid())
  profile Profile?
}

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

📦 Relacionamento um-para-muitos

Agora vamos avançar para um relacionamento um-para-muitos, onde um pedido pode ter um usuário e um usuário pode ter vários pedidos. Para isso, adicionaremos um modelo de pedido com um ID, data de criação e data de atualização. Vamos definir o relacionamento entre o usuário e o pedido usando o Prisma.

model Order {
  id         String   @id @default(cuid())
  createdAt  DateTime @default(now())
  updatedAt  DateTime @updatedAt
  user       User     @relation(fields: [userId], references: [id])
  userId     String
}

model User {
  id        String    @id @default(cuid())
  orders    Order[]
}

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

🔗 Relacionamento muitos-para-muitos

Agora vamos abordar o relacionamento muitos-para-muitos, onde um produto pode ter várias categorias e uma categoria pode pertencer a vários produtos. Para isso, adicionaremos um modelo de produto com um ID, nome e preço. Usaremos o Prisma para definir o relacionamento entre o produto e a categoria.

model Product {
  id          String     @id @default(cuid())
  name        String
  price       Int
  categories  Category[]  
}

model Category {
  id          String     @id @default(cuid())
  name        String
  products    Product[]  
}

🔄 Relacionamento auto-referenciado

Agora vamos explorar o relacionamento auto-referenciado, onde uma categoria pode ter uma categoria pai e uma categoria pai pode ter vários filhos. Para isso, adicionaremos um campo parentId ao modelo de categoria, que será uma chave estrangeira referenciando o próprio modelo de categoria.

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

🛠️ Modelagem manual de relacionamentos

Até agora, modelamos relacionamentos usando a sintaxe do Prisma, que nos permite definir o relacionamento diretamente no modelo. No entanto, também podemos modelar relacionamentos muitos-para-muitos de forma explícita, criando uma tabela de junção manualmente. Isso nos dá um pouco mais de controle sobre o relacionamento. Usaremos o Prisma para definir a tabela de junção.

model Product {
  id          String         @id @default(cuid())
  name        String
  price       Int
  categories  Category[]    
}

model Category {
  id           String        @id @default(cuid())
  name         String
}

model ProductCategory {
  productId    String
  categoryId   String

  // Foreign Key Constraints
  product      Product       @relation(fields: [productId], references: [id])
  category     Category      @relation(fields: [categoryId], references: [id])

  @@id([productId, categoryId])
}

✨ Modelagem automática de relacionamentos

No exemplo anterior, modelamos o relacionamento muitos-para-muitos de forma explícita, criando uma tabela de junção manualmente. No entanto, o Prisma também nos permite modelar relacionamentos muitos-para-muitos de forma implícita, onde o Prisma cria a tabela de junção automaticamente. Vamos modelar um relacionamento muitos-para-muitos implícito entre produtos e categorias.

model Product {
  id            String           @id @default(cuid())
  name          String
  price         Int
  categories    Category[]
}

model Category {
  id            String           @id @default(cuid())
  name          String
  products      Product[]
}

🎯 Desafio: Criando um usuário com perfil

Agora vamos enfrentar alguns desafios para aplicar o que aprendemos até agora. O primeiro desafio é criar um usuário com perfil. Vamos usar o Prisma para criar o usuário e o perfil, e depois encontrar o usuário incluindo o perfil.

async function createUserWithProfile() {
  await clean()

  const user = await prisma.user.create({
    data: {}
  })

  const profile = await prisma.profile.create({
    data: {
      name: faker.name.firstName(),
      user: {
        connect: { id: user.id }
      }
    }
  })

  console.log(`🔐 Criando usuário com perfil:`)
  console.log(`Usuário:`, user)
  console.log(`Perfil:`, profile)
}

createUserWithProfile()

🎯 Desafio: Criando um pedido com usuário

O próximo desafio é criar um pedido com um usuário. Vamos usar o Prisma para criar o pedido e conectar o usuário a ele.

async function createOrderWithUser() {
  await clean()

  const user = await createUser()

  const order = await prisma.order.create({
    data: {
      user: {
        connect: { id: user.id }
      }
    }
  })

  console.log(`📦 Criando pedido com usuário:`)
  console.log(`Pedido:`, order)
}

createOrderWithUser()

🎯 Desafio: Criando um produto com categorias

Agora vamos criar um produto e conectá-lo a uma ou mais categorias. Vamos usar o Prisma para criar o produto, selecionar categorias aleatórias e conectá-las ao produto.

async function createProductWithCategories() {
  await clean()

  const products = await createProducts()
  const categories = await createCategories()

  const product = await prisma.product.create({
    data: {
      name: faker.commerce.product(),
      categories: {
        connect: categories.map(category => ({ id: category.id }))
      }
    }
  })

  console.log(`📦 Criando produto com categorias:`)
  console.log(`Produto:`, product)
}

createProductWithCategories()

🎯 Desafio: Criando uma categoria com categoria pai

No último desafio, vamos criar uma categoria com uma categoria pai. Vamos usar o Prisma para criar as categorias, selecionar uma categoria pai aleatória e conectá-la à nova categoria.

async function createCategoryWithParent() {
  await clean()

  const categories = await createCategories()

  const category = await prisma.category.create({
    data: {
      name: faker.commerce.department(),
      parent: {
        connect: { id: getRandomItem(categories).id }
      }
    }
  })

  console.log(`📦 Criando categoria com categoria pai:`)
  console.log(`Categoria:`, category)
}

createCategoryWithParent()

🏁 Conclusão

Parabéns por concluir este Tutorial sobre relacionamentos no Prisma! Aprendemos a modelar e inserir dados em relacionamentos um-para-um, um-para-muitos, muitos-para-muitos e auto-referenciados. Também vimos como modelar relacionamentos manualmente ou deixar o Prisma fazer isso automaticamente. Espero que você tenha encontrado este tutorial útil e que possa aplicar esses conceitos em seus próprios projetos com Prisma. Fique à vontade para deixar um comentário se tiver alguma dúvida ou feedback. Obrigado!