NestJS Enterprise Backend APIs · Lección

Transacciones y migraciones

Implemente transacciones de base de datos para realizar operaciones atómicas y gestione eficazmente los cambios de esquema con las migraciones de TypeORM.

Transacciones y migraciones es una lección gratuita de NestJS Enterprise Backend APIs en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de NestJS Enterprise Backend APIs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de NestJS Enterprise Backend APIs incluye 3 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en 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.

Preguntas frecuentes

¿La lección «Transacciones y migraciones» es gratis?

Sí — el texto completo de «Transacciones y migraciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de NestJS Enterprise Backend APIs, actualiza a CoddyKit PRO. El curso de NestJS Enterprise Backend APIs incluye 3 lecciones en total.

¿Qué aprenderé en «Transacciones y migraciones»?

Implemente transacciones de base de datos para realizar operaciones atómicas y gestione eficazmente los cambios de esquema con las migraciones de TypeORM. Practicas NestJS Enterprise Backend APIs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar NestJS Enterprise Backend APIs?

No se requiere experiencia previa. NestJS Enterprise Backend APIs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Transacciones y migraciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de NestJS Enterprise Backend APIs?

Sí. Cada lección de NestJS Enterprise Backend APIs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Repositorios personalizados de TypeORM
Transacciones y migraciones
Carga inicial y pruebas de la base de datos

← Volver a NestJS Enterprise Backend APIs