Files
mtusi2026lab2/internal/chat/service.go
T

102 lines
3.2 KiB
Go

package chat
import (
"context"
"fmt"
"github.com/google/uuid"
"messenger/internal/platform/apperr"
"messenger/internal/platform/ident"
"messenger/internal/platform/pagination"
)
// UserLookup is what this module needs from the users module: one batched
// existence check. It is declared here, on the consumer side, so this
// package never imports the users package and tests substitute a map.
type UserLookup interface {
ExistingIDs(ctx context.Context, ids []uuid.UUID) ([]uuid.UUID, error)
}
type Service struct {
chats ChatRepository
messages MessageRepository
users UserLookup
}
func NewService(chats ChatRepository, messages MessageRepository, users UserLookup) *Service {
return &Service{chats: chats, messages: messages, users: users}
}
func (s *Service) Create(ctx context.Context, creator uuid.UUID, title string, memberIDs []uuid.UUID) (ChatWithMembers, error) {
chat, err := NewChat(ident.New(), title)
if err != nil {
return ChatWithMembers{}, err
}
members, err := ValidateMembers(memberIDs, creator)
if err != nil {
return ChatWithMembers{}, err
}
found, err := s.users.ExistingIDs(ctx, members)
if err != nil {
return ChatWithMembers{}, fmt.Errorf("check members: %w", err)
}
if len(found) != len(members) {
return ChatWithMembers{}, apperr.Invalid("member_ids must reference registered users")
}
if err := s.chats.Create(ctx, chat, members); err != nil {
return ChatWithMembers{}, err
}
return ChatWithMembers{Chat: chat, MemberIDs: members}, nil
}
func (s *Service) Get(ctx context.Context, actor, chatID uuid.UUID) (ChatWithMembers, error) {
return s.chats.GetForMember(ctx, chatID, actor)
}
func (s *Service) List(ctx context.Context, actor uuid.UUID, after *uuid.UUID, limit int) (pagination.Page[ChatWithMembers], error) {
items, err := s.chats.ListByMember(ctx, actor, after, limit+1)
if err != nil {
return pagination.Page[ChatWithMembers]{}, err
}
return pagination.Cut(items, limit, func(c ChatWithMembers) uuid.UUID { return c.ID }), nil
}
func (s *Service) Send(ctx context.Context, actor, chatID uuid.UUID, text string) (Message, error) {
if err := s.requireMember(ctx, actor, chatID); err != nil {
return Message{}, err
}
message, err := NewMessage(ident.New(), chatID, actor, text)
if err != nil {
return Message{}, err
}
if err := s.messages.Append(ctx, message); err != nil {
return Message{}, err
}
return message, nil
}
func (s *Service) History(ctx context.Context, actor, chatID uuid.UUID, after *uuid.UUID, limit int) (pagination.Page[Message], error) {
if err := s.requireMember(ctx, actor, chatID); err != nil {
return pagination.Page[Message]{}, err
}
items, err := s.messages.ListByChat(ctx, chatID, after, limit+1)
if err != nil {
return pagination.Page[Message]{}, err
}
return pagination.Cut(items, limit, func(m Message) uuid.UUID { return m.ID }), nil
}
// requireMember runs before any field validation, so an outsider gets the
// same answer for a foreign chat as for a missing one.
func (s *Service) requireMember(ctx context.Context, actor, chatID uuid.UUID) error {
ok, err := s.chats.IsMember(ctx, chatID, actor)
if err != nil {
return fmt.Errorf("check membership: %w", err)
}
if !ok {
return ErrNotFound
}
return nil
}