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" }