forked from mtusi2026/mtusi2026lab3
654 lines
16 KiB
Go
654 lines
16 KiB
Go
package postgres
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"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) CreateMessage(
|
|
ctx context.Context,
|
|
chatID string,
|
|
senderID string,
|
|
text string,
|
|
idempotencyKey string,
|
|
idempotencyTTL time.Duration,
|
|
) (model.Message, bool, error) {
|
|
tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})
|
|
if err != nil {
|
|
return model.Message{}, false, fmt.Errorf("begin create message transaction: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }()
|
|
|
|
visible, err := chatVisibleInTransaction(ctx, tx, chatID, senderID)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if !visible {
|
|
return model.Message{}, false, ErrNotFound
|
|
}
|
|
|
|
requestHash := sha256.Sum256([]byte(text))
|
|
message, replay, err := createIdempotentMessage(
|
|
ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL,
|
|
)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return model.Message{}, false, fmt.Errorf("commit create message transaction: %w", err)
|
|
}
|
|
return message, replay, nil
|
|
}
|
|
|
|
func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) {
|
|
const query = `
|
|
SELECT EXISTS (
|
|
SELECT 1
|
|
FROM chat_members
|
|
WHERE chat_id = $1 AND user_id = $2
|
|
)`
|
|
|
|
var visible bool
|
|
if err := tx.QueryRow(ctx, query, chatID, userID).Scan(&visible); err != nil {
|
|
return false, fmt.Errorf("check chat visibility: %w", err)
|
|
}
|
|
return visible, nil
|
|
}
|
|
|
|
func createIdempotentMessage(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
chatID string,
|
|
senderID string,
|
|
text string,
|
|
idempotencyKey string,
|
|
requestHash []byte,
|
|
idempotencyTTL time.Duration,
|
|
) (model.Message, bool, error) {
|
|
for {
|
|
record, found, err := lockIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if found && record.active {
|
|
if !bytes.Equal(record.requestHash, requestHash) {
|
|
return model.Message{}, false, ErrIdempotencyConflict
|
|
}
|
|
message, err := messageByID(ctx, tx, record.messageID)
|
|
return message, true, err
|
|
}
|
|
if found {
|
|
if err := deleteIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey); err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
}
|
|
|
|
messageID := uuid.NewString()
|
|
reserved, err := reserveIdempotencyKey(
|
|
ctx, tx, senderID, chatID, idempotencyKey, requestHash, messageID, idempotencyTTL,
|
|
)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if !reserved {
|
|
continue
|
|
}
|
|
|
|
message, err := insertMessage(ctx, tx, messageID, chatID, senderID, text)
|
|
return message, false, err
|
|
}
|
|
}
|
|
|
|
type idempotencyRecord struct {
|
|
requestHash []byte
|
|
messageID string
|
|
active bool
|
|
}
|
|
|
|
func lockIdempotencyRecord(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
userID string,
|
|
chatID string,
|
|
key string,
|
|
) (idempotencyRecord, bool, error) {
|
|
const query = `
|
|
SELECT request_hash, message_id, expires_at > statement_timestamp()
|
|
FROM message_idempotency
|
|
WHERE user_id = $1 AND chat_id = $2 AND key = $3
|
|
FOR UPDATE`
|
|
|
|
var record idempotencyRecord
|
|
err := tx.QueryRow(ctx, query, userID, chatID, key).Scan(
|
|
&record.requestHash,
|
|
&record.messageID,
|
|
&record.active,
|
|
)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return idempotencyRecord{}, false, nil
|
|
}
|
|
if err != nil {
|
|
return idempotencyRecord{}, false, fmt.Errorf("lock idempotency key: %w", err)
|
|
}
|
|
return record, true, nil
|
|
}
|
|
|
|
func deleteIdempotencyRecord(ctx context.Context, tx pgx.Tx, userID, chatID, key string) error {
|
|
const query = `
|
|
DELETE FROM message_idempotency
|
|
WHERE user_id = $1 AND chat_id = $2 AND key = $3`
|
|
if _, err := tx.Exec(ctx, query, userID, chatID, key); err != nil {
|
|
return fmt.Errorf("delete expired idempotency key: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func reserveIdempotencyKey(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
userID string,
|
|
chatID string,
|
|
key string,
|
|
requestHash []byte,
|
|
messageID string,
|
|
ttl time.Duration,
|
|
) (bool, error) {
|
|
const query = `
|
|
INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, expires_at)
|
|
VALUES ($1, $2, $3, $4, $5, statement_timestamp() + $6 * INTERVAL '1 second')
|
|
ON CONFLICT (user_id, chat_id, key) DO NOTHING
|
|
RETURNING true`
|
|
|
|
var inserted bool
|
|
err := tx.QueryRow(ctx, query, userID, chatID, key, requestHash, messageID, int64(ttl/time.Second)).Scan(&inserted)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return false, nil
|
|
}
|
|
if err != nil {
|
|
return false, fmt.Errorf("reserve idempotency key: %w", err)
|
|
}
|
|
return inserted, nil
|
|
}
|
|
|
|
func insertMessage(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
messageID string,
|
|
chatID string,
|
|
senderID string,
|
|
text string,
|
|
) (model.Message, error) {
|
|
const query = `
|
|
INSERT INTO messages (id, chat_id, sender_id, text)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING id, chat_id, sender_id, text, created_at`
|
|
|
|
var message model.Message
|
|
err := tx.QueryRow(ctx, query, messageID, chatID, senderID, text).Scan(
|
|
&message.ID,
|
|
&message.ChatID,
|
|
&message.SenderID,
|
|
&message.Text,
|
|
&message.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return model.Message{}, fmt.Errorf("insert message: %w", err)
|
|
}
|
|
return message, nil
|
|
}
|
|
|
|
func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) {
|
|
const query = `
|
|
SELECT id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE id = $1`
|
|
|
|
var message model.Message
|
|
err := tx.QueryRow(ctx, query, messageID).Scan(
|
|
&message.ID,
|
|
&message.ChatID,
|
|
&message.SenderID,
|
|
&message.Text,
|
|
&message.CreatedAt,
|
|
)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return model.Message{}, fmt.Errorf("idempotency result message not found")
|
|
}
|
|
if err != nil {
|
|
return model.Message{}, fmt.Errorf("get idempotency result message: %w", err)
|
|
}
|
|
return message, 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"
|
|
}
|