237 lines
5.1 KiB
Go
237 lines
5.1 KiB
Go
package store
|
|
|
|
import (
|
|
"errors"
|
|
"slices"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"mtusi2026-messenger/internal/model"
|
|
)
|
|
|
|
var (
|
|
ErrNotFound = errors.New("not found")
|
|
ErrConflict = errors.New("conflict")
|
|
ErrDuplicateMember = errors.New("duplicate member id")
|
|
ErrUnknownMember = errors.New("unknown member id")
|
|
ErrInvalidCursor = errors.New("invalid cursor")
|
|
)
|
|
|
|
type Memory struct {
|
|
mu sync.RWMutex
|
|
|
|
users map[uuid.UUID]model.User
|
|
usersByUsername map[string]uuid.UUID
|
|
chats map[uuid.UUID]model.Chat
|
|
messages map[uuid.UUID]model.Message
|
|
chatMessages map[uuid.UUID][]uuid.UUID
|
|
}
|
|
|
|
func New() *Memory {
|
|
return &Memory{
|
|
users: make(map[uuid.UUID]model.User),
|
|
usersByUsername: make(map[string]uuid.UUID),
|
|
chats: make(map[uuid.UUID]model.Chat),
|
|
messages: make(map[uuid.UUID]model.Message),
|
|
chatMessages: make(map[uuid.UUID][]uuid.UUID),
|
|
}
|
|
}
|
|
|
|
func (m *Memory) CreateUser(username, displayName string) (model.User, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
if _, exists := m.usersByUsername[username]; exists {
|
|
return model.User{}, ErrConflict
|
|
}
|
|
|
|
user := model.User{
|
|
ID: uuid.New(),
|
|
Username: username,
|
|
DisplayName: displayName,
|
|
CreatedAt: time.Now().UTC(),
|
|
}
|
|
|
|
m.users[user.ID] = user
|
|
m.usersByUsername[user.Username] = user.ID
|
|
|
|
return user, nil
|
|
}
|
|
|
|
func (m *Memory) GetUser(id uuid.UUID) (model.User, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
user, exists := m.users[id]
|
|
if !exists {
|
|
return model.User{}, ErrNotFound
|
|
}
|
|
|
|
return user, nil
|
|
}
|
|
|
|
func (m *Memory) CreateChat(title string, memberIDs []uuid.UUID) (model.Chat, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
seen := make(map[uuid.UUID]struct{}, len(memberIDs))
|
|
for _, id := range memberIDs {
|
|
if _, dup := seen[id]; dup {
|
|
return model.Chat{}, ErrDuplicateMember
|
|
}
|
|
seen[id] = struct{}{}
|
|
|
|
if _, exists := m.users[id]; !exists {
|
|
return model.Chat{}, ErrUnknownMember
|
|
}
|
|
}
|
|
|
|
chat := model.Chat{
|
|
ID: uuid.New(),
|
|
Title: title,
|
|
MemberIDs: append([]uuid.UUID(nil), memberIDs...),
|
|
CreatedAt: time.Now().UTC(),
|
|
}
|
|
|
|
m.chats[chat.ID] = chat
|
|
|
|
return chat, nil
|
|
}
|
|
|
|
func (m *Memory) GetChat(id uuid.UUID, userID uuid.UUID) (model.Chat, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
chat, exists := m.chats[id]
|
|
if !exists || !slices.Contains(chat.MemberIDs, userID) {
|
|
return model.Chat{}, ErrNotFound
|
|
}
|
|
|
|
chat.MemberIDs = append([]uuid.UUID(nil), chat.MemberIDs...)
|
|
|
|
return chat, nil
|
|
}
|
|
|
|
func (m *Memory) ListChats(
|
|
userID uuid.UUID,
|
|
afterCreatedAt *time.Time,
|
|
afterID *uuid.UUID,
|
|
limit int,
|
|
) ([]model.Chat, bool, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
chats := make([]model.Chat, 0)
|
|
for _, c := range m.chats {
|
|
if slices.Contains(c.MemberIDs, userID) {
|
|
c.MemberIDs = append([]uuid.UUID(nil), c.MemberIDs...)
|
|
chats = append(chats, c)
|
|
}
|
|
}
|
|
|
|
sort.Slice(chats, func(i, j int) bool {
|
|
if !chats[i].CreatedAt.Equal(chats[j].CreatedAt) {
|
|
return chats[i].CreatedAt.Before(chats[j].CreatedAt)
|
|
}
|
|
return chats[i].ID.String() < chats[j].ID.String()
|
|
})
|
|
|
|
start := 0
|
|
if afterCreatedAt != nil && afterID != nil {
|
|
start = sort.Search(len(chats), func(i int) bool {
|
|
chat := chats[i]
|
|
|
|
return chat.CreatedAt.After(*afterCreatedAt) ||
|
|
(chat.CreatedAt.Equal(*afterCreatedAt) &&
|
|
chat.ID.String() > afterID.String())
|
|
})
|
|
}
|
|
|
|
end := start + limit
|
|
hasMore := end < len(chats)
|
|
if end > len(chats) {
|
|
end = len(chats)
|
|
}
|
|
|
|
return chats[start:end], hasMore, nil
|
|
}
|
|
|
|
func (m *Memory) CreateMessage(
|
|
chatID uuid.UUID,
|
|
senderID uuid.UUID,
|
|
text string,
|
|
) (model.Message, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
chat, exists := m.chats[chatID]
|
|
if !exists || !slices.Contains(chat.MemberIDs, senderID) {
|
|
return model.Message{}, ErrNotFound
|
|
}
|
|
|
|
message := model.Message{
|
|
ID: uuid.New(),
|
|
ChatID: chatID,
|
|
SenderID: senderID,
|
|
Text: text,
|
|
CreatedAt: time.Now().UTC(),
|
|
}
|
|
|
|
m.messages[message.ID] = message
|
|
m.chatMessages[chatID] = append(m.chatMessages[chatID], message.ID)
|
|
|
|
return message, nil
|
|
}
|
|
|
|
func (m *Memory) ListMessages(
|
|
chatID uuid.UUID,
|
|
userID uuid.UUID,
|
|
afterCreatedAt *time.Time,
|
|
afterID *uuid.UUID,
|
|
limit int,
|
|
) ([]model.Message, bool, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
chat, exists := m.chats[chatID]
|
|
if !exists || !slices.Contains(chat.MemberIDs, userID) {
|
|
return nil, false, ErrNotFound
|
|
}
|
|
|
|
ids := m.chatMessages[chatID]
|
|
messages := make([]model.Message, 0, len(ids))
|
|
|
|
for _, id := range ids {
|
|
messages = append(messages, m.messages[id])
|
|
}
|
|
|
|
sort.Slice(messages, func(i, j int) bool {
|
|
if !messages[i].CreatedAt.Equal(messages[j].CreatedAt) {
|
|
return messages[i].CreatedAt.Before(messages[j].CreatedAt)
|
|
}
|
|
return messages[i].ID.String() < messages[j].ID.String()
|
|
})
|
|
|
|
start := 0
|
|
if afterCreatedAt != nil && afterID != nil {
|
|
start = sort.Search(len(messages), func(i int) bool {
|
|
msg := messages[i]
|
|
|
|
return msg.CreatedAt.After(*afterCreatedAt) ||
|
|
(msg.CreatedAt.Equal(*afterCreatedAt) &&
|
|
msg.ID.String() > afterID.String())
|
|
})
|
|
}
|
|
|
|
end := start + limit
|
|
hasMore := end < len(messages)
|
|
if end > len(messages) {
|
|
end = len(messages)
|
|
}
|
|
|
|
return messages[start:end], hasMore, nil
|
|
}
|