Files
mtusi2026lab4/internal/storage/message_postgres.go

243 lines
6.8 KiB
Go

package storage
import (
"context"
"encoding/json"
"errors"
"fmt"
"sort"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"mtusi2026lab2/internal/model"
)
var ErrMessageMemberNotFound = errors.New("sender is not a chat member")
type MessageStore struct {
pool *pgxpool.Pool
}
func NewMessageStore(pool *pgxpool.Pool) *MessageStore {
return &MessageStore{pool: pool}
}
func (s *MessageStore) CreateMessage(
ctx context.Context,
message model.Message,
) error {
const query = `
INSERT INTO messages (
id, chat_id, sender_id, text, created_at
)
VALUES ($1, $2, $3, $4, $5)
`
_, err := s.pool.Exec(ctx, query,
message.ID,
message.ChatID,
message.SenderID,
message.Text,
message.CreatedAt,
)
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "23503" {
return ErrMessageMemberNotFound
}
return fmt.Errorf("create message: %w", err)
}
return nil
}
// ListMessages implements keyset pagination.
// Cursor is the created_at + id of the previous page's last item.
func (s *MessageStore) ListMessages(
ctx context.Context,
chatID uuid.UUID,
limit int,
cursorTime *time.Time,
cursorID *uuid.UUID,
) ([]model.Message, bool, error) {
var rows pgx.Rows
var err error
if cursorTime == nil || cursorID == 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, *cursorTime, *cursorID, limit+1)
}
if err != nil {
return nil, false, fmt.Errorf("list messages: %w", err)
}
defer rows.Close()
messages := make([]model.Message, 0, limit+1)
for rows.Next() {
var message model.Message
if err := rows.Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
); err != nil {
return nil, false, fmt.Errorf("scan message: %w", err)
}
message.AttachmentIDs, err = s.attachmentIDs(ctx, message.ID)
if err != nil {
return nil, false, err
}
messages = append(messages, message)
}
if err := rows.Err(); err != nil {
return nil, false, fmt.Errorf("iterate messages: %w", err)
}
hasMore := len(messages) > limit
if hasMore {
messages = messages[:limit]
}
return messages, hasMore, nil
}
var ErrIdempotencyConflict = errors.New("idempotency key reused with different message")
// CreateMessageIdempotent stores both the message and its deduplication record
// in one PostgreSQL transaction. The unique constraint serializes concurrent
// attempts across independent API processes. A rollback records neither.
func (s *MessageStore) CreateMessageIdempotent(ctx context.Context, message model.Message, key string) (model.Message, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Message{}, fmt.Errorf("begin idempotent message: %w", err)
}
defer tx.Rollback(ctx)
// Expired keys may be reused; only the exact scope is pruned here.
_, err = tx.Exec(ctx, `DELETE FROM message_idempotency
WHERE sender_id=$1 AND chat_id=$2 AND idem_key=$3 AND created_at < NOW() - INTERVAL '24 hours'`,
message.SenderID, message.ChatID, key)
if err != nil {
return model.Message{}, fmt.Errorf("expire idempotency: %w", err)
}
tag, err := tx.Exec(ctx, `INSERT INTO message_idempotency
(sender_id, chat_id, idem_key, text, message_id)
VALUES ($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING`,
message.SenderID, message.ChatID, key, messageFingerprint(message), message.ID)
if err != nil {
return model.Message{}, fmt.Errorf("reserve idempotency: %w", err)
}
if tag.RowsAffected() == 0 {
var existingText string
var existingID uuid.UUID
err = tx.QueryRow(ctx, `SELECT text, message_id FROM message_idempotency
WHERE sender_id=$1 AND chat_id=$2 AND idem_key=$3`,
message.SenderID, message.ChatID, key).Scan(&existingText, &existingID)
if err != nil {
return model.Message{}, fmt.Errorf("lookup idempotency: %w", err)
}
if existingText != messageFingerprint(message) {
return model.Message{}, ErrIdempotencyConflict
}
var original model.Message
err = tx.QueryRow(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE id=$1`, existingID).
Scan(&original.ID, &original.ChatID, &original.SenderID, &original.Text, &original.CreatedAt)
if err != nil {
return model.Message{}, fmt.Errorf("read idempotent message: %w", err)
}
if err := tx.Commit(ctx); err != nil {
return model.Message{}, err
}
original.AttachmentIDs, err = s.attachmentIDs(ctx, original.ID)
if err != nil {
return model.Message{}, err
}
return original, nil
}
_, err = tx.Exec(ctx, `INSERT INTO messages (id,chat_id,sender_id,text,created_at)
VALUES ($1,$2,$3,$4,$5)`, message.ID, message.ChatID, message.SenderID, message.Text, message.CreatedAt)
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "23503" {
return model.Message{}, ErrMessageMemberNotFound
}
return model.Message{}, fmt.Errorf("insert idempotent message: %w", err)
}
if err := s.linkAttachments(ctx, tx, message); err != nil {
return model.Message{}, err
}
if err := tx.Commit(ctx); err != nil {
return model.Message{}, fmt.Errorf("commit idempotent message: %w", err)
}
return message, nil
}
func (s *MessageStore) attachmentIDs(ctx context.Context, messageID uuid.UUID) ([]uuid.UUID, error) {
rows, err := s.pool.Query(ctx, `SELECT attachment_id FROM message_attachments WHERE message_id=$1 ORDER BY attachment_id`, messageID)
if err != nil {
return nil, err
}
defer rows.Close()
ids := make([]uuid.UUID, 0)
for rows.Next() {
var id uuid.UUID
if err = rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}
func (s *MessageStore) linkAttachments(ctx context.Context, tx pgx.Tx, m model.Message) error {
for _, id := range m.AttachmentIDs {
tag, err := tx.Exec(ctx, `INSERT INTO message_attachments(message_id,attachment_id)
SELECT $1,a.id FROM attachments a WHERE a.id=$2 AND a.chat_id=$3`, m.ID, id, m.ChatID)
if err != nil {
return err
}
if tag.RowsAffected() != 1 {
return ErrAttachmentNotFound
}
}
return nil
}
var ErrAttachmentNotFound = errors.New("attachment not found in chat")
func messageFingerprint(m model.Message) string {
ids := append([]uuid.UUID(nil), m.AttachmentIDs...)
sort.Slice(ids, func(i, j int) bool { return ids[i].String() < ids[j].String() })
b, _ := json.Marshal(struct {
Text string `json:"text"`
IDs []uuid.UUID `json:"attachment_ids"`
}{m.Text, ids})
return string(b)
}