Files
mtusi2026lab5/app/internal/store/memory.go
T

369 lines
8.6 KiB
Go

package store
import (
"context"
"slices"
"strings"
"sync"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"github.com/google/uuid"
)
var _ Store = (*Memory)(nil)
type Memory struct {
mu sync.RWMutex
users map[string]domain.User
byName map[string]string
hashes map[string]string
chats map[string]*chatBucket
chatOrder []string
lastTime time.Time
idempotency map[string]domain.Message
attachments map[string]domain.Attachment
maxMessages int
messagesTotal int
}
type chatBucket struct {
chat domain.Chat
members map[string]struct{}
messages []domain.Message
}
func New() *Memory {
return NewWithLimit(0)
}
func NewWithLimit(maxMessages int) *Memory {
return &Memory{
users: make(map[string]domain.User),
byName: make(map[string]string),
hashes: make(map[string]string),
chats: make(map[string]*chatBucket),
idempotency: make(map[string]domain.Message),
attachments: make(map[string]domain.Attachment),
maxMessages: maxMessages,
}
}
func (m *Memory) MessagesTotal() int {
m.mu.RLock()
defer m.mu.RUnlock()
return m.messagesTotal
}
func (m *Memory) now() time.Time {
t := time.Now().UTC()
if !t.After(m.lastTime) {
t = m.lastTime.Add(time.Nanosecond)
}
m.lastTime = t
return t
}
func (m *Memory) CreateUser(_ context.Context, username, displayName, passwordHash string) (domain.User, error) {
if strings.TrimSpace(username) == "" || strings.TrimSpace(displayName) == "" {
return domain.User{}, domain.ErrInvalidArgument
}
m.mu.Lock()
defer m.mu.Unlock()
if _, taken := m.byName[username]; taken {
return domain.User{}, domain.ErrConflict
}
u := domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
CreatedAt: m.now(),
}
m.users[u.ID] = u
m.byName[username] = u.ID
m.hashes[u.ID] = passwordHash
return u, nil
}
func (m *Memory) UserByID(_ context.Context, id string) (domain.User, error) {
m.mu.RLock()
defer m.mu.RUnlock()
u, ok := m.users[id]
if !ok {
return domain.User{}, domain.ErrNotFound
}
return u, nil
}
func (m *Memory) CredentialsByUsername(_ context.Context, username string) (domain.User, string, error) {
m.mu.RLock()
defer m.mu.RUnlock()
id, ok := m.byName[username]
if !ok {
return domain.User{}, "", domain.ErrNotFound
}
return m.users[id], m.hashes[id], nil
}
func (m *Memory) UsernameExists(_ context.Context, username string) bool {
m.mu.RLock()
defer m.mu.RUnlock()
_, taken := m.byName[username]
return taken
}
func (m *Memory) CreateChat(_ context.Context, callerID, title string, memberIDs []string) (domain.Chat, error) {
if strings.TrimSpace(title) == "" {
return domain.Chat{}, domain.ErrInvalidArgument
}
if len(memberIDs) == 0 || len(memberIDs) > 100 {
return domain.Chat{}, domain.ErrInvalidArgument
}
seen := make(map[string]struct{}, len(memberIDs))
callerInMembers := false
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return domain.Chat{}, domain.ErrInvalidArgument
}
seen[id] = struct{}{}
if id == callerID {
callerInMembers = true
}
}
if !callerInMembers {
return domain.Chat{}, domain.ErrInvalidArgument
}
m.mu.Lock()
defer m.mu.Unlock()
for _, id := range memberIDs {
if _, ok := m.users[id]; !ok {
return domain.Chat{}, domain.ErrInvalidArgument
}
}
members := append([]string(nil), memberIDs...)
chat := domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: members,
CreatedAt: m.now(),
}
m.chats[chat.ID] = &chatBucket{
chat: chat,
members: seen,
}
m.chatOrder = append(m.chatOrder, chat.ID)
return cloneChat(chat), nil
}
func (m *Memory) ChatByID(_ context.Context, callerID, chatID string) (domain.Chat, error) {
m.mu.RLock()
defer m.mu.RUnlock()
b, ok := m.chats[chatID]
if !ok {
return domain.Chat{}, domain.ErrNotFound
}
if _, member := b.members[callerID]; !member {
return domain.Chat{}, domain.ErrNotFound
}
return cloneChat(b.chat), nil
}
func (m *Memory) ListChats(_ context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error) {
if limit <= 0 || limit > 100 {
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
}
c, err := domain.DecodeCursor(cursor)
if err != nil {
return domain.Page[domain.Chat]{}, err
}
if cursor != "" && c.Scope != "chats:"+callerID {
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
}
m.mu.RLock()
defer m.mu.RUnlock()
out := make([]domain.Chat, 0, limit+1)
for _, id := range m.chatOrder {
b := m.chats[id]
if _, member := b.members[callerID]; !member {
continue
}
if !c.Less(b.chat.CreatedAt, b.chat.ID) {
continue
}
out = append(out, cloneChat(b.chat))
if len(out) > limit {
break
}
}
page := domain.Page[domain.Chat]{}
if len(out) > limit {
last := out[limit-1]
page.NextCursor = domain.EncodeCursor(domain.Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
Scope: "chats:" + callerID,
})
out = out[:limit]
}
page.Items = out
return page, nil
}
func (m *Memory) AddMessage(_ context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
if strings.TrimSpace(text) == "" && len(attachmentIDs) == 0 {
return domain.Message{}, domain.ErrInvalidArgument
}
m.mu.Lock()
defer m.mu.Unlock()
b, ok := m.chats[chatID]
if !ok {
return domain.Message{}, domain.ErrNotFound
}
if _, member := b.members[callerID]; !member {
return domain.Message{}, domain.ErrNotFound
}
idemKey := callerID + "\x00" + chatID + "\x00" + idempotencyKey
if prev, ok := m.idempotency[idemKey]; ok {
if prev.Text != text || !slices.Equal(prev.AttachmentIDs, attachmentIDs) {
return domain.Message{}, domain.ErrIdempotencyConflict
}
return prev, nil
}
if m.maxMessages > 0 && m.messagesTotal >= m.maxMessages {
return domain.Message{}, domain.ErrUnavailable
}
for _, id := range attachmentIDs {
if att, ok := m.attachments[id]; !ok || att.ChatID != chatID {
return domain.Message{}, domain.ErrNotFound
}
}
msg := domain.Message{
ID: uuid.NewString(),
ChatID: chatID,
AuthorID: callerID,
Text: text,
CreatedAt: m.now(),
AttachmentIDs: attachmentIDs,
}
b.messages = append(b.messages, msg)
m.idempotency[idemKey] = msg
m.messagesTotal++
return msg, nil
}
func (m *Memory) ListMessages(_ context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if limit <= 0 || limit > 100 {
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
}
c, err := domain.DecodeCursor(cursor)
if err != nil {
return domain.Page[domain.Message]{}, err
}
if cursor != "" && c.Scope != "chat:"+chatID {
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
}
m.mu.RLock()
defer m.mu.RUnlock()
b, ok := m.chats[chatID]
if !ok {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
if _, member := b.members[callerID]; !member {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
start := 0
for ; start < len(b.messages); start++ {
if c.Less(b.messages[start].CreatedAt, b.messages[start].ID) {
break
}
}
end := start + limit
hasMore := end < len(b.messages)
if end > len(b.messages) {
end = len(b.messages)
}
out := make([]domain.Message, end-start)
copy(out, b.messages[start:end])
page := domain.Page[domain.Message]{Items: out}
if hasMore && len(out) > 0 {
last := out[len(out)-1]
page.NextCursor = domain.EncodeCursor(domain.Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
Scope: "chat:" + chatID,
})
}
return page, nil
}
func (m *Memory) CreateAttachment(_ context.Context, att domain.Attachment) (domain.Attachment, error) {
m.mu.Lock()
defer m.mu.Unlock()
if b, ok := m.chats[att.ChatID]; !ok {
return domain.Attachment{}, domain.ErrNotFound
} else if _, member := b.members[att.OwnerID]; !member {
return domain.Attachment{}, domain.ErrNotFound
}
att.CreatedAt = m.now()
att.UpdatedAt = att.CreatedAt
m.attachments[att.ID] = att
return att, nil
}
func (m *Memory) AttachmentForMember(_ context.Context, callerID, attachmentID string) (domain.Attachment, error) {
m.mu.RLock()
defer m.mu.RUnlock()
att, ok := m.attachments[attachmentID]
if !ok {
return domain.Attachment{}, domain.ErrNotFound
}
if _, member := m.chats[att.ChatID].members[callerID]; !member {
return domain.Attachment{}, domain.ErrNotFound
}
return att, nil
}
func (m *Memory) AttachmentExists(_ context.Context, attachmentID string) (bool, error) {
m.mu.RLock()
defer m.mu.RUnlock()
_, ok := m.attachments[attachmentID]
return ok, nil
}
func cloneChat(c domain.Chat) domain.Chat {
out := c
out.MemberIDs = append([]string(nil), c.MemberIDs...)
return out
}