Add S10 sqlc queries: profile/avatar updates, rename + redirect-rate-limit count, theme + session_epoch, restore, primary-email + delete, notif prefs CRUD

Status	File	+	-
M	`internal/users/queries/user_emails.sql`	15	0
A	`internal/users/queries/user_notification_prefs.sql`	16	0
M	`internal/users/queries/users.sql`	48	0
M	`internal/users/sqlc/models.go`	9	0
M	`internal/users/sqlc/querier.go`	28	0
M	`internal/users/sqlc/user_emails.sql.go`	48	0
A	`internal/users/sqlc/user_notification_prefs.sql.go`	76	0
M	`internal/users/sqlc/users.sql.go`	209	3

internal/users/queries/user_emails.sqlmodified

         verification_sent_at, verified_at, created_at
  FROM user_emails
  WHERE verification_token_hash = $1;
++
++-- name: SetUserEmailPrimary :exec
++-- Atomically unset the existing primary and set the supplied row as
++-- primary. Caller MUST have already verified the row belongs to the
++-- user and is verified.
++UPDATE user_emails SET is_primary = (id = $2) WHERE user_id = $1;
++
++-- name: DeleteUserEmail :execrows
++-- Scoped delete: caller must pass owning user_id. Refuses to delete
++-- the primary email (UI must guide the user to set a different primary first).
++DELETE FROM user_emails
++WHERE id = $1 AND user_id = $2 AND is_primary = false;
++
++-- name: CountVerifiedUserEmails :one
++SELECT count(*) FROM user_emails WHERE user_id = $1 AND verified = true;

internal/users/queries/user_notification_prefs.sqladded

++-- SPDX-License-Identifier: AGPL-3.0-or-later
++
++-- name: ListUserNotificationPrefs :many
++SELECT user_id, key, value, updated_at
++FROM user_notification_prefs
++WHERE user_id = $1
++ORDER BY key;
++
++-- name: UpsertUserNotificationPref :exec
++INSERT INTO user_notification_prefs (user_id, key, value)
++VALUES ($1, $2, $3)
++ON CONFLICT (user_id, key) DO UPDATE
++SET value = EXCLUDED.value;
++
++-- name: DeleteUserNotificationPref :exec
++DELETE FROM user_notification_prefs WHERE user_id = $1 AND key = $2;

internal/users/queries/users.sqlmodified

  -- name: CountUsers :one
  SELECT count(*) FROM users WHERE deleted_at IS NULL;
++
++-- name: UpdateUserProfile :exec
++UPDATE users
++SET display_name = $2,
++    bio          = $3,
++    location     = $4,
++    website      = $5,
++    company      = $6,
++    pronouns     = $7
++WHERE id = $1;
++
++-- name: UpdateUserAvatarKey :exec
++UPDATE users
++SET avatar_object_key = $2
++WHERE id = $1;
++
++-- name: RenameUser :exec
++-- Wrapped by the username-change flow inside a tx that also writes
++-- username_redirects, so the old name becomes a redirect target atomically.
++UPDATE users
++SET username = $2
++WHERE id = $1;
++
++-- name: CountRecentUsernameChanges :one
++-- Drives the 3-changes-per-60d cap.
++SELECT count(*) FROM username_redirects
++WHERE user_id = $1 AND changed_at > $2;
++
++-- name: UpdateUserTheme :exec
++UPDATE users SET theme = $2 WHERE id = $1;
++
++-- name: BumpUserSessionEpoch :exec
++UPDATE users SET session_epoch = session_epoch + 1 WHERE id = $1;
++
++-- name: GetUserSessionEpoch :one
++SELECT session_epoch FROM users WHERE id = $1;
++
++-- name: RestoreUserAccount :exec
++-- Clears deleted_at; called when a user logs in within the 14-day grace
++-- window. The login handler enforces the window check before calling.
++UPDATE users SET deleted_at = NULL WHERE id = $1;
++
++-- name: GetUserIncludingDeleted :one
++-- Like GetUserByID but returns the row even when deleted_at IS NOT NULL.
++SELECT * FROM users WHERE id = $1;
++
++-- name: GetUserByUsernameIncludingDeleted :one
++SELECT * FROM users WHERE username = $1;

internal/users/sqlc/models.gomodified

  	Company           string
  	Pronouns          string
  	AvatarObjectKey   pgtype.Text
++	Theme             string
++	SessionEpoch      int32
  }
  type UserEmail struct {
  	CreatedAt             pgtype.Timestamptz
  }
++type UserNotificationPref struct {
++	UserID    int64
++	Key       string
++	Value     []byte
++	UpdatedAt pgtype.Timestamptz
++}
++
  type UserRecoveryCode struct {
  	ID          int64
  	UserID      int64

internal/users/sqlc/querier.gomodified

  	// strictly greater. Returns rows affected — 0 means a replay attempt and
  	// the caller should reject the code.
  	BumpTOTPCounter(ctx context.Context, db DBTX, arg BumpTOTPCounterParams) (int64, error)
++	BumpUserSessionEpoch(ctx context.Context, db DBTX, id int64) error
  	// Sets confirmed_at on a pending row. Returns the number of rows updated;
  	// callers MUST check this to handle the parallel-enrollment race
  	// (only one of two concurrent confirms wins).
  	// 0 means rejected.
  	ConsumeRecoveryCode(ctx context.Context, db DBTX, arg ConsumeRecoveryCodeParams) (int64, error)
  	CountActiveUserTokens(ctx context.Context, db DBTX, userID int64) (int64, error)
++	// Drives the 3-changes-per-60d cap.
++	CountRecentUsernameChanges(ctx context.Context, db DBTX, arg CountRecentUsernameChangesParams) (int64, error)
  	CountUnusedRecoveryCodes(ctx context.Context, db DBTX, userID int64) (int64, error)
  	CountUserSSHKeys(ctx context.Context, db DBTX, userID int64) (int64, error)
  	CountUsers(ctx context.Context, db DBTX) (int64, error)
++	CountVerifiedUserEmails(ctx context.Context, db DBTX, userID int64) (int64, error)
  	// SPDX-License-Identifier: AGPL-3.0-or-later
  	CreateEmailVerification(ctx context.Context, db DBTX, arg CreateEmailVerificationParams) (EmailVerification, error)
  	// SPDX-License-Identifier: AGPL-3.0-or-later
  	CreateUserEmail(ctx context.Context, db DBTX, arg CreateUserEmailParams) (UserEmail, error)
  	DeleteExpiredEmailVerifications(ctx context.Context, db DBTX) error
  	DeleteExpiredPasswordResets(ctx context.Context, db DBTX) error
++	// Scoped delete: caller must pass owning user_id. Refuses to delete
++	// the primary email (UI must guide the user to set a different primary first).
++	DeleteUserEmail(ctx context.Context, db DBTX, arg DeleteUserEmailParams) (int64, error)
++	DeleteUserNotificationPref(ctx context.Context, db DBTX, arg DeleteUserNotificationPrefParams) error
  	DeleteUserRecoveryCodes(ctx context.Context, db DBTX, userID int64) error
  	// Scoped delete: caller must pass the owning user_id so a hijacked
  	// handler can never delete keys it doesn't own.
  	GetPasswordResetByTokenHash(ctx context.Context, db DBTX, tokenHash []byte) (PasswordReset, error)
  	GetUserByID(ctx context.Context, db DBTX, id int64) (User, error)
  	GetUserByUsername(ctx context.Context, db DBTX, username string) (User, error)
++	GetUserByUsernameIncludingDeleted(ctx context.Context, db DBTX, username string) (User, error)
  	GetUserEmailByAddress(ctx context.Context, db DBTX, email string) (UserEmail, error)
  	GetUserEmailByID(ctx context.Context, db DBTX, id int64) (UserEmail, error)
  	GetUserEmailByVerificationHash(ctx context.Context, db DBTX, verificationTokenHash []byte) (UserEmail, error)
++	// Like GetUserByID but returns the row even when deleted_at IS NOT NULL.
++	GetUserIncludingDeleted(ctx context.Context, db DBTX, id int64) (User, error)
  	// Hot path for sshd's AuthorizedKeysCommand. Index lookup via the UNIQUE
  	// index on fingerprint_sha256.
  	GetUserSSHKeyByFingerprint(ctx context.Context, db DBTX, fingerprintSha256 string) (UserSshKey, error)
++	GetUserSessionEpoch(ctx context.Context, db DBTX, id int64) (int32, error)
  	GetUserTOTP(ctx context.Context, db DBTX, userID int64) (UserTotp, error)
  	// Hot path for the auth middleware. token_hash is UNIQUE; returns at
  	// most one row. Caller MUST also check revoked_at IS NULL and
  	LinkUserPrimaryEmail(ctx context.Context, db DBTX, arg LinkUserPrimaryEmailParams) error
  	ListAuditLogForTarget(ctx context.Context, db DBTX, arg ListAuditLogForTargetParams) ([]AuthAuditLog, error)
  	ListUserEmailsForUser(ctx context.Context, db DBTX, userID int64) ([]UserEmail, error)
++	// SPDX-License-Identifier: AGPL-3.0-or-later
++	ListUserNotificationPrefs(ctx context.Context, db DBTX, userID int64) ([]UserNotificationPref, error)
  	ListUserSSHKeys(ctx context.Context, db DBTX, userID int64) ([]UserSshKey, error)
  	ListUserTokens(ctx context.Context, db DBTX, userID int64) ([]UserToken, error)
  	// SPDX-License-Identifier: AGPL-3.0-or-later
  	MarkUserEmailPrimaryVerified(ctx context.Context, db DBTX, id int64) error
  	MarkUserEmailVerified(ctx context.Context, db DBTX, id int64) error
  	PurgeStaleAuthThrottle(ctx context.Context, db DBTX, windowStartedAt pgtype.Timestamptz) error
++	// Wrapped by the username-change flow inside a tx that also writes
++	// username_redirects, so the old name becomes a redirect target atomically.
++	RenameUser(ctx context.Context, db DBTX, arg RenameUserParams) error
  	ResetAuthThrottle(ctx context.Context, db DBTX, arg ResetAuthThrottleParams) error
++	// Clears deleted_at; called when a user logs in within the 14-day grace
++	// window. The login handler enforces the window check before calling.
++	RestoreUserAccount(ctx context.Context, db DBTX, id int64) error
  	// Used by user suspension to revoke every active token in one statement.
  	RevokeAllUserTokens(ctx context.Context, db DBTX, userID int64) error
  	// Scoped revoke: caller must pass owning user_id so a hijacked handler
  	// can never revoke tokens it doesn't own. No-op on already-revoked rows.
  	RevokeUserToken(ctx context.Context, db DBTX, arg RevokeUserTokenParams) (int64, error)
++	// Atomically unset the existing primary and set the supplied row as
++	// primary. Caller MUST have already verified the row belongs to the
++	// user and is verified.
++	SetUserEmailPrimary(ctx context.Context, db DBTX, arg SetUserEmailPrimaryParams) error
  	SetVerificationToken(ctx context.Context, db DBTX, arg SetVerificationTokenParams) error
  	SoftDeleteUser(ctx context.Context, db DBTX, id int64) error
  	SuspendUser(ctx context.Context, db DBTX, arg SuspendUserParams) error
  	TouchSSHKeyLastUsed(ctx context.Context, db DBTX, arg TouchSSHKeyLastUsedParams) error
  	TouchUserLastLogin(ctx context.Context, db DBTX, id int64) error
  	TouchUserTokenLastUsed(ctx context.Context, db DBTX, arg TouchUserTokenLastUsedParams) error
++	UpdateUserAvatarKey(ctx context.Context, db DBTX, arg UpdateUserAvatarKeyParams) error
  	UpdateUserPassword(ctx context.Context, db DBTX, arg UpdateUserPasswordParams) error
++	UpdateUserProfile(ctx context.Context, db DBTX, arg UpdateUserProfileParams) error
++	UpdateUserTheme(ctx context.Context, db DBTX, arg UpdateUserThemeParams) error
++	UpsertUserNotificationPref(ctx context.Context, db DBTX, arg UpsertUserNotificationPrefParams) error
  	// SPDX-License-Identifier: AGPL-3.0-or-later
  	// Inserts a new pending TOTP row, or replaces an existing pending row for
  	// the same user. Confirmed rows are NOT replaced — disable+regenerate

internal/users/sqlc/user_emails.sql.gomodified

  	"context"
+ )
++const countVerifiedUserEmails = `-- name: CountVerifiedUserEmails :one
++SELECT count(*) FROM user_emails WHERE user_id = $1 AND verified = true
++`
++
++func (q *Queries) CountVerifiedUserEmails(ctx context.Context, db DBTX, userID int64) (int64, error) {
++	row := db.QueryRow(ctx, countVerifiedUserEmails, userID)
++	var count int64
++	err := row.Scan(&count)
++	return count, err
++}
++
  const createUserEmail = `-- name: CreateUserEmail :one
  INSERT INTO user_emails (user_id, email, is_primary, verified, verification_token_hash, verification_sent_at)
  	return i, err
+ }
++const deleteUserEmail = `-- name: DeleteUserEmail :execrows
++DELETE FROM user_emails
++WHERE id = $1 AND user_id = $2 AND is_primary = false
++`
++
++type DeleteUserEmailParams struct {
++	ID     int64
++	UserID int64
++}
++
++// Scoped delete: caller must pass owning user_id. Refuses to delete
++// the primary email (UI must guide the user to set a different primary first).
++func (q *Queries) DeleteUserEmail(ctx context.Context, db DBTX, arg DeleteUserEmailParams) (int64, error) {
++	result, err := db.Exec(ctx, deleteUserEmail, arg.ID, arg.UserID)
++	if err != nil {
++		return 0, err
++	}
++	return result.RowsAffected(), nil
++}
++
  const getUserEmailByAddress = `-- name: GetUserEmailByAddress :one
  SELECT id, user_id, email, is_primary, verified, verification_token_hash,
         verification_sent_at, verified_at, created_at
  	return err
+ }
++const setUserEmailPrimary = `-- name: SetUserEmailPrimary :exec
++UPDATE user_emails SET is_primary = (id = $2) WHERE user_id = $1
++`
++
++type SetUserEmailPrimaryParams struct {
++	UserID int64
++	ID     int64
++}
++
++// Atomically unset the existing primary and set the supplied row as
++// primary. Caller MUST have already verified the row belongs to the
++// user and is verified.
++func (q *Queries) SetUserEmailPrimary(ctx context.Context, db DBTX, arg SetUserEmailPrimaryParams) error {
++	_, err := db.Exec(ctx, setUserEmailPrimary, arg.UserID, arg.ID)
++	return err
++}
++
  const setVerificationToken = `-- name: SetVerificationToken :exec
  UPDATE user_emails
  SET verification_token_hash = $2,

internal/users/sqlc/user_notification_prefs.sql.goadded

++// Code generated by sqlc. DO NOT EDIT.
++// versions:
++//   sqlc v1.31.1
++// source: user_notification_prefs.sql
++
++package usersdb
++
++import (
++	"context"
++)
++
++const deleteUserNotificationPref = `-- name: DeleteUserNotificationPref :exec
++DELETE FROM user_notification_prefs WHERE user_id = $1 AND key = $2
++`
++
++type DeleteUserNotificationPrefParams struct {
++	UserID int64
++	Key    string
++}
++
++func (q *Queries) DeleteUserNotificationPref(ctx context.Context, db DBTX, arg DeleteUserNotificationPrefParams) error {
++	_, err := db.Exec(ctx, deleteUserNotificationPref, arg.UserID, arg.Key)
++	return err
++}
++
++const listUserNotificationPrefs = `-- name: ListUserNotificationPrefs :many
++
++SELECT user_id, key, value, updated_at
++FROM user_notification_prefs
++WHERE user_id = $1
++ORDER BY key
++`
++
++// SPDX-License-Identifier: AGPL-3.0-or-later
++func (q *Queries) ListUserNotificationPrefs(ctx context.Context, db DBTX, userID int64) ([]UserNotificationPref, error) {
++	rows, err := db.Query(ctx, listUserNotificationPrefs, userID)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []UserNotificationPref{}
++	for rows.Next() {
++		var i UserNotificationPref
++		if err := rows.Scan(
++			&i.UserID,
++			&i.Key,
++			&i.Value,
++			&i.UpdatedAt,
++		); err != nil {
++			return nil, err
++		}
++		items = append(items, i)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}
++
++const upsertUserNotificationPref = `-- name: UpsertUserNotificationPref :exec
++INSERT INTO user_notification_prefs (user_id, key, value)
++VALUES ($1, $2, $3)
++ON CONFLICT (user_id, key) DO UPDATE
++SET value = EXCLUDED.value
++`
++
++type UpsertUserNotificationPrefParams struct {
++	UserID int64
++	Key    string
++	Value  []byte
++}
++
++func (q *Queries) UpsertUserNotificationPref(ctx context.Context, db DBTX, arg UpsertUserNotificationPrefParams) error {
++	_, err := db.Exec(ctx, upsertUserNotificationPref, arg.UserID, arg.Key, arg.Value)
++	return err
++}

internal/users/sqlc/users.sql.gomodified

  	"github.com/jackc/pgx/v5/pgtype"
+ )
++const bumpUserSessionEpoch = `-- name: BumpUserSessionEpoch :exec
++UPDATE users SET session_epoch = session_epoch + 1 WHERE id = $1
++`
++
++func (q *Queries) BumpUserSessionEpoch(ctx context.Context, db DBTX, id int64) error {
++	_, err := db.Exec(ctx, bumpUserSessionEpoch, id)
++	return err
++}
++
++const countRecentUsernameChanges = `-- name: CountRecentUsernameChanges :one
++SELECT count(*) FROM username_redirects
++WHERE user_id = $1 AND changed_at > $2
++`
++
++type CountRecentUsernameChangesParams struct {
++	UserID    int64
++	ChangedAt pgtype.Timestamptz
++}
++
++// Drives the 3-changes-per-60d cap.
++func (q *Queries) CountRecentUsernameChanges(ctx context.Context, db DBTX, arg CountRecentUsernameChangesParams) (int64, error) {
++	row := db.QueryRow(ctx, countRecentUsernameChanges, arg.UserID, arg.ChangedAt)
++	var count int64
++	err := row.Scan(&count)
++	return count, err
++}
++
  const countUsers = `-- name: CountUsers :one
  SELECT count(*) FROM users WHERE deleted_at IS NULL
+ `
  INSERT INTO users (username, display_name, password_hash)
  VALUES ($1, $2, $3)
--RETURNING id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key
++RETURNING id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch
+ `
  type CreateUserParams struct {
  		&i.Company,
  		&i.Pronouns,
  		&i.AvatarObjectKey,
++		&i.Theme,
++		&i.SessionEpoch,
+ 	)
  	return i, err
+ }
  const getUserByID = `-- name: GetUserByID :one
--SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key
++SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch
  FROM users
  WHERE id = $1 AND deleted_at IS NULL
+ `
  		&i.Company,
  		&i.Pronouns,
  		&i.AvatarObjectKey,
++		&i.Theme,
++		&i.SessionEpoch,
+ 	)
  	return i, err
+ }
  const getUserByUsername = `-- name: GetUserByUsername :one
--SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key
++SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch
  FROM users
  WHERE username = $1 AND deleted_at IS NULL
+ `
  		&i.Company,
  		&i.Pronouns,
  		&i.AvatarObjectKey,
++		&i.Theme,
++		&i.SessionEpoch,
++	)
++	return i, err
++}
++
++const getUserByUsernameIncludingDeleted = `-- name: GetUserByUsernameIncludingDeleted :one
++SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch FROM users WHERE username = $1
++`
++
++func (q *Queries) GetUserByUsernameIncludingDeleted(ctx context.Context, db DBTX, username string) (User, error) {
++	row := db.QueryRow(ctx, getUserByUsernameIncludingDeleted, username)
++	var i User
++	err := row.Scan(
++		&i.ID,
++		&i.Username,
++		&i.DisplayName,
++		&i.PrimaryEmailID,
++		&i.PasswordHash,
++		&i.PasswordAlgo,
++		&i.PasswordUpdatedAt,
++		&i.EmailVerified,
++		&i.LastLoginAt,
++		&i.SuspendedAt,
++		&i.SuspendedReason,
++		&i.DeletedAt,
++		&i.CreatedAt,
++		&i.UpdatedAt,
++		&i.Bio,
++		&i.Location,
++		&i.Website,
++		&i.Company,
++		&i.Pronouns,
++		&i.AvatarObjectKey,
++		&i.Theme,
++		&i.SessionEpoch,
+ 	)
  	return i, err
+ }
++const getUserIncludingDeleted = `-- name: GetUserIncludingDeleted :one
++SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch FROM users WHERE id = $1
++`
++
++// Like GetUserByID but returns the row even when deleted_at IS NOT NULL.
++func (q *Queries) GetUserIncludingDeleted(ctx context.Context, db DBTX, id int64) (User, error) {
++	row := db.QueryRow(ctx, getUserIncludingDeleted, id)
++	var i User
++	err := row.Scan(
++		&i.ID,
++		&i.Username,
++		&i.DisplayName,
++		&i.PrimaryEmailID,
++		&i.PasswordHash,
++		&i.PasswordAlgo,
++		&i.PasswordUpdatedAt,
++		&i.EmailVerified,
++		&i.LastLoginAt,
++		&i.SuspendedAt,
++		&i.SuspendedReason,
++		&i.DeletedAt,
++		&i.CreatedAt,
++		&i.UpdatedAt,
++		&i.Bio,
++		&i.Location,
++		&i.Website,
++		&i.Company,
++		&i.Pronouns,
++		&i.AvatarObjectKey,
++		&i.Theme,
++		&i.SessionEpoch,
++	)
++	return i, err
++}
++
++const getUserSessionEpoch = `-- name: GetUserSessionEpoch :one
++SELECT session_epoch FROM users WHERE id = $1
++`
++
++func (q *Queries) GetUserSessionEpoch(ctx context.Context, db DBTX, id int64) (int32, error) {
++	row := db.QueryRow(ctx, getUserSessionEpoch, id)
++	var session_epoch int32
++	err := row.Scan(&session_epoch)
++	return session_epoch, err
++}
++
  const linkUserPrimaryEmail = `-- name: LinkUserPrimaryEmail :exec
  UPDATE users
  SET primary_email_id = $2
  	return err
+ }
++const renameUser = `-- name: RenameUser :exec
++UPDATE users
++SET username = $2
++WHERE id = $1
++`
++
++type RenameUserParams struct {
++	ID       int64
++	Username string
++}
++
++// Wrapped by the username-change flow inside a tx that also writes
++// username_redirects, so the old name becomes a redirect target atomically.
++func (q *Queries) RenameUser(ctx context.Context, db DBTX, arg RenameUserParams) error {
++	_, err := db.Exec(ctx, renameUser, arg.ID, arg.Username)
++	return err
++}
++
++const restoreUserAccount = `-- name: RestoreUserAccount :exec
++UPDATE users SET deleted_at = NULL WHERE id = $1
++`
++
++// Clears deleted_at; called when a user logs in within the 14-day grace
++// window. The login handler enforces the window check before calling.
++func (q *Queries) RestoreUserAccount(ctx context.Context, db DBTX, id int64) error {
++	_, err := db.Exec(ctx, restoreUserAccount, id)
++	return err
++}
++
  const softDeleteUser = `-- name: SoftDeleteUser :exec
  UPDATE users
  SET deleted_at = now()
  	return err
+ }
++const updateUserAvatarKey = `-- name: UpdateUserAvatarKey :exec
++UPDATE users
++SET avatar_object_key = $2
++WHERE id = $1
++`
++
++type UpdateUserAvatarKeyParams struct {
++	ID              int64
++	AvatarObjectKey pgtype.Text
++}
++
++func (q *Queries) UpdateUserAvatarKey(ctx context.Context, db DBTX, arg UpdateUserAvatarKeyParams) error {
++	_, err := db.Exec(ctx, updateUserAvatarKey, arg.ID, arg.AvatarObjectKey)
++	return err
++}
++
  const updateUserPassword = `-- name: UpdateUserPassword :exec
  UPDATE users
  SET password_hash       = $2,
  	_, err := db.Exec(ctx, updateUserPassword, arg.ID, arg.PasswordHash, arg.PasswordAlgo)
  	return err
+ }
++
++const updateUserProfile = `-- name: UpdateUserProfile :exec
++UPDATE users
++SET display_name = $2,
++    bio          = $3,
++    location     = $4,
++    website      = $5,
++    company      = $6,
++    pronouns     = $7
++WHERE id = $1
++`
++
++type UpdateUserProfileParams struct {
++	ID          int64
++	DisplayName string
++	Bio         string
++	Location    string
++	Website     string
++	Company     string
++	Pronouns    string
++}
++
++func (q *Queries) UpdateUserProfile(ctx context.Context, db DBTX, arg UpdateUserProfileParams) error {
++	_, err := db.Exec(ctx, updateUserProfile,
++		arg.ID,
++		arg.DisplayName,
++		arg.Bio,
++		arg.Location,
++		arg.Website,
++		arg.Company,
++		arg.Pronouns,
++	)
++	return err
++}
++
++const updateUserTheme = `-- name: UpdateUserTheme :exec
++UPDATE users SET theme = $2 WHERE id = $1
++`
++
++type UpdateUserThemeParams struct {
++	ID    int64
++	Theme string
++}
++
++func (q *Queries) UpdateUserTheme(ctx context.Context, db DBTX, arg UpdateUserThemeParams) error {
++	_, err := db.Exec(ctx, updateUserTheme, arg.ID, arg.Theme)
++	return err
++}

tenseleyflow/shithub / `a41bd07`

8 changed files