637 lines
21 KiB
Go
637 lines
21 KiB
Go
package main
|
||
|
||
import (
|
||
"context"
|
||
"encoding/base64"
|
||
"errors"
|
||
"log/slog"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/jackc/pgx/v5"
|
||
"github.com/jackc/pgx/v5/pgconn"
|
||
"github.com/jackc/pgx/v5/pgxpool"
|
||
)
|
||
|
||
// Фиксированная ширина (6 знаков) => строки курсора сравниваются
|
||
// лексикографически так же, как время. Формат: RFC 3339 UTC с "Z".
|
||
const tsLayout = "2006-01-02T15:04:05.000000Z"
|
||
|
||
var (
|
||
errConflict = errors.New("conflict")
|
||
errInvalid = errors.New("invalid")
|
||
errNotFound = errors.New("not found")
|
||
errUnauthorized = errors.New("unauthorized")
|
||
)
|
||
|
||
type User struct {
|
||
ID string `json:"id"`
|
||
Username string `json:"username"`
|
||
DisplayName string `json:"display_name"`
|
||
CreatedAt string `json:"created_at"`
|
||
}
|
||
|
||
type Chat struct {
|
||
ID string `json:"id"`
|
||
Title string `json:"title"`
|
||
MemberIDs []string `json:"member_ids"`
|
||
CreatedAt string `json:"created_at"`
|
||
}
|
||
|
||
type Message struct {
|
||
ID string `json:"id"`
|
||
ChatID string `json:"chat_id"`
|
||
SenderID string `json:"sender_id"`
|
||
Text string `json:"text"`
|
||
CreatedAt string `json:"created_at"`
|
||
}
|
||
|
||
type Session struct {
|
||
Token string `json:"token"`
|
||
TokenType string `json:"token_type"`
|
||
ExpiresAt string `json:"expires_at"`
|
||
User User `json:"user"`
|
||
}
|
||
|
||
func formatTS(t time.Time) string { return t.UTC().Format(tsLayout) }
|
||
|
||
// Store — тонкая обёртка над *pgxpool.Pool (+ опциональный Redis-кэш сессий).
|
||
// Пул соединений и его лимиты настраиваются в openPool; здесь только запросы.
|
||
type Store struct {
|
||
db *pgxpool.Pool
|
||
cache *sessionCache // nil => кэш не настроен, работаем только с Postgres
|
||
sessionTTL time.Duration
|
||
revoked sync.Map // string(token_hash) -> time.Time: см. denyLocally
|
||
}
|
||
|
||
func NewStore(db *pgxpool.Pool, cache *sessionCache, sessionTTL time.Duration) *Store {
|
||
return &Store{db: db, cache: cache, sessionTTL: sessionTTL}
|
||
}
|
||
|
||
// isUniqueViolation: SQLSTATE 23505 — PostgreSQL error code для unique_violation.
|
||
func isUniqueViolation(err error) bool {
|
||
var pgErr *pgconn.PgError
|
||
return errors.As(err, &pgErr) && pgErr.Code == "23505"
|
||
}
|
||
|
||
// isForeignKeyViolation: SQLSTATE 23503 — ссылка на несуществующую строку
|
||
// (например, неизвестный user_id в chat_members).
|
||
func isForeignKeyViolation(err error) bool {
|
||
var pgErr *pgconn.PgError
|
||
return errors.As(err, &pgErr) && pgErr.Code == "23503"
|
||
}
|
||
|
||
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
u := User{ID: newUUID(), Username: username, DisplayName: displayName}
|
||
var createdAt time.Time
|
||
err := s.db.QueryRow(ctx,
|
||
`INSERT INTO users (id, username, display_name, password_hash)
|
||
VALUES ($1, $2, $3, $4) RETURNING created_at`,
|
||
u.ID, username, displayName, passwordHash).Scan(&createdAt)
|
||
if err != nil {
|
||
if isUniqueViolation(err) {
|
||
return User{}, errConflict
|
||
}
|
||
return User{}, err
|
||
}
|
||
u.CreatedAt = formatTS(createdAt)
|
||
return u, nil
|
||
}
|
||
|
||
func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
var u User
|
||
var createdAt time.Time
|
||
err := s.db.QueryRow(ctx,
|
||
`SELECT id, username, display_name, created_at FROM users WHERE id = $1`,
|
||
id).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt)
|
||
if errors.Is(err, pgx.ErrNoRows) {
|
||
return User{}, errNotFound
|
||
}
|
||
if err != nil {
|
||
return User{}, err
|
||
}
|
||
u.CreatedAt = formatTS(createdAt)
|
||
return u, nil
|
||
}
|
||
|
||
// AuthenticateUser проверяет Basic username:password. Несуществующий
|
||
// username и неверный пароль дают одну и ту же ошибку — чтобы ответ не
|
||
// раскрывал, какой username существует.
|
||
func (s *Store) AuthenticateUser(ctx context.Context, username, password string) (User, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
var u User
|
||
var createdAt time.Time
|
||
var hash string
|
||
err := s.db.QueryRow(ctx,
|
||
`SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1`,
|
||
username).Scan(&u.ID, &u.Username, &u.DisplayName, &hash, &createdAt)
|
||
if errors.Is(err, pgx.ErrNoRows) {
|
||
return User{}, errUnauthorized
|
||
}
|
||
if err != nil {
|
||
return User{}, err
|
||
}
|
||
ok, err := verifyPassword(hash, password)
|
||
if err != nil || !ok {
|
||
return User{}, errUnauthorized
|
||
}
|
||
u.CreatedAt = formatTS(createdAt)
|
||
return u, nil
|
||
}
|
||
|
||
// CreateChat — атомарная составная операция: вставка чата и всех строк
|
||
// членства в одной транзакции. Неизвестный участник нарушает FK на
|
||
// chat_members.user_id -> откат целиком, ни чат, ни частичный список
|
||
// участников не остаются в БД.
|
||
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string) (Chat, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
tx, err := s.db.Begin(ctx)
|
||
if err != nil {
|
||
return Chat{}, err
|
||
}
|
||
defer tx.Rollback(ctx) //nolint:errcheck — не влияет после успешного Commit
|
||
|
||
c := Chat{ID: newUUID(), Title: title, MemberIDs: memberIDs}
|
||
var createdAt time.Time
|
||
if err := tx.QueryRow(ctx,
|
||
`INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at`,
|
||
c.ID, title).Scan(&createdAt); err != nil {
|
||
return Chat{}, err
|
||
}
|
||
|
||
if _, err := tx.Exec(ctx,
|
||
`INSERT INTO chat_members (chat_id, user_id)
|
||
SELECT $1, unnest($2::uuid[])`,
|
||
c.ID, memberIDs); err != nil {
|
||
if isForeignKeyViolation(err) {
|
||
return Chat{}, errInvalid
|
||
}
|
||
return Chat{}, err
|
||
}
|
||
|
||
if err := tx.Commit(ctx); err != nil {
|
||
return Chat{}, err
|
||
}
|
||
c.CreatedAt = formatTS(createdAt)
|
||
return c, nil
|
||
}
|
||
|
||
// GetChat возвращает чат, только если userID — его участник; чужой и
|
||
// несуществующий чат неразличимы (оба errNotFound — так и задано в контракте).
|
||
func (s *Store) GetChat(ctx context.Context, userID, chatID string) (Chat, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
var c Chat
|
||
var createdAt time.Time
|
||
err := s.db.QueryRow(ctx,
|
||
`SELECT c.id, c.title, c.created_at
|
||
FROM chats c
|
||
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $2
|
||
WHERE c.id = $1`,
|
||
chatID, userID).Scan(&c.ID, &c.Title, &createdAt)
|
||
if errors.Is(err, pgx.ErrNoRows) {
|
||
return Chat{}, errNotFound
|
||
}
|
||
if err != nil {
|
||
return Chat{}, err
|
||
}
|
||
members, err := s.chatMembers(ctx, c.ID)
|
||
if err != nil {
|
||
return Chat{}, err
|
||
}
|
||
c.MemberIDs = members
|
||
c.CreatedAt = formatTS(createdAt)
|
||
return c, nil
|
||
}
|
||
|
||
func (s *Store) chatMembers(ctx context.Context, chatID string) ([]string, error) {
|
||
rows, err := s.db.Query(ctx,
|
||
`SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
// make(..., 0), не var out []string: nil-слайс маршалится в JSON как
|
||
// null, а не [] — контракт (и smoke-тест) ожидает массив даже пустой.
|
||
out := make([]string, 0)
|
||
for rows.Next() {
|
||
var id string
|
||
if err := rows.Scan(&id); err != nil {
|
||
return nil, err
|
||
}
|
||
out = append(out, id)
|
||
}
|
||
return out, rows.Err()
|
||
}
|
||
|
||
func (s *Store) AddMessage(ctx context.Context, userID, chatID, text string) (Message, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
var isMember bool
|
||
if err := s.db.QueryRow(ctx,
|
||
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
|
||
chatID, userID).Scan(&isMember); err != nil {
|
||
return Message{}, err
|
||
}
|
||
if !isMember {
|
||
return Message{}, errNotFound
|
||
}
|
||
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: text}
|
||
var createdAt time.Time
|
||
err := s.db.QueryRow(ctx,
|
||
`INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||
VALUES ($1, $2, $3, $4, clock_timestamp()) RETURNING created_at`,
|
||
m.ID, chatID, userID, text).Scan(&createdAt)
|
||
if err != nil {
|
||
return Message{}, err
|
||
}
|
||
m.CreatedAt = formatTS(createdAt)
|
||
return m, nil
|
||
}
|
||
|
||
// ListMessages — keyset-пагинация: fetch limit+1 строк, чтобы одним запросом
|
||
// узнать и страницу, и есть ли следующая, без отдельного COUNT(*).
|
||
func (s *Store) ListMessages(ctx context.Context, userID, chatID string, after *pos, limit int) ([]Message, bool, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
var isMember bool
|
||
if err := s.db.QueryRow(ctx,
|
||
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
|
||
chatID, userID).Scan(&isMember); err != nil {
|
||
return nil, false, err
|
||
}
|
||
if !isMember {
|
||
return nil, false, errNotFound
|
||
}
|
||
|
||
var rows pgx.Rows
|
||
var err error
|
||
if after == nil {
|
||
rows, err = s.db.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.db.Query(ctx,
|
||
`SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||
WHERE chat_id = $1 AND (created_at, id) > ($2::timestamptz, $3::uuid)
|
||
ORDER BY created_at, id
|
||
LIMIT $4`,
|
||
chatID, after.ts, after.id, limit+1)
|
||
}
|
||
if err != nil {
|
||
return nil, false, err
|
||
}
|
||
defer rows.Close()
|
||
|
||
// make(..., 0), не var out []Message: nil-слайс маршалится в JSON как
|
||
// null, а не [] — "items" в ответе должен быть массивом даже пустым.
|
||
out := make([]Message, 0)
|
||
for rows.Next() {
|
||
var m Message
|
||
var createdAt time.Time
|
||
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &createdAt); err != nil {
|
||
return nil, false, err
|
||
}
|
||
m.CreatedAt = formatTS(createdAt)
|
||
out = append(out, m)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, false, err
|
||
}
|
||
more := len(out) > limit
|
||
if more {
|
||
out = out[:limit]
|
||
}
|
||
return out, more, nil
|
||
}
|
||
|
||
func (s *Store) ListChats(ctx context.Context, userID string, after *pos, limit int) ([]Chat, bool, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
var rows pgx.Rows
|
||
var err error
|
||
if after == nil {
|
||
rows, err = s.db.Query(ctx,
|
||
`SELECT c.id, c.title, c.created_at
|
||
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
|
||
WHERE cm.user_id = $1
|
||
ORDER BY c.created_at, c.id
|
||
LIMIT $2`,
|
||
userID, limit+1)
|
||
} else {
|
||
rows, err = s.db.Query(ctx,
|
||
`SELECT c.id, c.title, c.created_at
|
||
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
|
||
WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
|
||
ORDER BY c.created_at, c.id
|
||
LIMIT $4`,
|
||
userID, after.ts, after.id, limit+1)
|
||
}
|
||
if err != nil {
|
||
return nil, false, err
|
||
}
|
||
defer rows.Close()
|
||
|
||
// make(..., 0), не var out []Chat: та же причина, что в ListMessages.
|
||
out := make([]Chat, 0)
|
||
for rows.Next() {
|
||
var c Chat
|
||
var createdAt time.Time
|
||
if err := rows.Scan(&c.ID, &c.Title, &createdAt); err != nil {
|
||
return nil, false, err
|
||
}
|
||
c.CreatedAt = formatTS(createdAt)
|
||
out = append(out, c)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, false, err
|
||
}
|
||
more := len(out) > limit
|
||
if more {
|
||
out = out[:limit]
|
||
}
|
||
// member_ids для каждого чата страницы — одним batched-запросом, не N+1.
|
||
if len(out) > 0 {
|
||
ids := make([]string, len(out))
|
||
for i, c := range out {
|
||
ids[i] = c.ID
|
||
}
|
||
memberRows, err := s.db.Query(ctx,
|
||
`SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[])`,
|
||
ids)
|
||
if err != nil {
|
||
return nil, false, err
|
||
}
|
||
members := make(map[string][]string, len(out))
|
||
for memberRows.Next() {
|
||
var chatID, memberID string
|
||
if err := memberRows.Scan(&chatID, &memberID); err != nil {
|
||
memberRows.Close()
|
||
return nil, false, err
|
||
}
|
||
members[chatID] = append(members[chatID], memberID)
|
||
}
|
||
memberRows.Close()
|
||
if err := memberRows.Err(); err != nil {
|
||
return nil, false, err
|
||
}
|
||
for i := range out {
|
||
out[i].MemberIDs = members[out[i].ID]
|
||
}
|
||
}
|
||
return out, more, nil
|
||
}
|
||
|
||
// --- сессии ------------------------------------------------------------
|
||
|
||
// CreateSession выдаёт новый opaque bearer-токен поверх уже
|
||
// аутентифицированного пользователя (см. AuthenticateUser) и кладёт его в
|
||
// Postgres (источник истины) и, если настроен, в кэш.
|
||
func (s *Store) CreateSession(ctx context.Context, u User) (Session, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
token, err := newSessionToken()
|
||
if err != nil {
|
||
return Session{}, err
|
||
}
|
||
hash := hashToken(token)
|
||
expiresAt := time.Now().UTC().Add(s.sessionTTL)
|
||
if _, err := s.db.Exec(ctx,
|
||
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)`,
|
||
hash, u.ID, expiresAt); err != nil {
|
||
return Session{}, err
|
||
}
|
||
// Avoid caching positive auth decisions across replicas.
|
||
_ = expiresAt
|
||
return Session{
|
||
Token: token,
|
||
TokenType: "Bearer",
|
||
ExpiresAt: formatTS(expiresAt),
|
||
User: u,
|
||
}, nil
|
||
}
|
||
|
||
// ValidateSession — горячий путь: сначала кэш (если настроен), затем
|
||
// Postgres. Любой сбой кэша (промах ИЛИ ошибка связи) просто идёт в
|
||
// Postgres — отказ Redis никогда не трактуется как "токен валиден" и
|
||
// никогда не трактуется как "запрос анонимный, но пропустим".
|
||
func (s *Store) ValidateSession(ctx context.Context, token string) (User, bool, error) {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
hash := hashToken(token)
|
||
|
||
// Multi-replica correctness: never trust a positive Redis cache hit.
|
||
// PostgreSQL is authoritative for revocation on every request.
|
||
|
||
var u User
|
||
var createdAt, expiresAt time.Time
|
||
err := s.db.QueryRow(ctx,
|
||
`SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()`,
|
||
hash).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt, &expiresAt)
|
||
if errors.Is(err, pgx.ErrNoRows) {
|
||
return User{}, false, nil
|
||
}
|
||
if err != nil {
|
||
return User{}, false, err
|
||
}
|
||
u.CreatedAt = formatTS(createdAt)
|
||
// Avoid caching positive auth decisions across replicas.
|
||
_ = expiresAt
|
||
return u, true, nil
|
||
}
|
||
|
||
func (s *Store) RevokeSession(ctx context.Context, token string) error {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
hash := hashToken(token)
|
||
if _, err := s.db.Exec(ctx,
|
||
`UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`,
|
||
hash); err != nil {
|
||
return err
|
||
}
|
||
// All replicas check PostgreSQL, so a failed Redis DEL cannot resurrect a token.
|
||
_ = s.cache.invalidate(ctx, hash, s.sessionTTL)
|
||
return nil
|
||
}
|
||
|
||
// denyLocally/locallyRevoked — in-memory deny-list отозванных токенов на
|
||
// случай, когда Redis не позволил инвалидировать запись. Записи живут не
|
||
// дольше срока сессии и вычищаются при добавлении новых.
|
||
func (s *Store) denyLocally(hash []byte, until time.Time) {
|
||
now := time.Now()
|
||
s.revoked.Range(func(k, v any) bool {
|
||
if now.After(v.(time.Time)) {
|
||
s.revoked.Delete(k)
|
||
}
|
||
return true
|
||
})
|
||
s.revoked.Store(string(hash), until)
|
||
}
|
||
|
||
// ReconcileRevoked вызывается при старте процесса, ДО приёма запросов.
|
||
// Локальный deny-list и надгробия живут недолго или только в памяти и не
|
||
// переживают рестарт API, а запись в Redis, которую logout не смог
|
||
// инвалидировать, — переживает. Источник истины об отзыве — Postgres
|
||
// (revoked_at), поэтому для каждой отозванной и ещё не истёкшей сессии
|
||
// повторяем инвалидацию кэша; если Redis по-прежнему не даёт ни DEL, ни
|
||
// SET — токен заносится в локальный deny-list уже из БД. Ошибка чтения из
|
||
// Postgres фатальна для старта: без неё нельзя гарантировать, что отозванный
|
||
// токен не оживёт из кэша.
|
||
func (s *Store) ReconcileRevoked(ctx context.Context) error {
|
||
if s.cache == nil {
|
||
return nil
|
||
}
|
||
rows, err := s.db.Query(ctx,
|
||
`SELECT token_hash, expires_at FROM sessions
|
||
WHERE revoked_at IS NOT NULL AND expires_at > now()`)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
type revokedSession struct {
|
||
hash []byte
|
||
expiresAt time.Time
|
||
}
|
||
var revoked []revokedSession
|
||
for rows.Next() {
|
||
var r revokedSession
|
||
if err := rows.Scan(&r.hash, &r.expiresAt); err != nil {
|
||
rows.Close()
|
||
return err
|
||
}
|
||
revoked = append(revoked, r)
|
||
}
|
||
rows.Close() // освобождаем соединение до походов в Redis
|
||
if err := rows.Err(); err != nil {
|
||
return err
|
||
}
|
||
for _, r := range revoked {
|
||
if !s.cache.invalidate(ctx, r.hash, time.Until(r.expiresAt)) {
|
||
s.denyLocally(r.hash, r.expiresAt)
|
||
}
|
||
}
|
||
slog.Info("отозванные сессии сверены с кэшем", "count", len(revoked))
|
||
return nil
|
||
}
|
||
|
||
func (s *Store) locallyRevoked(hash []byte) bool {
|
||
v, ok := s.revoked.Load(string(hash))
|
||
if !ok {
|
||
return false
|
||
}
|
||
if time.Now().After(v.(time.Time)) {
|
||
s.revoked.Delete(string(hash))
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
|
||
func (s *Store) Ready(ctx context.Context) error {
|
||
ctx, cancel := withTimeout(ctx)
|
||
defer cancel()
|
||
return s.db.Ping(ctx)
|
||
}
|
||
|
||
// --- keyset cursor -----------------------------------------------------
|
||
|
||
// pos — позиция последнего отданного элемента. Курсор привязан к scope
|
||
// ("m:<chat_id>" или "c:<user_id>"), поэтому курсор чужого чата даёт 400.
|
||
type pos struct{ ts, id string }
|
||
|
||
func encodeCursor(scope, ts, id string) string {
|
||
return base64.RawURLEncoding.EncodeToString([]byte(scope + "|" + ts + "|" + id))
|
||
}
|
||
|
||
func decodeCursor(scope, raw string) (*pos, bool) {
|
||
b, err := base64.RawURLEncoding.DecodeString(raw)
|
||
if err != nil {
|
||
return nil, false
|
||
}
|
||
parts := strings.Split(string(b), "|")
|
||
if len(parts) != 3 || parts[0] != scope || parts[1] == "" || parts[2] == "" {
|
||
return nil, false
|
||
}
|
||
// Непустые строки — не значит валидные. ts должен быть настоящей меткой
|
||
// времени нашего формата, id — настоящим UUID: без этого структурно
|
||
// похожий, но мусорный курсор тихо дал бы пустую страницу вместо 400.
|
||
if _, err := time.Parse(tsLayout, parts[1]); err != nil {
|
||
return nil, false
|
||
}
|
||
if !uuidRe.MatchString(parts[2]) {
|
||
return nil, false
|
||
}
|
||
return &pos{ts: parts[1], id: parts[2]}, true
|
||
}
|
||
|
||
|
||
func (s *Store) AddMessageIdempotent(parent context.Context, userID, chatID, key, body string) (Message, error) {
|
||
ctx, cancel := context.WithTimeout(parent, 8*time.Second)
|
||
defer cancel()
|
||
tx, err := s.db.Begin(ctx)
|
||
if err != nil {
|
||
return Message{}, err
|
||
}
|
||
defer tx.Rollback(ctx)
|
||
var member bool
|
||
if err = tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2)`, chatID, userID).Scan(&member); err != nil {
|
||
return Message{}, err
|
||
}
|
||
if !member {
|
||
return Message{}, errNotFound
|
||
}
|
||
// The request fingerprint is canonical for lab3: text plus the normalized empty attachment list.
|
||
fingerprint := body
|
||
var existingID *string
|
||
var oldFingerprint string
|
||
err = tx.QueryRow(ctx, `INSERT INTO message_idempotency (user_id,chat_id,key,body_fingerprint,message_id,expires_at)
|
||
VALUES ($1,$2,$3,$4,NULL,now()+interval '24 hours')
|
||
ON CONFLICT (user_id,chat_id,key) DO UPDATE SET key=EXCLUDED.key
|
||
RETURNING message_id,body_fingerprint`, userID, chatID, key, fingerprint).Scan(&existingID, &oldFingerprint)
|
||
if err != nil {
|
||
return Message{}, err
|
||
}
|
||
if oldFingerprint != fingerprint {
|
||
return Message{}, errConflict
|
||
}
|
||
if existingID != nil {
|
||
var m Message
|
||
var t time.Time
|
||
err = tx.QueryRow(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE id=$1`, *existingID).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &t)
|
||
if err != nil {
|
||
return Message{}, err
|
||
}
|
||
m.CreatedAt = formatTS(t)
|
||
if err = tx.Commit(ctx); err != nil {
|
||
return Message{}, err
|
||
}
|
||
return m, nil
|
||
}
|
||
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: body}
|
||
var t time.Time
|
||
err = tx.QueryRow(ctx, `INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES($1,$2,$3,$4,clock_timestamp()) RETURNING created_at`, m.ID, chatID, userID, body).Scan(&t)
|
||
if err != nil {
|
||
return Message{}, err
|
||
}
|
||
m.CreatedAt = formatTS(t)
|
||
_, err = tx.Exec(ctx, `UPDATE message_idempotency SET message_id=$4 WHERE user_id=$1 AND chat_id=$2 AND key=$3`, userID, chatID, key, m.ID)
|
||
if err != nil {
|
||
return Message{}, err
|
||
}
|
||
if err = tx.Commit(ctx); err != nil {
|
||
return Message{}, err
|
||
}
|
||
return m, nil
|
||
}
|