forked from mtusi2026/mtusi2026lab4
243 lines
6.8 KiB
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)
|
|
}
|