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 }