@breadstone/ziegel-platform-transaction

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

For detailed API documentation, visit: API Docs

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