forked from mtusi2026/mtusi2026lab3
181 lines
5.3 KiB
Go
181 lines
5.3 KiB
Go
package store
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"time"
|
|
|
|
"gitflic.ru/project/bulla-max/mtusi2026lab/internal/common"
|
|
"gitflic.ru/project/bulla-max/mtusi2026lab/internal/model"
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
func (s *Store) CreateMessage(ctx context.Context, chatID, senderID uuid.UUID, text, idempotencyKey string) (model.Message, error) {
|
|
ctx, cancel := s.withTimeout(ctx)
|
|
defer cancel()
|
|
|
|
fingerprint := sha256.Sum256([]byte(text))
|
|
|
|
if message, found, err := s.findIdempotentMessage(ctx, senderID, chatID, idempotencyKey, fingerprint[:]); err != nil {
|
|
return model.Message{}, err
|
|
} else if found {
|
|
return message, nil
|
|
}
|
|
|
|
message := model.Message{
|
|
ID: uuid.New(),
|
|
ChatID: chatID,
|
|
SenderID: senderID,
|
|
Text: text,
|
|
CreatedAt: common.NowUTC(),
|
|
}
|
|
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return model.Message{}, dbError(err)
|
|
}
|
|
defer rollback(tx)
|
|
|
|
tag, err := tx.Exec(ctx, `
|
|
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
|
SELECT $1, $2, $3, $4, $5
|
|
WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3)`,
|
|
message.ID, message.ChatID, message.SenderID, message.Text, time.Time(message.CreatedAt))
|
|
if err != nil {
|
|
return model.Message{}, dbError(err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return model.Message{}, common.NotFound("chat not found")
|
|
}
|
|
|
|
expiresAt := time.Time(message.CreatedAt).Add(s.idempotencyTTL)
|
|
tag, err = tx.Exec(ctx, `
|
|
INSERT INTO message_idempotency
|
|
(sender_id, chat_id, idempotency_key, request_hash, message_id, created_at, expires_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
|
ON CONFLICT (sender_id, chat_id, idempotency_key) DO UPDATE
|
|
SET request_hash = EXCLUDED.request_hash,
|
|
message_id = EXCLUDED.message_id,
|
|
created_at = EXCLUDED.created_at,
|
|
expires_at = EXCLUDED.expires_at
|
|
WHERE message_idempotency.expires_at <= now()`,
|
|
senderID, chatID, idempotencyKey, fingerprint[:], message.ID,
|
|
time.Time(message.CreatedAt), expiresAt)
|
|
if err != nil {
|
|
return model.Message{}, dbError(err)
|
|
}
|
|
|
|
if tag.RowsAffected() == 0 {
|
|
rollback(tx)
|
|
stored, found, lookupErr := s.findIdempotentMessage(ctx, senderID, chatID, idempotencyKey, fingerprint[:])
|
|
if lookupErr != nil {
|
|
return model.Message{}, lookupErr
|
|
}
|
|
if !found {
|
|
return model.Message{}, common.Internal()
|
|
}
|
|
return stored, nil
|
|
}
|
|
|
|
if err = tx.Commit(ctx); err != nil {
|
|
return model.Message{}, dbError(err)
|
|
}
|
|
|
|
return message, nil
|
|
}
|
|
|
|
func (s *Store) findIdempotentMessage(ctx context.Context, senderID, chatID uuid.UUID, idempotencyKey string, expectedHash []byte) (model.Message, bool, error) {
|
|
var message model.Message
|
|
var createdAt time.Time
|
|
var storedHash []byte
|
|
|
|
err := s.pool.QueryRow(ctx, `
|
|
SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, i.request_hash
|
|
FROM message_idempotency i
|
|
JOIN messages m ON m.id = i.message_id
|
|
JOIN chat_members cm ON cm.chat_id = i.chat_id AND cm.user_id = i.sender_id
|
|
WHERE i.sender_id = $1
|
|
AND i.chat_id = $2
|
|
AND i.idempotency_key = $3
|
|
AND i.expires_at > now()`,
|
|
senderID, chatID, idempotencyKey).Scan(
|
|
&message.ID, &message.ChatID, &message.SenderID, &message.Text, &createdAt, &storedHash)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return model.Message{}, false, nil
|
|
}
|
|
if err != nil {
|
|
return model.Message{}, false, dbError(err)
|
|
}
|
|
if !bytes.Equal(storedHash, expectedHash) {
|
|
return model.Message{}, false, common.Conflict("idempotency key reused with a different message")
|
|
}
|
|
|
|
message.CreatedAt = common.RFCFormTime(createdAt.UTC())
|
|
return message, true, nil
|
|
}
|
|
|
|
func (s *Store) ListMessages(ctx context.Context, userID, chatID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.Page[model.Message], error) {
|
|
ctx, cancel := s.withTimeout(ctx)
|
|
defer cancel()
|
|
|
|
isMember, err := s.IsMember(ctx, userID, chatID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !isMember {
|
|
return nil, common.NotFound("chat not found")
|
|
}
|
|
// AGENT: Cursor context is checked only after membership, so a foreign
|
|
// caller gets 404 and cannot probe cursor validity against someone else's chat.
|
|
if cursor != nil && cursor.ContextID != chatID {
|
|
return nil, common.BadRequest("bad cursor value")
|
|
}
|
|
|
|
cursorTime, cursorID := cursorValues(cursor)
|
|
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, dbError(err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
messages := make([]model.Message, 0, limit)
|
|
for rows.Next() {
|
|
message, scanErr := scanMessage(rows)
|
|
if scanErr != nil {
|
|
return nil, dbError(scanErr)
|
|
}
|
|
messages = append(messages, message)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return nil, dbError(err)
|
|
}
|
|
|
|
hasMore := len(messages) > limit
|
|
if hasMore {
|
|
messages = messages[:limit]
|
|
}
|
|
|
|
return &common.Page[model.Message]{
|
|
Items: messages,
|
|
NextCursor: common.NextCursor(messages, hasMore, chatID),
|
|
}, nil
|
|
}
|
|
|
|
func scanMessage(row rowScanner) (model.Message, error) {
|
|
var message model.Message
|
|
var createdAt time.Time
|
|
if err := row.Scan(&message.ID, &message.ChatID, &message.SenderID, &message.Text, &createdAt); err != nil {
|
|
return model.Message{}, err
|
|
}
|
|
message.CreatedAt = common.RFCFormTime(createdAt.UTC())
|
|
return message, nil
|
|
}
|