Files
2026-10-22 16:20:54 +03:00

443 lines
10 KiB
Go

package postgres
import (
"context"
"errors"
"fmt"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/dizi/mtusi2026lab5/internal/model"
)
type Store struct {
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *Store {
return &Store{pool: pool}
}
func (s *Store) Ping(ctx context.Context) error {
return s.pool.Ping(ctx)
}
func (s *Store) CreateUser(
ctx context.Context,
username string,
displayName string,
passwordHash string,
) (model.User, error) {
const query = `
INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1, $2, $3, $4)
RETURNING id, username, display_name, created_at`
var user model.User
err := s.pool.QueryRow(ctx, query, uuid.NewString(), username, displayName, passwordHash).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
)
if isUniqueViolation(err) {
return model.User{}, ErrConflict
}
if err != nil {
return model.User{}, fmt.Errorf("create user: %w", err)
}
return user, nil
}
func (s *Store) UserByID(ctx context.Context, id string) (model.User, error) {
const query = `
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1`
var user model.User
err := s.pool.QueryRow(ctx, query, id).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.User{}, ErrNotFound
}
if err != nil {
return model.User{}, fmt.Errorf("get user by id: %w", err)
}
return user, nil
}
func (s *Store) UserByUsername(ctx context.Context, username string) (model.UserCredentials, error) {
const query = `
SELECT id, username, display_name, created_at, password_hash
FROM users
WHERE username = $1`
var credentials model.UserCredentials
err := s.pool.QueryRow(ctx, query, username).Scan(
&credentials.ID,
&credentials.Username,
&credentials.DisplayName,
&credentials.CreatedAt,
&credentials.PasswordHash,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.UserCredentials{}, ErrNotFound
}
if err != nil {
return model.UserCredentials{}, fmt.Errorf("get user by username: %w", err)
}
return credentials, nil
}
func (s *Store) CreateChat(
ctx context.Context,
title string,
memberIDs []string,
callerID string,
) (model.Chat, error) {
if !validMembers(memberIDs, callerID) {
return model.Chat{}, ErrInvalidMembers
}
tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return model.Chat{}, fmt.Errorf("begin create chat transaction: %w", err)
}
defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }()
valid, err := allUsersExist(ctx, tx, memberIDs)
if err != nil {
return model.Chat{}, err
}
if !valid {
return model.Chat{}, ErrInvalidMembers
}
chat, err := insertChat(ctx, tx, title)
if err != nil {
return model.Chat{}, err
}
if err := insertMembers(ctx, tx, chat.ID, memberIDs); err != nil {
return model.Chat{}, err
}
if err := tx.Commit(ctx); err != nil {
return model.Chat{}, fmt.Errorf("commit create chat transaction: %w", err)
}
chat.MemberIDs = append([]string(nil), memberIDs...)
return chat, nil
}
func validMembers(memberIDs []string, callerID string) bool {
callerUUID, err := uuid.Parse(callerID)
if err != nil {
return false
}
seen := make(map[uuid.UUID]struct{}, len(memberIDs))
callerIncluded := false
for _, memberID := range memberIDs {
memberUUID, err := uuid.Parse(memberID)
if err != nil {
return false
}
if _, exists := seen[memberUUID]; exists {
return false
}
seen[memberUUID] = struct{}{}
callerIncluded = callerIncluded || memberUUID == callerUUID
}
return callerIncluded
}
func allUsersExist(ctx context.Context, tx pgx.Tx, memberIDs []string) (bool, error) {
const query = `
SELECT count(*)
FROM users
WHERE id::text = ANY($1)`
var count int
if err := tx.QueryRow(ctx, query, memberIDs).Scan(&count); err != nil {
return false, fmt.Errorf("check chat members: %w", err)
}
return count == len(memberIDs), nil
}
func insertChat(ctx context.Context, tx pgx.Tx, title string) (model.Chat, error) {
const query = `
INSERT INTO chats (id, title)
VALUES ($1, $2)
RETURNING id, title, created_at`
var chat model.Chat
if err := tx.QueryRow(ctx, query, uuid.NewString(), title).Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil {
return model.Chat{}, fmt.Errorf("insert chat: %w", err)
}
return chat, nil
}
func insertMembers(ctx context.Context, tx pgx.Tx, chatID string, memberIDs []string) error {
const query = `
INSERT INTO chat_members (chat_id, user_id, position)
VALUES ($1, $2, $3)`
batch := &pgx.Batch{}
for position, memberID := range memberIDs {
batch.Queue(query, chatID, memberID, position)
}
results := tx.SendBatch(ctx, batch)
defer func() { _ = results.Close() }()
for range memberIDs {
if _, err := results.Exec(); err != nil {
return fmt.Errorf("insert chat member: %w", err)
}
}
if err := results.Close(); err != nil {
return fmt.Errorf("close chat members batch: %w", err)
}
return nil
}
func (s *Store) ChatForUser(ctx context.Context, chatID, userID string) (model.Chat, error) {
const query = `
SELECT c.id, c.title, c.created_at,
array_agg(cm.user_id::text ORDER BY cm.position)
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE c.id = $1
AND EXISTS (
SELECT 1
FROM chat_members visible
WHERE visible.chat_id = c.id AND visible.user_id = $2
)
GROUP BY c.id, c.title, c.created_at`
var chat model.Chat
err := s.pool.QueryRow(ctx, query, chatID, userID).Scan(
&chat.ID,
&chat.Title,
&chat.CreatedAt,
&chat.MemberIDs,
)
if errors.Is(err, pgx.ErrNoRows) {
return model.Chat{}, ErrNotFound
}
if err != nil {
return model.Chat{}, fmt.Errorf("get chat for user: %w", err)
}
return chat, nil
}
func (s *Store) ListChats(
ctx context.Context,
userID string,
after *model.Position,
limit int,
) ([]model.Chat, bool, error) {
if after != nil {
valid, err := s.visibleChatPositionExists(ctx, userID, *after)
if err != nil {
return nil, false, err
}
if !valid {
return nil, false, ErrInvalidCursor
}
}
const query = `
SELECT c.id, c.title, c.created_at,
array_agg(all_members.user_id::text ORDER BY all_members.position)
FROM chats c
JOIN chat_members visible ON visible.chat_id = c.id AND visible.user_id = $1
JOIN chat_members all_members ON all_members.chat_id = c.id
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3::uuid))
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at, c.id
LIMIT $4`
var afterTime any
var afterID any
if after != nil {
afterTime = after.CreatedAt
afterID = after.ID
}
rows, err := s.pool.Query(ctx, query, userID, afterTime, afterID, limit+1)
if err != nil {
return nil, false, fmt.Errorf("list chats: %w", err)
}
defer rows.Close()
chats, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Chat](func(row pgx.CollectableRow) (model.Chat, error) {
var chat model.Chat
err := row.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs)
return chat, err
}))
if err != nil {
return nil, false, fmt.Errorf("scan chats: %w", err)
}
return page(chats, limit)
}
func (s *Store) visibleChatPositionExists(
ctx context.Context,
userID string,
position model.Position,
) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1 AND c.created_at = $2 AND c.id = $3
)`
var exists bool
if err := s.pool.QueryRow(ctx, query, userID, position.CreatedAt, position.ID).Scan(&exists); err != nil {
return false, fmt.Errorf("validate chat cursor: %w", err)
}
return exists, nil
}
func (s *Store) ListMessages(
ctx context.Context,
chatID string,
userID string,
after *model.Position,
limit int,
) ([]model.Message, bool, error) {
visible, err := s.chatVisible(ctx, chatID, userID)
if err != nil {
return nil, false, err
}
if !visible {
return nil, false, ErrNotFound
}
if after != nil {
valid, err := s.messagePositionExists(ctx, chatID, *after)
if err != nil {
return nil, false, err
}
if !valid {
return nil, false, ErrInvalidCursor
}
}
const query = `
SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at,
ARRAY(
SELECT ma.attachment_id::text
FROM message_attachments ma
WHERE ma.message_id = m.id
ORDER BY ma.position
)
FROM messages m
WHERE m.chat_id = $1
AND ($2::timestamptz IS NULL OR (m.created_at, m.id) > ($2, $3::uuid))
ORDER BY m.created_at, m.id
LIMIT $4`
var afterTime any
var afterID any
if after != nil {
afterTime = after.CreatedAt
afterID = after.ID
}
rows, err := s.pool.Query(ctx, query, chatID, afterTime, afterID, limit+1)
if err != nil {
return nil, false, fmt.Errorf("list messages: %w", err)
}
defer rows.Close()
messages, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Message](func(row pgx.CollectableRow) (model.Message, error) {
var message model.Message
err := row.Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
&message.AttachmentIDs,
)
return message, err
}))
if err != nil {
return nil, false, fmt.Errorf("scan messages: %w", err)
}
return page(messages, limit)
}
func (s *Store) chatVisible(ctx context.Context, chatID, userID string) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM chat_members
WHERE chat_id = $1 AND user_id = $2
)`
var exists bool
if err := s.pool.QueryRow(ctx, query, chatID, userID).Scan(&exists); err != nil {
return false, fmt.Errorf("check chat visibility: %w", err)
}
return exists, nil
}
func (s *Store) messagePositionExists(
ctx context.Context,
chatID string,
position model.Position,
) (bool, error) {
const query = `
SELECT EXISTS (
SELECT 1
FROM messages
WHERE chat_id = $1 AND created_at = $2 AND id = $3
)`
var exists bool
if err := s.pool.QueryRow(ctx, query, chatID, position.CreatedAt, position.ID).Scan(&exists); err != nil {
return false, fmt.Errorf("validate message cursor: %w", err)
}
return exists, nil
}
func page[T any](items []T, limit int) ([]T, bool, error) {
if limit < 1 {
return nil, false, fmt.Errorf("limit must be positive")
}
if len(items) <= limit {
return items, false, nil
}
return items[:limit], true, nil
}
func isUniqueViolation(err error) bool {
var postgresError *pgconn.PgError
return errors.As(err, &postgresError) && postgresError.Code == "23505"
}