Files
mtusi2026lab3/internal/storage/message_postgres.go

188 lines
5.1 KiB
Go

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
}