INSERT, UPDATE & transaksi

Menulis ke database di MySQL punya satu batasan yang tidak ada di PostgreSQL, dan ia menentukan bentuk hampir semua fungsi tulismu.

INSERT dan kenyataan MySQL

const hasil = await db
  .insertInto("artikel")
  .values({
    judul: "Rupiah menguat",
    slug: "rupiah-menguat",
    isi: "<p>…</p>",
    penulis_id: 7,
    status: "draf",
    premium: 0,
    created_at: Math.floor(Date.now() / 1000),
  })
  .executeTakeFirstOrThrow();

const id = Number(hasil.insertId);   // BigInt → number

// Kalau butuh barisnya, ambil lagi. Dua kueri — memang begitu di MySQL.
const artikel = await db
  .selectFrom("artikel").selectAll()
  .where("id", "=", id)
  .executeTakeFirstOrThrow();

Insert massal dan jebakan insertId

const hasil = await db
  .insertInto("artikel_tag")
  .values(tagIds.map((tagId) => ({ artikel_id: id, tag_id: tagId })))
  .executeTakeFirstOrThrow();

// hasil.insertId = ID BARIS PERTAMA saja.
// hasil.numInsertedOrUpdatedRows = jumlahnya.
// ID sisanya HANYA berurutan kalau innodb_autoinc_lock_mode = 0 atau 1.
// Jangan pernah mengandalkannya.

Upsert

await db
  .insertInto("statistik_harian")
  .values({ artikel_id: id, tanggal: hariIni, hits: 1 })
  .onDuplicateKeyUpdate((eb) => ({
    hits: eb("statistik_harian.hits", "+", 1),
  }))
  .execute();

onDuplicateKeyUpdate adalah padanan MySQL untuk ON CONFLICT. Ia butuh UNIQUE pada (artikel_id, tanggal) — tanpa itu ia diam saja dan membuat baris duplikat setiap kali.

UPDATE

const hasil = await db
  .updateTable("artikel")
  .set({
    status: "terbit",
    terbit_pada: new Date(),
  })
  .where("id", "=", id)
  .where("status", "=", "tinjau")     // hanya dari status yang sah
  .executeTakeFirstOrThrow();

if (hasil.numUpdatedRows === 0n) {
  throw new Error("Artikel tidak ada atau statusnya bukan 'tinjau'");
}

Batasi dengan kepemilikan, bukan dengan if

// BURUK: dua kueri, dan celah di antaranya
const a = await ambilArtikel(id);
if (a.penulis_id !== member.id) throw new Error("Bukan milikmu");
await db.updateTable("artikel").set(data).where("id", "=", id).execute();

// BAIK: satu kueri, kepemilikan jadi bagian dari WHERE
const hasil = await db
  .updateTable("artikel")
  .set(data)
  .where("id", "=", id)
  .where("penulis_id", "=", member.id)
  .executeTakeFirstOrThrow();

if (hasil.numUpdatedRows === 0n) throw new ActionError({ code: "FORBIDDEN" });

Versi kedua tidak bisa lupa memeriksa. Baris orang lain tidak pernah ditemukan, jadi tidak mungkin tersunting. Terapkan pola ini di setiap operasi tulis yang menyentuh data milik seseorang.

Transaksi

const idLangganan = await db.transaction().execute(async (trx) => {
  const langganan = await trx
    .insertInto("langganan")
    .values({
      member_id: memberId,
      paket: "bulanan",
      status: "menunggu",
      dibuat_pada: new Date(),
    })
    .executeTakeFirstOrThrow();

  const id = Number(langganan.insertId);

  await trx
    .insertInto("tagihan")
    .values({ langganan_id: id, jumlah: 49000, status: "menunggu" })
    .execute();

  return id;
});

Aturan yang menyelamatkan alur pembayaranmu

// BURUK: memanggil Midtrans di dalam transaksi
await db.transaction().execute(async (trx) => {
  const id = await buatLangganan(trx, memberId);
  const snap = await midtrans.buatTransaksi(id, 49000);   // ← jaringan!
  await simpanToken(trx, id, snap.token);
});

Panggilan ke Midtrans bisa memakan 2–5 detik, dan bisa menggantung sampai timeout. Selama itu transaksi memegang baris terkunci dan satu koneksi dari pool. Di jam sibuk, sepuluh pembeli bersamaan bisa menghabiskan pool-mu — dan yang tumbang bukan halaman pembayaran saja, tapi seluruh portal, karena pool-nya sama.

// BAIK: transaksi pendek, jaringan di luarnya
const id = await db.transaction().execute(async (trx) => {
  return buatLangganan(trx, memberId);
});

const snap = await midtrans.buatTransaksi(id, 49000);

await db.updateTable("langganan")
  .set({ snap_token: snap.token })
  .where("id", "=", id)
  .execute();

Aturannya: transaksi hanya berisi kueri database, dan sependek mungkin. Tidak ada panggilan HTTP, tidak ada pembacaan berkas, tidak ada await ke apa pun yang bukan trx.

Tingkat isolasi

await db
  .transaction()
  .setIsolationLevel("read committed")
  .execute(async (trx) => { … });

Default MySQL adalah REPEATABLE READ, yang lebih ketat dari default PostgreSQL dan bisa menyebabkan gap lock yang mengejutkan pada INSERT bersamaan di rentang yang sama. Untuk alur pembayaran dan penghitung, READ COMMITTED biasanya pilihan yang lebih tenang. Jangan mengubahnya secara global tanpa mengukur — tapi ketahui bahwa opsinya ada saat kamu melihat deadlock.

Deadlock itu normal, dan harus diulang

export async function denganUlang<T>(fn: () => Promise<T>, maks = 3): Promise<T> {
  for (let i = 0; ; i++) {
    try {
      return await fn();
    } catch (e: any) {
      const bisaDiulang = e?.code === "ER_LOCK_DEADLOCK" || e?.errno === 1213;
      if (!bisaDiulang || i >= maks) throw e;
      await new Promise((r) => setTimeout(r, 50 * 2 ** i));
    }
  }
}

MySQL mendeteksi deadlock dan membatalkan salah satu transaksi. Itu perilaku yang benar, bukan kerusakan — dan aplikasi yang benar mengulanginya. Bungkus operasi tulis yang berjalan bersamaan, terutama penghitung hit artikel dan pembaruan status langganan.