1---
2title: Use Transactions for Multi-Step Operations
3impact: HIGH
4impactDescription: Ensures data consistency in multi-step operations
5tags: database, transactions, typeorm, consistency
6---
7 
8## Use Transactions for Multi-Step Operations
9 
10When multiple database operations must succeed or fail together, wrap them in a transaction. This prevents partial updates that leave your data in an inconsistent state. Use TypeORM's transaction APIs or the DataSource query runner for complex scenarios.
11 
12**Incorrect (multiple saves without transaction):**
13 
14```typescript
15// Multiple saves without transaction
16@Injectable()
17export class OrdersService {
18  async createOrder(userId: string, items: OrderItem[]): Promise<Order> {
19    // If any step fails, data is inconsistent
20    const order = await this.orderRepo.save({ userId, status: 'pending' });
21 
22    for (const item of items) {
23      await this.orderItemRepo.save({ orderId: order.id, ...item });
24      await this.inventoryRepo.decrement({ productId: item.productId }, 'stock', item.quantity);
25    }
26 
27    await this.paymentService.charge(order.id);
28    // If payment fails, order and inventory are already modified!
29 
30    return order;
31  }
32}
33```
34 
35**Correct (use DataSource.transaction for automatic rollback):**
36 
37```typescript
38// Use DataSource.transaction() for automatic rollback
39@Injectable()
40export class OrdersService {
41  constructor(private dataSource: DataSource) {}
42 
43  async createOrder(userId: string, items: OrderItem[]): Promise<Order> {
44    return this.dataSource.transaction(async (manager) => {
45      // All operations use the same transactional manager
46      const order = await manager.save(Order, { userId, status: 'pending' });
47 
48      for (const item of items) {
49        await manager.save(OrderItem, { orderId: order.id, ...item });
50        await manager.decrement(
51          Inventory,
52          { productId: item.productId },
53          'stock',
54          item.quantity,
55        );
56      }
57 
58      // If this throws, everything rolls back
59      await this.paymentService.chargeWithManager(manager, order.id);
60 
61      return order;
62    });
63  }
64}
65 
66// QueryRunner for manual transaction control
67@Injectable()
68export class TransferService {
69  constructor(private dataSource: DataSource) {}
70 
71  async transfer(fromId: string, toId: string, amount: number): Promise<void> {
72    const queryRunner = this.dataSource.createQueryRunner();
73    await queryRunner.connect();
74    await queryRunner.startTransaction();
75 
76    try {
77      // Debit source account
78      await queryRunner.manager.decrement(
79        Account,
80        { id: fromId },
81        'balance',
82        amount,
83      );
84 
85      // Verify sufficient funds
86      const source = await queryRunner.manager.findOne(Account, {
87        where: { id: fromId },
88      });
89      if (source.balance < 0) {
90        throw new BadRequestException('Insufficient funds');
91      }
92 
93      // Credit destination account
94      await queryRunner.manager.increment(
95        Account,
96        { id: toId },
97        'balance',
98        amount,
99      );
100 
101      // Log the transaction
102      await queryRunner.manager.save(TransactionLog, {
103        fromId,
104        toId,
105        amount,
106        timestamp: new Date(),
107      });
108 
109      await queryRunner.commitTransaction();
110    } catch (error) {
111      await queryRunner.rollbackTransaction();
112      throw error;
113    } finally {
114      await queryRunner.release();
115    }
116  }
117}
118 
119// Repository method with transaction support
120@Injectable()
121export class UsersRepository {
122  constructor(
123    @InjectRepository(User) private repo: Repository<User>,
124    private dataSource: DataSource,
125  ) {}
126 
127  async createWithProfile(
128    userData: CreateUserDto,
129    profileData: CreateProfileDto,
130  ): Promise<User> {
131    return this.dataSource.transaction(async (manager) => {
132      const user = await manager.save(User, userData);
133      await manager.save(Profile, { ...profileData, userId: user.id });
134      return user;
135    });
136  }
137}
138```
139 
140Reference: [TypeORM Transactions](https://typeorm.io/transactions)
141