forked from mtusi2026/mtusi2026lab3
322 lines
5.8 KiB
Go
322 lines
5.8 KiB
Go
package postgres
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"mtusi2026lab3/internal/application"
|
|
"mtusi2026lab3/internal/domain"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
func (s *PostgreSQLStore) CreateMessageIdempotently(
|
|
ctx context.Context,
|
|
write application.IdempotentMessageWrite,
|
|
) (domain.Message, error) {
|
|
queryContext, cancel := s.withTimeout(ctx)
|
|
defer cancel()
|
|
|
|
transaction, err := s.pool.BeginTx(queryContext, pgx.TxOptions{})
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("begin idempotent message transaction: %w", err)
|
|
}
|
|
defer func() { _ = transaction.Rollback(queryContext) }()
|
|
|
|
var isMember bool
|
|
err = transaction.QueryRow(
|
|
queryContext,
|
|
`
|
|
SELECT EXISTS (
|
|
SELECT 1
|
|
FROM chat_members
|
|
WHERE chat_id = $1
|
|
AND user_id = $2
|
|
)
|
|
`,
|
|
write.ChatID,
|
|
write.ActorID,
|
|
).Scan(&isMember)
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("check chat membership: %w", err)
|
|
}
|
|
if !isMember {
|
|
return domain.Message{}, ErrNotFound
|
|
}
|
|
|
|
_, err = transaction.Exec(
|
|
queryContext,
|
|
`
|
|
DELETE FROM message_idempotency
|
|
WHERE user_id = $1
|
|
AND method = $2
|
|
AND canonical_path = $3
|
|
AND idempotency_key = $4
|
|
AND expires_at <= CURRENT_TIMESTAMP
|
|
`,
|
|
write.ActorID,
|
|
write.Method,
|
|
write.CanonicalPath,
|
|
write.Key,
|
|
)
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("delete expired idempotency key: %w", err)
|
|
}
|
|
|
|
message := domain.Message{
|
|
ID: uuid.NewString(),
|
|
ChatID: write.ChatID,
|
|
SenderID: write.ActorID,
|
|
Text: write.Text,
|
|
}
|
|
|
|
var storedHash []byte
|
|
var storedMessageID string
|
|
err = transaction.QueryRow(
|
|
queryContext,
|
|
`
|
|
INSERT INTO message_idempotency (
|
|
user_id,
|
|
method,
|
|
canonical_path,
|
|
idempotency_key,
|
|
request_hash,
|
|
message_id,
|
|
expires_at
|
|
)
|
|
VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
CURRENT_TIMESTAMP + $7 * INTERVAL '1 second'
|
|
)
|
|
ON CONFLICT DO NOTHING
|
|
RETURNING request_hash, message_id::text
|
|
`,
|
|
write.ActorID,
|
|
write.Method,
|
|
write.CanonicalPath,
|
|
write.Key,
|
|
write.RequestHash[:],
|
|
message.ID,
|
|
int64(write.TTL/time.Second),
|
|
).Scan(&storedHash, &storedMessageID)
|
|
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
err = transaction.QueryRow(
|
|
queryContext,
|
|
`
|
|
SELECT request_hash, message_id::text
|
|
FROM message_idempotency
|
|
WHERE user_id = $1
|
|
AND method = $2
|
|
AND canonical_path = $3
|
|
AND idempotency_key = $4
|
|
`,
|
|
write.ActorID,
|
|
write.Method,
|
|
write.CanonicalPath,
|
|
write.Key,
|
|
).Scan(&storedHash, &storedMessageID)
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("read idempotency result: %w", err)
|
|
}
|
|
|
|
if !bytes.Equal(storedHash, write.RequestHash[:]) {
|
|
return domain.Message{}, application.ErrIdempotencyConflict
|
|
}
|
|
|
|
err = transaction.QueryRow(
|
|
queryContext,
|
|
`
|
|
SELECT
|
|
id::text,
|
|
chat_id::text,
|
|
sender_id::text,
|
|
text,
|
|
created_at
|
|
FROM messages
|
|
WHERE id = $1
|
|
`,
|
|
storedMessageID,
|
|
).Scan(
|
|
&message.ID,
|
|
&message.ChatID,
|
|
&message.SenderID,
|
|
&message.Text,
|
|
&message.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("read idempotent message: %w", err)
|
|
}
|
|
|
|
if err = transaction.Commit(queryContext); err != nil {
|
|
return domain.Message{}, fmt.Errorf("commit idempotency replay: %w", err)
|
|
}
|
|
return message, nil
|
|
}
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("claim idempotency key: %w", err)
|
|
}
|
|
|
|
err = transaction.QueryRow(
|
|
queryContext,
|
|
`
|
|
INSERT INTO messages (
|
|
id,
|
|
chat_id,
|
|
sender_id,
|
|
text
|
|
)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING created_at
|
|
`,
|
|
message.ID,
|
|
message.ChatID,
|
|
message.SenderID,
|
|
message.Text,
|
|
).Scan(&message.CreatedAt)
|
|
if err != nil {
|
|
return domain.Message{}, fmt.Errorf("insert message: %w", err)
|
|
}
|
|
|
|
if err = transaction.Commit(queryContext); err != nil {
|
|
return domain.Message{}, fmt.Errorf("commit idempotent message: %w", err)
|
|
}
|
|
|
|
return message, nil
|
|
}
|
|
|
|
func (s *PostgreSQLStore) GetMessages(
|
|
ctx context.Context,
|
|
chatID string,
|
|
callerID string,
|
|
limit int,
|
|
cursor *domain.MessageCursor,
|
|
) ([]domain.Message, bool, 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 nil, false, fmt.Errorf(
|
|
"check chat membership: %w",
|
|
err,
|
|
)
|
|
}
|
|
|
|
if !isMember {
|
|
return nil, false, ErrNotFound
|
|
}
|
|
|
|
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 nil, false, fmt.Errorf(
|
|
"query messages: %w",
|
|
err,
|
|
)
|
|
}
|
|
defer rows.Close()
|
|
|
|
items := make([]domain.Message, 0, limit+1)
|
|
|
|
for rows.Next() {
|
|
var message domain.Message
|
|
|
|
if err := rows.Scan(
|
|
&message.ID,
|
|
&message.ChatID,
|
|
&message.SenderID,
|
|
&message.Text,
|
|
&message.CreatedAt,
|
|
); err != nil {
|
|
return nil, false, fmt.Errorf(
|
|
"scan message page: %w",
|
|
err,
|
|
)
|
|
}
|
|
|
|
items = append(items, message)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, false, fmt.Errorf(
|
|
"iterate message page: %w",
|
|
err,
|
|
)
|
|
}
|
|
|
|
hasMore := len(items) > limit
|
|
if hasMore {
|
|
items = items[:limit]
|
|
}
|
|
return items, hasMore, nil
|
|
}
|