retry tx not working as expected

[cakir-enes]

so even though on the errors I see conn returns a SQLSTATE 28000 error it still doenst retry and I cant reproduce it locally I try to by closing db manually which gives some other error but it does retry on that one, this just doenst retry on this one

package jetutil

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"math"
	"math/rand"
	"strings"
	"time"

	"github.com/go-jet/jet/v2/qrm"
)

func WithRetry(t qrm.DB) qrm.DB {
	return &RetryableTx{
		tx:         t,
		retryTimes: 5,
		baseDelay:  time.Millisecond * 100, // Start with 100ms
		maxDelay:   time.Second * 10,       // Cap at 10 seconds
		multiplier: 2.0,                    // Double each time
		jitter:     0.1,                    // 10% jitter
	}
}

// WithRetryConfig allows custom retry configuration
func WithRetryConfig(t qrm.DB, retries int, baseDelay, maxDelay time.Duration) qrm.DB {
	return &RetryableTx{
		tx:         t,
		retryTimes: retries,
		baseDelay:  baseDelay,
		maxDelay:   maxDelay,
		multiplier: 2.0,
		jitter:     0.1,
	}
}

type RetryableTx struct {
	tx         qrm.DB
	retryTimes int
	baseDelay  time.Duration
	maxDelay   time.Duration
	multiplier float64
	jitter     float64
}

var _ qrm.DB = (*RetryableTx)(nil)

// isRetryableError determines if an error is worth retrying
func (r *RetryableTx) isRetryableError(err error) bool {
	if err == qrm.ErrNoRows {
		return false
	}
	errStr := err.Error()
	return containsAny(errStr,
		"SQLSTATE 28000",       // SSL/auth errors
		"timeout",              // Timeouts
		"connection refused",   // Connection issues
		"connection reset",     // Network resets
		"too many connections", // Pool exhaustion
		"deadlock",             // Deadlocks
		"connection lost",      // Connection drops
		"server closed",        // Server issues
		"i/o timeout",          // I/O timeouts
		"broken pipe",          // Network issues
	)
}

func containsAny(s string, substr ...string) bool {
	for _, sub := range substr {
		if strings.Contains(s, sub) {
			return true
		}
	}
	return false
}

// truncateError truncates error message to maxLen characters
func truncateError(err error, maxLen int) string {
	errStr := err.Error()
	if len(errStr) <= maxLen {
		return errStr
	}
	return errStr[:maxLen-3] + "..."
}

// calculateBackoff calculates the delay with exponential backoff and jitter
func (r *RetryableTx) calculateBackoff(attempt int) time.Duration {
	// Exponential backoff: baseDelay * multiplier^attempt
	delay := float64(r.baseDelay) * math.Pow(r.multiplier, float64(attempt))

	// Apply jitter (random variation of ±jitter%)
	jitterRange := delay * r.jitter
	jitterOffset := (rand.Float64()*2 - 1) * jitterRange // nolint:gosec
	delay += jitterOffset

	// Ensure delay is positive and within bounds
	if delay < 0 {
		delay = float64(r.baseDelay)
	}

	finalDelay := time.Duration(delay)
	if finalDelay > r.maxDelay {
		finalDelay = r.maxDelay
	}

	return finalDelay
}

func (r *RetryableTx) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
	var lastErr error

	for attempt := 0; attempt <= r.retryTimes; attempt++ {
		// Check if context is already cancelled
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		default:
		}

		res, err := r.tx.ExecContext(ctx, query, args...)
		if err == nil {
			return res, nil
		}

		lastErr = err
		if err == qrm.ErrNoRows {
			return nil, err
		}
		// Don't retry on the last attempt
		if attempt == r.retryTimes {
			break
		}

		// Only retry if it's a retryable error
		if !r.isRetryableError(err) {
			return nil, errors.New(truncateError(err, 180))
		}

		// Calculate backoff delay
		backoffDelay := r.calculateBackoff(attempt)

		// Wait with context cancellation support
		timer := time.NewTimer(backoffDelay)
		select {
		case <-ctx.Done():
			timer.Stop()
			return nil, ctx.Err()
		case <-timer.C:
			// Continue to next retry
		}
	}

	return nil, fmt.Errorf("failed after %d retries: %w", r.retryTimes, lastErr)
}

func (r *RetryableTx) Exec(query string, args ...any) (sql.Result, error) {
	return r.ExecContext(context.Background(), query, args...)
}

func (r *RetryableTx) Query(query string, args ...any) (*sql.Rows, error) {
	return r.QueryContext(context.Background(), query, args...)
}

func (r *RetryableTx) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) {
	var lastErr error

	for attempt := 0; attempt <= r.retryTimes; attempt++ {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		default:
		}

		rows, err := r.tx.QueryContext(ctx, query, args...)
		if err == nil {
			return rows, nil
		}

		lastErr = err

		if attempt == r.retryTimes {
			break
		}

		if err == qrm.ErrNoRows {
			return nil, err
		}

		if !r.isRetryableError(err) {
			return nil, errors.New(truncateError(err, 180))
		}

		backoffDelay := r.calculateBackoff(attempt)
		timer := time.NewTimer(backoffDelay)
		select {
		case <-ctx.Done():
			timer.Stop()
			return nil, ctx.Err()
		case <-timer.C:
		}
	}

	return nil, fmt.Errorf("query failed after %d retries: %w", r.retryTimes, lastErr)
}

any ideas? Im calling these like this btw

tx, err := db.Begin()
...
Exec(WithRetry(tx)..

[houtn11]

How is this issue related to jet?