Enterprise transaction management for the ziegel platform. Provides distributed transactions, compensation patterns, and transactional workflows for enterprise applications.

Transaction Management: Enterprise transaction patterns with distributed transactions, compensation, and workflow coordination.

🚀 Overview

@breadstone/ziegel-platform-transaction provides:

• Distributed Transactions: ACID transactions across multiple resources
• Compensation Patterns: Saga pattern implementation for long-running transactions
• Transaction Coordination: Two-phase commit and transaction orchestration
• Isolation Levels: Configurable transaction isolation levels
• Deadlock Detection: Automatic deadlock detection and resolution
• Transaction Logging: Comprehensive transaction audit trails

📦 Installation

npm install @breadstone/ziegel-platform-transaction
# or
yarn add @breadstone/ziegel-platform-transaction

🧩 Features & Usage Examples

Basic Transactions

import { TransactionManager, Transactional } from '@breadstone/ziegel-platform-transaction';

class UserService {
  @Transactional()
  async createUser(userData: CreateUserRequest) {
    // All operations in this method run in a transaction
    const user = await this.userRepository.create(userData);
    await this.auditService.logUserCreation(user.id);
    return user;
  }
}

Distributed Transactions

import { DistributedTransactionManager, TransactionScope } from '@breadstone/ziegel-platform-transaction';

const txManager = new DistributedTransactionManager();

await txManager.execute(async (scope: TransactionScope) => {
  await scope.enlist(databaseA);
  await scope.enlist(databaseB);

  await databaseA.updateAccount(accountId, -amount);
  await databaseB.updateAccount(targetAccountId, amount);
});

Saga Pattern (Compensation)

import { SagaOrchestrator, SagaStep } from '@breadstone/ziegel-platform-transaction';

class OrderSaga extends SagaOrchestrator {
  async execute(order: Order) {
    await this.addStep(
      new SagaStep(
        () => this.reserveInventory(order),
        () => this.releaseInventory(order),
      ),
    );

    await this.addStep(
      new SagaStep(
        () => this.processPayment(order),
        () => this.refundPayment(order),
      ),
    );

    await this.addStep(
      new SagaStep(
        () => this.shipOrder(order),
        () => this.cancelShipment(order),
      ),
    );
  }
}

Transaction Isolation

import { IsolationLevel, TransactionOptions } from '@breadstone/ziegel-platform-transaction';

const options: TransactionOptions = {
  isolationLevel: IsolationLevel.ReadCommitted,
  timeout: 30000,
  readOnly: false,
};

await transactionManager.executeWithOptions(options, async () => {
  // Transaction logic with specific isolation level
});

📚 Package import points

import {
  // Core Transaction Management
  TransactionManager,
  DistributedTransactionManager,
  Transactional,

  // Saga Pattern
  SagaOrchestrator,
  SagaStep,

  // Configuration
  TransactionOptions,
  IsolationLevel,
  TransactionScope,

  // Utilities
  TransactionContext,
  CompensationAction,
} from '@breadstone/ziegel-platform-transaction';

📚 API Documentation

Related Packages

• @breadstone/ziegel-platform: Core platform services
• @breadstone/ziegel-data: Data access and repository patterns
• @breadstone/ziegel-core: Foundation utilities

License

MIT

Issues

Please report bugs and feature requests in the Issue Tracker

---

Part of the ziegel Enterprise TypeScript Framework