slidge-whatsapp 0.2.2__cp312-cp312-manylinux_2_36_aarch64.whl → 0.2.6__cp312-cp312-manylinux_2_36_aarch64.whl

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

@@ -0,0 +1,309 @@
+// Copyright (c) 2022 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"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"go.mau.fi/util/exsync"
+)
+
+type Dialect int
+
+const (
+	DialectUnknown Dialect = iota
+	Postgres
+	SQLite
+)
+
+func (dialect Dialect) String() string {
+	switch dialect {
+	case Postgres:
+		return "postgres"
+	case SQLite:
+		return "sqlite3"
+	default:
+		return ""
+	}
+}
+
+func ParseDialect(engine string) (Dialect, error) {
+	engine = strings.ToLower(engine)
+
+	if strings.HasPrefix(engine, "postgres") || engine == "pgx" {
+		return Postgres, nil
+	} else if strings.HasPrefix(engine, "sqlite") || strings.HasPrefix(engine, "litestream") {
+		return SQLite, nil
+	} else {
+		return DialectUnknown, fmt.Errorf("unknown dialect '%s'", engine)
+	}
+}
+
+type Rows interface {
+	Close() error
+	ColumnTypes() ([]*sql.ColumnType, error)
+	Columns() ([]string, error)
+	Err() error
+	Next() bool
+	NextResultSet() bool
+	Scan(...any) error
+}
+
+type Scannable interface {
+	Scan(...any) error
+}
+
+// Expected implementations of Scannable
+var (
+	_ Scannable = (*sql.Row)(nil)
+	_ Scannable = (Rows)(nil)
+)
+
+type UnderlyingExecable interface {
+	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
+	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
+	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
+}
+
+type UnderlyingExecutableWithTx interface {
+	UnderlyingExecable
+	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
+}
+
+type Execable interface {
+	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
+	QueryContext(ctx context.Context, query string, args ...any) (Rows, error)
+	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
+}
+
+type Conn interface {
+	Execable
+	internalTxnStarter
+}
+
+type Transaction interface {
+	Execable
+	Commit() error
+	Rollback() error
+}
+
+// Expected implementations of Execable
+var (
+	_ UnderlyingExecable         = (*sql.Tx)(nil)
+	_ UnderlyingExecutableWithTx = (*sql.DB)(nil)
+	_ UnderlyingExecutableWithTx = (*sql.Conn)(nil)
+	_ Execable                   = (*LoggingExecable)(nil)
+	_ Transaction                = (*LoggingTxn)(nil)
+)
+
+type Database struct {
+	LoggingDB    loggingDB
+	RawDB        *sql.DB
+	ReadOnlyDB   *sql.DB
+	Owner        string
+	VersionTable string
+	Log          DatabaseLogger
+	Dialect      Dialect
+	UpgradeTable UpgradeTable
+
+	txnCtxKey      contextKey
+	txnDeadlockMap *exsync.Set[int64]
+
+	IgnoreForeignTables       bool
+	IgnoreUnsupportedDatabase bool
+	DeadlockDetection         bool
+}
+
+var ForceDeadlockDetection bool
+
+var positionalParamPattern = regexp.MustCompile(`\$(\d+)`)
+
+func (db *Database) mutateQuery(query string) string {
+	switch db.Dialect {
+	case SQLite:
+		return positionalParamPattern.ReplaceAllString(query, "?$1")
+	default:
+		return query
+	}
+}
+
+func (db *Database) Child(versionTable string, upgradeTable UpgradeTable, log DatabaseLogger) *Database {
+	if log == nil {
+		log = db.Log
+	}
+	return &Database{
+		RawDB:        db.RawDB,
+		LoggingDB:    db.LoggingDB,
+		Owner:        "",
+		VersionTable: versionTable,
+		UpgradeTable: upgradeTable,
+		Log:          log,
+		Dialect:      db.Dialect,
+
+		txnCtxKey:      db.txnCtxKey,
+		txnDeadlockMap: db.txnDeadlockMap,
+
+		IgnoreForeignTables:       true,
+		IgnoreUnsupportedDatabase: db.IgnoreUnsupportedDatabase,
+		DeadlockDetection:         db.DeadlockDetection,
+	}
+}
+
+func NewWithDB(db *sql.DB, rawDialect string) (*Database, error) {
+	dialect, err := ParseDialect(rawDialect)
+	if err != nil {
+		return nil, err
+	}
+	wrappedDB := &Database{
+		RawDB:   db,
+		Dialect: dialect,
+		Log:     NoopLogger,
+
+		IgnoreForeignTables: true,
+		VersionTable:        "version",
+
+		txnCtxKey:      contextKey(nextContextKeyDatabaseTransaction.Add(1)),
+		txnDeadlockMap: exsync.NewSet[int64](),
+
+		DeadlockDetection: ForceDeadlockDetection,
+	}
+	wrappedDB.LoggingDB.UnderlyingExecable = db
+	wrappedDB.LoggingDB.db = wrappedDB
+	return wrappedDB, nil
+}
+
+func NewWithDialect(uri, rawDialect string) (*Database, error) {
+	db, err := sql.Open(rawDialect, uri)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewWithDB(db, rawDialect)
+}
+
+type PoolConfig struct {
+	Type string `yaml:"type"`
+	URI  string `yaml:"uri"`
+
+	MaxOpenConns int `yaml:"max_open_conns"`
+	MaxIdleConns int `yaml:"max_idle_conns"`
+
+	ConnMaxIdleTime string `yaml:"conn_max_idle_time"`
+	ConnMaxLifetime string `yaml:"conn_max_lifetime"`
+}
+
+type Config struct {
+	PoolConfig   `yaml:",inline"`
+	ReadOnlyPool PoolConfig `yaml:"ro_pool"`
+
+	DeadlockDetection bool `yaml:"deadlock_detection"`
+}
+
+func (db *Database) Close() error {
+	err := db.RawDB.Close()
+	if db.ReadOnlyDB != nil {
+		if err2 := db.ReadOnlyDB.Close(); err2 != nil {
+			if err == nil {
+				err = fmt.Errorf("closing read-only db failed: %w", err2)
+			} else {
+				err = fmt.Errorf("%w (closing read-only db also failed: %v)", err, err2)
+			}
+		}
+	}
+	return err
+}
+
+func (db *Database) Configure(cfg Config) error {
+	db.DeadlockDetection = cfg.DeadlockDetection || ForceDeadlockDetection
+
+	if err := db.configure(db.ReadOnlyDB, cfg.ReadOnlyPool); err != nil {
+		return err
+	}
+
+	return db.configure(db.RawDB, cfg.PoolConfig)
+}
+
+func (db *Database) configure(rawDB *sql.DB, cfg PoolConfig) error {
+	if rawDB == nil {
+		return nil
+	}
+
+	rawDB.SetMaxOpenConns(cfg.MaxOpenConns)
+	rawDB.SetMaxIdleConns(cfg.MaxIdleConns)
+	if len(cfg.ConnMaxIdleTime) > 0 {
+		maxIdleTimeDuration, err := time.ParseDuration(cfg.ConnMaxIdleTime)
+		if err != nil {
+			return fmt.Errorf("failed to parse max_conn_idle_time: %w", err)
+		}
+		rawDB.SetConnMaxIdleTime(maxIdleTimeDuration)
+	}
+	if len(cfg.ConnMaxLifetime) > 0 {
+		maxLifetimeDuration, err := time.ParseDuration(cfg.ConnMaxLifetime)
+		if err != nil {
+			return fmt.Errorf("failed to parse max_conn_idle_time: %w", err)
+		}
+		rawDB.SetConnMaxLifetime(maxLifetimeDuration)
+	}
+	return nil
+}
+
+func NewFromConfig(owner string, cfg Config, logger DatabaseLogger) (*Database, error) {
+	wrappedDB, err := NewWithDialect(cfg.URI, cfg.Type)
+	if err != nil {
+		return nil, err
+	}
+
+	wrappedDB.Owner = owner
+	if logger != nil {
+		wrappedDB.Log = logger
+	}
+
+	if cfg.ReadOnlyPool.MaxOpenConns > 0 {
+		if cfg.ReadOnlyPool.Type == "" {
+			cfg.ReadOnlyPool.Type = cfg.Type
+		}
+
+		roUri := cfg.ReadOnlyPool.URI
+		if roUri == "" {
+			uriParts := strings.Split(cfg.URI, "?")
+
+			qs := url.Values{}
+			if len(uriParts) == 2 {
+				var err error
+				qs, err = url.ParseQuery(uriParts[1])
+				if err != nil {
+					return nil, err
+				}
+
+				qs.Del("_txlock")
+				qs.Del("_auto_vacuum")
+				qs.Del("_vacuum")
+			}
+			qs.Set("_query_only", "true")
+
+			roUri = uriParts[0] + "?" + qs.Encode()
+		}
+
+		wrappedDB.ReadOnlyDB, err = sql.Open(cfg.ReadOnlyPool.Type, roUri)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = wrappedDB.Configure(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return wrappedDB, nil
+}

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

@@ -0,0 +1,233 @@
+// Copyright (c) 2023 Sumner Evans
+//
+// 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 (
+	"errors"
+	"fmt"
+	"runtime"
+
+	"go.mau.fi/util/exzerolog"
+)
+
+var ErrAlreadyIterated = errors.New("this iterator has been already iterated")
+
+// RowIter is a wrapper for [Rows] that allows conveniently iterating over rows
+// with a predefined scanner function.
+type RowIter[T any] interface {
+	// Iter iterates over the rows and calls the given function for each row.
+	//
+	// If the function returns false, the iteration is stopped.
+	// If the function returns an error, the iteration is stopped and the error is
+	// returned.
+	Iter(func(T) (bool, error)) error
+
+	// AsList collects all rows into a slice.
+	AsList() ([]T, error)
+}
+
+type ConvertRowFn[T any] func(Scannable) (T, error)
+
+// NewRowIter is a proxy for NewRowIterWithError for more convenient usage.
+//
+// For example:
+//
+//	func exampleConvertRowFn(rows Scannable) (*YourType, error) {
+//		...
+//	}
+//	func exampleFunction() {
+//		iter := dbutil.ConvertRowFn[*YourType](exampleConvertRowFn).NewRowIter(
+//			db.Query("SELECT ..."),
+//		)
+//	}
+func (crf ConvertRowFn[T]) NewRowIter(rows Rows, err error) RowIter[T] {
+	return newRowIterWithError(rows, crf, err)
+}
+
+type rowIterImpl[T any] struct {
+	Rows
+	ConvertRow ConvertRowFn[T]
+
+	iterated bool
+	caller   string
+	err      error
+}
+
+// NewRowIter creates a new RowIter from the given Rows and scanner function.
+//
+// Deprecated: use NewRowIterWithError instead to avoid an unnecessary separate error check on the Query result.
+//
+// Instead of
+//
+//	func DoQuery(...) (dbutil.RowIter, error) {
+//		rows, err := db.Query(...)
+//		if err != nil {
+//			return nil, err
+//		}
+//		return dbutil.NewRowIter(rows, convertFn), nil
+//	}
+//
+// you should use
+//
+//	func DoQuery(...) dbutil.RowIter {
+//		rows, err := db.Query(...)
+//		return dbutil.NewRowIterWithError(rows, convertFn, err)
+//	}
+//
+// or alternatively pre-wrap the convertFn
+//
+//	var converter = dbutil.ConvertRowFn(convertFn)
+//	func DoQuery(...) dbutil.RowIter {
+//		return converter.NewRowIter(db.Query(...))
+//	}
+//
+// Embedding the error in the iterator allows the caller to do only one error check instead of two:
+//
+//	iter, err := DoQuery(...)
+//	if err != nil { ... }
+//	result, err := iter.Iter(...)
+//	if err != nil { ... }
+//
+// vs
+//
+//	result, err := DoQuery(...).Iter(...)
+//	if err != nil { ... }
+func NewRowIter[T any](rows Rows, convertFn ConvertRowFn[T]) RowIter[T] {
+	return newRowIterWithError(rows, convertFn, nil)
+}
+
+// NewRowIterWithError creates a new RowIter from the given Rows and scanner function with default error. If not nil, it will be returned without calling iterator function.
+func NewRowIterWithError[T any](rows Rows, convertFn ConvertRowFn[T], err error) RowIter[T] {
+	return newRowIterWithError(rows, convertFn, err)
+}
+
+func newRowIterWithError[T any](rows Rows, convertFn ConvertRowFn[T], err error) RowIter[T] {
+	ri := &rowIterImpl[T]{Rows: rows, ConvertRow: convertFn, err: err}
+	if err == nil {
+		callerSkip := 2
+		if pc, file, line, ok := runtime.Caller(callerSkip); ok {
+			ri.caller = exzerolog.CallerWithFunctionName(pc, file, line)
+		}
+		runtime.SetFinalizer(ri, (*rowIterImpl[T]).destroy)
+	}
+	return ri
+}
+
+func ScanSingleColumn[T any](rows Scannable) (val T, err error) {
+	err = rows.Scan(&val)
+	return
+}
+
+type NewableDataStruct[T any] interface {
+	DataStruct[T]
+	New() T
+}
+
+func ScanDataStruct[T NewableDataStruct[T]](rows Scannable) (T, error) {
+	var val T
+	return val.New().Scan(rows)
+}
+
+func (i *rowIterImpl[T]) destroy() {
+	if !i.iterated {
+		panic(fmt.Errorf("RowIter created at %s wasn't iterated", i.caller))
+	}
+}
+
+func (i *rowIterImpl[T]) Iter(fn func(T) (bool, error)) error {
+	if i == nil {
+		return nil
+	} else if i.Rows == nil || i.err != nil {
+		return i.err
+	}
+	defer func() {
+		_ = i.Rows.Close()
+		i.iterated = true
+	}()
+
+	for i.Rows.Next() {
+		if item, err := i.ConvertRow(i.Rows); err != nil {
+			i.err = err
+			return err
+		} else if cont, err := fn(item); err != nil {
+			i.err = err
+			return err
+		} else if !cont {
+			break
+		}
+	}
+
+	err := i.Rows.Err()
+	if err != nil {
+		i.err = err
+	} else {
+		i.err = ErrAlreadyIterated
+	}
+	return err
+}
+
+func (i *rowIterImpl[T]) AsList() (list []T, err error) {
+	err = i.Iter(func(item T) (bool, error) {
+		list = append(list, item)
+		return true, nil
+	})
+	return
+}
+
+func RowIterAsMap[T any, Key comparable, Value any](ri RowIter[T], getKeyValue func(T) (Key, Value)) (map[Key]Value, error) {
+	m := make(map[Key]Value)
+	err := ri.Iter(func(item T) (bool, error) {
+		k, v := getKeyValue(item)
+		m[k] = v
+		return true, nil
+	})
+	return m, err
+}
+
+type sliceIterImpl[T any] struct {
+	items []T
+	err   error
+}
+
+func NewSliceIter[T any](items []T) RowIter[T] {
+	return &sliceIterImpl[T]{items: items}
+}
+
+func NewSliceIterWithError[T any](items []T, err error) RowIter[T] {
+	return &sliceIterImpl[T]{items: items, err: err}
+}
+
+func (i *sliceIterImpl[T]) Iter(fn func(T) (bool, error)) error {
+	if i == nil {
+		return nil
+	} else if i.err != nil {
+		return i.err
+	}
+
+	for _, item := range i.items {
+		if cont, err := fn(item); err != nil {
+			i.err = err
+			return err
+		} else if !cont {
+			break
+		}
+	}
+
+	i.err = ErrAlreadyIterated
+	return nil
+}
+
+func (i *sliceIterImpl[T]) AsList() ([]T, error) {
+	if i == nil {
+		return nil, nil
+	} else if i.err != nil {
+		return nil, i.err
+	}
+
+	i.err = ErrAlreadyIterated
+	return i.items, nil
+}

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

@@ -0,0 +1,47 @@
+package dbutil
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+	"unsafe"
+)
+
+// JSON is a utility type for using arbitrary JSON data as values in database Exec and Scan calls.
+type JSON struct {
+	Data any
+}
+
+func (j JSON) Scan(i any) error {
+	switch value := i.(type) {
+	case nil:
+		return nil
+	case string:
+		return json.Unmarshal([]byte(value), j.Data)
+	case []byte:
+		return json.Unmarshal(value, j.Data)
+	default:
+		return fmt.Errorf("invalid type %T for dbutil.JSON.Scan", i)
+	}
+}
+
+func (j JSON) Value() (driver.Value, error) {
+	if j.Data == nil {
+		return nil, nil
+	}
+	v, err := json.Marshal(j.Data)
+	return unsafe.String(unsafe.SliceData(v), len(v)), err
+}
+
+// JSONPtr is a convenience function for wrapping a pointer to a value in the JSON utility, but removing typed nils
+// (i.e. preventing nils from turning into the string "null" in the database).
+func JSONPtr[T any](val *T) JSON {
+	return JSON{Data: UntypedNil(val)}
+}
+
+func UntypedNil[T any](val *T) any {
+	if val == nil {
+		return nil
+	}
+	return val
+}

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

@@ -0,0 +1,129 @@
+package dbutil
+
+import (
+	"context"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+type DatabaseLogger interface {
+	QueryTiming(ctx context.Context, method, query string, args []any, nrows int, duration time.Duration, err error)
+	WarnUnsupportedVersion(current, compat, latest int)
+	PrepareUpgrade(current, compat, latest int)
+	DoUpgrade(from, to int, message string, txn TxnMode)
+	// Deprecated: legacy warning method, return errors instead
+	Warn(msg string, args ...any)
+}
+
+type noopLogger struct{}
+
+var NoopLogger DatabaseLogger = &noopLogger{}
+
+func (n noopLogger) WarnUnsupportedVersion(_, _, _ int)      {}
+func (n noopLogger) PrepareUpgrade(_, _, _ int)              {}
+func (n noopLogger) DoUpgrade(_, _ int, _ string, _ TxnMode) {}
+func (n noopLogger) Warn(msg string, args ...any)            {}
+
+func (n noopLogger) QueryTiming(_ context.Context, _, _ string, _ []any, _ int, _ time.Duration, _ error) {
+}
+
+type zeroLogger struct {
+	l *zerolog.Logger
+	ZeroLogSettings
+}
+
+type ZeroLogSettings struct {
+	CallerSkipFrame int
+	Caller          bool
+
+	// TraceLogAllQueries specifies whether or not all queries should be logged
+	// at the TRACE level.
+	TraceLogAllQueries bool
+}
+
+func ZeroLogger(log zerolog.Logger, cfg ...ZeroLogSettings) DatabaseLogger {
+	return ZeroLoggerPtr(&log, cfg...)
+}
+
+func ZeroLoggerPtr(log *zerolog.Logger, cfg ...ZeroLogSettings) DatabaseLogger {
+	wrapped := &zeroLogger{l: log}
+	if len(cfg) > 0 {
+		wrapped.ZeroLogSettings = cfg[0]
+	} else {
+		wrapped.ZeroLogSettings = ZeroLogSettings{
+			CallerSkipFrame: 2, // Skip LoggingExecable.ExecContext and zeroLogger.QueryTiming
+			Caller:          true,
+		}
+	}
+	return wrapped
+}
+
+func (z zeroLogger) WarnUnsupportedVersion(current, compat, latest int) {
+	z.l.Warn().
+		Int("current_version", current).
+		Int("oldest_compatible_version", compat).
+		Int("latest_known_version", latest).
+		Msg("Unsupported database schema version, continuing anyway")
+}
+
+func (z zeroLogger) PrepareUpgrade(current, compat, latest int) {
+	evt := z.l.Info().
+		Int("current_version", current).
+		Int("oldest_compatible_version", compat).
+		Int("latest_known_version", latest)
+	if current >= latest {
+		evt.Msg("Database is up to date")
+	} else {
+		evt.Msg("Preparing to update database schema")
+	}
+}
+
+func (z zeroLogger) DoUpgrade(from, to int, message string, txn TxnMode) {
+	z.l.Info().
+		Int("from", from).
+		Int("to", to).
+		Str("txn_mode", string(txn)).
+		Str("description", message).
+		Msg("Upgrading database")
+}
+
+var whitespaceRegex = regexp.MustCompile(`\s+`)
+
+func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args []any, nrows int, duration time.Duration, err error) {
+	log := zerolog.Ctx(ctx)
+	if log.GetLevel() == zerolog.Disabled || log == zerolog.DefaultContextLogger {
+		log = z.l
+	}
+	if (!z.TraceLogAllQueries || log.GetLevel() != zerolog.TraceLevel) && duration < 1*time.Second {
+		return
+	}
+	if nrows > -1 {
+		rowLog := log.With().Int("rows", nrows).Logger()
+		log = &rowLog
+	}
+	query = strings.TrimSpace(whitespaceRegex.ReplaceAllLiteralString(query, " "))
+	log.Trace().
+		Err(err).
+		Int64("duration_µs", duration.Microseconds()).
+		Str("method", method).
+		Str("query", query).
+		Interface("query_args", args).
+		Msg("Query")
+	if duration >= 1*time.Second {
+		evt := log.Warn().
+			Float64("duration_seconds", duration.Seconds()).
+			Str("method", method).
+			Str("query", query)
+		if z.Caller {
+			evt = evt.Caller(z.CallerSkipFrame)
+		}
+		evt.Msg("Query took long")
+	}
+}
+
+func (z zeroLogger) Warn(msg string, args ...any) {
+	z.l.Warn().Msgf(msg, args...) // zerolog-allow-msgf
+}