slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/massinsert.go

@@ -0,0 +1,164 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dbutil
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// Array is an interface for small fixed-size arrays.
+// It exists because generics can't specify array sizes: https://github.com/golang/go/issues/44253
+type Array interface {
+	[0]any | [1]any | [2]any | [3]any | [4]any | [5]any | [6]any | [7]any | [8]any | [9]any |
+		[10]any | [11]any | [12]any | [13]any | [14]any | [15]any | [16]any | [17]any | [18]any | [19]any |
+		[20]any | [21]any | [22]any | [23]any | [24]any | [25]any | [26]any | [27]any | [28]any | [29]any
+}
+
+// MassInsertable represents a struct that contains dynamic values for a mass insert query.
+type MassInsertable[T Array] interface {
+	GetMassInsertValues() T
+}
+
+// MassInsertBuilder contains pre-validated templates for building mass insert SQL queries.
+type MassInsertBuilder[Item MassInsertable[DynamicParams], StaticParams Array, DynamicParams Array] struct {
+	queryTemplate       string
+	placeholderTemplate string
+}
+
+// NewMassInsertBuilder creates a new MassInsertBuilder that can build mass insert database queries.
+//
+// Parameters in mass insert queries are split into two types: static parameters
+// and dynamic parameters. Static parameters are the same for all items being
+// inserted, while dynamic parameters are different for each item.
+//
+// The given query should be a normal INSERT query for a single row. It can also
+// have ON CONFLICT clauses, as long as the clause uses `excluded` instead of
+// positional parameters.
+//
+// The placeholder template is used to replace the `VALUES` part of the given
+// query. It should contain a positional placeholder ($1, $2, ...) for each
+// static placeholder, and a fmt directive (`$%d`) for each dynamic placeholder.
+//
+// The given query and placeholder template are validated here and the function
+// will panic if they're invalid (e.g. if the `VALUES` part of the insert query
+// can't be found, or if the placeholder template doesn't have the right things).
+// The idea is to use this function to populate a global variable with the mass
+// insert builder, so the panic will happen at startup if the query or
+// placeholder template are invalid (instead of returning an error when trying
+// to use the query later).
+//
+// Example:
+//
+//	type Message struct {
+//		ChatID    int
+//		RemoteID  string
+//		MXID      id.EventID
+//		Timestamp time.Time
+//	}
+//
+//	func (msg *Message) GetMassInsertValues() [3]any {
+//		return [3]any{msg.RemoteID, msg.MXID, msg.Timestamp.UnixMilli()}
+//	}
+//
+//	const insertMessageQuery = `INSERT INTO message (chat_id, remote_id, mxid, timestamp) VALUES ($1, $2, $3, $4)`
+//	var massInsertMessageBuilder = dbutil.NewMassInsertBuilder[Message, [2]any](insertMessageQuery, "($1, $%d, $%d, $%d, $%d)")
+//
+//	func DoMassInsert(ctx context.Context, messages []*Message) error {
+//		query, params := massInsertMessageBuilder.Build([1]any{messages[0].ChatID}, messages)
+//		return db.Exec(ctx, query, params...)
+//	}
+func NewMassInsertBuilder[Item MassInsertable[DynamicParams], StaticParams Array, DynamicParams Array](
+	singleInsertQuery, placeholderTemplate string,
+) *MassInsertBuilder[Item, StaticParams, DynamicParams] {
+	var dyn DynamicParams
+	var stat StaticParams
+	totalParams := len(dyn) + len(stat)
+	mainQueryVariablePlaceholderParts := make([]string, totalParams)
+	for i := 0; i < totalParams; i++ {
+		mainQueryVariablePlaceholderParts[i] = fmt.Sprintf(`\$%d`, i+1)
+	}
+	mainQueryVariablePlaceholderRegex := regexp.MustCompile(fmt.Sprintf(`\(\s*%s\s*\)`, strings.Join(mainQueryVariablePlaceholderParts, `\s*,\s*`)))
+	queryPlaceholders := mainQueryVariablePlaceholderRegex.FindAllString(singleInsertQuery, -1)
+	if len(queryPlaceholders) == 0 {
+		panic(fmt.Errorf("invalid insert query: placeholders not found"))
+	} else if len(queryPlaceholders) > 1 {
+		panic(fmt.Errorf("invalid insert query: multiple placeholders found"))
+	}
+	for i := 0; i < len(stat); i++ {
+		if !strings.Contains(placeholderTemplate, fmt.Sprintf("$%d", i+1)) {
+			panic(fmt.Errorf("invalid placeholder template: static placeholder $%d not found", i+1))
+		}
+	}
+	if strings.Contains(placeholderTemplate, fmt.Sprintf("$%d", len(stat)+1)) {
+		panic(fmt.Errorf("invalid placeholder template: non-static placeholder $%d found", len(stat)+1))
+	}
+	fmtParams := make([]any, len(dyn))
+	for i := 0; i < len(dyn); i++ {
+		fmtParams[i] = fmt.Sprintf("$%d", len(stat)+i+1)
+	}
+	formattedPlaceholder := fmt.Sprintf(placeholderTemplate, fmtParams...)
+	if strings.Contains(formattedPlaceholder, "!(EXTRA string=") {
+		panic(fmt.Errorf("invalid placeholder template: extra string found"))
+	}
+	for i := 0; i < len(dyn); i++ {
+		if !strings.Contains(formattedPlaceholder, fmt.Sprintf("$%d", len(stat)+i+1)) {
+			panic(fmt.Errorf("invalid placeholder template: dynamic placeholder $%d not found", len(stat)+i+1))
+		}
+	}
+	return &MassInsertBuilder[Item, StaticParams, DynamicParams]{
+		queryTemplate:       strings.Replace(singleInsertQuery, queryPlaceholders[0], "%s", 1),
+		placeholderTemplate: placeholderTemplate,
+	}
+}
+
+// Build constructs a ready-to-use mass insert SQL query using the prepared templates in this builder.
+//
+// This method always only produces one query. If there are lots of items,
+// chunking them beforehand may be required to avoid query parameter limits.
+// For example, SQLite (3.32+) has a limit of 32766 parameters by default,
+// while Postgres allows up to 65535. To find out if there are too many items,
+// divide the maximum number of parameters by the number of dynamic columns in
+// your data and subtract the number of static columns.
+//
+// Example of chunking input data:
+//
+//	var mib dbutil.MassInsertBuilder
+//	var db *dbutil.Database
+//	func MassInsert(ctx context.Context, ..., data []T) error {
+//		return db.DoTxn(ctx, nil, func(ctx context.Context) error {
+//			for _, chunk := range exslices.Chunk(data, 100) {
+//				query, params := mib.Build(staticParams)
+//				_, err := db.Exec(ctx, query, params...)
+//				if err != nil {
+//					return err
+//				}
+//			}
+//			return nil
+//		}
+//	}
+func (mib *MassInsertBuilder[Item, StaticParams, DynamicParams]) Build(static StaticParams, data []Item) (query string, params []any) {
+	var itemValues DynamicParams
+	params = make([]any, len(static)+len(itemValues)*len(data))
+	placeholders := make([]string, len(data))
+	for i := 0; i < len(static); i++ {
+		params[i] = static[i]
+	}
+	fmtParams := make([]any, len(itemValues))
+	for i, item := range data {
+		baseIndex := len(static) + len(itemValues)*i
+		itemValues = item.GetMassInsertValues()
+		for j := 0; j < len(itemValues); j++ {
+			params[baseIndex+j] = itemValues[j]
+			fmtParams[j] = baseIndex + j + 1
+		}
+		placeholders[i] = fmt.Sprintf(mib.placeholderTemplate, fmtParams...)
+	}
+	query = fmt.Sprintf(mib.queryTemplate, strings.Join(placeholders, ", "))
+	return
+}

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/queryhelper.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dbutil
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"time"
+
+	"golang.org/x/exp/constraints"
+)
+
+// DataStruct is an interface for structs that represent a single database row.
+type DataStruct[T any] interface {
+	Scan(row Scannable) (T, error)
+}
+
+// QueryHelper is a generic helper struct for SQL query execution boilerplate.
+//
+// After implementing the Scan and Init methods in a data struct, the query
+// helper allows writing query functions in a single line.
+type QueryHelper[T DataStruct[T]] struct {
+	db      *Database
+	newFunc func(qh *QueryHelper[T]) T
+}
+
+func MakeQueryHelper[T DataStruct[T]](db *Database, new func(qh *QueryHelper[T]) T) *QueryHelper[T] {
+	return &QueryHelper[T]{db: db, newFunc: new}
+}
+
+// ValueOrErr is a helper function that returns the value if err is nil, or
+// returns nil and the error if err is not nil. It can be used to avoid
+// `if err != nil { return nil, err }` boilerplate in certain cases like
+// DataStruct.Scan implementations.
+func ValueOrErr[T any](val *T, err error) (*T, error) {
+	if err != nil {
+		return nil, err
+	}
+	return val, nil
+}
+
+// StrPtr returns a pointer to the given string, or nil if the string is empty.
+func StrPtr[T ~string](val T) *string {
+	if val == "" {
+		return nil
+	}
+	strVal := string(val)
+	return &strVal
+}
+
+// NumPtr returns a pointer to the given number, or nil if the number is zero.
+func NumPtr[T constraints.Integer | constraints.Float](val T) *T {
+	if val == 0 {
+		return nil
+	}
+	return &val
+}
+
+// UnixPtr returns a pointer to the given time as unix seconds, or nil if the time is zero.
+func UnixPtr(val time.Time) *int64 {
+	return ConvertedPtr(val, time.Time.Unix)
+}
+
+// UnixMilliPtr returns a pointer to the given time as unix milliseconds, or nil if the time is zero.
+func UnixMilliPtr(val time.Time) *int64 {
+	return ConvertedPtr(val, time.Time.UnixMilli)
+}
+
+type Zeroable interface {
+	IsZero() bool
+}
+
+// ConvertedPtr returns a pointer to the converted version of the given value, or nil if the input is zero.
+//
+// This is primarily meant for time.Time, but it can be used with any type that has implements `IsZero() bool`.
+//
+//	yourTime := time.Now()
+//	unixMSPtr := dbutil.TimePtr(yourTime, time.Time.UnixMilli)
+func ConvertedPtr[Input Zeroable, Output any](val Input, converter func(Input) Output) *Output {
+	if val.IsZero() {
+		return nil
+	}
+	converted := converter(val)
+	return &converted
+}
+
+func (qh *QueryHelper[T]) GetDB() *Database {
+	return qh.db
+}
+
+func (qh *QueryHelper[T]) New() T {
+	return qh.newFunc(qh)
+}
+
+// Exec executes a query with ExecContext and returns the error.
+//
+// It omits the sql.Result return value, as it is rarely used. When the result
+// is wanted, use `qh.GetDB().Exec(...)` instead, which is
+// otherwise equivalent.
+func (qh *QueryHelper[T]) Exec(ctx context.Context, query string, args ...any) error {
+	_, err := qh.db.Exec(ctx, query, args...)
+	return err
+}
+
+func (qh *QueryHelper[T]) scanNew(row Scannable) (T, error) {
+	return qh.New().Scan(row)
+}
+
+// QueryOne executes a query with QueryRowContext, uses the associated DataStruct
+// to scan it, and returns the value. If the query returns no rows, it returns nil
+// and no error.
+func (qh *QueryHelper[T]) QueryOne(ctx context.Context, query string, args ...any) (val T, err error) {
+	val, err = qh.scanNew(qh.db.QueryRow(ctx, query, args...))
+	if errors.Is(err, sql.ErrNoRows) {
+		return *new(T), nil
+	}
+	return val, err
+}
+
+// QueryMany executes a query with QueryContext, uses the associated DataStruct
+// to scan each row, and returns the values. If the query returns no rows, it
+// returns a non-nil zero-length slice and no error.
+func (qh *QueryHelper[T]) QueryMany(ctx context.Context, query string, args ...any) ([]T, error) {
+	return qh.QueryManyIter(ctx, query, args...).AsList()
+}
+
+// QueryManyIter executes a query with QueryContext and returns a RowIter
+// that will use the associated DataStruct to scan each row.
+func (qh *QueryHelper[T]) QueryManyIter(ctx context.Context, query string, args ...any) RowIter[T] {
+	rows, err := qh.db.Query(ctx, query, args...)
+	return NewRowIterWithError(rows, qh.scanNew, err)
+}

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/reflectscan.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dbutil
+
+import (
+	"reflect"
+)
+
+func reflectScan[T any](row Scannable) (*T, error) {
+	t := new(T)
+	val := reflect.ValueOf(t).Elem()
+	fields := reflect.VisibleFields(val.Type())
+	scanInto := make([]any, len(fields))
+	for i, field := range fields {
+		scanInto[i] = val.FieldByIndex(field.Index).Addr().Interface()
+	}
+	err := row.Scan(scanInto...)
+	return t, err
+}
+
+// NewSimpleReflectRowIter creates a new RowIter that uses reflection to scan rows into the given type.
+//
+// This is a simplified implementation that always scans to all struct fields. It does not support any kind of struct tags.
+func NewSimpleReflectRowIter[T any](rows Rows, err error) RowIter[*T] {
+	return ConvertRowFn[*T](reflectScan[T]).NewRowIter(rows, err)
+}

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/transaction.go

@@ -0,0 +1,180 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dbutil
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"runtime"
+	"sync/atomic"
+	"time"
+
+	"github.com/petermattis/goid"
+	"github.com/rs/zerolog"
+
+	"go.mau.fi/util/exerrors"
+	"go.mau.fi/util/random"
+)
+
+var (
+	ErrTxn       = errors.New("transaction")
+	ErrTxnBegin  = fmt.Errorf("%w: begin", ErrTxn)
+	ErrTxnCommit = fmt.Errorf("%w: commit", ErrTxn)
+)
+
+type contextKey int64
+
+const (
+	ContextKeyDoTxnCallerSkip contextKey = 1
+)
+
+var nextContextKeyDatabaseTransaction atomic.Uint64
+
+func init() {
+	nextContextKeyDatabaseTransaction.Store(1 << 61)
+}
+
+func (db *Database) Exec(ctx context.Context, query string, args ...any) (sql.Result, error) {
+	return db.Execable(ctx).ExecContext(ctx, query, args...)
+}
+
+func (db *Database) Query(ctx context.Context, query string, args ...any) (Rows, error) {
+	return db.Execable(ctx).QueryContext(ctx, query, args...)
+}
+
+func (db *Database) QueryRow(ctx context.Context, query string, args ...any) *sql.Row {
+	return db.Execable(ctx).QueryRowContext(ctx, query, args...)
+}
+
+var ErrTransactionDeadlock = errors.New("attempt to start new transaction in goroutine with transaction")
+var ErrQueryDeadlock = errors.New("attempt to query without context in goroutine with transaction")
+var ErrAcquireDeadlock = errors.New("attempt to acquire connection without context in goroutine with transaction")
+
+func (db *Database) BeginTx(ctx context.Context, opts *TxnOptions) (*LoggingTxn, error) {
+	if ctx == nil {
+		panic("BeginTx() called with nil ctx")
+	}
+	return db.LoggingDB.BeginTx(ctx, opts)
+}
+
+func (db *Database) DoTxn(ctx context.Context, opts *TxnOptions, fn func(ctx context.Context) error) error {
+	if ctx == nil {
+		panic("DoTxn() called with nil ctx")
+	}
+	if ctx.Value(db.txnCtxKey) != nil {
+		zerolog.Ctx(ctx).Trace().Msg("Already in a transaction, not creating a new one")
+		return fn(ctx)
+	} else if db.DeadlockDetection {
+		goroutineID := goid.Get()
+		if !db.txnDeadlockMap.Add(goroutineID) {
+			panic(ErrTransactionDeadlock)
+		}
+		defer db.txnDeadlockMap.Remove(goroutineID)
+	}
+
+	log := zerolog.Ctx(ctx).With().Str("db_txn_id", random.String(12)).Logger()
+	slowLog := log
+
+	callerSkip := 1
+	if val := ctx.Value(ContextKeyDoTxnCallerSkip); val != nil {
+		callerSkip += val.(int)
+	}
+	if pc, file, line, ok := runtime.Caller(callerSkip); ok {
+		slowLog = log.With().Str(zerolog.CallerFieldName, zerolog.CallerMarshalFunc(pc, file, line)).Logger()
+	}
+
+	start := time.Now()
+	deadlockCh := make(chan struct{})
+	go func() {
+		ticker := time.NewTicker(5 * time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				slowLog.Warn().
+					Float64("duration_seconds", time.Since(start).Seconds()).
+					Msg("Transaction still running")
+			case <-deadlockCh:
+				return
+			}
+		}
+	}()
+	defer func() {
+		close(deadlockCh)
+		dur := time.Since(start)
+		if dur > time.Second {
+			slowLog.Warn().
+				Float64("duration_seconds", dur.Seconds()).
+				Msg("Transaction took long")
+		}
+	}()
+	tx, err := db.BeginTx(ctx, opts)
+	if err != nil {
+		log.Trace().Err(err).Msg("Failed to begin transaction")
+		return exerrors.NewDualError(ErrTxnBegin, err)
+	}
+	log.Trace().Msg("Transaction started")
+	tx.noTotalLog = true
+	ctx = log.WithContext(ctx)
+	ctx = context.WithValue(ctx, db.txnCtxKey, tx)
+	err = fn(ctx)
+	if err != nil {
+		log.Trace().Err(err).Msg("Database transaction failed, rolling back")
+		rollbackErr := tx.Rollback()
+		if rollbackErr != nil {
+			log.Warn().Err(rollbackErr).Msg("Rollback after transaction error failed")
+		} else {
+			log.Trace().Msg("Rollback successful")
+		}
+		return err
+	}
+	err = tx.Commit()
+	if err != nil {
+		log.Trace().Err(err).Msg("Commit failed")
+		return exerrors.NewDualError(ErrTxnCommit, err)
+	}
+	log.Trace().Msg("Commit successful")
+	return nil
+}
+
+func (db *Database) Execable(ctx context.Context) Execable {
+	if ctx == nil {
+		panic("Conn() called with nil ctx")
+	}
+	txn, ok := ctx.Value(db.txnCtxKey).(Transaction)
+	if ok {
+		return txn
+	}
+	if db.DeadlockDetection && db.txnDeadlockMap.Has(goid.Get()) {
+		panic(ErrQueryDeadlock)
+	}
+	return &db.LoggingDB
+}
+
+func (db *Database) AcquireConn(ctx context.Context) (Conn, error) {
+	if ctx == nil {
+		return nil, fmt.Errorf("AcquireConn() called with nil ctx")
+	}
+	_, ok := ctx.Value(db.txnCtxKey).(Transaction)
+	if ok {
+		return nil, fmt.Errorf("cannot acquire connection while in a transaction")
+	}
+	if db.DeadlockDetection && db.txnDeadlockMap.Has(goid.Get()) {
+		panic(ErrAcquireDeadlock)
+	}
+	conn, err := db.RawDB.Conn(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &LoggingExecable{
+		UnderlyingExecable: conn,
+		db:                 db,
+	}, nil
+}