txn

README

txn: Generic Distributed Transaction Management for Go

The txn package provides a robust and flexible framework for managing distributed transactions across multiple data sources in your Go applications. By harnessing the power of Go generics, txn enables a clean, database-agnostic approach to transaction handling, ensuring data consistency and atomicity even in complex, distributed environments.

Before of all, Check the Real World Example

Key Features

• Distributed Transactions: Coordinate transactions across multiple data sources seamlessly.
• Database Independence: Work with various databases (PostgreSQL, MongoDB etc.) using specialized adapters.
• Clean Architecture: Maintain a clear separation of concerns, keeping your business logic decoupled from data access details.
• Atomicity: Ensure that all operations within a transaction either succeed or fail together, maintaining data integrity.
• Flexibility: Easily extend the framework by creating custom adapters for your specific data sources.

Installation

go get github.com/9ssi7/txn

go get github.com/9ssi7/txn/txngorm // For GORM Adapter
go get github.com/9ssi7/txn/txnmongo // For MongoDB Adapter

Usage

1. Create a Tx Instance:

tx := txn.New()

1. Register Adapters:

gormAdapter := txngorm.New(gormDB)
tx.Register(gormAdapter)

mongoAdapter := txnmongo.New(mongoClient)
tx.Register(mongoAdapter)

// Register more adapters as needed...

1. Manage Transactions:

err := tx.Begin(context.Background())
if err != nil {
    // Handle error
}
defer tx.End(context.Background()) // Ensure resources are cleaned up

// Perform operations on each data source using their respective adapters
// ...

if err := tx.Commit(context.Background()); err != nil {
   tx.Rollback(context.Background())
    // Handle commit error
}

Adapters

The txn package supports multiple database adapters:

• txngorm: GORM
• txnmongo: MongoDB

Contributing

Contributions are welcome! Please feel free to submit issues, bug reports, or pull requests.

License

This project is licensed under the Apache License 2.0. See the LICENSE file for details.

Documentation

Overview

Copyright 2024 The txn Authors

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Package txn provides a generic framework for managing distributed transactions across multiple data sources in Go applications. It offers a simple and flexible way to coordinate transaction operations, ensuring data consistency and atomicity.

Key Concepts:

• Tx: The core interface for transaction management. It provides methods to begin, commit, rollback, and cancel transactions.
• Adapter: An interface that defines the contract for interacting with a specific data source within a transaction. Each adapter is responsible for implementing the necessary operations (begin, commit, rollback) for its respective data source.

Index

• type Adapter
• type Tx
  • func New() Tx

Types

type Adapter

type Adapter interface {

	// Begin starts a transaction on the data source.
	Begin(ctx context.Context) error

	// Commit commits the transaction on the data source.
	Commit(ctx context.Context) error

	// Rollback rolls back the transaction on the data source.
	Rollback(ctx context.Context) error

	// End is called at the end of a transaction to clean up any resources.
	// It's called regardless of whether the transaction was committed or rolled back.
	End(ctx context.Context)
}

Adapter defines the interface for interacting with a specific data source within a transaction.

type Tx

type Tx interface {

	// Begin starts a new transaction.
	Begin(ctx context.Context) error

	// Commit commits the transaction.
	Commit(ctx context.Context) error

	// Rollback rolls back the transaction.
	Rollback(ctx context.Context) error

	// Cancel cancels the transaction. This is useful in cases where you want
	// to abort the transaction without waiting for the context to be canceled.
	Cancel(ctx context.Context)

	// Register registers an adapter for a specific data source to participate
	// in the transaction.
	Register(Adapter)
}

Tx is the core interface for managing transactions.

func New

func New() Tx

New creates a new Tx instance.