Files
mtusi2026lab2-implementation/internal/repository/postgres/store.go
T

238 lines
6.3 KiB
Go

package postgres
import (
"context"
"errors"
"fmt"
"time"
"uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"messenger/internal/domain"
)
const (
maxConns = 10
connectTimeout = 3 * time.Second
statementTimeout = "5000"
)
type Store struct {
pool *pgxpool.Pool
}
func NewPool(ctx context.Context, databaseURL string) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(databaseURL)
if err != nil {
return nil, err
}
cfg.MaxConns = maxConns
cfg.ConnConfig.ConnectTimeout = connectTimeout
cfg.ConnConfig.RuntimeParams["statement_timeout"] = statementTimeout
return pgxpool.NewWithConfig(ctx, cfg)
}
func New(pool *pgxpool.Pool) *Store {
return &Store{pool: pool}
}
func (s *Store) Ping(ctx context.Context) error {
return dbErr(s.pool.Ping(ctx))
}
func (s *Store) CreateUser(ctx context.Context, u domain.User, passwordHash string) error {
_, err := s.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)
return dbErr(err)
}
func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (domain.User, error) {
var u domain.User
err := s.pool.QueryRow(ctx,
`SELECT id, username, display_name, created_at FROM users WHERE id = $1`, id,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
return u, dbErr(err)
}
func (s *Store) GetUserByUsername(ctx context.Context, username string) (domain.User, string, error) {
var u domain.User
var hash string
err := s.pool.QueryRow(ctx,
`SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1`, username,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
return u, hash, dbErr(err)
}
func (s *Store) CreateChat(ctx context.Context, c domain.Chat) error {
tx, err := s.pool.Begin(ctx)
if err != nil {
return dbErr(err)
}
defer tx.Rollback(ctx)
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 dbErr(err)
}
for i, userID := range c.MemberIDs {
if _, err := tx.Exec(ctx, `INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)`,
c.ID, userID, i); err != nil {
return dbErr(err)
}
}
return dbErr(tx.Commit(ctx))
}
func (s *Store) GetChat(ctx context.Context, id uuid.UUID) (domain.Chat, error) {
var c domain.Chat
err := s.pool.QueryRow(ctx, `SELECT id, title, created_at FROM chats WHERE id = $1`, id).
Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return domain.Chat{}, dbErr(err)
}
chats := []domain.Chat{c}
if err := s.loadMembers(ctx, chats); err != nil {
return domain.Chat{}, err
}
return chats[0], nil
}
func (s *Store) ListUserChats(ctx context.Context, userID uuid.UUID, after *domain.Cursor, limit int) ([]domain.Chat, bool, error) {
var rows pgx.Rows
var err error
if after == nil {
rows, err = s.pool.Query(ctx, `
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1
ORDER BY c.created_at, c.id
LIMIT $2`, userID, limit+1)
} else {
rows, err = s.pool.Query(ctx, `
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1 AND (c.created_at, c.id) > ($2, $3)
ORDER BY c.created_at, c.id
LIMIT $4`, userID, after.CreatedAt, after.ID, limit+1)
}
if err != nil {
return nil, false, dbErr(err)
}
chats, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (domain.Chat, error) {
var c domain.Chat
err := row.Scan(&c.ID, &c.Title, &c.CreatedAt)
return c, err
})
if err != nil {
return nil, false, dbErr(err)
}
more := len(chats) > limit
if more {
chats = chats[:limit]
}
if err := s.loadMembers(ctx, chats); err != nil {
return nil, false, err
}
return chats, more, nil
}
func (s *Store) loadMembers(ctx context.Context, chats []domain.Chat) error {
if len(chats) == 0 {
return nil
}
ids := make([]uuid.UUID, len(chats))
index := make(map[uuid.UUID]int, len(chats))
for i, c := range chats {
ids[i] = c.ID
index[c.ID] = i
}
rows, err := s.pool.Query(ctx,
`SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1) ORDER BY chat_id, position`, ids)
if err != nil {
return dbErr(err)
}
defer rows.Close()
for rows.Next() {
var chatID, userID uuid.UUID
if err := rows.Scan(&chatID, &userID); err != nil {
return dbErr(err)
}
i := index[chatID]
chats[i].MemberIDs = append(chats[i].MemberIDs, userID)
}
return dbErr(rows.Err())
}
func (s *Store) CreateMessage(ctx context.Context, m domain.Message) error {
_, err := s.pool.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)
return dbErr(err)
}
func (s *Store) ListMessages(ctx context.Context, chatID uuid.UUID, after *domain.Cursor, limit int) ([]domain.Message, bool, error) {
var rows pgx.Rows
var err error
if after == nil {
rows, err = s.pool.Query(ctx, `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2`, chatID, limit+1)
} else {
rows, err = s.pool.Query(ctx, `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4`, chatID, after.CreatedAt, after.ID, limit+1)
}
if err != nil {
return nil, false, dbErr(err)
}
msgs, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (domain.Message, error) {
var m domain.Message
err := row.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt)
return m, err
})
if err != nil {
return nil, false, dbErr(err)
}
more := len(msgs) > limit
if more {
msgs = msgs[:limit]
}
return msgs, more, nil
}
func dbErr(err error) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return domain.ErrNotFound
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case "23505":
return domain.ErrConflict
case "23503":
return domain.ErrNotFound
}
switch pgErr.Code[:2] {
case "08", "53", "57":
return fmt.Errorf("%w: %v", domain.ErrUnavailable, err)
}
return err
}
return fmt.Errorf("%w: %v", domain.ErrUnavailable, err)
}