package postgres import ( "bytes" "context" "errors" "fmt" "time" "mtusi2026lab4/internal/application" "mtusi2026lab4/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 } attachmentUUIDs := make([]uuid.UUID, len(write.AttachmentIDs)) for index, attachmentID := range write.AttachmentIDs { parsedID, parseErr := uuid.Parse(attachmentID) if parseErr != nil { return domain.Message{}, fmt.Errorf("parse validated attachment id: %w", parseErr) } attachmentUUIDs[index] = parsedID } if len(attachmentUUIDs) > 0 { rows, queryError := transaction.Query( queryContext, ` SELECT id::text, status FROM attachments WHERE chat_id = $1 AND id = ANY($2::uuid[]) ORDER BY id FOR UPDATE `, write.ChatID, attachmentUUIDs, ) if queryError != nil { return domain.Message{}, fmt.Errorf("lock message attachments: %w", queryError) } availableCount := 0 readyCount := 0 for rows.Next() { var attachmentID string var status domain.AttachmentStatus if queryError = rows.Scan(&attachmentID, &status); queryError != nil { rows.Close() return domain.Message{}, fmt.Errorf("scan locked message attachment: %w", queryError) } availableCount++ if status == domain.AttachmentStatusReady { readyCount++ } } queryError = rows.Err() rows.Close() if queryError != nil { return domain.Message{}, fmt.Errorf("iterate locked message attachments: %w", queryError) } if availableCount != len(attachmentUUIDs) { return domain.Message{}, ErrNotFound } if readyCount != len(attachmentUUIDs) { return domain.Message{}, application.ErrAttachmentNotReady } } _, 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, AttachmentIDs: append([]string(nil), write.AttachmentIDs...), } 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, COALESCE( ARRAY( SELECT attachment_id::text FROM message_attachments WHERE message_id = messages.id ORDER BY position ), ARRAY[]::text[] ) FROM messages WHERE id = $1 `, storedMessageID, ).Scan( &message.ID, &message.ChatID, &message.SenderID, &message.Text, &message.CreatedAt, &message.AttachmentIDs, ) 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 len(attachmentUUIDs) > 0 { _, err = transaction.Exec( queryContext, ` INSERT INTO message_attachments ( message_id, chat_id, attachment_id, position ) SELECT $1, $2, attachment_id, (ordinality - 1)::smallint FROM unnest($3::uuid[]) WITH ORDINALITY AS input(attachment_id, ordinality) `, message.ID, message.ChatID, attachmentUUIDs, ) if err != nil { return domain.Message{}, fmt.Errorf("link message attachments: %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, COALESCE( ARRAY( SELECT attachment_id::text FROM message_attachments WHERE message_id = messages.id ORDER BY position ), ARRAY[]::text[] ) 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, COALESCE( ARRAY( SELECT attachment_id::text FROM message_attachments WHERE message_id = messages.id ORDER BY position ), ARRAY[]::text[] ) 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, &message.AttachmentIDs, ); 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 }