Belajar NestJS - Transaction & Persistence Advanced

#Pendahuluan

Operasi database yang melibatkan beberapa langkah harus konsisten — jika satu langkah gagal, semua harus dibatalkan. Di sinilah transaksi berperan. Episode 10 membahas transaksi di TypeORM, unit of work, optimasi query, dan connection pooling.

Konsep ini penting untuk aplikasi yang memproses uang, stok, atau data yang membutuhkan konsistensi ketat.

#Manajemen Transaksi

#Mengapa Transaksi Dibutuhkan

Bayangkan transfer uang: saldo pengirim dikurangi dan saldo penerima ditambah. Jika langkah kedua gagal, saldo pengirim berkurang tanpa diterima siapa pun. Transaksi memastikan kedua operasi berhasil bersama-sama atau gagal bersama-sama.

#Transaksi dengan DataSource

TypeORM menyediakan API transaksi lewat DataSource:

Transaksi memakai DataSource

import { Injectable } from "@nestjs/common";
import { InjectDataSource } from "@nestjs/typeorm";
import { DataSource } from "typeorm";
 
@Injectable()
export class TransferService {
  constructor(
    @InjectDataSource()
    private readonly dataSource: DataSource,
  ) {}
 
  async transfer(fromId: number, toId: number, amount: number): Promise<void> {
    await this.dataSource.transaction(async (manager) => {
      const from = await manager.findOneBy(User, { id: fromId });
      const to = await manager.findOneBy(User, { id: toId });
 
      from.balance -= amount;
      to.balance += amount;
 
      await manager.save([from, to]);
    });
  }
}

Callback yang menerima manager menjalankan semua operasi dalam satu transaksi. Jika ada exception, transaksi otomatis di-rollback.

#Unit of Work dan Repository Orchestration

#Konsep Unit of Work

Unit of Work mengelompokkan beberapa operasi menjadi satu unit logis. EntityManager dari TypeORM adalah implementasi unit of work — semua perubahan dalam transaksi di-manage oleh satu manager.

Orchestrasi beberapa repository

async createOrder(orderData: OrderDto): Promise<void> {
  await this.dataSource.transaction(async (manager) => {
    const order = manager.create(Order, orderData);
    await manager.save(order);
 
    for (const item of orderData.items) {
      await manager.decrement(Product, { id: item.productId }, "stock", item.qty);
    }
  });
}

Dalam satu transaksi, service mengoordinasikan pembuatan order sekaligus pengurangan stok — contoh orchestration antar repository.

#Optimasi Query

#Eager Loading

Relasi bisa dimuat bersamaan dengan entity utama memakai relations:

Eager loading relasi

async findOrdersWithUser(): Promise<Order[]> {
  return this.ordersRepository.find({
    relations: {
      user: true,
      items: true,
    },
  });
}

Memuat user dan items sekaligus menghindari masalah N+1 — banyak query kecil yang memperlambat aplikasi.

#Lazy Loading

Alternatifnya, relasi lazy dimuat hanya saat diakses:

Relasi lazy

@Entity()
export class Order {
  @ManyToOne(() => User)
  user: Promise<User>;
}

Dengan Promise<User>, relasi dimuat saat di-await. Berhati-hatilah dengan lazy loading karena bisa memicu query yang tak terduga di dalam loop.

#Index dan Query Efisien

Selalu tambahkan index untuk kolom yang sering difilter:

Entity dengan index

@Entity()
export class User {
  @Column()
  name: string;
 
  @Index()
  @Column({ unique: true })
  email: string;
}

Index mempercepat pencarian berdasarkan email secara signifikan, terutama pada tabel besar.

#Connection Pooling dan Performance Tuning

#Pool Koneksi Database

Connection pool menjaga sekumpulan koneksi database yang dipakai ulang, mengurangi overhead membuat koneksi baru setiap request:

Konfigurasi pool di TypeORM

TypeOrmModule.forRoot({
  type: "postgres",
  url: process.env.DATABASE_URL,
  autoLoadEntities: true,
  synchronize: false,
  poolSize: 10,
})

poolSize: 10 membatasi jumlah koneksi bersamaan. Atur sesuai beban dan kemampuan database.

#Performance Tuning Lainnya

Beberapa praktik tuning: matikan synchronize di production, batasi hasil dengan take dan skip, hindari select * yang tidak perlu, dan gunakan query builder untuk query kompleks. Kombinasi ini menjaga aplikasi tetap responsif seiring data bertambah.

#Penutup

Episode 10 memperkuat kemampuan persistence kalian: transaksi untuk konsistensi, unit of work untuk orchestration, optimasi query untuk kecepatan, dan connection pooling untuk skalabilitas.

Inti yang harus dibawa pulang:

• Transaksi memastikan operasi multi-langkah konsisten atau gagal bersama.
• dataSource.transaction menerima callback dengan manager.
• Unit of work mengoordinasikan beberapa repository dalam satu transaksi.
• Eager loading menghindari masalah N+1.
• Index mempercepat query pada kolom yang sering difilter.
• Connection pool memakai ulang koneksi dan mengurangi overhead.

Di episode 11 selanjutnya kita akan membahas background jobs dan scheduling — task scheduling dengan @nestjs/schedule, queue processing dengan Bull atau BullMQ, retry policy dan delayed jobs, serta monitoring job dan failure handling.