Files
XHChat/server/internal/groups/store.go
T

361 lines
11 KiB
Go

package groups
import (
"context"
"errors"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
)
var ErrUnavailable = errors.New("group unavailable")
var ErrAction = errors.New("group action unavailable")
var ErrLimit = errors.New("group member limit reached")
type Group struct {
ID string `json:"id"`
Name string `json:"name"`
State string `json:"state"`
Role string `json:"role"`
Version string `json:"membershipVersion"`
Preferences
}
type ListedGroup struct {
Group
Unread int `json:"unread"`
}
type Preferences struct {
Pinned bool `json:"pinned"`
Muted bool `json:"muted"`
}
type Member struct {
ID string `json:"id"`
Username string `json:"username"`
State string `json:"state"`
Role string `json:"role"`
}
type Detail struct {
Group
Members []Member `json:"members"`
}
type Change struct {
Action string `json:"action"`
Target string `json:"target"`
Name string `json:"name"`
}
type Store struct{ db *pgxpool.Pool }
func New(db *pgxpool.Pool) *Store { return &Store{db: db} }
func (s *Store) Create(ctx context.Context, owner, name string) (Group, error) {
result := Group{Name: name, State: "active", Role: "owner", Version: "1"}
err := s.db.QueryRow(ctx, `
WITH created AS (INSERT INTO chat_groups(name,owner_id) VALUES($2,$1) RETURNING id)
INSERT INTO group_members(group_id,user_id,state,joined_version)
SELECT id,$1,'active',1 FROM created RETURNING group_id
`, owner, name).Scan(&result.ID)
return result, err
}
const groupColumns = `g.id,g.name,m.state,CASE WHEN g.owner_id=m.user_id THEN 'owner' ELSE m.role END,g.membership_version::text,m.pinned,m.muted`
const groupRows = `
FROM chat_groups g JOIN group_members m ON m.group_id=g.id WHERE m.user_id=$1
`
func (s *Store) List(ctx context.Context, user, device string) ([]ListedGroup, error) {
rows, err := s.db.Query(ctx, "SELECT "+groupColumns+`, (
SELECT count(*) FROM (
SELECT 1 FROM group_messages x
JOIN group_epoch_devices enrolled ON (enrolled.group_id,enrolled.epoch_id)=(x.group_id,x.epoch_id) AND enrolled.device_id=$2
JOIN group_epochs epoch ON (epoch.group_id,epoch.id)=(x.group_id,x.epoch_id)
JOIN devices d ON d.id=enrolled.device_id AND d.revoked_at IS NULL
WHERE x.group_id=g.id AND epoch.membership_version>=m.joined_version AND x.sender_device<>$2
AND x.sequence>COALESCE((SELECT seen.sequence FROM group_seen seen WHERE seen.group_id=g.id AND seen.device_id=$2),0)
ORDER BY x.sequence LIMIT 100
) AS unread
)`+groupRows+" ORDER BY m.pinned DESC, g.created_at DESC, g.id LIMIT 200", user, device)
if err != nil {
return nil, err
}
defer rows.Close()
result := make([]ListedGroup, 0)
for rows.Next() {
var g ListedGroup
if err := rows.Scan(&g.ID, &g.Name, &g.State, &g.Role, &g.Version, &g.Pinned, &g.Muted, &g.Unread); err != nil {
return nil, err
}
result = append(result, g)
}
return result, rows.Err()
}
func (s *Store) Detail(ctx context.Context, user, id string) (Detail, error) {
result := Detail{Members: make([]Member, 0)}
tx, err := s.db.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly})
if err != nil {
return result, err
}
defer tx.Rollback(ctx)
err = tx.QueryRow(ctx, "SELECT "+groupColumns+" "+groupRows+" AND g.id=$2", user, id).
Scan(&result.ID, &result.Name, &result.State, &result.Role, &result.Version, &result.Pinned, &result.Muted)
if errors.Is(err, pgx.ErrNoRows) {
return result, ErrUnavailable
}
if err != nil {
return result, err
}
if result.State != "active" {
return result, tx.Commit(ctx)
}
rows, err := tx.Query(ctx, `
SELECT m.user_id,u.username,m.state,CASE WHEN m.user_id=g.owner_id THEN 'owner' ELSE m.role END
FROM group_members m JOIN users u ON u.id=m.user_id JOIN chat_groups g ON g.id=m.group_id
WHERE m.group_id=$1 AND (m.state='active' OR $2 IN ('owner','admin'))
ORDER BY u.username
`, id, result.Role)
if err != nil {
return result, err
}
defer rows.Close()
for rows.Next() {
var member Member
if err := rows.Scan(&member.ID, &member.Username, &member.State, &member.Role); err != nil {
return result, err
}
result.Members = append(result.Members, member)
}
if err = rows.Err(); err != nil {
return result, err
}
return result, tx.Commit(ctx)
}
func (s *Store) SetPreferences(ctx context.Context, id, user, device string, pinned, muted *bool) (Preferences, error) {
var result Preferences
tx, err := s.db.Begin(ctx)
if err != nil {
return result, err
}
defer tx.Rollback(ctx)
if _, _, err := lockTransport(ctx, tx, id, user, device); err != nil {
return result, err
}
err = tx.QueryRow(ctx, `
UPDATE group_members SET pinned=COALESCE($3,pinned), muted=COALESCE($4,muted)
WHERE group_id=$1 AND user_id=$2 AND state='active' RETURNING pinned,muted
`, id, user, pinned, muted).Scan(&result.Pinned, &result.Muted)
if err != nil {
return result, err
}
return result, tx.Commit(ctx)
}
func (s *Store) Change(ctx context.Context, user, id string, change Change) ([]string, error) {
tx, err := s.db.Begin(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback(ctx)
// Serialize membership and version changes on the group row.
var owner string
var version int64
err = tx.QueryRow(ctx, "SELECT owner_id,membership_version FROM chat_groups WHERE id=$1 FOR UPDATE", id).Scan(&owner, &version)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrUnavailable
}
if err != nil {
return nil, err
}
var state, role string
err = tx.QueryRow(ctx, "SELECT state,role FROM group_members WHERE group_id=$1 AND user_id=$2", id, user).Scan(&state, &role)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrUnavailable
}
if err != nil {
return nil, err
}
if owner == user {
role = "owner"
}
var users []string
if change.Action == "disband" && role == "owner" {
users, err = groupChangeAudience(ctx, tx, id, owner, "all")
if err != nil {
return nil, err
}
}
activeChanged := false
if state == "invited" {
switch change.Action {
case "accept":
_, err = tx.Exec(ctx, "UPDATE group_members SET state='active',joined_version=$3 WHERE group_id=$1 AND user_id=$2", id, user, version+1)
activeChanged = true
case "decline":
_, err = tx.Exec(ctx, "DELETE FROM group_members WHERE group_id=$1 AND user_id=$2", id, user)
default:
return nil, ErrAction
}
} else {
activeChanged, err = changeActive(ctx, tx, user, id, owner, role, change)
}
if err != nil {
return nil, err
}
if activeChanged {
if _, err = tx.Exec(ctx, "UPDATE chat_groups SET membership_version=membership_version+1 WHERE id=$1", id); err != nil {
return nil, err
}
}
if change.Action != "disband" {
audience := "active"
switch {
case change.Action == "rename":
audience = "all"
case change.Action == "invite", change.Action == "decline", change.Action == "remove" && !activeChanged:
audience = "managers"
}
users, err = groupChangeAudience(ctx, tx, id, owner, audience)
if err != nil {
return nil, err
}
// Removed and invited users need to refresh their own group list as well.
users = append(users, user)
if change.Action == "invite" || change.Action == "remove" {
users = append(users, change.Target)
}
}
return users, tx.Commit(ctx)
}
func groupChangeAudience(ctx context.Context, tx pgx.Tx, group, owner, audience string) ([]string, error) {
rows, err := tx.Query(ctx, `
SELECT user_id::text FROM group_members WHERE group_id=$1 AND (
$3='all' OR (state='active' AND ($3='active' OR user_id=$2 OR role='admin'))
)
`, group, owner, audience)
if err != nil {
return nil, err
}
return pgx.CollectRows(rows, pgx.RowTo[string])
}
func changeActive(ctx context.Context, tx pgx.Tx, user, id, owner, role string, change Change) (bool, error) {
manage := role == "owner" || role == "admin"
switch change.Action {
case "leave":
if role == "owner" {
return false, ErrAction
}
_, err := tx.Exec(ctx, "DELETE FROM group_members WHERE group_id=$1 AND user_id=$2", id, user)
return true, err
case "disband":
if role != "owner" {
return false, ErrAction
}
_, err := tx.Exec(ctx, "DELETE FROM chat_groups WHERE id=$1", id)
return false, err
case "rename":
if !manage {
return false, ErrAction
}
_, err := tx.Exec(ctx, "UPDATE chat_groups SET name=$2 WHERE id=$1", id, change.Name)
return false, err
case "invite":
if !manage || change.Target == user {
return false, ErrAction
}
return false, invite(ctx, tx, user, id, change.Target)
case "transfer":
if role != "owner" || change.Target == owner {
return false, ErrAction
}
tag, err := tx.Exec(ctx, `
UPDATE chat_groups SET owner_id=$2 WHERE id=$1 AND EXISTS (
SELECT 1 FROM group_members WHERE group_id=$1 AND user_id=$2 AND state='active'
)
`, id, change.Target)
if err != nil {
return false, err
}
if tag.RowsAffected() == 0 {
return false, ErrAction
}
_, err = tx.Exec(ctx, "UPDATE group_members SET role='member' WHERE group_id=$1 AND user_id IN ($2,$3)", id, owner, change.Target)
if err != nil {
return false, err
}
_, err = tx.Exec(ctx, "DELETE FROM group_invite_links WHERE group_id=$1", id)
// The new owner establishes a new authenticated MLS session for the same roster.
return true, err
case "remove", "promote", "demote":
if !manage || change.Target == owner || change.Target == user {
return false, ErrAction
}
return changeMember(ctx, tx, id, role, change)
default:
return false, ErrAction
}
}
func invite(ctx context.Context, tx pgx.Tx, user, id, target string) error {
if err := checkMemberLimit(ctx, tx, id); err != nil {
return err
}
tag, err := tx.Exec(ctx, `
INSERT INTO group_members(group_id,user_id,state)
SELECT $1,$3,'invited' FROM contact_relationships
WHERE first_user=LEAST($2::uuid,$3::uuid) AND second_user=GREATEST($2::uuid,$3::uuid)
AND status='accepted'
ON CONFLICT(group_id,user_id) DO NOTHING
`, id, user, target)
if err == nil && tag.RowsAffected() == 0 {
return ErrAction
}
return err
}
func checkMemberLimit(ctx context.Context, tx pgx.Tx, id string) error {
var count int
if err := tx.QueryRow(ctx, "SELECT count(*) FROM group_members WHERE group_id=$1", id).Scan(&count); err != nil {
return err
}
if count >= 32 {
return ErrLimit
}
return nil
}
func changeMember(ctx context.Context, tx pgx.Tx, id, role string, change Change) (bool, error) {
if change.Action == "remove" {
var state string
err := tx.QueryRow(ctx, `
DELETE FROM group_members WHERE group_id=$1 AND user_id=$2 AND ($3='owner' OR role='member')
RETURNING state
`, id, change.Target, role).Scan(&state)
if errors.Is(err, pgx.ErrNoRows) {
return false, ErrAction
}
return state == "active", err
}
if role != "owner" {
return false, ErrAction
}
next := "member"
if change.Action == "promote" {
next = "admin"
}
tag, err := tx.Exec(ctx, "UPDATE group_members SET role=$3 WHERE group_id=$1 AND user_id=$2 AND state='active'", id, change.Target, next)
if err == nil && tag.RowsAffected() == 0 {
return false, ErrAction
}
return false, err
}