Mastering Prisma Transactions in NestJS for Safe Database Writes

Hello! When building backend applications for clients, data integrity is everything. Imagine an e-commerce checkout or a financial transfer where money leaves an account, but the receiving record fails to update. Without proper transaction handling, your database ends up in an inconsistent state.

In this guide, I want to show you how I handle complex database operations safely using NestJS, Prisma, and PostgreSQL. We will look at how to use interactive transactions to ensure multiple dependent queries either all succeed or all roll back.

---

Why Standard Queries Are Not Enough

By default, every Prisma Client query executes independently. If you run two write operations back to back like this:

await this.prisma.account.update({
  where: { id: senderId },
  data: { balance: { decrement: 100 } },
});

// What happens if your server crashes right here?

await this.prisma.account.update({
  where: { id: receiverId },
  data: { balance: { increment: 100 } },
});

If something goes wrong between the first and second query, the sender loses money, but the receiver never gets it. In a production environment, this is a nightmare.

When I build scalable backends—whether it is for logistics platforms like JobsiteX or data-heavy apps—I rely heavily on database transactions to guarantee atomicity.

---

Using Prisma Interactive Transactions in NestJS

Prisma provides two types of transactions: Sequential Transactions ($transaction([ ... ])) and Interactive Transactions ($transaction(async (prisma) => { ... })).

For most real-world scenarios that require reading data, running conditional checks, and writing updates, interactive transactions are the best choice.

Here is a practical service example inside a NestJS application:

import { Injectable, BadRequestException } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Injectable()
export class WalletService {
  constructor(private readonly prisma: PrismaService) {}

  async transferFunds(senderId: string, receiverId: string, amount: number) {
    return this.prisma.$transaction(async (tx) => {
      // 1. Check sender balance inside the transaction
      const sender = await tx.account.findUnique({
        where: { id: senderId },
      });

      if (!sender || sender.balance < amount) {
        throw new BadRequestException('Insufficient funds');
      }

      // 2. Deduct from sender
      const updatedSender = await tx.account.update({
        where: { id: senderId },
        data: { balance: { decrement: amount } },
      });

      // 3. Add to receiver
      await tx.account.update({
        where: { id: receiverId },
        data: { balance: { increment: amount } },
      });

      // 4. Create an immutable transaction log
      await tx.transactionLog.create({
        data: {
          senderId,
          receiverId,
          amount,
          status: 'COMPLETED',
        },
      });

      return updatedSender;
    });
  }
}