Files
mtusi2026lab3/internal/store/postgres_messages.go
T
2026-10-18 15:05:51 +03:00

221 lines
3.6 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"mtusi2026lab3/internal/domain"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
)
func (s *PostgreSQLStore) CreateMessage(
ctx context.Context,
chatID string,
senderID string,
text string,
) (domain.Message, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
message := domain.Message{
ID: uuid.NewString(),
ChatID: chatID,
SenderID: senderID,
Text: text,
}
err := s.pool.QueryRow(
queryContext,
`
INSERT INTO messages (
id,
chat_id,
sender_id,
text
)
SELECT
$1,
$2,
$3,
$4
FROM chat_members
WHERE chat_id = $2
AND user_id = $3
RETURNING created_at
`,
message.ID,
message.ChatID,
message.SenderID,
message.Text,
).Scan(&message.CreatedAt)
if err == nil {
return message, nil
}
// INSERT ... SELECT возвращает zero rows, если отправитель
// не является участником указанного чата.
if errors.Is(err, pgx.ErrNoRows) {
return domain.Message{}, ErrNotFound
}
return domain.Message{}, fmt.Errorf("insert message: %w", err)
}
func (s *PostgreSQLStore) GetMessages(
ctx context.Context,
chatID string,
callerID string,
limit int,
cursorString string,
) (domain.MessagePage, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var isMember bool
err := s.pool.QueryRow(
queryContext,
`
SELECT EXISTS (
SELECT 1
FROM chat_members
WHERE chat_id = $1
AND user_id = $2
)
`,
chatID,
callerID,
).Scan(&isMember)
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
"check chat membership: %w",
err,
)
}
if !isMember {
return domain.MessagePage{}, ErrNotFound
}
var cursor *domain.CursorData
if cursorString != "" {
decodedCursor, err := domain.DecodeCursor(
cursorString,
chatID,
)
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
"%w: %v",
ErrInvalidCursor,
err,
)
}
cursor = decodedCursor
}
var rows pgx.Rows
if cursor == nil {
rows, err = s.pool.Query(
queryContext,
`
SELECT
id::text,
chat_id::text,
sender_id::text,
text,
created_at
FROM messages
WHERE chat_id = $1
ORDER BY
created_at,
id
LIMIT $2
`,
chatID,
limit+1,
)
} else {
rows, err = s.pool.Query(
queryContext,
`
SELECT
id::text,
chat_id::text,
sender_id::text,
text,
created_at
FROM messages
WHERE chat_id = $1
AND (created_at, id) > ($2, $3)
ORDER BY
created_at,
id
LIMIT $4
`,
chatID,
cursor.CreatedAt,
cursor.MessageID,
limit+1,
)
}
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
"query messages: %w",
err,
)
}
defer rows.Close()
page := domain.MessagePage{
Items: make([]domain.Message, 0, limit),
}
for rows.Next() {
var message domain.Message
if err := rows.Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
); err != nil {
return domain.MessagePage{}, fmt.Errorf(
"scan message page: %w",
err,
)
}
page.Items = append(page.Items, message)
}
if err := rows.Err(); err != nil {
return domain.MessagePage{}, fmt.Errorf(
"iterate message page: %w",
err,
)
}
if len(page.Items) > limit {
page.Items = page.Items[:limit]
lastMessage := page.Items[len(page.Items)-1]
nextCursor := domain.EncodeCursor(
lastMessage.CreatedAt,
lastMessage.ID,
chatID,
)
page.NextCursor = &nextCursor
}
return page, nil
}