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