persistence

type NoopStorable ¶

type NoopStorable struct {
	IsNewValue bool
}

NoopStorable is a no-op implementation of the Storable interface.

func (n NoopStorable) IsNew() bool

type ReadRepository ¶

type ReadRepository[K comparable, T any] interface {
	FindByKey(ctx context.Context, key K) (*T, error)
}

ReadRepository component used to retrieve T instances from a storage system.

type Storable ¶

type Storable interface {
	// IsNew checks if the type was just created.
	IsNew() bool
}

Storable is an interface indicating the implementing type can be stored into a persistence system.

type Transaction ¶

type Transaction interface {
	// Commit commits the transaction.
	Commit(ctx context.Context) error
	// Rollback rolls back the transaction.
	Rollback(ctx context.Context) error
}

Transaction is a database transaction interface that provides methods for managing transaction lifecycle. Implementations should handle the underlying database-specific transaction operations while maintaining consistent behavior. Use with WithTxContext and FromTxContext to propagate transactions through context.

func FromTxContext(ctx context.Context, driver TxDriver) (Transaction, bool)

type TxDriver ¶

type TxDriver string

TxDriver is a type that represents the driver of a transaction.

It is used as a key in the context to store and retrieve the Transaction instance.

type TxFactory ¶

type TxFactory interface {
	// Driver returns the [TxDriver] associated with this factory.
	Driver() TxDriver
	// NewTx creates a new [Transaction] instance.
	NewTx(ctx context.Context) (Transaction, error)
}

TxFactory is a component responsible for the creation of persistence transactions.

type TxManager ¶

type TxManager struct {
	// contains filtered or unexported fields
}

TxManager is a manager for transaction factories that allows registering multiple transaction factories and executing functions within the context of all registered transactions. It provides a way to coordinate multiple transactions as a single logical transaction.

It is useful for scenarios where multiple databases or transaction sources need to be coordinated together, ensuring that all operations across these transactions are either committed or rolled back as a single unit of work.

func NewTxManager() *TxManager

func (m *TxManager) Execute(ctx context.Context, fn func(ctx context.Context) error) (err error)

func (m *TxManager) GetFactories() []TxFactory

func (m *TxManager) Register(factory TxFactory)

type WriteBatchRepository ¶

type WriteBatchRepository[K comparable, T Storable] interface {
	SaveAll(ctx context.Context, entities []T) error
	DeleteAll(ctx context.Context, entities []T) error
	DeleteAllByKeys(ctx context.Context, keys []K) error
}

WriteBatchRepository component used to write several T instances into a storage system.

type WriteRepository ¶

type WriteRepository[K comparable, T Storable] interface {
	Save(ctx context.Context, entity T) error
	DeleteByKey(ctx context.Context, key K) error
	Delete(ctx context.Context, entity T) error
}

WriteRepository component used to write T instances into a storage system.