Files
mtusi2026lab2/internal/store/postgres.go
T

391 lines
11 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package store
import (
"context"
"errors"
"net"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
// PG — источник истины для пользователей, чатов и сообщений.
// Запросы только с параметрами. Пул ограничен, у сессии соединения есть statement_timeout.
type PG struct {
pool *pgxpool.Pool
}
func Open(ctx context.Context, databaseURL string, maxConns int32) (*PG, error) {
cfg, err := pgxpool.ParseConfig(databaseURL)
if err != nil {
return nil, err
}
if maxConns < 1 {
maxConns = 10
}
cfg.MaxConns = maxConns
cfg.MinConns = 1
cfg.MaxConnLifetime = 30 * time.Minute
cfg.MaxConnIdleTime = 5 * time.Minute
cfg.HealthCheckPeriod = 30 * time.Second
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
cfg.ConnConfig.RuntimeParams["application_name"] = "messenger"
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
cfg.ConnConfig.RuntimeParams["lock_timeout"] = "3000"
cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000"
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, err
}
pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, err
}
return &PG{pool: pool}, nil
}
func (p *PG) Close() { p.pool.Close() }
func (p *PG) Pool() *pgxpool.Pool { return p.pool }
func (p *PG) Ping(ctx context.Context) error {
return mapDB(p.pool.Ping(ctx))
}
func (p *PG) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
u := User{
ID: newID(),
Username: username,
DisplayName: displayName,
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
}
_, err := p.pool.Exec(ctx, `
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)`,
u.ID, u.Username, u.DisplayName, passwordHash, u.CreatedAt)
if err != nil {
return User{}, mapDB(err)
}
return u, nil
}
func (p *PG) User(ctx context.Context, id string) (User, error) {
row := p.pool.QueryRow(ctx, `
SELECT id::text, username, display_name, created_at
FROM users WHERE id = $1`, id)
return scanUser(row)
}
func (p *PG) UserByUsername(ctx context.Context, username string) (User, string, error) {
var u User
var hash string
err := p.pool.QueryRow(ctx, `
SELECT id::text, username, display_name, created_at, password_hash
FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
if err != nil {
return User{}, "", mapDB(err)
}
u.CreatedAt = u.CreatedAt.UTC()
return u, hash, nil
}
// CreateChat пишет чат и всех участников в одной транзакции.
// Если кого-то из списка нет, COMMIT не случается и строка чата не остаётся.
func (p *PG) CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) {
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return Chat{}, ErrInvalid
}
seen[id] = struct{}{}
}
if _, ok := seen[caller]; !ok {
return Chat{}, ErrInvalid
}
tx, err := p.pool.Begin(ctx)
if err != nil {
return Chat{}, mapDB(err)
}
defer func() { _ = tx.Rollback(ctx) }()
c := Chat{
ID: newID(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...),
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
}
if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, c.ID, c.Title, c.CreatedAt); err != nil {
return Chat{}, mapDB(err)
}
var n int
if err := tx.QueryRow(ctx, `SELECT count(*) FROM users WHERE id::text = ANY($1::text[])`, memberIDs).Scan(&n); err != nil {
return Chat{}, mapDB(err)
}
if n != len(memberIDs) {
return Chat{}, ErrInvalid
}
for i, id := range memberIDs {
if _, err := tx.Exec(ctx, `
INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)`,
c.ID, id, i); err != nil {
return Chat{}, mapDB(err)
}
}
if err := tx.Commit(ctx); err != nil {
return Chat{}, mapDB(err)
}
return c, nil
}
func (p *PG) ChatFor(ctx context.Context, chatID, userID string) (Chat, error) {
var c Chat
err := p.pool.QueryRow(ctx, `
SELECT c.id::text, c.title, c.created_at
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $2
WHERE c.id = $1`, chatID, userID).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return Chat{}, mapDB(err)
}
c.CreatedAt = c.CreatedAt.UTC()
ids, err := p.memberIDs(ctx, p.pool, []string{c.ID})
if err != nil {
return Chat{}, err
}
c.MemberIDs = ids[c.ID]
if c.MemberIDs == nil {
c.MemberIDs = []string{}
}
return c, nil
}
func (p *PG) ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) {
hasCursor := cur != nil
at := time.Time{}
var id any
if hasCursor {
at = cur.At
id = cur.ID
}
rows, err := p.pool.Query(ctx, `
SELECT c.id::text, c.title, c.created_at
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $1
WHERE NOT $2::bool OR (c.created_at, c.id) > ($3::timestamptz, $4::uuid)
ORDER BY c.created_at, c.id
LIMIT $5`, userID, hasCursor, at, id, limit+1)
if err != nil {
return nil, false, mapDB(err)
}
defer rows.Close()
items := make([]Chat, 0)
ids := make([]string, 0)
for rows.Next() {
var c Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, false, mapDB(err)
}
c.CreatedAt = c.CreatedAt.UTC()
items = append(items, c)
ids = append(ids, c.ID)
}
if err := rows.Err(); err != nil {
return nil, false, mapDB(err)
}
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
ids = ids[:limit]
}
members, err := p.memberIDs(ctx, p.pool, ids)
if err != nil {
return nil, false, err
}
for i := range items {
items[i].MemberIDs = members[items[i].ID]
if items[i].MemberIDs == nil {
items[i].MemberIDs = []string{}
}
}
return items, hasMore, nil
}
func (p *PG) AddMessage(ctx context.Context, chatID, senderID, text string) (Message, error) {
tx, err := p.pool.Begin(ctx)
if err != nil {
return Message{}, mapDB(err)
}
defer func() { _ = tx.Rollback(ctx) }()
// Блокировка строки чата сериализует writers одного чата.
// Иначе два COMMIT с одним created_at упорядочились бы случайным UUID, а не фактом записи.
var exists string
err = tx.QueryRow(ctx, `SELECT id::text FROM chats WHERE id = $1 FOR UPDATE`, chatID).Scan(&exists)
if err != nil {
return Message{}, mapDB(err)
}
var member int
if err := tx.QueryRow(ctx, `
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&member); err != nil {
return Message{}, mapDB(err)
}
var last time.Time
err = tx.QueryRow(ctx, `
SELECT created_at FROM messages WHERE chat_id = $1
ORDER BY created_at DESC LIMIT 1`, chatID).Scan(&last)
if errors.Is(err, pgx.ErrNoRows) {
last = time.Time{}
} else if err != nil {
return Message{}, mapDB(err)
}
now := time.Now().UTC().Truncate(time.Microsecond)
if !last.IsZero() && !now.After(last.UTC()) {
now = last.UTC().Add(time.Microsecond)
}
m := Message{
ID: newID(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: now,
}
if _, err := tx.Exec(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)`, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt); err != nil {
return Message{}, mapDB(err)
}
if err := tx.Commit(ctx); err != nil {
return Message{}, mapDB(err)
}
return m, nil
}
func (p *PG) ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) {
var member int
err := p.pool.QueryRow(ctx, `
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&member)
if err != nil {
return nil, false, mapDB(err)
}
if cur != nil {
var one int
err := p.pool.QueryRow(ctx, `
SELECT 1 FROM messages
WHERE chat_id = $1 AND id = $2 AND created_at = $3`, chatID, cur.ID, cur.At).Scan(&one)
if errors.Is(err, pgx.ErrNoRows) {
return nil, false, ErrBadCursor
}
if err != nil {
return nil, false, mapDB(err)
}
}
hasCursor := cur != nil
at := time.Time{}
var id any
if hasCursor {
at = cur.At
id = cur.ID
}
rows, err := p.pool.Query(ctx, `
SELECT id::text, chat_id::text, sender_id::text, text, created_at
FROM messages
WHERE chat_id = $1
AND (NOT $2::bool OR (created_at, id) > ($3::timestamptz, $4::uuid))
ORDER BY created_at, id
LIMIT $5`, chatID, hasCursor, at, id, limit+1)
if err != nil {
return nil, false, mapDB(err)
}
defer rows.Close()
items := make([]Message, 0)
for rows.Next() {
var m Message
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
return nil, false, mapDB(err)
}
m.CreatedAt = m.CreatedAt.UTC()
items = append(items, m)
}
if err := rows.Err(); err != nil {
return nil, false, mapDB(err)
}
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
}
return items, hasMore, nil
}
type queryer interface {
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
}
func (p *PG) memberIDs(ctx context.Context, q queryer, chatIDs []string) (map[string][]string, error) {
out := make(map[string][]string, len(chatIDs))
if len(chatIDs) == 0 {
return out, nil
}
rows, err := q.Query(ctx, `
SELECT chat_id::text, user_id::text
FROM chat_members
WHERE chat_id::text = ANY($1::text[])
ORDER BY chat_id, position`, chatIDs)
if err != nil {
return nil, mapDB(err)
}
defer rows.Close()
for rows.Next() {
var chatID, userID string
if err := rows.Scan(&chatID, &userID); err != nil {
return nil, mapDB(err)
}
out[chatID] = append(out[chatID], userID)
}
if err := rows.Err(); err != nil {
return nil, mapDB(err)
}
return out, nil
}
func scanUser(row pgx.Row) (User, error) {
var u User
err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if err != nil {
return User{}, mapDB(err)
}
u.CreatedAt = u.CreatedAt.UTC()
return u, nil
}
func mapDB(err error) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return ErrNotFound
}
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
return ErrUnavailable
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case "23505":
return ErrConflict
case "23503", "23514", "22P02":
return ErrInvalid
case "57014", "55P03":
return ErrUnavailable
}
}
var netErr net.Error
if errors.As(err, &netErr) {
return ErrUnavailable
}
return err
}