type HttpWriter struct {
    w             http.ResponseWriter
    headerWritten bool
    statusCode    int
}

func NewHttpWriter(w http.ResponseWriter) http.ResponseWriter {
    return &HttpWriter{w: w}
}

func (w *HttpWriter) Header() http.Header {
    return w.w.Header()
}

func (w *HttpWriter) WriteHeader(statusCode int) {
    w.w.WriteHeader(statusCode)
    w.headerWritten = true
    w.statusCode = statusCode
}

func (w *HttpWriter) Write(data []byte) (int, error) {
    if !w.headerWritten {
        log.Println("⚠️ Предупреждение: Write() вызван без предварительного WriteHeader()")
    }
    if w.statusCode >= 500 {
        log.Println("⚠️ Статус 500: запись игнорируется")
        return 0, nil
    }
    return w.w.Write(data)
}

func middleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        writer := NewHttpWriter(w)
        h.ServeHTTP(writer, r)
    })
}

w := varmq.NewVoidWorker(func(data any) {
   // обработка задачи
}, 2)
q := w.BindQueue()

import "github.com/goptics/sqliteq"

db := sqliteq.New("test.db")
pq, _ := db.NewQueue("orders")
q := w.WithPersistentQueue(pq)

import "github.com/goptics/redisq"

rdb := redisq.New("redis://localhost:6379")
pq := rdb.NewDistributedQueue("transactions")
q := w.WithDistributedQueue(pq)

import "testing/synctest"

func TestSharedValue(t *testing.T) {
    synctest.Run(func() {
        var shared atomic.Int64
        go func() {
            shared.Store(1)
            time.Sleep(1 * time.Microsecond)
            shared.Store(2)
        }()
        time.Sleep(5 * time.Microsecond)
        if shared.Load() != 2 {
            t.Errorf("shared = %d, want 2", shared.Load())
        }
    })
}

ctx := context.Background()

// Создание
gorm.G[User](db).Create(ctx, &User{Name: "Alice"})

// Поиск
user, err := gorm.G[User](db).Where("name = ?", "Alice").First(ctx)

// Обновление
gorm.G[User](db).Where("id = ?", user.ID).Update(ctx, "age", 30)

// Удаление
gorm.G[User](db).Where("id = ?", user.ID).Delete(ctx)

type LoggingRoundTripper struct {
    rt http.RoundTripper
}

func (l *LoggingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
    log.Printf("📤 Запрос: %s %s", req.Method, req.URL)
    resp, err := l.rt.RoundTrip(req)
    if err == nil {
        log.Printf("📥 Ответ: %d", resp.StatusCode)
    }
    return resp, err
}

client := &http.Client{
    Transport: &LoggingRoundTripper{rt: http.DefaultTransport},
}