slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.0b0__cp311-cp311-manylinux_2_36_aarch64.whl

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
+}

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

@@ -0,0 +1,250 @@
+// 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"
+)
+
+type upgradeFunc func(context.Context, *Database) error
+
+type upgrade struct {
+	message string
+	fn      upgradeFunc
+
+	upgradesTo    int
+	compatVersion int
+	transaction   TxnMode
+}
+
+func (u *upgrade) DangerouslyRun(ctx context.Context, db *Database) (upgradesTo, compat int, err error) {
+	return u.upgradesTo, u.compatVersion, u.fn(ctx, db)
+}
+
+var ErrUnsupportedDatabaseVersion = errors.New("unsupported database schema version")
+var ErrForeignTables = errors.New("the database contains foreign tables")
+var ErrNotOwned = errors.New("the database is owned by")
+var ErrUnsupportedDialect = errors.New("unsupported database dialect")
+
+func DangerousInternalUpgradeVersionTable(ctx context.Context, db *Database) error {
+	return db.upgradeVersionTable(ctx)
+}
+
+func (db *Database) upgradeVersionTable(ctx context.Context) error {
+	if compatColumnExists, err := db.ColumnExists(ctx, db.VersionTable, "compat"); err != nil {
+		return fmt.Errorf("failed to check if version table is up to date: %w", err)
+	} else if !compatColumnExists {
+		if tableExists, err := db.TableExists(ctx, db.VersionTable); err != nil {
+			return fmt.Errorf("failed to check if version table exists: %w", err)
+		} else if !tableExists {
+			_, err = db.Exec(ctx, fmt.Sprintf("CREATE TABLE %s (version INTEGER, compat INTEGER)", db.VersionTable))
+			if err != nil {
+				return fmt.Errorf("failed to create version table: %w", err)
+			}
+		} else {
+			_, err = db.Exec(ctx, fmt.Sprintf("ALTER TABLE %s ADD COLUMN compat INTEGER", db.VersionTable))
+			if err != nil {
+				return fmt.Errorf("failed to add compat column to version table: %w", err)
+			}
+		}
+	}
+	return nil
+}
+
+func (db *Database) getVersion(ctx context.Context) (version, compat int, err error) {
+	if err = db.upgradeVersionTable(ctx); err != nil {
+		return
+	}
+
+	var compatNull sql.NullInt32
+	err = db.QueryRow(ctx, fmt.Sprintf("SELECT version, compat FROM %s LIMIT 1", db.VersionTable)).Scan(&version, &compatNull)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if compatNull.Valid && compatNull.Int32 != 0 {
+		compat = int(compatNull.Int32)
+	} else {
+		compat = version
+	}
+	return
+}
+
+const (
+	tableExistsPostgres = "SELECT EXISTS(SELECT 1 FROM information_schema.tables WHERE table_name=$1)"
+	tableExistsSQLite   = "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND tbl_name=?1)"
+)
+
+func (db *Database) TableExists(ctx context.Context, table string) (exists bool, err error) {
+	switch db.Dialect {
+	case SQLite:
+		err = db.QueryRow(ctx, tableExistsSQLite, table).Scan(&exists)
+	case Postgres:
+		err = db.QueryRow(ctx, tableExistsPostgres, table).Scan(&exists)
+	default:
+		err = ErrUnsupportedDialect
+	}
+	return
+}
+
+const (
+	columnExistsPostgres = "SELECT EXISTS(SELECT 1 FROM information_schema.columns WHERE table_name=$1 AND column_name=$2)"
+	columnExistsSQLite   = "SELECT EXISTS(SELECT 1 FROM pragma_table_info(?1) WHERE name=?2)"
+)
+
+func (db *Database) ColumnExists(ctx context.Context, table, column string) (exists bool, err error) {
+	switch db.Dialect {
+	case SQLite:
+		err = db.QueryRow(ctx, columnExistsSQLite, table, column).Scan(&exists)
+	case Postgres:
+		err = db.QueryRow(ctx, columnExistsPostgres, table, column).Scan(&exists)
+	default:
+		err = ErrUnsupportedDialect
+	}
+	return
+}
+
+const createOwnerTable = `
+CREATE TABLE IF NOT EXISTS database_owner (
+	key   INTEGER PRIMARY KEY DEFAULT 0,
+	owner TEXT NOT NULL
+)
+`
+
+func (db *Database) checkDatabaseOwner(ctx context.Context) error {
+	var owner string
+	if !db.IgnoreForeignTables {
+		if exists, err := db.TableExists(ctx, "state_groups_state"); err != nil {
+			return fmt.Errorf("failed to check if state_groups_state exists: %w", err)
+		} else if exists {
+			return fmt.Errorf("%w (found state_groups_state, likely belonging to Synapse)", ErrForeignTables)
+		} else if exists, err = db.TableExists(ctx, "roomserver_rooms"); err != nil {
+			return fmt.Errorf("failed to check if roomserver_rooms exists: %w", err)
+		} else if exists {
+			return fmt.Errorf("%w (found roomserver_rooms, likely belonging to Dendrite)", ErrForeignTables)
+		}
+	}
+	if db.Owner == "" {
+		return nil
+	}
+	if _, err := db.Exec(ctx, createOwnerTable); err != nil {
+		return fmt.Errorf("failed to ensure database owner table exists: %w", err)
+	} else if err = db.QueryRow(ctx, "SELECT owner FROM database_owner WHERE key=0").Scan(&owner); errors.Is(err, sql.ErrNoRows) {
+		_, err = db.Exec(ctx, "INSERT INTO database_owner (key, owner) VALUES (0, $1)", db.Owner)
+		if err != nil {
+			return fmt.Errorf("failed to insert database owner: %w", err)
+		}
+	} else if err != nil {
+		return fmt.Errorf("failed to check database owner: %w", err)
+	} else if owner != db.Owner {
+		return fmt.Errorf("%w %s", ErrNotOwned, owner)
+	}
+	return nil
+}
+
+func (db *Database) setVersion(ctx context.Context, version, compat int) error {
+	_, err := db.Exec(ctx, fmt.Sprintf("DELETE FROM %s", db.VersionTable))
+	if err != nil {
+		return err
+	}
+	_, err = db.Exec(ctx, fmt.Sprintf("INSERT INTO %s (version, compat) VALUES ($1, $2)", db.VersionTable), version, compat)
+	return err
+}
+
+func (db *Database) DoSQLiteTransactionWithoutForeignKeys(ctx context.Context, doUpgrade func(context.Context) error) error {
+	conn, err := db.AcquireConn(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to acquire connection: %w", err)
+	}
+	_, err = conn.ExecContext(ctx, "PRAGMA foreign_keys=OFF")
+	if err != nil {
+		return fmt.Errorf("failed to disable foreign keys: %w", err)
+	}
+	err = db.DoTxn(ctx, &TxnOptions{Conn: conn}, func(ctx context.Context) error {
+		err := doUpgrade(ctx)
+		if err != nil {
+			return err
+		}
+		_, err = conn.ExecContext(ctx, "PRAGMA foreign_key_check")
+		if err != nil {
+			return fmt.Errorf("failed to check foreign keys after upgrade: %w", err)
+		}
+		return nil
+	})
+	if err != nil {
+		_, _ = conn.ExecContext(ctx, "PRAGMA foreign_keys=ON")
+		return err
+	}
+	_, err = conn.ExecContext(ctx, "PRAGMA foreign_keys=ON")
+	if err != nil {
+		return fmt.Errorf("failed to enable foreign keys: %w", err)
+	}
+	return nil
+}
+
+func (db *Database) Upgrade(ctx context.Context) error {
+	err := db.checkDatabaseOwner(ctx)
+	if err != nil {
+		return err
+	}
+
+	version, compat, err := db.getVersion(ctx)
+	if err != nil {
+		return err
+	}
+
+	if compat > len(db.UpgradeTable) {
+		if db.IgnoreUnsupportedDatabase {
+			db.Log.WarnUnsupportedVersion(version, compat, len(db.UpgradeTable))
+			return nil
+		}
+		return fmt.Errorf("%w: currently on v%d (compatible down to v%d), latest known: v%d", ErrUnsupportedDatabaseVersion, version, compat, len(db.UpgradeTable))
+	}
+
+	db.Log.PrepareUpgrade(version, compat, len(db.UpgradeTable))
+	logVersion := version
+	for version < len(db.UpgradeTable) {
+		upgradeItem := db.UpgradeTable[version]
+		if upgradeItem.fn == nil {
+			version++
+			continue
+		}
+		doUpgrade := func(ctx context.Context) error {
+			err = upgradeItem.fn(ctx, db)
+			if err != nil {
+				return fmt.Errorf("failed to run upgrade v%d->v%d: %w", version, upgradeItem.upgradesTo, err)
+			}
+			version = upgradeItem.upgradesTo
+			logVersion = version
+			err = db.setVersion(ctx, version, upgradeItem.compatVersion)
+			if err != nil {
+				return err
+			}
+			return nil
+		}
+		db.Log.DoUpgrade(logVersion, upgradeItem.upgradesTo, upgradeItem.message, upgradeItem.transaction)
+		switch upgradeItem.transaction {
+		case TxnModeOff:
+			err = doUpgrade(ctx)
+		case TxnModeOn:
+			err = db.DoTxn(ctx, nil, doUpgrade)
+		case TxnModeSQLiteForeignKeysOff:
+			switch db.Dialect {
+			case SQLite:
+				err = db.DoSQLiteTransactionWithoutForeignKeys(ctx, doUpgrade)
+			default:
+				err = db.DoTxn(ctx, nil, doUpgrade)
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}