package storage import ( "context" "errors" "fmt" "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) } 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, message.Text, 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 != message.Text { 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 } 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 := tx.Commit(ctx); err != nil { return model.Message{}, fmt.Errorf("commit idempotent message: %w", err) } return message, nil }