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:" или "c:"), поэтому курсор чужого чата даёт 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 }