DEV Community: Leandro Martins

Entendendo o Fluxo de Trabalho do Prisma Utilizando Migrations

Leandro Martins — Wed, 17 Jul 2024 01:56:29 +0000

Prisma é um ORM (Object-Relational Mapping) moderno que facilita a interação com bancos de dados em aplicações Node.js e TypeScript. Uma das funcionalidades mais importantes do Prisma é o sistema de migrações, que permite manter o esquema do banco de dados sincronizado com o modelo de dados da aplicação. Neste post, vamos explorar o fluxo de trabalho do Prisma utilizando migrations.

O que são Migrations?

Migrations são um método para controlar e aplicar alterações no esquema do banco de dados de forma sistemática e versionada. Elas permitem que você defina mudanças estruturais no banco de dados, como criar ou alterar tabelas, de maneira incremental e reversível.

Fluxo de Trabalho do Prisma com Migrations

O fluxo de trabalho típico com migrations no Prisma envolve os seguintes passos:

Instalação e Configuração Inicial
Definição do Esquema
Criação de uma Migration
Aplicação da Migration
Gerenciamento de Migrations

Passo 1: Instalação e Configuração Inicial

Primeiro, precisamos instalar o Prisma no projeto e inicializá-lo:

npm install @prisma/client
npx prisma init

Este comando cria um diretório prisma contendo um arquivo schema.prisma, onde definimos nosso modelo de dados.

Passo 2: Definição do Esquema

No arquivo schema.prisma, definimos os modelos que representam as tabelas do banco de dados. Por exemplo, vamos definir um modelo User:

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
}

Aqui, estamos definindo uma tabela User com colunas id, email e name.

Passo 3: Criação de uma Migration

Depois de definir ou alterar o esquema, criamos uma migration para refletir essas mudanças no banco de dados:

npx prisma migrate dev --name init

O comando migrate dev cria uma nova migration e aplica as mudanças ao banco de dados. O parâmetro --name permite dar um nome descritivo à migration, como init no exemplo acima.

Passo 4: Aplicação da Migration

As migrations são aplicadas automaticamente ao banco de dados quando usamos o comando migrate dev. Isso garante que o banco de dados esteja sempre em sincronia com o modelo de dados definido no schema.prisma.

Se você quiser aplicar migrations em um ambiente de produção, utilize o comando:

npx prisma migrate deploy

Este comando aplica todas as migrations pendentes no banco de dados de produção.

Passo 5: Gerenciamento de Migrations

Prisma mantém um histórico de todas as migrations aplicadas no banco de dados. Isso é útil para rastrear mudanças e reverter migrations, se necessário. Para ver o histórico de migrations, você pode usar:

npx prisma migrate status

Este comando mostra o estado atual das migrations, incluindo quais migrations foram aplicadas e quais estão pendentes.

Exemplo Prático

Vamos ver um exemplo prático de como adicionar um novo campo ao modelo User e criar uma migration para essa mudança.

Adicionar o campo ao modelo User no schema.prisma:

model User {
  id        Int     @id @default(autoincrement())
  email     String  @unique
  name      String?
  birthdate DateTime?
}

Criar uma nova migration:

npx prisma migrate dev --name add-birthdate-to-user

Aplicar a migration:

O comando migrate dev já aplica a migration ao banco de dados. Agora, o banco de dados terá o novo campo birthdate na tabela User.
Verificar o estado das migrations:
```
npx prisma migrate status
```
Este comando mostrará que a migration add-birthdate-to-user foi aplicada com sucesso.

Conclusão

O fluxo de trabalho do Prisma utilizando migrations é uma maneira eficiente e segura de gerenciar mudanças no esquema do banco de dados. Através de uma sequência clara de passos – definir o esquema, criar migrations, aplicar mudanças e gerenciar o histórico de migrations – é possível manter o banco de dados sincronizado com o modelo de dados da aplicação, facilitando o desenvolvimento e a manutenção do software.

Com Prisma, você não apenas simplifica o gerenciamento do banco de dados, mas também ganha uma poderosa ferramenta para garantir que todas as mudanças sejam rastreáveis e reversíveis, contribuindo para um processo de desenvolvimento mais robusto e ágil.

Understanding One-to-One Relations with Prisma ORM

Leandro Martins — Sat, 15 Jun 2024 18:36:49 +0000

Prisma ORM is a powerful tool for managing databases in Node.js and TypeScript projects. One of its most important features is the ability to define relationships between tables, including One-to-One (one-to-one) relationships. In this post, we will explore how to set up and work with One-to-One relationships in Prisma ORM.

What is a One-to-One Relationship?

In a database, a One-to-One relationship means that a record in one table is directly associated with a single record in another table. For example, let's say you have two tables: User and Profile. Each User has a single Profile and each Profile belongs to a single User.

Setting Up a One-to-One Relationship in Prisma

Let's see how to define a One-to-One relationship between two tables using Prisma ORM. For this example, we will create the User and Profile tables.

Step 1: Initial Setup

First, make sure you have Prisma installed in your project:

npm install @prisma/client
npx prisma init

This will create a prisma directory containing the schema.prisma file where we will define our data model.

Step 2: Defining the Models

Open the schema.prisma file and define the User and Profile models:

model User {
  id      Int     @id @default(autoincrement())
  email   String  @unique
  name    String?
  profile Profile?

  @@map("users")
}

model Profile {
  id     Int    @id @default(autoincrement())
  bio    String
  userId Int    @unique
  user   User   @relation(fields: [userId], references: [id])

  @@map("profiles")
}

Here, we define two models:

User: Represents a user with a unique ID, a unique email, an optional name, and an optional profile.
Profile: Represents a profile with a unique ID, a bio, and a userId field that is a foreign key referencing the id of the User.

Step 3: Migrating the Database

After defining the models, we need to migrate the database to reflect these changes:

npx prisma migrate dev --name init

This will create the users and profiles tables in your database with the One-to-One relationship configured.

Working with One-to-One Relationships

Now that we have our models defined and migrated, let's see how to create, read, and manipulate data with this relationship.

Creating a User and a Profile

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {
  const user = await prisma.user.create({
    data: {
      email: 'alice@prisma.io',
      name: 'Alice',
      profile: {
        create: {
          bio: 'Software Developer',
        },
      },
    },
  });

  console.log(user);
}

main()
  .catch((e) => {
    throw e;
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

In this example, we are creating a User with an associated Profile in a single operation.

Reading Related Data

To fetch a user along with their profile, we use the include operation:

const userWithProfile = await prisma.user.findUnique({
  where: {
    email: 'alice@prisma.io',
  },
  include: {
    profile: true,
  },
});

console.log(userWithProfile);

Updating a Profile

To update the profile of an existing user:

const updatedProfile = await prisma.profile.update({
  where: {
    userId: userWithProfile.id,
  },
  data: {
    bio: 'Full Stack Developer',
  },
});

console.log(updatedProfile);

Conclusion

Defining and working with One-to-One relationships in Prisma ORM is straightforward and intuitive. With the correct configuration in the schema.prisma file and using the methods provided by Prisma Client, you can easily manage and interact with related data in your database.

Prisma not only simplifies the process of defining relationships but also provides a powerful API for working with this data, making application development more efficient and productive.