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"` } 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 groupRows = ` SELECT g.id,g.name,m.state,CASE WHEN g.owner_id=m.user_id THEN 'owner' ELSE m.role END,g.membership_version::text 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 string) ([]Group, error) { rows, err := s.db.Query(ctx, groupRows+" ORDER BY g.created_at DESC, g.id LIMIT 200", user) if err != nil { return nil, err } defer rows.Close() result := make([]Group, 0) for rows.Next() { var g Group if err := rows.Scan(&g.ID, &g.Name, &g.State, &g.Role, &g.Version); 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, groupRows+" AND g.id=$2", user, id). Scan(&result.ID, &result.Name, &result.State, &result.Role, &result.Version) 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) Change(ctx context.Context, user, id string, change Change) error { tx, err := s.db.Begin(ctx) if err != nil { return 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 ErrUnavailable } if err != nil { return 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 ErrUnavailable } if err != nil { return err } if owner == user { role = "owner" } 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 ErrAction } } else { activeChanged, err = changeActive(ctx, tx, user, id, owner, role, change) } if err != nil { return err } if activeChanged { if _, err = tx.Exec(ctx, "UPDATE chat_groups SET membership_version=membership_version+1 WHERE id=$1", id); err != nil { return err } } return tx.Commit(ctx) } 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 "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 { 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 } 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 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 }