Files
mtusi2026lab3/internal/postgres/store.go
T

654 lines
16 KiB
Go

package postgres
import (
"bytes"
"context"
"crypto/sha256"
"errors"
"fmt"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model"
)
type Store struct {
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *Store {
return &Store{pool: pool}
}
func (s *Store) Ping(ctx context.Context) error {
return s.pool.Ping(ctx)
}
func (s *Store) CreateUser(
ctx context.Context,
username string,
displayName string,
passwordHash string,
) (model.User, error) {
const query = `
INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1, $2, $3, $4)
RETURNING id, username, display_name, created_at`
var user model.User
err := s.pool.QueryRow(ctx, query, uuid.NewString(), username, displayName, passwordHash).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
)
if isUniqueViolation(err) {
return model.User{}, ErrConflict
}
if err != nil {
return model.User{}, fmt.Errorf("create user: %w", err)
}
return user, nil
}
func (s *Store) UserByID(ctx context.Context, id string) (model.User, error) {
const query = `
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1`
var user model.User
err := s.pool.QueryRow(ctx, query, id).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.User{}, ErrNotFound
}
if err != nil {
return model.User{}, fmt.Errorf("get user by id: %w", err)
}
return user, nil
}
func (s *Store) UserByUsername(ctx context.Context, username string) (model.UserCredentials, error) {
const query = `
SELECT id, username, display_name, created_at, password_hash
FROM users
WHERE username = $1`
var credentials model.UserCredentials
err := s.pool.QueryRow(ctx, query, username).Scan(
&credentials.ID,
&credentials.Username,
&credentials.DisplayName,
&credentials.CreatedAt,
&credentials.PasswordHash,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.UserCredentials{}, ErrNotFound
}
if err != nil {
return model.UserCredentials{}, fmt.Errorf("get user by username: %w", err)
}
return credentials, nil
}
func (s *Store) CreateChat(
ctx context.Context,
title string,
memberIDs []string,
callerID string,
) (model.Chat, error) {
if !validMembers(memberIDs, callerID) {
return model.Chat{}, ErrInvalidMembers
}
tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return model.Chat{}, fmt.Errorf("begin create chat transaction: %w", err)
}
defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }()
valid, err := allUsersExist(ctx, tx, memberIDs)
if err != nil {
return model.Chat{}, err
}
if !valid {
return model.Chat{}, ErrInvalidMembers
}
chat, err := insertChat(ctx, tx, title)
if err != nil {
return model.Chat{}, err
}
if err := insertMembers(ctx, tx, chat.ID, memberIDs); err != nil {
return model.Chat{}, err
}
if err := tx.Commit(ctx); err != nil {
return model.Chat{}, fmt.Errorf("commit create chat transaction: %w", err)
}
chat.MemberIDs = append([]string(nil), memberIDs...)
return chat, nil
}
func validMembers(memberIDs []string, callerID string) bool {
callerUUID, err := uuid.Parse(callerID)
if err != nil {
return false
}
seen := make(map[uuid.UUID]struct{}, len(memberIDs))
callerIncluded := false
for _, memberID := range memberIDs {
memberUUID, err := uuid.Parse(memberID)
if err != nil {
return false
}
if _, exists := seen[memberUUID]; exists {
return false
}
seen[memberUUID] = struct{}{}
callerIncluded = callerIncluded || memberUUID == callerUUID
}
return callerIncluded
}
func allUsersExist(ctx context.Context, tx pgx.Tx, memberIDs []string) (bool, error) {
const query = `
SELECT count(*)
FROM users
WHERE id::text = ANY($1)`
var count int
if err := tx.QueryRow(ctx, query, memberIDs).Scan(&count); err != nil {
return false, fmt.Errorf("check chat members: %w", err)
}
return count == len(memberIDs), nil
}
func insertChat(ctx context.Context, tx pgx.Tx, title string) (model.Chat, error) {
const query = `
INSERT INTO chats (id, title)
VALUES ($1, $2)
RETURNING id, title, created_at`
var chat model.Chat
if err := tx.QueryRow(ctx, query, uuid.NewString(), title).Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil {
return model.Chat{}, fmt.Errorf("insert chat: %w", err)
}
return chat, nil
}
func insertMembers(ctx context.Context, tx pgx.Tx, chatID string, memberIDs []string) error {
const query = `
INSERT INTO chat_members (chat_id, user_id, position)
VALUES ($1, $2, $3)`
batch := &pgx.Batch{}
for position, memberID := range memberIDs {
batch.Queue(query, chatID, memberID, position)
}
results := tx.SendBatch(ctx, batch)
defer func() { _ = results.Close() }()
for range memberIDs {
if _, err := results.Exec(); err != nil {
return fmt.Errorf("insert chat member: %w", err)
}
}
if err := results.Close(); err != nil {
return fmt.Errorf("close chat members batch: %w", err)
}
return nil
}
func (s *Store) ChatForUser(ctx context.Context, chatID, userID string) (model.Chat, error) {
const query = `
SELECT c.id, c.title, c.created_at,
array_agg(cm.user_id::text ORDER BY cm.position)
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE c.id = $1
AND EXISTS (
SELECT 1
FROM chat_members visible
WHERE visible.chat_id = c.id AND visible.user_id = $2
)
GROUP BY c.id, c.title, c.created_at`
var chat model.Chat
err := s.pool.QueryRow(ctx, query, chatID, userID).Scan(
&chat.ID,
&chat.Title,
&chat.CreatedAt,
&chat.MemberIDs,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.Chat{}, ErrNotFound
}
if err != nil {
return model.Chat{}, fmt.Errorf("get chat for user: %w", err)
}
return chat, nil
}
func (s *Store) ListChats(
ctx context.Context,
userID string,
after *model.Position,
limit int,
) ([]model.Chat, bool, error) {
if after != nil {
valid, err := s.visibleChatPositionExists(ctx, userID, *after)
if err != nil {
return nil, false, err
}
if !valid {
return nil, false, ErrInvalidCursor
}
}
const query = `
SELECT c.id, c.title, c.created_at,
array_agg(all_members.user_id::text ORDER BY all_members.position)
FROM chats c
JOIN chat_members visible ON visible.chat_id = c.id AND visible.user_id = $1
JOIN chat_members all_members ON all_members.chat_id = c.id
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3::uuid))
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at, c.id
LIMIT $4`
var afterTime any
var afterID any
if after != nil {
afterTime = after.CreatedAt
afterID = after.ID
}
rows, err := s.pool.Query(ctx, query, userID, afterTime, afterID, limit+1)
if err != nil {
return nil, false, fmt.Errorf("list chats: %w", err)
}
defer rows.Close()
chats, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Chat](func(row pgx.CollectableRow) (model.Chat, error) {
var chat model.Chat
err := row.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs)
return chat, err
}))
if err != nil {
return nil, false, fmt.Errorf("scan chats: %w", err)
}
return page(chats, limit)
}
func (s *Store) visibleChatPositionExists(
ctx context.Context,
userID string,
position model.Position,
) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1 AND c.created_at = $2 AND c.id = $3
)`
var exists bool
if err := s.pool.QueryRow(ctx, query, userID, position.CreatedAt, position.ID).Scan(&exists); err != nil {
return false, fmt.Errorf("validate chat cursor: %w", err)
}
return exists, nil
}
func (s *Store) CreateMessage(
ctx context.Context,
chatID string,
senderID string,
text string,
idempotencyKey string,
idempotencyTTL time.Duration,
) (model.Message, bool, error) {
tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return model.Message{}, false, fmt.Errorf("begin create message transaction: %w", err)
}
defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }()
visible, err := chatVisibleInTransaction(ctx, tx, chatID, senderID)
if err != nil {
return model.Message{}, false, err
}
if !visible {
return model.Message{}, false, ErrNotFound
}
requestHash := sha256.Sum256([]byte(text))
message, replay, err := createIdempotentMessage(
ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL,
)
if err != nil {
return model.Message{}, false, err
}
if err := tx.Commit(ctx); err != nil {
return model.Message{}, false, fmt.Errorf("commit create message transaction: %w", err)
}
return message, replay, nil
}
func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM chat_members
WHERE chat_id = $1 AND user_id = $2
)`
var visible bool
if err := tx.QueryRow(ctx, query, chatID, userID).Scan(&visible); err != nil {
return false, fmt.Errorf("check chat visibility: %w", err)
}
return visible, nil
}
func createIdempotentMessage(
ctx context.Context,
tx pgx.Tx,
chatID string,
senderID string,
text string,
idempotencyKey string,
requestHash []byte,
idempotencyTTL time.Duration,
) (model.Message, bool, error) {
for {
record, found, err := lockIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey)
if err != nil {
return model.Message{}, false, err
}
if found && record.active {
if !bytes.Equal(record.requestHash, requestHash) {
return model.Message{}, false, ErrIdempotencyConflict
}
message, err := messageByID(ctx, tx, record.messageID)
return message, true, err
}
if found {
if err := deleteIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey); err != nil {
return model.Message{}, false, err
}
}
messageID := uuid.NewString()
reserved, err := reserveIdempotencyKey(
ctx, tx, senderID, chatID, idempotencyKey, requestHash, messageID, idempotencyTTL,
)
if err != nil {
return model.Message{}, false, err
}
if !reserved {
continue
}
message, err := insertMessage(ctx, tx, messageID, chatID, senderID, text)
return message, false, err
}
}
type idempotencyRecord struct {
requestHash []byte
messageID string
active bool
}
func lockIdempotencyRecord(
ctx context.Context,
tx pgx.Tx,
userID string,
chatID string,
key string,
) (idempotencyRecord, bool, error) {
const query = `
SELECT request_hash, message_id, expires_at > statement_timestamp()
FROM message_idempotency
WHERE user_id = $1 AND chat_id = $2 AND key = $3
FOR UPDATE`
var record idempotencyRecord
err := tx.QueryRow(ctx, query, userID, chatID, key).Scan(
&record.requestHash,
&record.messageID,
&record.active,
)
if errors.Is(err, pgx.ErrNoRows) {
return idempotencyRecord{}, false, nil
}
if err != nil {
return idempotencyRecord{}, false, fmt.Errorf("lock idempotency key: %w", err)
}
return record, true, nil
}
func deleteIdempotencyRecord(ctx context.Context, tx pgx.Tx, userID, chatID, key string) error {
const query = `
DELETE FROM message_idempotency
WHERE user_id = $1 AND chat_id = $2 AND key = $3`
if _, err := tx.Exec(ctx, query, userID, chatID, key); err != nil {
return fmt.Errorf("delete expired idempotency key: %w", err)
}
return nil
}
func reserveIdempotencyKey(
ctx context.Context,
tx pgx.Tx,
userID string,
chatID string,
key string,
requestHash []byte,
messageID string,
ttl time.Duration,
) (bool, error) {
const query = `
INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, expires_at)
VALUES ($1, $2, $3, $4, $5, statement_timestamp() + $6 * INTERVAL '1 second')
ON CONFLICT (user_id, chat_id, key) DO NOTHING
RETURNING true`
var inserted bool
err := tx.QueryRow(ctx, query, userID, chatID, key, requestHash, messageID, int64(ttl/time.Second)).Scan(&inserted)
if errors.Is(err, pgx.ErrNoRows) {
return false, nil
}
if err != nil {
return false, fmt.Errorf("reserve idempotency key: %w", err)
}
return inserted, nil
}
func insertMessage(
ctx context.Context,
tx pgx.Tx,
messageID string,
chatID string,
senderID string,
text string,
) (model.Message, error) {
const query = `
INSERT INTO messages (id, chat_id, sender_id, text)
VALUES ($1, $2, $3, $4)
RETURNING id, chat_id, sender_id, text, created_at`
var message model.Message
err := tx.QueryRow(ctx, query, messageID, chatID, senderID, text).Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
)
if err != nil {
return model.Message{}, fmt.Errorf("insert message: %w", err)
}
return message, nil
}
func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) {
const query = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE id = $1`
var message model.Message
err := tx.QueryRow(ctx, query, messageID).Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.Message{}, fmt.Errorf("idempotency result message not found")
}
if err != nil {
return model.Message{}, fmt.Errorf("get idempotency result message: %w", err)
}
return message, nil
}
func (s *Store) ListMessages(
ctx context.Context,
chatID string,
userID string,
after *model.Position,
limit int,
) ([]model.Message, bool, error) {
visible, err := s.chatVisible(ctx, chatID, userID)
if err != nil {
return nil, false, err
}
if !visible {
return nil, false, ErrNotFound
}
if after != nil {
valid, err := s.messagePositionExists(ctx, chatID, *after)
if err != nil {
return nil, false, err
}
if !valid {
return nil, false, ErrInvalidCursor
}
}
const query = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3::uuid))
ORDER BY created_at, id
LIMIT $4`
var afterTime any
var afterID any
if after != nil {
afterTime = after.CreatedAt
afterID = after.ID
}
rows, err := s.pool.Query(ctx, query, chatID, afterTime, afterID, limit+1)
if err != nil {
return nil, false, fmt.Errorf("list messages: %w", err)
}
defer rows.Close()
messages, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Message](func(row pgx.CollectableRow) (model.Message, error) {
var message model.Message
err := row.Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
)
return message, err
}))
if err != nil {
return nil, false, fmt.Errorf("scan messages: %w", err)
}
return page(messages, limit)
}
func (s *Store) chatVisible(ctx context.Context, chatID, userID string) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM chat_members
WHERE chat_id = $1 AND user_id = $2
)`
var exists bool
if err := s.pool.QueryRow(ctx, query, chatID, userID).Scan(&exists); err != nil {
return false, fmt.Errorf("check chat visibility: %w", err)
}
return exists, nil
}
func (s *Store) messagePositionExists(
ctx context.Context,
chatID string,
position model.Position,
) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM messages
WHERE chat_id = $1 AND created_at = $2 AND id = $3
)`
var exists bool
if err := s.pool.QueryRow(ctx, query, chatID, position.CreatedAt, position.ID).Scan(&exists); err != nil {
return false, fmt.Errorf("validate message cursor: %w", err)
}
return exists, nil
}
func page[T any](items []T, limit int) ([]T, bool, error) {
if limit < 1 {
return nil, false, fmt.Errorf("limit must be positive")
}
if len(items) <= limit {
return items, false, nil
}
return items[:limit], true, nil
}
func isUniqueViolation(err error) bool {
var postgresError *pgconn.PgError
return errors.As(err, &postgresError) && postgresError.Code == "23505"
}