NestJS Enterprise Backend APIs · Урок

Транзакции и миграции

Реализуйте транзакции базы данных для атомарных операций и эффективно управляйте изменениями схемы с помощью миграций TypeORM.

«Транзакции и миграции» — бесплатный урок NestJS Enterprise Backend APIs на CoddyKit. Это урок 2 из 3. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения NestJS Enterprise Backend APIs, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс NestJS Enterprise Backend APIs содержит 3 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

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.

Часто задаваемые вопросы

Урок «Транзакции и миграции» бесплатный?

Да — полный текст урока «Транзакции и миграции» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс NestJS Enterprise Backend APIs, подпишись на CoddyKit PRO. Курс NestJS Enterprise Backend APIs содержит 3 уроков всего.

Чему я научусь в уроке «Транзакции и миграции»?

Реализуйте транзакции базы данных для атомарных операций и эффективно управляйте изменениями схемы с помощью миграций TypeORM. Ты практикуешь NestJS Enterprise Backend APIs с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать NestJS Enterprise Backend APIs?

Предыдущий опыт не требуется. NestJS Enterprise Backend APIs на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 3.

Сколько времени занимает урок «Транзакции и миграции»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке NestJS Enterprise Backend APIs?

Да. Каждый урок NestJS Enterprise Backend APIs включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к NestJS Enterprise Backend APIs