NestJS Enterprise Backend APIs · Aula

Transações e Migrações

Implemente transações de banco de dados para operações atômicas e gerencie alterações de esquema com eficiência usando migrações do TypeORM.

Transações e Migrações é uma aula grátis de NestJS Enterprise Backend APIs no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de NestJS Enterprise Backend APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de NestJS Enterprise Backend APIs inclui 3 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Atomic Operations: Transactions

Imagine transferring money between two bank accounts. If the deduction from one account succeeds but the addition to the other fails, your data is inconsistent!

Database transactions solve this by grouping multiple database operations into a single, atomic unit. Either all operations succeed (commit), or none of them do (rollback).

Understanding ACID Properties

Transactions ensure data reliability by adhering to ACID properties:

Atomicity: All or nothing.
Consistency: Database state remains valid.
Isolation: Concurrent transactions don't interfere.
Durability: Committed changes are permanent.

These properties are vital for maintaining data integrity in complex applications.

TypeORM Manual Transactions

TypeORM allows you to manage transactions manually using the DataSource or EntityManager. This gives you fine-grained control over when to commit or rollback.

You typically use dataSource.transaction(async manager => { ... }), where manager is a transactional entity manager.

Manual Transaction Example

Here's a simplified example of transferring funds within a transaction. If any step fails, the entire operation is rolled back.

import { DataSource, Entity, PrimaryGeneratedColumn, Column, Repository } from 'typeorm';

@Entity()
export class Account {
  @PrimaryGeneratedColumn() id: number;
  @Column({ type: 'decimal', precision: 10, scale: 2 }) balance: number;
}

async function runTransaction() {
  const AppDataSource = new DataSource({
    type: 'sqlite',
    database: ':memory:',
    entities: [Account],
    synchronize: true,
  });

  await AppDataSource.initialize();
  const accountRepo = AppDataSource.getRepository(Account);

  await AppDataSource.transaction(async manager => {
    const sender = await manager.save(accountRepo.create({ balance: 100 }));
    const receiver = await manager.save(accountRepo.create({ balance: 50 }));

    console.log(`Initial: Sender ${sender.balance}, Receiver ${receiver.balance}`);

    sender.balance -= 20;
    receiver.balance += 20;

    await manager.save(sender);
    // Simulate an error here to trigger rollback:
    // throw new Error('Failed to update receiver!');
    await manager.save(receiver);

    console.log(`Final: Sender ${sender.balance}, Receiver ${receiver.balance}`);
  });

  await AppDataSource.destroy();
}

// To run this in a Node.js context:
// runTransaction().catch(console.error);
// For CoddyKit, we just show the code.

Decorators for Transactions

NestJS and TypeORM often work together. For convenience, TypeORM provides the @Transaction() and @TransactionManager() decorators.

You can apply @Transaction() to a service method, and TypeORM will automatically wrap the method's execution in a transaction.

Decorator Transaction Example

Using the @Transaction() decorator makes your service code cleaner, as you don't need to manually handle transaction commits or rollbacks.

import { Injectable } from '@nestjs/common';
import { Repository, EntityManager } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Transaction } from 'typeorm'; // Import Transaction decorator

// Assume Account Entity is defined elsewhere
class Account { 
  id: number; 
  balance: number; 
}

@Injectable()
export class BankService {
  constructor(
    @InjectRepository(Account) private accountRepository: Repository<Account>,
  ) {}

  @Transaction()
  async transferFunds(
    senderId: number,
    receiverId: number,
    amount: number,
    @TransactionManager() manager?: EntityManager, // Manager is injected
  ): Promise<boolean> {
    const accountManager = manager || this.accountRepository.manager; // Use injected manager

    const sender = await accountManager.findOneBy(Account, { id: senderId });
    const receiver = await accountManager.findOneBy(Account, { id: receiverId });

    if (!sender || !receiver || sender.balance < amount) {
      throw new Error('Transfer failed: Invalid accounts or insufficient funds');
    }

    sender.balance -= amount;
    receiver.balance += amount;

    await accountManager.save(sender);
    await accountManager.save(receiver);

    console.log(`Transferred ${amount}. Sender: ${sender.balance}, Receiver: ${receiver.balance}`);
    return true;
  }
}

// Note: This code is illustrative within a NestJS service context. 
// It's not runnable as a standalone script without a full NestJS setup.

Managing Schema Changes: Migrations

As your application evolves, your database schema will change (e.g., adding new columns, tables). Directly modifying the database can be risky and hard to track.

Database migrations provide a structured, version-controlled way to apply changes to your database schema, ensuring consistency across environments.

Generating TypeORM Migrations

TypeORM has a powerful CLI to generate migration files. It compares your entities with the current database schema and creates a script to bridge the differences.

First, ensure your ormconfig.json or DataSource is set up correctly. Then, run the command:

npx typeorm migration:generate src/migration/MyNewMigration

This creates a timestamped .ts file in the specified folder.

Migration File Structure

Each migration file contains two key methods:

up(queryRunner: QueryRunner): Promise: Defines changes to apply to the database (e.g., create table, add column).
down(queryRunner: QueryRunner): Promise: Defines how to revert the changes made by up (e.g., drop table, remove column).

This allows you to easily roll forward and backward through schema versions.

import { MigrationInterface, QueryRunner, Table } from 'typeorm';

export class MyNewMigration1678886400000 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: 'products',
        columns: [
          { name: 'id', type: 'int', isPrimary: true, isGenerated: true, generationStrategy: 'increment' },
          { name: 'name', type: 'varchar' },
          { name: 'price', type: 'decimal', precision: 10, scale: 2, default: 0 },
        ],
      }),
      true,
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable('products');
  }
}

Applying and Reverting Migrations

Once you've written or generated your migration files, you need to apply them to your database:

Apply all pending migrations: npx typeorm migration:run
Revert the last applied migration: npx typeorm migration:revert

Always run migrations in your development and production environments to keep schemas synchronized.

Check Your Knowledge

Which of the following statements about database transactions and migrations in TypeORM is FALSE?

Recap: Transactions & Migrations

You've learned about two critical concepts for robust database management:

Transactions: Ensure data integrity through atomic operations following ACID principles, using TypeORM's manual methods or the @Transaction() decorator.
Migrations: Provide a structured way to evolve your database schema, using TypeORM CLI to generate and apply changes via up() and down() methods.

Mastering these will help you build more reliable and maintainable backend APIs.

Perguntas Frequentes

A aula “Transações e Migrações” é grátis?

Sim — o texto completo de “Transações e Migrações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de NestJS Enterprise Backend APIs, atualize para CoddyKit PRO. O curso de NestJS Enterprise Backend APIs inclui 3 aulas no total.

O que vou aprender em “Transações e Migrações”?

Implemente transações de banco de dados para operações atômicas e gerencie alterações de esquema com eficiência usando migrações do TypeORM. Você pratica NestJS Enterprise Backend APIs com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar NestJS Enterprise Backend APIs?

Nenhuma experiência prévia é necessária. NestJS Enterprise Backend APIs no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Transações e Migrações”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de NestJS Enterprise Backend APIs?

Sim. Cada aula de NestJS Enterprise Backend APIs inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Repositórios Personalizados do TypeORM
Transações e Migrações
Carga Inicial e Testes do Banco de Dados

← Voltar para NestJS Enterprise Backend APIs