kozmod / oniontx Goto Github PK

	defer func() {
		switch p := recover(); {
		case p != nil:
			if rbErr := tx.Rollback(ctx); rbErr != nil {
				err = xerrors.Errorf("transactor - panic [%v]: %w", p, errors.Join(rbErr, ErrRollbackFailed))
				return
			}
			err = xerrors.Errorf("transactor - panic [%v]: %w", p, ErrRollbackSuccess)
		case err != nil:
			if rbErr := tx.Rollback(ctx); rbErr != nil {
				err = xerrors.Errorf("transactor - call: %w", errors.Join(err, rbErr, ErrRollbackFailed))
				return
			}
			err = xerrors.Errorf("transactor - call: %w", errors.Join(err, ErrRollbackSuccess))
		default:
			if err = tx.Commit(ctx); err != nil {
				err = xerrors.Errorf("transactor: %w", errors.Join(err, ErrCommitFailed))
			}
		}
	}()

// Inject returns new context.Context contains Tx as value.
func (p *ContextOperator[B, T]) Inject(ctx context.Context, tx T) context.Context {
	key := p.Key()  // 👈🏻
	return context.WithValue(ctx, key, tx)
}

// Extract returns Tx extracted from context.Context.
func (p *ContextOperator[B, T]) Extract(ctx context.Context) (T, bool) {
	key := p.Key() // 👈🏻
	c, ok := ctx.Value(key).(T)
	return c, ok
}

// Key returns key (CtxKey) for injecting or extracting Tx from context.Context.
func (p *ContextOperator[B, T]) Key() CtxKey {
	return CtxKey(fmt.Sprintf("%p", p.beginner)) // 1️⃣
}

func Benchmark(bch *testing.B) {
	var (
		c = committerMock{}
		b = &beginnerMock[*committerMock, any]{}
	)

	benchmarks := []struct {
		name     string
		operator СtxOperator[*committerMock]
		fn       func(ctx context.Context, o СtxOperator[*committerMock]) context.Context
	}{
		{
			name:     "current",
			operator: NewContextOperator[*beginnerMock[*committerMock, any], *committerMock](&b),
			fn: func(ctx context.Context, o СtxOperator[*committerMock]) context.Context {
				c := o.Inject(ctx, &c)
				_, _ = o.Extract(ctx)
				return c
			},
		},
		{
			name:     "new",
			operator: NewContextOperatorV2[*beginnerMock[*committerMock, any], *committerMock](&b),
			fn: func(ctx context.Context, o СtxOperator[*committerMock]) context.Context {
				c := o.Inject(ctx, &c)
				_, _ = o.Extract(ctx)
				return c
			},
		},
	}
	for _, bm := range benchmarks {
		bch.Run(bm.name, func(b *testing.B) {
			var (
				ctx = context.Background()
				o   = bm.operator
			)
			bch.ReportAllocs()
			bch.ResetTimer()
			for i := 0; i < b.N; i++ {
				ctx = bm.fn(ctx, o)
			}
			_ = ctx
		})
	}
}

type (
	TxBeginner[C TxCommitter, O any] interface {
		comparable
		BeginTx(ctx context.Context, opts ...Option[O]) (C, error)
	}

	TxCommitter interface {
		Rollback(ctx context.Context) error
		Commit(ctx context.Context) error
	}

	Option[TxOpt any] interface {
		Apply(in TxOpt)
	}

	СtxOperator[C TxCommitter] interface {
		Inject(ctx context.Context, c C) context.Context
		Extract(ctx context.Context) (C, bool)
	}
)

// ContextOperator inject and extract Tx from context.Context.
type ContextOperator[B comparable, T Tx] struct {
	key func() B
}

// NewContextOperator returns new ContextOperator.
func NewContextOperator[B comparable, T Tx](key func() B) *ContextOperator[B, T] {
	return &ContextOperator[B, T]{
		key: key,
	}
}

// Inject returns new context.Context contains Tx as value.
func (p *ContextOperator[B, T]) Inject(ctx context.Context, tx T) context.Context {
	return context.WithValue(ctx, p.key(), tx)
}

// Extract returns Tx extracted from context.Context.
func (p *ContextOperator[B, T]) Extract(ctx context.Context) (T, bool) {
	c, ok := ctx.Value(p.key()).(T)
	return c, ok
}

	defer func() {
		switch p := recover(); {
		case p != nil:
			if rbErr := tx.Rollback(ctx); rbErr != nil {
				err = xerrors.Errorf("transactor - panic [%v]: %w", p, errors.Join(rbErr, ErrRollbackFailed))
				return
			}
			err = xerrors.Errorf("transactor - panic [%v]: %w", p, ErrRollbackSuccess)
		case err != nil:
			if rbErr := tx.Rollback(ctx); rbErr != nil {
				err = xerrors.Errorf("transactor: %w", errors.Join(err, rbErr, ErrRollbackFailed))
				return
			}
			err = xerrors.Errorf("transactor: %w", errors.Join(err, ErrRollbackSuccess))
		default:
			if err = tx.Commit(ctx); err != nil {
				err = xerrors.Errorf("transactor: %w", errors.Join(err, ErrCommitFailed))
			}
		}
	}()

	ctx = t.operator.Inject(ctx, tx)  // 👈🏻 ❗️❗️❗️
	return fn(ctx)

// Inject returns new context.Context contains Tx as value.
func (p *ContextOperator[B, T]) Inject(ctx context.Context, tx T) context.Context {
	key := p.Key()
	return context.WithValue(ctx, key, tx)
}

// Extract returns Tx extracted from context.Context.
func (p *ContextOperator[B, T]) Extract(ctx context.Context) (T, bool) {
	key := p.Key()
	c, ok := ctx.Value(key).(T)
	return c, ok
}

// Key returns key (CtxKey) for injecting or extracting Tx from context.Context.
func (p *ContextOperator[B, T]) Key() CtxKey {
	return CtxKey(fmt.Sprintf("%p", p.beginner))
}

func Benchmark_v1(b *testing.B) {
	const (
		k = "a"
		v = "x"
	)

	b.ResetTimer()
	b.ReportAllocs()
	var ctx context.Context = context.WithValue(context.Background(), k, v)
	for i := 0; i < b.N; i++ {
		_, ok := ctx.Value(k).(string)
		if !ok {
			ctx = context.WithValue(ctx, k, v)
		}
	}
	_ = ctx
}

func Benchmark_v2(b *testing.B) {
	const (
		k = "a"
		v = "x"
	)

	b.ResetTimer()
	b.ReportAllocs()
	var ctx context.Context = context.WithValue(context.Background(), k, v)
	for i := 0; i < b.N; i++ {
		c, _ := ctx.Value(k).(string)
		ctx = context.WithValue(ctx, k, c)
	}
	_ = ctx
}

	tx, ok := t.operator.Extract(ctx)
	if !ok {
		tx, err = t.beginner.BeginTx(ctx, opts...)
		if err != nil {
			return xerrors.Errorf("transactor - cannot begin: %w", errors.Join(err, ErrBeginTx))
		}
	}

	defer func() {
		switch p := recover(); {
// ...

	if !ok {
		ctx = t.operator.Inject(ctx, tx)
	}
	return fn(ctx)
}

// TryGetTx returns pointer of sql.Tx wrapper and "true" from context.Context or return `false`.
func (t *Transactor) TryGetTx(ctx context.Context) (*Tx, bool) {
	return t.transactor.TryGetTx(ctx)
}

// TxBeginner returns pointer of sql.DB wrapper.
func (t *Transactor) TxBeginner() *DB {
	return t.transactor.TxBeginner()
}

// TryGetTx returns pointer of sql.Tx and "true" from context.Context or return `false`.
func (t *Transactor) TryGetTx(ctx context.Context) (*sql.Tx, bool) {
	wrapper, ok := t.transactor.TryGetTx(ctx)
	if !ok || wrapper == nil || wrapper.Tx == nil {
		return nil, false
	}
	return wrapper.Tx, true
}

// TxBeginner returns pointer of sql.DB.
func (t *Transactor) TxBeginner() *sql.DB {
	return t.transactor.TxBeginner().DB
}

type Transactor struct {
	transactor *oniontx.Transactor[*DB, *Tx, *sql.TxOptions]
	operator   *oniontx.ContextOperator[*DB, *Tx, *sql.TxOptions]
}

		var (
			ctx, cancel = context.WithCancel(context.Background())
			transactor  = ostdlib.NewTransactor(db)
			repositoryA = NewTextRepository(transactor, false)
			repositoryB = NewTextRepository(transactor, false)
			useCase     = NewUseCase(repositoryA, repositoryB, transactor)
		)

		cancel()
...

.PHONT: deps.update
deps.update: ## Update dependencies versions (root and sub modules)
	@GOTOOLCHAIN=local go get -u all
	@go mod tidy
	@for d in */ ; do pushd "$$d" && go get -u all && go mod tidy && popd; done
	@go work sync

// ContextOperator inject and extract Tx from context.Context.
type ContextOperator[B any 👈🏻 , T Tx] struct {
	beginner *B
}

// NewContextOperator returns new ContextOperator.
func NewContextOperator[B any, T Tx](b *B) *ContextOperator[B, T] {
	return &ContextOperator[B, T]{
		beginner: b,
	}
}

// Inject returns new context.Context contains Tx as value.
func (p *ContextOperator[B, T]) Inject(ctx context.Context, tx T) context.Context {
	return context.WithValue(ctx, p.beginner, tx) 👈🏻
}

// Extract returns Tx extracted from context.Context.
func (p *ContextOperator[B, T]) Extract(ctx context.Context) (T, bool) {
	c, ok := ctx.Value(p.beginner).(T) 👈🏻
	return c, ok
}

// ContextOperator inject and extract Tx from context.Context.
type ContextOperator[B comparable, T Tx] struct {
	beginner B
}

// NewContextOperator returns new ContextOperator.
func NewContextOperator[B comparable, T Tx](b B) *ContextOperator[B, T] {
	return &ContextOperator[B, T]{
		beginner: b,
	}
}

// NewContextOperator returns new ContextOperator.
func NewContextOperator[B any, T Tx](b *B 👈🏻) *ContextOperator[B, T] {
	return &ContextOperator[B, T]{
		beginner: b,
	}
}