So schreiben Sie transaktionale Datenbankaufrufe in TypeScript

Wenn Sie Webdienste schreiben, interagieren Sie wahrscheinlich mit einer Datenbank. Gelegentlich müssen Sie Änderungen vornehmen, die atomar angewendet werden müssen – entweder sind alle erfolgreich oder keine. Hier kommen Transaktionen ins Spiel. In diesem Artikel zeige ich Ihnen, wie Sie Transaktionen in Ihren Code implementieren, um Probleme mit undichten Abstraktionen zu vermeiden.

Beispiel

Ein häufiges Beispiel ist die Zahlungsabwicklung:

• Sie müssen das Guthaben des Benutzers abrufen und prüfen, ob es ausreicht.
• Dann aktualisieren Sie den Kontostand und speichern ihn.

Struktur

Normalerweise verfügt Ihre Anwendung über zwei Module, um die Geschäftslogik vom datenbankbezogenen Code zu trennen.

Repository-Modul

Dieses Modul übernimmt alle datenbankbezogenen Vorgänge, wie zum Beispiel SQL-Abfragen. Im Folgenden definieren wir zwei Funktionen:

• get_balance – Ruft den Kontostand des Benutzers aus der Datenbank ab.
• set_balance – Aktualisiert den Kontostand des Benutzers.

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}
    `;
  }
}

Servicemodul

Das Servicemodul enthält Geschäftslogik, z. B. das Abrufen des Kontostands, seine Validierung und das Speichern des aktualisierten Kontostands.

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);
  }
}

In der Funktion bill_customer rufen wir zunächst mit get_balance den Kontostand des Benutzers ab. Anschließend prüfen wir, ob das Guthaben ausreicht und aktualisieren es mit set_balance.

Transaktionen

Das Problem mit dem obigen Code besteht darin, dass sich der Kontostand zwischen dem Abruf und der Aktualisierung ändern kann. Um dies zu vermeiden, müssen wir Transaktionen verwenden. Sie können dies auf zwei Arten lösen:

• Geschäftslogik in das Repository-Modul einbetten: Dieser Ansatz koppelt Geschäftsregeln mit Datenbankoperationen, was das Testen erschwert.
• Verwenden Sie eine Transaktion im Servicemodul: Dies könnte zu undichten Abstraktionen führen, da das Servicemodul Datenbanksitzungen explizit verwalten müsste.

Stattdessen empfehle ich einen saubereren Ansatz.

Transaktionscode

Eine gute Möglichkeit, Transaktionen abzuwickeln, besteht darin, eine Funktion zu erstellen, die einen Rückruf in eine Transaktion einschließt. Diese Funktion stellt ein Sitzungsobjekt bereit, das keine unnötigen internen Details offenlegt und so undichte Abstraktionen verhindert. Das Sitzungsobjekt wird innerhalb der Transaktion an alle datenbankbezogenen Funktionen übergeben.

So können Sie es umsetzen:

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}
    `;
  }
}

In diesem Beispiel startet die Funktion run_in_session eine Transaktion und führt darin einen Rückruf aus. Der SessionObject-Typ abstrahiert die Datenbanksitzung, um den Verlust interner Details zu verhindern. Alle datenbankbezogenen Funktionen akzeptieren jetzt ein Sitzungsobjekt und stellen so sicher, dass sie an derselben Transaktion teilnehmen können.

Aktualisiertes Servicemodul

Das Servicemodul wurde aktualisiert, um Transaktionen zu nutzen. So sieht es aus:

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}
    `;
  }
}

In der Funktion bill_customer_transactional rufen wir run_in_session auf und übergeben einen Rückruf mit dem Sitzungsobjekt als Parameter. Anschließend übergeben wir diesen Parameter an jede Funktion des Repositorys, die wir aufrufen. Dadurch wird sichergestellt, dass sowohl get_balance als auch set_balance innerhalb derselben Transaktion ausgeführt werden. Wenn sich das Gleichgewicht zwischen den beiden Aufrufen ändert, schlägt die Transaktion fehl und die Datenintegrität bleibt erhalten.

Abschluss

Durch den effektiven Einsatz von Transaktionen wird sichergestellt, dass Ihre Datenbankvorgänge konsistent bleiben, insbesondere wenn mehrere Schritte erforderlich sind. Der von mir beschriebene Ansatz hilft Ihnen, Transaktionen zu verwalten, ohne dass Abstraktionen verloren gehen, und macht Ihren Code dadurch wartbarer. Versuchen Sie, dieses Muster in Ihrem nächsten Projekt zu implementieren, um Ihre Logik sauber und Ihre Daten sicher zu halten!

Danke fürs Lesen!

?Vergessen Sie nicht zu liken, wenn Ihnen der Artikel gefallen hat?

Kontakte
Wenn Ihnen dieser Artikel gefällt, zögern Sie nicht, sich auf LinkedIn zu vernetzen und mir auf Twitter zu folgen.

Abonnieren Sie meine Mailingliste: https://sergedevs.com

Unbedingt liken und folgen?

Das obige ist der detaillierte Inhalt vonSo schreiben Sie transaktionale Datenbankaufrufe in TypeScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!