Files
mtusi2026lab4/internal/store/store.go
T
2026-11-06 17:33:49 +03:00

571 lines
14 KiB
Go

package store
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strconv"
"sync/atomic"
"unicode"
"unicode/utf8"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"mtusi2026/internal/cursor"
"mtusi2026/internal/idgen"
"mtusi2026/internal/model"
)
var (
ErrUsernameTaken = errors.New("username taken")
ErrChatNotFound = errors.New("chat not found or not accessible")
ErrValidation = errors.New("validation failed")
ErrCapacityExceeded = errors.New("message capacity exceeded")
ErrAttachmentNotFound = errors.New("attachment not found or not accessible")
ErrUsernameNotFound = errors.New("username not found")
ErrSessionNotFound = errors.New("session not found or expired")
)
type Store struct {
pool *pgxpool.Pool
Limiter *Limiter
chatSQLQueries atomic.Int64
}
func (s *Store) ResetChatSQLQueries() {
s.chatSQLQueries.Store(0)
}
func (s *Store) ChatSQLQueries() int64 {
return s.chatSQLQueries.Load()
}
func (s *Store) IsChatMember(ctx context.Context, chatID, userID string) (bool, error) {
var ok bool
err := s.pool.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&ok)
return ok, err
}
func (s *Store) CreateAttachment(ctx context.Context, a model.Attachment) (model.Attachment, error) {
err := s.pool.QueryRow(ctx,
`INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8)
RETURNING status, created_at, updated_at`,
a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, a.ObjectKey,
).Scan(&a.Status, &a.CreatedAt, &a.UpdatedAt)
a.Variants = []model.Variant{}
return a, err
}
func (s *Store) GetAttachmentForUser(ctx context.Context, id, userID string) (model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx,
`SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256,
a.object_key, a.status, a.created_at, a.updated_at
FROM attachments a
JOIN chat_members cm ON cm.chat_id = a.chat_id AND cm.user_id = $2
WHERE a.id = $1`, id, userID,
).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256,
&a.ObjectKey, &a.Status, &a.CreatedAt, &a.UpdatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return model.Attachment{}, ErrAttachmentNotFound
}
a.Variants = []model.Variant{}
return a, err
}
func (s *Store) loadAttachmentIDs(ctx context.Context, msgs []model.Message) error {
if len(msgs) == 0 {
return nil
}
ids := make([]string, len(msgs))
pos := make(map[string]int, len(msgs))
for i := range msgs {
ids[i] = msgs[i].ID
pos[msgs[i].ID] = i
msgs[i].AttachmentIDs = []string{}
}
rows, err := s.pool.Query(ctx,
`SELECT message_id, attachment_id FROM message_attachments
WHERE message_id IN (SELECT unnest($1::text[])::uuid)
ORDER BY message_id, position`, ids)
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
var mid, aid string
if err := rows.Scan(&mid, &aid); err != nil {
return err
}
if i, ok := pos[mid]; ok {
msgs[i].AttachmentIDs = append(msgs[i].AttachmentIDs, aid)
}
}
return rows.Err()
}
func New(pool *pgxpool.Pool, limiter *Limiter) *Store {
return &Store{pool: pool, Limiter: limiter}
}
func txAttachmentIDs(ctx context.Context, tx pgx.Tx, messageID string) ([]string, error) {
rows, err := tx.Query(ctx,
`SELECT attachment_id FROM message_attachments WHERE message_id = $1 ORDER BY position`, messageID)
if err != nil {
return nil, err
}
defer rows.Close()
ids := []string{}
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (model.User, error) {
var u model.User
err := s.pool.QueryRow(ctx,
`INSERT INTO users (username, display_name, password_hash)
VALUES ($1, $2, $3)
RETURNING id, username, display_name, created_at`,
username, displayName, passwordHash,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if err != nil {
if isUniqueViolation(err) {
return model.User{}, ErrUsernameTaken
}
return model.User{}, err
}
return u, nil
}
func (s *Store) GetUserByID(ctx context.Context, id string) (model.User, bool, error) {
var u model.User
err := s.pool.QueryRow(ctx,
`SELECT id, username, display_name, created_at FROM users WHERE id = $1`,
id,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return model.User{}, false, nil
}
if err != nil {
return model.User{}, false, err
}
return u, true, nil
}
func (s *Store) CreateChat(ctx context.Context, callerID, title string, memberIDs []string) (model.Chat, error) {
if len(memberIDs) == 0 || len(memberIDs) > 100 {
return model.Chat{}, ErrValidation
}
seen := make(map[string]bool, len(memberIDs))
callerIncluded := false
for _, id := range memberIDs {
if seen[id] {
return model.Chat{}, ErrValidation
}
seen[id] = true
if id == callerID {
callerIncluded = true
}
}
if !callerIncluded {
return model.Chat{}, ErrValidation
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Chat{}, err
}
defer tx.Rollback(ctx)
var c model.Chat
err = tx.QueryRow(ctx,
`INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at`,
title,
).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return model.Chat{}, err
}
for _, memberID := range memberIDs {
_, err = tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)`,
c.ID, memberID,
)
if err != nil {
if isForeignKeyViolation(err) {
return model.Chat{}, ErrValidation
}
return model.Chat{}, err
}
}
if err := tx.Commit(ctx); err != nil {
return model.Chat{}, err
}
c.MemberIDs = append([]string{}, memberIDs...)
return c, nil
}
func (s *Store) GetChat(ctx context.Context, chatID, userID string) (model.Chat, error) {
var c model.Chat
s.chatSQLQueries.Add(1)
err := s.pool.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, &c.CreatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return model.Chat{}, ErrChatNotFound
}
return model.Chat{}, fmt.Errorf("get chat: %w", err)
}
memberIDs, err := s.listChatMemberIDs(ctx, c.ID)
if err != nil {
return model.Chat{}, err
}
c.MemberIDs = memberIDs
return c, nil
}
func (s *Store) listChatMemberIDs(ctx context.Context, chatID string) ([]string, error) {
s.chatSQLQueries.Add(1)
rows, err := s.pool.Query(ctx, `SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID)
if err != nil {
return nil, err
}
defer rows.Close()
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}
func (s *Store) ListChatsForUser(ctx context.Context, userID, cursorStr string, limit int) ([]model.Chat, *string, error) {
var after *cursor.Cursor
if cursorStr != "" {
c, err := cursor.Decode(cursorStr)
if err != nil || c.Scope != "chats:"+userID {
return nil, nil, ErrValidation
}
after = &c
}
query := `
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`
args := []any{userID}
if after != nil {
query += ` AND (c.created_at, c.id) > ($2, $3)`
args = append(args, after.CreatedAt, after.ID)
}
query += ` ORDER BY c.created_at ASC, c.id ASC LIMIT $` + strconv.Itoa(len(args)+1)
args = append(args, limit+1)
rows, err := s.pool.Query(ctx, query, args...)
if err != nil {
return nil, nil, err
}
defer rows.Close()
var page []model.Chat
for rows.Next() {
var c model.Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, nil, err
}
page = append(page, c)
}
if err := rows.Err(); err != nil {
return nil, nil, err
}
var next *string
if len(page) > limit {
last := page[limit-1]
nc := cursor.Encode(cursor.Cursor{Scope: "chats:" + userID, CreatedAt: last.CreatedAt, ID: last.ID})
next = &nc
page = page[:limit]
}
for i := range page {
memberIDs, err := s.listChatMemberIDs(ctx, page[i].ID)
if err != nil {
return nil, nil, err
}
page[i].MemberIDs = memberIDs
}
return page, next, nil
}
var ErrIdempotencyConflict = errors.New("idempotency key reused with different body")
func (s *Store) CreateMessage(ctx context.Context, chatID, senderID, idemKey, text string, attIDs []string) (model.Message, error) {
if attIDs == nil {
attIDs = []string{}
}
if !ValidMessageBody(text, len(attIDs) > 0) {
return model.Message{}, ErrValidation
}
hash := requestHash(text, attIDs)
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Message{}, err
}
defer tx.Rollback(ctx)
var isMember bool
if err := tx.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2)`,
chatID, senderID).Scan(&isMember); err != nil {
return model.Message{}, err
}
if !isMember {
return model.Message{}, ErrChatNotFound
}
if len(attIDs) > 0 {
var n int
if err := tx.QueryRow(ctx,
`SELECT count(*) FROM attachments
WHERE chat_id = $1 AND id IN (SELECT unnest($2::text[])::uuid)`,
chatID, attIDs).Scan(&n); err != nil {
return model.Message{}, err
}
if n != len(attIDs) {
return model.Message{}, ErrAttachmentNotFound
}
}
msgID := idgen.GenerateUUIDv4()
tag, err := tx.Exec(ctx,
`INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id)
VALUES ($1,$2,$3,$4,$5)
ON CONFLICT (user_id, chat_id, key) DO NOTHING`,
senderID, chatID, idemKey, hash, msgID)
if err != nil {
return model.Message{}, err
}
if tag.RowsAffected() == 0 {
var storedHash string
var m model.Message
var textBytes []byte
if err := tx.QueryRow(ctx, `
SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at
FROM idempotency_keys k
JOIN messages m ON m.id = k.message_id
WHERE k.user_id=$1 AND k.chat_id=$2 AND k.key=$3
`, senderID, chatID, idemKey).Scan(
&storedHash, &m.ID, &m.ChatID, &m.SenderID, &textBytes, &m.CreatedAt,
); err != nil {
return model.Message{}, err
}
m.Text = string(textBytes)
if storedHash != hash {
return model.Message{}, ErrIdempotencyConflict
}
if m.AttachmentIDs, err = txAttachmentIDs(ctx, tx, m.ID); err != nil {
return model.Message{}, err
}
return m, nil
}
var m model.Message
var textBytes []byte
err = tx.QueryRow(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1,$2,$3,$4, clock_timestamp())
RETURNING id, chat_id, sender_id, text, created_at
`, msgID, chatID, senderID, []byte(text)).Scan(
&m.ID, &m.ChatID, &m.SenderID, &textBytes, &m.CreatedAt,
)
if err != nil {
if isCheckViolation(err) {
return model.Message{}, ErrValidation
}
return model.Message{}, err
}
m.Text = string(textBytes)
for i, id := range attIDs {
if _, err := tx.Exec(ctx,
`INSERT INTO message_attachments (message_id, attachment_id, position) VALUES ($1,$2,$3)`,
m.ID, id, i); err != nil {
return model.Message{}, err
}
}
if err := tx.Commit(ctx); err != nil {
return model.Message{}, err
}
m.AttachmentIDs = attIDs
return m, nil
}
func (s *Store) ListMessages(ctx context.Context, chatID, userID, cursorStr string, limit int) ([]model.Message, *string, error) {
var isMember bool
err := s.pool.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID,
).Scan(&isMember)
if err != nil {
return nil, nil, err
}
if !isMember {
return nil, nil, ErrChatNotFound
}
var after *cursor.Cursor
if cursorStr != "" {
dc, err := cursor.Decode(cursorStr)
if err != nil || dc.Scope != "messages:"+chatID {
return nil, nil, ErrValidation
}
after = &dc
}
query := `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1`
args := []any{chatID}
if after != nil {
query += ` AND (created_at, id) > ($2, $3)`
args = append(args, after.CreatedAt, after.ID)
}
query += ` ORDER BY created_at ASC, id ASC LIMIT $` + strconv.Itoa(len(args)+1)
args = append(args, limit+1)
rows, err := s.pool.Query(ctx, query, args...)
if err != nil {
return nil, nil, err
}
defer rows.Close()
var page []model.Message
for rows.Next() {
var m model.Message
var textBytes []byte
if err := rows.Scan(
&m.ID, &m.ChatID, &m.SenderID, &textBytes, &m.CreatedAt,
); err != nil {
return nil, nil, err
}
m.Text = string(textBytes)
page = append(page, m)
}
if err := rows.Err(); err != nil {
return nil, nil, err
}
var next *string
if len(page) > limit {
last := page[limit-1]
nc := cursor.Encode(cursor.Cursor{Scope: "messages:" + chatID, CreatedAt: last.CreatedAt, ID: last.ID})
next = &nc
page = page[:limit]
}
if err := s.loadAttachmentIDs(ctx, page); err != nil {
return nil, nil, err
}
return page, next, nil
}
func isUniqueViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23505"
}
func isForeignKeyViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23503"
}
func isCheckViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23514"
}
func ValidMessageBody(s string, hasAttachments bool) bool {
if !utf8.ValidString(s) || utf8.RuneCountInString(s) > 4000 {
return false
}
hasContent := false
for _, r := range s {
if !unicode.IsSpace(r) {
hasContent = true
}
}
return hasAttachments || hasContent
}
func requestHash(text string, ids []string) string {
b, _ := json.Marshal(struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}{text, ids})
sum := sha256.Sum256(b)
return hex.EncodeToString(sum[:])
}
func (s *Store) GetUserByUsername(ctx context.Context, username string) (model.User, string, error) {
var u model.User
var passwordHash string
err := s.pool.QueryRow(ctx,
`SELECT id, username, display_name, created_at, password_hash
FROM users WHERE username = $1`,
username,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &passwordHash)
if errors.Is(err, pgx.ErrNoRows) {
return model.User{}, "", ErrUsernameNotFound
}
if err != nil {
return model.User{}, "", err
}
return u, passwordHash, nil
}