forked from mtusi2026/mtusi2026lab3
436 lines
10 KiB
Go
436 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/mtusi2026lab3/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 id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE chat_id = $1
|
|
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3::uuid))
|
|
ORDER BY created_at, 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,
|
|
)
|
|
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"
|
|
}
|