Cara Menulis Panggilan Pangkalan Data Transaksi dalam TypeScript

Jika anda menulis perkhidmatan web, kemungkinan besar anda berinteraksi dengan pangkalan data. Kadangkala, anda perlu membuat perubahan yang mesti digunakan secara atom — sama ada semuanya berjaya, atau tidak ada. Di sinilah urus niaga masuk. Dalam artikel ini, saya akan menunjukkan kepada anda cara melaksanakan transaksi dalam kod anda untuk mengelakkan isu dengan abstraksi bocor.

Contoh

Contoh biasa ialah memproses pembayaran:

• Anda perlu mendapatkan baki pengguna dan semak sama ada ia mencukupi.
• Kemudian, anda mengemas kini baki dan menyimpannya.

Struktur

Lazimnya, aplikasi anda akan mempunyai dua modul untuk memisahkan logik perniagaan daripada kod berkaitan pangkalan data.

Modul Repositori

Modul ini mengendalikan semua operasi berkaitan pangkalan data, seperti pertanyaan SQL. Di bawah, kami mentakrifkan dua fungsi:

• get_balance — Mendapatkan semula baki pengguna daripada pangkalan data.
• set_balance — Mengemas kini baki pengguna.

import { Injectable } from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
export class BillingRepository {
  constructor(
    private readonly db_connection: postgres.Sql,
  ) {}

  async get_balance(customer_id: string): Promise<number | null> {
    const rows = await this.db_connection`
      SELECT amount FROM balances 
      WHERE customer_id=${customer_id}
    `;
    return (rows[0]?.amount) ?? null;
  }

  async set_balance(customer_id: string, amount: number): Promise<void> {
    await this.db_connection`
      UPDATE balances 
      SET amount=${amount} 
      WHERE customer_id=${customer_id}
    `;
  }
}

Modul Perkhidmatan

Modul perkhidmatan mengandungi logik perniagaan, seperti mengambil baki, mengesahkannya dan menyimpan baki yang dikemas kini.

import { Injectable } from '@nestjs/common';
import { BillingRepository } from 'src/billing/billing.repository';

@Injectable()
export class BillingService {
  constructor(
    private readonly billing_repository: BillingRepository,
  ) {}

  async bill_customer(customer_id: string, amount: number) {
    const balance = await this.billing_repository.get_balance(customer_id);

    // The balance may change between the time of this check and the update.
    if (balance === null || balance < amount) {
      return new Error('Insufficient funds');
    }

    await this.billing_repository.set_balance(customer_id, balance - amount);
  }
}

Dalam fungsi bill_customer, kami mula-mula mendapatkan semula baki pengguna menggunakan get_balance. Kemudian, kami menyemak sama ada baki itu mencukupi dan mengemas kininya dengan set_balance.

Transaksi

Masalah dengan kod di atas ialah baki boleh berubah antara masa ia diambil dan dikemas kini. Untuk mengelakkan perkara ini, kita perlu menggunakan transaksi. Anda boleh mengendalikan perkara ini dalam dua cara:

• Benamkan logik perniagaan dalam modul repositori: Pendekatan ini menggabungkan peraturan perniagaan dengan operasi pangkalan data, menjadikan ujian lebih sukar.
• Gunakan transaksi dalam modul perkhidmatan: Ini boleh menyebabkan abstraksi bocor, kerana modul perkhidmatan perlu mengurus sesi pangkalan data secara eksplisit.

Sebaliknya, saya mengesyorkan pendekatan yang lebih bersih.

Kod Transaksi

Cara yang baik untuk mengendalikan urus niaga ialah dengan mencipta fungsi yang membungkus panggilan balik dalam transaksi. Fungsi ini menyediakan objek sesi yang tidak mendedahkan butiran dalaman yang tidak perlu, menghalang abstraksi bocor. Objek sesi dihantar ke semua fungsi berkaitan pangkalan data dalam transaksi.

Begini cara anda boleh melaksanakannya:

import { Injectable } from '@nestjs/common';
import postgres, { TransactionSql } from 'postgres';

export type SessionObject = TransactionSql<Record<string, unknown>>;

@Injectable()
export class BillingRepository {
  constructor(
    private readonly db_connection: postgres.Sql,
  ) {}

  async run_in_session<T>(cb: (sql: SessionObject) => T | Promise<T>) {
    return await this.db_connection.begin((session) => cb(session));
  }

  async get_balance(
    customer_id: string, 
    session: postgres.TransactionSql | postgres.Sql = this.db_connection
  ): Promise<number | null> {
    const rows = await session`
      SELECT amount FROM balances 
      WHERE customer_id=${customer_id}
    `;
    return (rows[0]?.amount) ?? null;
  }

  async set_balance(
    customer_id: string, 
    amount: number, 
    session: postgres.TransactionSql | postgres.Sql = this.db_connection
  ): Promise<void> {
    await session`
      UPDATE balances 
      SET amount=${amount} 
      WHERE customer_id=${customer_id}
    `;
  }
}

Dalam contoh ini, fungsi run_in_session memulakan transaksi dan melaksanakan panggilan balik di dalamnya. Jenis SessionObject mengabstrakkan sesi pangkalan data untuk mengelakkan butiran dalaman bocor. Semua fungsi berkaitan pangkalan data kini menerima objek sesi, memastikan mereka boleh mengambil bahagian dalam transaksi yang sama.

Modul Perkhidmatan Kemas Kini

Modul perkhidmatan dikemas kini untuk memanfaatkan transaksi. Begini rupanya:

import { Injectable } from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
export class BillingRepository {
  constructor(
    private readonly db_connection: postgres.Sql,
  ) {}

  async get_balance(customer_id: string): Promise<number | null> {
    const rows = await this.db_connection`
      SELECT amount FROM balances 
      WHERE customer_id=${customer_id}
    `;
    return (rows[0]?.amount) ?? null;
  }

  async set_balance(customer_id: string, amount: number): Promise<void> {
    await this.db_connection`
      UPDATE balances 
      SET amount=${amount} 
      WHERE customer_id=${customer_id}
    `;
  }
}

Dalam fungsi bill_customer_transactional, kami memanggil run_in_session dan menghantar panggilan balik dengan objek sesi sebagai parameter, kemudian kami menghantar parameter ini kepada setiap fungsi repositori yang kami panggil. Ini memastikan bahawa kedua-dua get_balance dan set_balance dijalankan dalam transaksi yang sama. Jika baki berubah antara kedua-dua panggilan, transaksi akan gagal, mengekalkan integriti data.

Kesimpulan

Menggunakan transaksi dengan berkesan memastikan operasi pangkalan data anda kekal konsisten, terutamanya apabila berbilang langkah terlibat. Pendekatan yang saya gariskan membantu anda mengurus urus niaga tanpa membocorkan abstraksi, menjadikan kod anda lebih mudah diselenggara. Cuba laksanakan corak ini dalam projek anda yang seterusnya untuk memastikan logik anda bersih dan data anda selamat!

Terima kasih kerana membaca!

?Jangan lupa like jika anda menyukai artikel tersebut?

Kenalan
Jika anda menyukai artikel ini, jangan teragak-agak untuk berhubung di LinkedIn dan ikuti saya di Twitter.

Langgan senarai mel saya: https://sergedevs.com

Pastikan suka dan ikuti ?

Atas ialah kandungan terperinci Cara Menulis Panggilan Pangkalan Data Transaksi dalam TypeScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!