refactor: разделил приложение на domain application adapters и HTTP DTO

This commit is contained in:
2026-10-20 21:44:59 +03:00
parent 13ee5a0e56
commit 3f69970b05
59 changed files with 1324 additions and 1087 deletions
+1
View File
@@ -10,6 +10,7 @@ POSTGRES_DB=messenger
SESSION_TTL_SECONDS=3600
SESSION_STORE=postgres
CURSOR_SIGNING_KEY_FILE=/run/secrets/cursor_signing_key
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
+47 -2
View File
@@ -7,11 +7,56 @@
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Локальные секреты не входят в Git. Перед первым запуском оператор создаёт каталог
`secrets/`, генерирует пароль PostgreSQL и общий для всех API-реплик ключ подписи
курсоров длиной не менее 32 байт. Значение `database_url` должно использовать имя
Compose-сервиса `postgres`, а не `localhost`. Пример генерации синтетических
локальных значений без их вывода в терминал:
```bash
mkdir -p secrets
openssl rand -hex 32 > secrets/postgres_password.txt
openssl rand -base64 48 > secrets/cursor_signing_key.txt
printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' \
"$(cat secrets/postgres_password.txt)" > secrets/database_url.txt
chmod 600 secrets/*.txt
cp .env.example .env
```
Полная последовательность запуска, проверки LB и безопасной остановки будет
зафиксирована после завершения новой Compose-топологии lab3.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Перенесённая основа lab2 разделена на явные слои:
- `internal/domain` — сущности и бизнес-инварианты без HTTP/JSON-зависимостей;
- `internal/application` — сценарии, команды и узкие порты репозиториев;
- `internal/adapter/postgres`, `memory`, `redis`, `cache` — реализации внешних
зависимостей и кэширующий декоратор;
- `internal/transport/http/dto` — wire-модели HTTP-контракта и преобразование
domain → response DTO;
- `internal/transport/http/handlers` — тонкие обработчики, по одному
нетривиальному endpoint на файл;
- `cmd/server` — composition root, единственное место сборки зависимостей.
PostgreSQL остаётся источником истины для пользователей, сессий, чатов и
сообщений. Redis содержит только удаляемую производную копию неизменяемых данных
чата; его отказ не делает API неготовым и не отменяет подтверждённую запись в
PostgreSQL.
Пагинационный курсор теперь формируется в application-слое из канонических
полей границы `(created_at, id, scope_id)` и подписывается HMAC-SHA-256. Подпись
не скрывает payload, но обнаруживает подмену. В scope входит пользователь для
списка чатов и чат для истории сообщений. Все реплики обязаны использовать один
`CURSOR_SIGNING_KEY` или `CURSOR_SIGNING_KEY_FILE`; в Compose используется Docker
secret `cursor_signing_key`. Репозитории получают только уже проверенную
типизированную границу и ничего не знают о формате HTTP-курсора.
`.env.example` перечисляет реально читаемые приложением параметры PostgreSQL,
пула, readiness/shutdown, Redis-кэша и ключа курсора. `API_REPLICAS` и
`IDEMPOTENCY_TTL_SECONDS` зарезервированы для следующих этапов lab3. Секретных
значений в шаблоне нет: там указаны только пути внутри контейнера.
## Доказательства критериев
+20 -9
View File
@@ -10,10 +10,12 @@ import (
"syscall"
"time"
applicationCache "mtusi2026lab3/internal/cache"
cacheadapter "mtusi2026lab3/internal/adapter/cache"
"mtusi2026lab3/internal/adapter/postgres"
redisadapter "mtusi2026lab3/internal/adapter/redis"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/config"
"mtusi2026lab3/internal/database"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/handlers"
"mtusi2026lab3/internal/transport/http/middleware"
)
@@ -37,15 +39,15 @@ func main() {
}
defer databasePool.Close()
postgresStore := store.NewPostgreSQLStore(
postgresStore := postgres.NewPostgreSQLStore(
databasePool,
cfg.DatabaseQueryTimeout,
)
var applicationStore store.Repository = postgresStore
var applicationStore application.Repository = postgresStore
if cfg.RedisURL != "" {
redisChatCache, cacheError := applicationCache.NewRedisChatCache(
redisChatCache, cacheError := redisadapter.NewRedisChatCache(
cfg.RedisURL,
cfg.RedisCacheTTL,
cfg.RedisOperationTimeout,
@@ -71,20 +73,29 @@ func main() {
}
cacheCancel()
applicationStore = store.NewCachedRepository(
applicationStore = cacheadapter.NewCachedRepository(
postgresStore,
redisChatCache,
log.Default(),
)
}
cursorCodec, err := application.NewCursorCodec(cfg.CursorSigningKey)
if err != nil {
log.Fatalf("[FATAL] Invalid cursor configuration: %v", err)
}
service, err := application.NewService(applicationStore, cursorCodec, cfg.SessionTTL)
if err != nil {
log.Fatalf("[FATAL] Application initialization failed: %v", err)
}
handler := handlers.NewHandler(
applicationStore,
service,
handlers.WithReadiness(
databasePool,
cfg.ReadinessTimeout,
),
handlers.WithSessionTTL(cfg.SessionTTL),
)
mux := http.NewServeMux()
@@ -100,7 +111,7 @@ func main() {
mux.HandleFunc("POST /api/v1/users", handler.CreateUser)
requireAuth := func(next http.HandlerFunc) http.HandlerFunc {
return middleware.RequireAuth(postgresStore, next)
return middleware.RequireAuth(service, next)
}
mux.HandleFunc(
+4
View File
@@ -73,6 +73,7 @@ services:
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-postgres}
CURSOR_SIGNING_KEY_FILE: ${CURSOR_SIGNING_KEY_FILE:-/run/secrets/cursor_signing_key}
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
CACHE_TTL: ${CACHE_TTL:-5m}
@@ -93,6 +94,7 @@ services:
SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-10s}
secrets:
- database_url
- cursor_signing_key
ports:
- "${APP_PORT:-8080}:${APP_PORT:-8080}"
depends_on:
@@ -158,3 +160,5 @@ secrets:
file: ./secrets/postgres_password.txt
database_url:
file: ./secrets/database_url.txt
cursor_signing_key:
file: ./secrets/cursor_signing_key.txt
@@ -1,25 +1,26 @@
package store
package cache
import (
"context"
"errors"
"log"
applicationCache "mtusi2026lab3/internal/cache"
"mtusi2026lab3/internal/adapter/redis"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
)
// CachedRepository декорирует основной Repository. Все операции, кроме чтения
// и создания чата, автоматически делегируются встроенному Repository.
type CachedRepository struct {
Repository
chatCache applicationCache.ChatCache
application.Repository
chatCache redis.ChatCache
logger *log.Logger
}
func NewCachedRepository(
repository Repository,
chatCache applicationCache.ChatCache,
repository application.Repository,
chatCache redis.ChatCache,
logger *log.Logger,
) *CachedRepository {
if logger == nil {
@@ -60,13 +61,13 @@ func (r *CachedRepository) GetChatByID(
chat, err := r.chatCache.Get(ctx, chatID)
if err == nil {
if !containsMember(chat.MemberIDs, callerID) {
return domain.Chat{}, ErrNotFound
return domain.Chat{}, domain.ErrNotFound
}
return chat, nil
}
shouldFillCache := errors.Is(err, applicationCache.ErrMiss)
shouldFillCache := errors.Is(err, redis.ErrMiss)
if !shouldFillCache {
r.logger.Printf("[WARN] Redis chat cache read failed: %v", err)
}
@@ -95,4 +96,4 @@ func containsMember(memberIDs []string, callerID string) bool {
return false
}
var _ Repository = (*CachedRepository)(nil)
var _ application.Repository = (*CachedRepository)(nil)
@@ -1,4 +1,4 @@
package store
package cache
import (
"context"
@@ -7,7 +7,9 @@ import (
"log"
"testing"
applicationCache "mtusi2026lab3/internal/cache"
"mtusi2026lab3/internal/adapter/memory"
"mtusi2026lab3/internal/adapter/redis"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
)
@@ -28,7 +30,7 @@ func (c *fakeChatCache) Get(
chat, exists := c.chats[chatID]
if !exists {
return domain.Chat{}, applicationCache.ErrMiss
return domain.Chat{}, redis.ErrMiss
}
return chat, nil
@@ -48,7 +50,7 @@ func (c *fakeChatCache) Set(
}
type countingRepository struct {
Repository
application.Repository
getChatCalls int
}
@@ -66,7 +68,7 @@ func cachedRepositoryFixture(
) (*countingRepository, *fakeChatCache, domain.User, domain.User, domain.Chat) {
t.Helper()
legacy := NewMemoryStore()
legacy := memory.NewMemoryStore()
member, err := legacy.CreateUser("cache_member", "Участник")
if err != nil {
t.Fatalf("create member: %v", err)
@@ -81,7 +83,7 @@ func cachedRepositoryFixture(
}
repository := &countingRepository{
Repository: NewMemoryRepository(legacy),
Repository: memory.NewMemoryRepository(legacy),
}
chatCache := &fakeChatCache{
chats: make(map[string]domain.Chat),
@@ -150,7 +152,7 @@ func TestCachedRepositoryChecksMembershipOnHit(t *testing.T) {
)
_, err := cached.GetChatByID(context.Background(), expected.ID, outsider.ID)
if !errors.Is(err, ErrNotFound) {
if !errors.Is(err, domain.ErrNotFound) {
t.Fatalf("expected ErrNotFound for outsider, got %v", err)
}
if repository.getChatCalls != 0 {
+8
View File
@@ -0,0 +1,8 @@
package memory
import "mtusi2026lab3/internal/domain"
var (
ErrNotFound = domain.ErrNotFound
ErrConflict = domain.ErrConflict
)
@@ -1,4 +1,4 @@
package store
package memory
import (
"context"
@@ -6,6 +6,7 @@ import (
"sync"
"time"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
)
@@ -119,10 +120,10 @@ func (r *MemoryRepository) GetChatsForUser(
ctx context.Context,
userID string,
limit int,
cursor string,
) (domain.ChatPage, error) {
cursor *domain.ChatCursor,
) ([]domain.Chat, bool, error) {
if err := ctx.Err(); err != nil {
return domain.ChatPage{}, err
return nil, false, err
}
return r.legacy.GetChatsForUser(userID, limit, cursor)
@@ -146,10 +147,10 @@ func (r *MemoryRepository) GetMessages(
chatID string,
callerID string,
limit int,
cursor string,
) (domain.MessagePage, error) {
cursor *domain.MessageCursor,
) ([]domain.Message, bool, error) {
if err := ctx.Err(); err != nil {
return domain.MessagePage{}, err
return nil, false, err
}
return r.legacy.GetMessages(
@@ -244,4 +245,4 @@ func memoryTokenHashKey(tokenHash []byte) ([32]byte, error) {
return key, nil
}
var _ Repository = (*MemoryRepository)(nil)
var _ application.Repository = (*MemoryRepository)(nil)
@@ -1,4 +1,4 @@
package store
package memory
import (
"fmt"
@@ -124,20 +124,8 @@ func (s *MemoryStore) GetChatByID(chatID, callerID string) (domain.Chat, error)
func (s *MemoryStore) GetChatsForUser(
userID string,
limit int,
cursorStr string,
) (domain.ChatPage, error) {
var cursorData *domain.ChatCursorData
if cursorStr != "" {
decodedCursor, err := domain.DecodeChatCursor(cursorStr, userID)
if err != nil {
return domain.ChatPage{},
fmt.Errorf("%w: %v", ErrInvalidCursor, err)
}
cursorData = decodedCursor
}
cursorData *domain.ChatCursor,
) ([]domain.Chat, bool, error) {
s.mu.RLock()
defer s.mu.RUnlock()
@@ -175,13 +163,8 @@ func (s *MemoryStore) GetChatsForUser(
})
}
page := domain.ChatPage{
Items: make([]domain.Chat, 0),
NextCursor: nil,
}
if start >= len(chats) {
return page, nil
return make([]domain.Chat, 0), false, nil
}
end := start + limit
@@ -189,20 +172,9 @@ func (s *MemoryStore) GetChatsForUser(
end = len(chats)
}
page.Items = make([]domain.Chat, end-start)
copy(page.Items, chats[start:end])
if end < len(chats) {
lastChat := page.Items[len(page.Items)-1]
nextCursor := domain.EncodeChatCursor(
lastChat.CreatedAt,
lastChat.ID,
userID,
)
page.NextCursor = &nextCursor
}
return page, nil
items := make([]domain.Chat, end-start)
copy(items, chats[start:end])
return items, end < len(chats), nil
}
// ---Сообщения---
@@ -259,14 +231,14 @@ func (s *MemoryStore) CreateMessage(
func (s *MemoryStore) GetMessages(
chatID, callerID string,
limit int,
cursorStr string,
) (domain.MessagePage, error) {
cursorData *domain.MessageCursor,
) ([]domain.Message, bool, error) {
s.mu.RLock()
defer s.mu.RUnlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return domain.MessagePage{}, ErrNotFound
return nil, false, ErrNotFound
}
isMember := false
@@ -277,21 +249,7 @@ func (s *MemoryStore) GetMessages(
}
}
if !isMember {
return domain.MessagePage{}, ErrNotFound
}
var cursorData *domain.CursorData
if cursorStr != "" {
decodedCursor, err := domain.DecodeCursor(cursorStr, chatID)
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
"%w: %v",
ErrInvalidCursor,
err,
)
}
cursorData = decodedCursor
return nil, false, ErrNotFound
}
messages := s.messagesByChatID[chatID]
@@ -313,13 +271,8 @@ func (s *MemoryStore) GetMessages(
})
}
page := domain.MessagePage{
Items: make([]domain.Message, 0),
NextCursor: nil,
}
if start >= len(messages) {
return page, nil
return make([]domain.Message, 0), false, nil
}
end := len(messages)
@@ -328,18 +281,7 @@ func (s *MemoryStore) GetMessages(
}
// копируем только возвращаемую страницу, а не всю историю, изменяя внутренний срез
page.Items = make([]domain.Message, end-start)
copy(page.Items, messages[start:end])
if end < len(messages) {
lastItem := page.Items[len(page.Items)-1]
nextCursor := domain.EncodeCursor(
lastItem.CreatedAt,
lastItem.ID,
chatID,
)
page.NextCursor = &nextCursor
}
return page, nil
items := make([]domain.Message, end-start)
copy(items, messages[start:end])
return items, end < len(messages), nil
}
@@ -1,4 +1,4 @@
package store
package postgres
import (
"context"
@@ -160,26 +160,8 @@ func (s *PostgreSQLStore) GetChatsForUser(
ctx context.Context,
userID string,
limit int,
cursorString string,
) (domain.ChatPage, error) {
var cursor *domain.ChatCursorData
if cursorString != "" {
decodedCursor, err := domain.DecodeChatCursor(
cursorString,
userID,
)
if err != nil {
return domain.ChatPage{}, fmt.Errorf(
"%w: %v",
ErrInvalidCursor,
err,
)
}
cursor = decodedCursor
}
cursor *domain.ChatCursor,
) ([]domain.Chat, bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
@@ -254,16 +236,14 @@ func (s *PostgreSQLStore) GetChatsForUser(
}
if err != nil {
return domain.ChatPage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"query chats for user: %w",
err,
)
}
defer rows.Close()
page := domain.ChatPage{
Items: make([]domain.Chat, 0, limit),
}
items := make([]domain.Chat, 0, limit+1)
for rows.Next() {
var chat domain.Chat
@@ -274,33 +254,25 @@ func (s *PostgreSQLStore) GetChatsForUser(
&chat.CreatedAt,
&chat.MemberIDs,
); err != nil {
return domain.ChatPage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"scan chat page: %w",
err,
)
}
page.Items = append(page.Items, chat)
items = append(items, chat)
}
if err := rows.Err(); err != nil {
return domain.ChatPage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"iterate chat page: %w",
err,
)
}
if len(page.Items) > limit {
page.Items = page.Items[:limit]
lastChat := page.Items[len(page.Items)-1]
nextCursor := domain.EncodeChatCursor(
lastChat.CreatedAt,
lastChat.ID,
userID,
)
page.NextCursor = &nextCursor
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
}
return page, nil
return items, hasMore, nil
}
+5
View File
@@ -0,0 +1,5 @@
package postgres
import "mtusi2026lab3/internal/application"
var _ application.Repository = (*PostgreSQLStore)(nil)
+8
View File
@@ -0,0 +1,8 @@
package postgres
import "mtusi2026lab3/internal/domain"
var (
ErrNotFound = domain.ErrNotFound
ErrConflict = domain.ErrConflict
)
@@ -1,4 +1,4 @@
package store
package postgres
import (
"context"
@@ -70,8 +70,8 @@ func (s *PostgreSQLStore) GetMessages(
chatID string,
callerID string,
limit int,
cursorString string,
) (domain.MessagePage, error) {
cursor *domain.MessageCursor,
) ([]domain.Message, bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
@@ -91,32 +91,14 @@ func (s *PostgreSQLStore) GetMessages(
callerID,
).Scan(&isMember)
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"check chat membership: %w",
err,
)
}
if !isMember {
return domain.MessagePage{}, ErrNotFound
}
var cursor *domain.CursorData
if cursorString != "" {
decodedCursor, err := domain.DecodeCursor(
cursorString,
chatID,
)
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
"%w: %v",
ErrInvalidCursor,
err,
)
}
cursor = decodedCursor
return nil, false, ErrNotFound
}
var rows pgx.Rows
@@ -167,16 +149,14 @@ func (s *PostgreSQLStore) GetMessages(
}
if err != nil {
return domain.MessagePage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"query messages: %w",
err,
)
}
defer rows.Close()
page := domain.MessagePage{
Items: make([]domain.Message, 0, limit),
}
items := make([]domain.Message, 0, limit+1)
for rows.Next() {
var message domain.Message
@@ -188,33 +168,25 @@ func (s *PostgreSQLStore) GetMessages(
&message.Text,
&message.CreatedAt,
); err != nil {
return domain.MessagePage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"scan message page: %w",
err,
)
}
page.Items = append(page.Items, message)
items = append(items, message)
}
if err := rows.Err(); err != nil {
return domain.MessagePage{}, fmt.Errorf(
return nil, false, fmt.Errorf(
"iterate message page: %w",
err,
)
}
if len(page.Items) > limit {
page.Items = page.Items[:limit]
lastMessage := page.Items[len(page.Items)-1]
nextCursor := domain.EncodeCursor(
lastMessage.CreatedAt,
lastMessage.ID,
chatID,
)
page.NextCursor = &nextCursor
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
}
return page, nil
return items, hasMore, nil
}
@@ -1,4 +1,4 @@
package store
package postgres
import (
"context"
@@ -1,4 +1,4 @@
package store
package postgres
import (
"context"
@@ -1,4 +1,4 @@
package store
package postgres
import (
"context"
@@ -1,4 +1,4 @@
package cache
package redis
import (
"context"
@@ -11,10 +11,10 @@ import (
"mtusi2026lab3/internal/domain"
"github.com/google/uuid"
"github.com/redis/go-redis/v9"
goredis "github.com/redis/go-redis/v9"
)
const chatKeyPrefix = "chat:v1:"
const chatKeyPrefix = "chat:v2:"
var ErrMiss = errors.New("cache miss")
@@ -26,7 +26,7 @@ type ChatCache interface {
}
type RedisChatCache struct {
client *redis.Client
client *goredis.Client
ttl time.Duration
operationTimeout time.Duration
}
@@ -37,7 +37,7 @@ func NewRedisChatCache(
operationTimeout time.Duration,
poolSize int,
) (*RedisChatCache, error) {
options, err := redis.ParseURL(strings.TrimSpace(redisURL))
options, err := goredis.ParseURL(strings.TrimSpace(redisURL))
if err != nil {
return nil, fmt.Errorf("parse Redis URL: %w", err)
}
@@ -50,7 +50,7 @@ func NewRedisChatCache(
options.MaxRetries = -1
return &RedisChatCache{
client: redis.NewClient(options),
client: goredis.NewClient(options),
ttl: ttl,
operationTimeout: operationTimeout,
}, nil
@@ -82,7 +82,7 @@ func (c *RedisChatCache) Get(
operationContext,
chatKey(chatID),
).Bytes()
if errors.Is(err, redis.Nil) {
if errors.Is(err, goredis.Nil) {
return domain.Chat{}, ErrMiss
}
if err != nil {
+55
View File
@@ -0,0 +1,55 @@
package application
import (
"context"
"fmt"
"mtusi2026lab3/internal/domain"
)
func (s *Service) CreateChat(ctx context.Context, command CreateChatCommand) (domain.Chat, error) {
if err := domain.ValidateChatInput(command.Title, command.MemberIDs, command.ActorID); err != nil {
return domain.Chat{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
return s.repository.CreateChat(ctx, command.Title, command.MemberIDs)
}
func (s *Service) GetChat(ctx context.Context, actorID, chatID string) (domain.Chat, error) {
return s.repository.GetChatByID(ctx, chatID, actorID)
}
func (s *Service) ListChats(
ctx context.Context,
actorID string,
limit int,
cursorToken string,
) (domain.ChatPage, error) {
var cursor *domain.ChatCursor
if cursorToken != "" {
decoded, err := s.cursors.DecodeChat(cursorToken, actorID)
if err != nil {
return domain.ChatPage{}, ErrInvalidCursor
}
cursor = decoded
}
items, hasMore, err := s.repository.GetChatsForUser(ctx, actorID, limit, cursor)
if err != nil {
return domain.ChatPage{}, err
}
page := domain.ChatPage{Items: items}
if page.Items == nil {
page.Items = make([]domain.Chat, 0)
}
if hasMore {
last := page.Items[len(page.Items)-1]
next, encodeErr := s.cursors.EncodeChat(domain.ChatCursor{
CreatedAt: last.CreatedAt, ChatID: last.ID, UserID: actorID,
})
if encodeErr != nil {
return domain.ChatPage{}, encodeErr
}
page.NextCursor = &next
}
return page, nil
}
+24
View File
@@ -0,0 +1,24 @@
package application
type CreateUserCommand struct {
Username string
DisplayName string
Password string
}
type CreateSessionCommand struct {
Username string
Password string
}
type CreateChatCommand struct {
ActorID string
Title string
MemberIDs []string
}
type SendMessageCommand struct {
ActorID string
ChatID string
Text string
}
+121
View File
@@ -0,0 +1,121 @@
package application
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
"strings"
"time"
"mtusi2026lab3/internal/domain"
"github.com/google/uuid"
)
const cursorVersion = 1
type CursorCodec struct {
key []byte
}
type cursorPayload struct {
Version int `json:"v"`
Kind string `json:"kind"`
CreatedAt string `json:"created_at"`
ID string `json:"id"`
ScopeID string `json:"scope_id"`
}
func NewCursorCodec(key string) (*CursorCodec, error) {
if len(key) < 32 {
return nil, fmt.Errorf("cursor signing key must contain at least 32 bytes")
}
return &CursorCodec{key: []byte(key)}, nil
}
func (c *CursorCodec) EncodeChat(cursor domain.ChatCursor) (string, error) {
return c.encode(cursorPayload{
Version: cursorVersion, Kind: "chat", CreatedAt: cursor.CreatedAt.UTC().Format(time.RFC3339Nano),
ID: cursor.ChatID, ScopeID: cursor.UserID,
})
}
func (c *CursorCodec) DecodeChat(token, expectedUserID string) (*domain.ChatCursor, error) {
payload, err := c.decode(token, "chat", expectedUserID)
if err != nil {
return nil, err
}
return &domain.ChatCursor{CreatedAt: payload.createdAt, ChatID: payload.id, UserID: payload.scopeID}, nil
}
func (c *CursorCodec) EncodeMessage(cursor domain.MessageCursor) (string, error) {
return c.encode(cursorPayload{
Version: cursorVersion, Kind: "message", CreatedAt: cursor.CreatedAt.UTC().Format(time.RFC3339Nano),
ID: cursor.MessageID, ScopeID: cursor.ChatID,
})
}
func (c *CursorCodec) DecodeMessage(token, expectedChatID string) (*domain.MessageCursor, error) {
payload, err := c.decode(token, "message", expectedChatID)
if err != nil {
return nil, err
}
return &domain.MessageCursor{CreatedAt: payload.createdAt, MessageID: payload.id, ChatID: payload.scopeID}, nil
}
func (c *CursorCodec) encode(payload cursorPayload) (string, error) {
encodedPayload, err := json.Marshal(payload)
if err != nil {
return "", fmt.Errorf("encode cursor payload: %w", err)
}
mac := hmac.New(sha256.New, c.key)
_, _ = mac.Write(encodedPayload)
return base64.RawURLEncoding.EncodeToString(encodedPayload) + "." +
base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil
}
type decodedCursor struct {
createdAt time.Time
id string
scopeID string
}
func (c *CursorCodec) decode(token, expectedKind, expectedScopeID string) (decodedCursor, error) {
parts := strings.Split(token, ".")
if len(parts) != 2 {
return decodedCursor{}, ErrInvalidCursor
}
payloadBytes, err := base64.RawURLEncoding.DecodeString(parts[0])
if err != nil {
return decodedCursor{}, ErrInvalidCursor
}
signature, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil {
return decodedCursor{}, ErrInvalidCursor
}
mac := hmac.New(sha256.New, c.key)
_, _ = mac.Write(payloadBytes)
if !hmac.Equal(signature, mac.Sum(nil)) {
return decodedCursor{}, ErrInvalidCursor
}
var payload cursorPayload
if err = json.Unmarshal(payloadBytes, &payload); err != nil ||
payload.Version != cursorVersion || payload.Kind != expectedKind ||
payload.ScopeID != expectedScopeID {
return decodedCursor{}, ErrInvalidCursor
}
createdAt, err := time.Parse(time.RFC3339Nano, payload.CreatedAt)
if err != nil {
return decodedCursor{}, ErrInvalidCursor
}
if _, err = uuid.Parse(payload.ID); err != nil {
return decodedCursor{}, ErrInvalidCursor
}
if _, err = uuid.Parse(payload.ScopeID); err != nil {
return decodedCursor{}, ErrInvalidCursor
}
return decodedCursor{createdAt: createdAt.UTC(), id: payload.ID, scopeID: payload.ScopeID}, nil
}
+70
View File
@@ -0,0 +1,70 @@
package application
import (
"errors"
"testing"
"time"
"mtusi2026lab3/internal/domain"
)
const cursorTestKey = "cursor-test-key-with-more-than-thirty-two-bytes"
func TestCursorCodecRoundTrip(t *testing.T) {
codec, err := NewCursorCodec(cursorTestKey)
if err != nil {
t.Fatal(err)
}
expected := domain.MessageCursor{
CreatedAt: time.Date(2026, 10, 18, 12, 30, 0, 123, time.UTC),
MessageID: "42eea32e-d9b5-4bc6-b4fc-94e9b0477adf",
ChatID: "9fa3f49c-e62e-4209-8414-d6d5f69805bf",
}
token, err := codec.EncodeMessage(expected)
if err != nil {
t.Fatal(err)
}
actual, err := codec.DecodeMessage(token, expected.ChatID)
if err != nil {
t.Fatal(err)
}
if *actual != expected {
t.Fatalf("cursor changed after round trip: got %#v, want %#v", *actual, expected)
}
}
func TestCursorCodecRejectsTamperingAndWrongScope(t *testing.T) {
codec, err := NewCursorCodec(cursorTestKey)
if err != nil {
t.Fatal(err)
}
token, err := codec.EncodeChat(domain.ChatCursor{
CreatedAt: time.Now().UTC(),
ChatID: "42eea32e-d9b5-4bc6-b4fc-94e9b0477adf",
UserID: "9fa3f49c-e62e-4209-8414-d6d5f69805bf",
})
if err != nil {
t.Fatal(err)
}
replacement := "A"
if token[len(token)-1:] == replacement {
replacement = "B"
}
tampered := token[:len(token)-1] + replacement
if _, err = codec.DecodeChat(tampered, "9fa3f49c-e62e-4209-8414-d6d5f69805bf"); !errors.Is(err, ErrInvalidCursor) {
t.Fatalf("tampered cursor: got %v, want ErrInvalidCursor", err)
}
if _, err = codec.DecodeChat(token, "e6ca4af0-69ed-4784-8ce0-ee035299fe08"); !errors.Is(err, ErrInvalidCursor) {
t.Fatalf("wrong scope: got %v, want ErrInvalidCursor", err)
}
if _, err = codec.DecodeMessage(token, "9fa3f49c-e62e-4209-8414-d6d5f69805bf"); !errors.Is(err, ErrInvalidCursor) {
t.Fatalf("wrong cursor kind: got %v, want ErrInvalidCursor", err)
}
}
func TestCursorCodecRequiresStrongSharedKey(t *testing.T) {
if _, err := NewCursorCodec("too-short"); err == nil {
t.Fatal("expected short cursor signing key to be rejected")
}
}
+10
View File
@@ -0,0 +1,10 @@
package application
import "errors"
var (
ErrInvalidCursor = errors.New("invalid cursor")
ErrInvalidCredentials = errors.New("invalid credentials")
ErrInvalidInput = errors.New("invalid input")
ErrCredentialState = errors.New("invalid stored credential state")
)
+52
View File
@@ -0,0 +1,52 @@
package application
import (
"context"
"fmt"
"mtusi2026lab3/internal/domain"
)
func (s *Service) SendMessage(ctx context.Context, command SendMessageCommand) (domain.Message, error) {
if err := domain.ValidateMessageText(command.Text); err != nil {
return domain.Message{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
return s.repository.CreateMessage(ctx, command.ChatID, command.ActorID, command.Text)
}
func (s *Service) ListMessages(
ctx context.Context,
actorID string,
chatID string,
limit int,
cursorToken string,
) (domain.MessagePage, error) {
var cursor *domain.MessageCursor
if cursorToken != "" {
decoded, err := s.cursors.DecodeMessage(cursorToken, chatID)
if err != nil {
return domain.MessagePage{}, ErrInvalidCursor
}
cursor = decoded
}
items, hasMore, err := s.repository.GetMessages(ctx, chatID, actorID, limit, cursor)
if err != nil {
return domain.MessagePage{}, err
}
page := domain.MessagePage{Items: items}
if page.Items == nil {
page.Items = make([]domain.Message, 0)
}
if hasMore {
last := page.Items[len(page.Items)-1]
next, encodeErr := s.cursors.EncodeMessage(domain.MessageCursor{
CreatedAt: last.CreatedAt, MessageID: last.ID, ChatID: chatID,
})
if encodeErr != nil {
return domain.MessagePage{}, encodeErr
}
page.NextCursor = &next
}
return page, nil
}
+37
View File
@@ -0,0 +1,37 @@
package application
import (
"context"
"time"
"mtusi2026lab3/internal/domain"
)
type UserRepository interface {
CreateUser(ctx context.Context, username, displayName, passwordHash string) (domain.User, error)
GetUserByUsername(ctx context.Context, username string) (domain.User, string, error)
}
type SessionRepository interface {
CreateSession(ctx context.Context, tokenHash []byte, userID string, expiresAt time.Time) error
GetUserBySession(ctx context.Context, tokenHash []byte) (domain.User, error)
DeleteSession(ctx context.Context, tokenHash []byte) error
}
type ChatRepository interface {
CreateChat(ctx context.Context, title string, memberIDs []string) (domain.Chat, error)
GetChatByID(ctx context.Context, chatID, callerID string) (domain.Chat, error)
GetChatsForUser(ctx context.Context, userID string, limit int, cursor *domain.ChatCursor) ([]domain.Chat, bool, error)
}
type MessageRepository interface {
CreateMessage(ctx context.Context, chatID, senderID, text string) (domain.Message, error)
GetMessages(ctx context.Context, chatID, callerID string, limit int, cursor *domain.MessageCursor) ([]domain.Message, bool, error)
}
type Repository interface {
UserRepository
SessionRepository
ChatRepository
MessageRepository
}
+31
View File
@@ -0,0 +1,31 @@
package application
import (
"fmt"
"time"
)
type Service struct {
repository Repository
cursors *CursorCodec
sessionTTL time.Duration
now func() time.Time
}
func NewService(repository Repository, cursors *CursorCodec, sessionTTL time.Duration) (*Service, error) {
if repository == nil {
return nil, fmt.Errorf("repository is required")
}
if cursors == nil {
return nil, fmt.Errorf("cursor codec is required")
}
if sessionTTL <= 0 {
return nil, fmt.Errorf("session TTL must be positive")
}
return &Service{
repository: repository,
cursors: cursors,
sessionTTL: sessionTTL,
now: func() time.Time { return time.Now().UTC() },
}, nil
}
+57
View File
@@ -0,0 +1,57 @@
package application
import (
"context"
"errors"
"fmt"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/security"
)
const dummyPasswordHash = "$argon2id$v=19$m=19456,t=2,p=1$" +
"AAAAAAAAAAAAAAAAAAAAAA$" +
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
func (s *Service) CreateSession(ctx context.Context, command CreateSessionCommand) (domain.Session, error) {
user, passwordHash, err := s.repository.GetUserByUsername(ctx, command.Username)
userNotFound := errors.Is(err, domain.ErrNotFound)
if userNotFound {
passwordHash = dummyPasswordHash
} else if err != nil {
return domain.Session{}, err
}
passwordMatches, verifyErr := security.VerifyPassword(command.Password, passwordHash)
if verifyErr != nil {
return domain.Session{}, fmt.Errorf("%w: %v", ErrCredentialState, verifyErr)
}
if userNotFound || !passwordMatches {
return domain.Session{}, ErrInvalidCredentials
}
token, tokenHash, err := security.GenerateSessionToken()
if err != nil {
return domain.Session{}, fmt.Errorf("generate session token: %w", err)
}
expiresAt := s.now().Add(s.sessionTTL)
if err = s.repository.CreateSession(ctx, tokenHash, user.ID, expiresAt); err != nil {
return domain.Session{}, err
}
return domain.Session{
Token: token, TokenType: "Bearer", ExpiresAt: expiresAt, User: user,
}, nil
}
func (s *Service) Authenticate(ctx context.Context, token string) (domain.User, []byte, error) {
tokenHash := security.HashSessionToken(token)
user, err := s.repository.GetUserBySession(ctx, tokenHash)
if err != nil {
return domain.User{}, nil, err
}
return user, tokenHash, nil
}
func (s *Service) DeleteSession(ctx context.Context, tokenHash []byte) error {
return s.repository.DeleteSession(ctx, tokenHash)
}
+29
View File
@@ -0,0 +1,29 @@
package application
import (
"context"
"fmt"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/security"
)
func (s *Service) CreateUser(ctx context.Context, command CreateUserCommand) (domain.User, error) {
if err := domain.ValidateUser(command.Username, command.DisplayName); err != nil {
return domain.User{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
if err := security.ValidatePassword(command.Password); err != nil {
return domain.User{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
passwordHash, err := security.HashPassword(command.Password)
if err != nil {
return domain.User{}, fmt.Errorf("hash password: %w", err)
}
return s.repository.CreateUser(
ctx,
command.Username,
command.DisplayName,
passwordHash,
)
}
+14 -4
View File
@@ -14,7 +14,8 @@ type Config struct {
HTTPHost string
HTTPPort string
SessionTTL time.Duration
SessionTTL time.Duration
CursorSigningKey string
DatabaseURL string
DatabaseMaxConns int32
@@ -51,6 +52,14 @@ func Load() (Config, error) {
return Config{}, err
}
cursorSigningKey, err := requiredValueOrFile(
"CURSOR_SIGNING_KEY",
"CURSOR_SIGNING_KEY_FILE",
)
if err != nil {
return Config{}, err
}
databaseMaxConns, err := int32FromEnv("DB_MAX_CONNS", 10, 1)
if err != nil {
return Config{}, err
@@ -150,9 +159,10 @@ func Load() (Config, error) {
}
return Config{
HTTPHost: envOrDefault("APP_HOST", "0.0.0.0"),
HTTPPort: envOrDefault("APP_PORT", "8080"),
SessionTTL: sessionTTL,
HTTPHost: envOrDefault("APP_HOST", "0.0.0.0"),
HTTPPort: envOrDefault("APP_PORT", "8080"),
SessionTTL: sessionTTL,
CursorSigningKey: cursorSigningKey,
DatabaseURL: databaseURL,
DatabaseMaxConns: databaseMaxConns,
+21
View File
@@ -0,0 +1,21 @@
package domain
import "time"
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
type ChatCursor struct {
CreatedAt time.Time
ChatID string
UserID string
}
type ChatPage struct {
Items []Chat
NextCursor *string
}
+8
View File
@@ -0,0 +1,8 @@
package domain
import "errors"
var (
ErrNotFound = errors.New("not found")
ErrConflict = errors.New("conflict")
)
+22
View File
@@ -0,0 +1,22 @@
package domain
import "time"
type Message struct {
ID string
ChatID string
SenderID string
Text string
CreatedAt time.Time
}
type MessageCursor struct {
CreatedAt time.Time
MessageID string
ChatID string
}
type MessagePage struct {
Items []Message
NextCursor *string
}
-256
View File
@@ -1,256 +0,0 @@
package domain
import (
"encoding/base64"
"fmt"
"regexp"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
)
var (
//регулярка по контракту
usernameRegex = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt time.Time `json:"created_at"`
}
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt time.Time `json:"expires_at"`
User User `json:"user"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt time.Time `json:"created_at"`
}
// страница выдачи истории сообщений
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func (u *User) Validate() error {
if !usernameRegex.MatchString(u.Username) {
return fmt.Errorf("username must match [a-z0-9_]{3,32}")
}
nameRunes := utf8.RuneCountInString(u.DisplayName)
if nameRunes < 1 || nameRunes > 100 {
return fmt.Errorf("display_name length must be between 1 and 100 code points")
}
if strings.TrimSpace(u.DisplayName) == "" {
return fmt.Errorf("display_name cannot be only whitespace")
}
return nil
}
func ValidateChatInput(title string, memberIDs []string, callerID string) error {
titleRunes := utf8.RuneCountInString(title)
if titleRunes < 1 || titleRunes > 100 || strings.TrimSpace(title) == "" {
return fmt.Errorf("invalid chat title")
}
if len(memberIDs) == 0 {
return fmt.Errorf("member_ids cannot be empty")
}
if len(memberIDs) > 100 {
return fmt.Errorf("member_ids must contain at most 100 users")
}
hasCaller := false
seen := make(map[string]bool)
for _, id := range memberIDs {
if _, err := uuid.Parse(id); err != nil {
return fmt.Errorf("invalid member uuid: %s", id)
}
if seen[id] {
return fmt.Errorf("duplicate member_id: %s", id)
}
seen[id] = true
if id == callerID {
hasCaller = true
}
}
if !hasCaller {
return fmt.Errorf("caller must be in member_ids")
}
return nil
}
func ValidateMessageText(text string) error {
textRunes := utf8.RuneCountInString(text)
if textRunes < 1 || textRunes > 4000 {
return fmt.Errorf("message text length must be between 1 and 4000 code points")
}
if strings.TrimSpace(text) == "" {
return fmt.Errorf("message text cannot be only whitespace")
}
return nil
}
type CursorData struct {
CreatedAt time.Time
MessageID string
ChatID string
}
const messageCursorVersion = "v1"
func EncodeCursor(createdAt time.Time, messageID, chatID string) string {
raw := fmt.Sprintf(
"%s|%s|%s|%s",
messageCursorVersion,
createdAt.UTC().Format(time.RFC3339Nano),
messageID,
chatID,
)
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func DecodeCursor(
cursorStr string,
expectedChatID string,
) (*CursorData, error) {
raw, err := base64.RawURLEncoding.DecodeString(cursorStr)
if err != nil {
return nil, fmt.Errorf("invalid base64 cursor")
}
parts := strings.Split(string(raw), "|")
if len(parts) != 4 {
return nil, fmt.Errorf("malformed cursor")
}
if parts[0] != messageCursorVersion {
return nil, fmt.Errorf("unsupported cursor version")
}
createdAt, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return nil, fmt.Errorf("invalid cursor timestamp")
}
messageID := parts[2]
chatID := parts[3]
if _, err := uuid.Parse(messageID); err != nil {
return nil, fmt.Errorf("invalid cursor message_id")
}
if _, err := uuid.Parse(chatID); err != nil {
return nil, fmt.Errorf("invalid cursor chat_id")
}
if chatID != expectedChatID {
return nil, fmt.Errorf("cursor belongs to another chat")
}
return &CursorData{
CreatedAt: createdAt.UTC(),
MessageID: messageID,
ChatID: chatID,
}, nil
}
// страница со списком чатов пользователя
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
const chatCursorVersion = "v1"
type ChatCursorData struct {
CreatedAt time.Time
ChatID string
UserID string
}
// EncodeChatCursor создаёт непрозрачную границу списка чатов.
// Версия позволяет в будущем изменить внутренний формат курсора.
func EncodeChatCursor(createdAt time.Time, chatID, userID string) string {
raw := fmt.Sprintf(
"%s|%s|%s|%s",
chatCursorVersion,
createdAt.UTC().Format(time.RFC3339Nano),
chatID,
userID,
)
// RawURLEncoding не использует символы +, / и завершающий =,
// поэтому курсор безопаснее передавать в query string.
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func DecodeChatCursor(
cursorStr string,
expectedUserID string,
) (*ChatCursorData, error) {
decoded, err := base64.RawURLEncoding.DecodeString(cursorStr)
if err != nil {
return nil, fmt.Errorf("invalid base64 chat cursor")
}
parts := strings.Split(string(decoded), "|")
if len(parts) != 4 {
return nil, fmt.Errorf("malformed chat cursor")
}
if parts[0] != chatCursorVersion {
return nil, fmt.Errorf("unsupported chat cursor version")
}
createdAt, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return nil, fmt.Errorf("invalid chat cursor timestamp")
}
chatID := parts[2]
if _, err = uuid.Parse(chatID); err != nil {
return nil, fmt.Errorf("invalid chat cursor chat_id")
}
userID := parts[3]
if _, err = uuid.Parse(userID); err != nil {
return nil, fmt.Errorf("invalid chat cursor user_id")
}
if userID != expectedUserID {
return nil, fmt.Errorf("chat cursor belongs to another user")
}
return &ChatCursorData{
CreatedAt: createdAt,
ChatID: chatID,
UserID: userID,
}, nil
}
+10
View File
@@ -0,0 +1,10 @@
package domain
import "time"
type Session struct {
Token string
TokenType string
ExpiresAt time.Time
User User
}
+11
View File
@@ -0,0 +1,11 @@
package domain
import "time"
// User is the transport-independent representation of a messenger user.
type User struct {
ID string
Username string
DisplayName string
CreatedAt time.Time
}
+77
View File
@@ -0,0 +1,77 @@
package domain
import (
"fmt"
"regexp"
"strings"
"unicode/utf8"
"github.com/google/uuid"
)
var usernameRegex = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
func ValidateUser(username, displayName string) error {
if !usernameRegex.MatchString(username) {
return fmt.Errorf("username must match [a-z0-9_]{3,32}")
}
nameRunes := utf8.RuneCountInString(displayName)
if nameRunes < 1 || nameRunes > 100 {
return fmt.Errorf("display_name length must be between 1 and 100 code points")
}
if strings.TrimSpace(displayName) == "" {
return fmt.Errorf("display_name cannot be only whitespace")
}
return nil
}
// Validate remains as a compatibility convenience for existing callers.
func (u User) Validate() error {
return ValidateUser(u.Username, u.DisplayName)
}
func ValidateChatInput(title string, memberIDs []string, callerID string) error {
titleRunes := utf8.RuneCountInString(title)
if titleRunes < 1 || titleRunes > 100 || strings.TrimSpace(title) == "" {
return fmt.Errorf("invalid chat title")
}
if len(memberIDs) == 0 {
return fmt.Errorf("member_ids cannot be empty")
}
if len(memberIDs) > 100 {
return fmt.Errorf("member_ids must contain at most 100 users")
}
hasCaller := false
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, err := uuid.Parse(id); err != nil {
return fmt.Errorf("invalid member uuid: %s", id)
}
if _, exists := seen[id]; exists {
return fmt.Errorf("duplicate member_id: %s", id)
}
seen[id] = struct{}{}
if id == callerID {
hasCaller = true
}
}
if !hasCaller {
return fmt.Errorf("caller must be in member_ids")
}
return nil
}
func ValidateMessageText(text string) error {
textRunes := utf8.RuneCountInString(text)
if textRunes < 1 || textRunes > 4000 {
return fmt.Errorf("message text length must be between 1 and 4000 code points")
}
if strings.TrimSpace(text) == "" {
return fmt.Errorf("message text cannot be only whitespace")
}
return nil
}
-9
View File
@@ -1,9 +0,0 @@
package store
import "errors"
var (
ErrNotFound = errors.New("not found")
ErrConflict = errors.New("conflict")
ErrInvalidCursor = errors.New("invalid cursor")
)
-80
View File
@@ -1,80 +0,0 @@
package store
import (
"context"
"time"
"mtusi2026lab3/internal/domain"
)
type Repository interface {
CreateUser(
ctx context.Context,
username string,
displayName string,
passwordHash string,
) (domain.User, error)
GetUserByID(
ctx context.Context,
userID string,
) (domain.User, error)
GetUserByUsername(
ctx context.Context,
username string,
) (domain.User, string, error)
CreateChat(
ctx context.Context,
title string,
memberIDs []string,
) (domain.Chat, error)
GetChatByID(
ctx context.Context,
chatID string,
callerID string,
) (domain.Chat, error)
GetChatsForUser(
ctx context.Context,
userID string,
limit int,
cursor string,
) (domain.ChatPage, error)
CreateMessage(
ctx context.Context,
chatID string,
senderID string,
text string,
) (domain.Message, error)
GetMessages(
ctx context.Context,
chatID string,
callerID string,
limit int,
cursor string,
) (domain.MessagePage, error)
CreateSession(
ctx context.Context,
tokenHash []byte,
userID string,
expiresAt time.Time,
) error
GetUserBySession(
ctx context.Context,
tokenHash []byte,
) (domain.User, error)
DeleteSession(
ctx context.Context,
tokenHash []byte,
) error
}
var _ Repository = (*PostgreSQLStore)(nil)
+38
View File
@@ -0,0 +1,38 @@
package dto
import (
"time"
"mtusi2026lab3/internal/domain"
)
type CreateChatRequest struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
type ChatResponse struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
type ChatPageResponse struct {
Items []ChatResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func ChatFromDomain(chat domain.Chat) ChatResponse {
return ChatResponse{
ID: chat.ID, Title: chat.Title, MemberIDs: chat.MemberIDs, CreatedAt: chat.CreatedAt,
}
}
func ChatPageFromDomain(page domain.ChatPage) ChatPageResponse {
items := make([]ChatResponse, len(page.Items))
for index, chat := range page.Items {
items[index] = ChatFromDomain(chat)
}
return ChatPageResponse{Items: items, NextCursor: page.NextCursor}
}
+39
View File
@@ -0,0 +1,39 @@
package dto
import (
"time"
"mtusi2026lab3/internal/domain"
)
type CreateMessageRequest struct {
Text string `json:"text"`
}
type MessageResponse struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt time.Time `json:"created_at"`
}
type MessagePageResponse struct {
Items []MessageResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func MessageFromDomain(message domain.Message) MessageResponse {
return MessageResponse{
ID: message.ID, ChatID: message.ChatID, SenderID: message.SenderID,
Text: message.Text, CreatedAt: message.CreatedAt,
}
}
func MessagePageFromDomain(page domain.MessagePage) MessagePageResponse {
items := make([]MessageResponse, len(page.Items))
for index, message := range page.Items {
items[index] = MessageFromDomain(message)
}
return MessagePageResponse{Items: items, NextCursor: page.NextCursor}
}
+21
View File
@@ -0,0 +1,21 @@
package dto
import (
"time"
"mtusi2026lab3/internal/domain"
)
type SessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt time.Time `json:"expires_at"`
User UserResponse `json:"user"`
}
func SessionFromDomain(session domain.Session) SessionResponse {
return SessionResponse{
Token: session.Token, TokenType: session.TokenType, ExpiresAt: session.ExpiresAt,
User: UserFromDomain(session.User),
}
}
+26
View File
@@ -0,0 +1,26 @@
package dto
import (
"time"
"mtusi2026lab3/internal/domain"
)
type CreateUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
type UserResponse struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt time.Time `json:"created_at"`
}
func UserFromDomain(user domain.User) UserResponse {
return UserResponse{
ID: user.ID, Username: user.Username, DisplayName: user.DisplayName, CreatedAt: user.CreatedAt,
}
}
-168
View File
@@ -1,168 +0,0 @@
package handlers
import (
"errors"
"net/http"
"strconv"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
"github.com/google/uuid"
)
type CreateChatRequest struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
var req CreateChatRequest
if err := decodeJSON(r, &req); err != nil {
writeDecodeJSONError(w, reqID, err)
return
}
//вызывающий есть в списке, нет дубликатов, валидные UUID
if err := domain.ValidateChatInput(req.Title, req.MemberIDs, currentUser.ID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
chat, err := h.store.CreateChat(
r.Context(),
req.Title,
req.MemberIDs,
)
if errors.Is(err, store.ErrNotFound) {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"one or more members do not exist",
reqID,
)
return
}
if err != nil {
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
reqID,
)
return
}
response.WriteJSON(w, http.StatusCreated, chat, reqID)
}
// инфа о чате
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", reqID)
return
}
chat, err := h.store.GetChatByID(
r.Context(),
chatID,
currentUser.ID,
)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
//посторонний или несуществующий чат -> 404
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", reqID)
return
}
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
reqID,
)
return
}
response.WriteJSON(w, http.StatusOK, chat, reqID)
}
// список всех чатов текущего пользователя
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
query := r.URL.Query()
limit := 50
if query.Has("limit") {
limitStr := query.Get("limit")
val, err := strconv.Atoi(limitStr)
if err != nil || val < 1 || val > 100 {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"limit must be an integer between 1 and 100",
reqID,
)
return
}
limit = val
}
cursor := query.Get("cursor")
if query.Has("cursor") && cursor == "" {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"cursor must not be empty",
reqID,
)
return
}
page, err := h.store.GetChatsForUser(
r.Context(),
currentUser.ID,
limit,
cursor,
)
if err != nil {
if errors.Is(err, store.ErrInvalidCursor) {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"invalid cursor",
reqID,
)
return
}
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
reqID,
)
return
}
response.WriteJSON(w, http.StatusOK, page, reqID)
}
@@ -0,0 +1,44 @@
package handlers
import (
"errors"
"net/http"
"strings"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
)
func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
var request dto.CreateChatRequest
if err := decodeJSON(r, &request); err != nil {
writeDecodeJSONError(w, requestID, err)
return
}
chat, err := h.service.CreateChat(r.Context(), application.CreateChatCommand{
ActorID: currentUser.ID, Title: request.Title, MemberIDs: request.MemberIDs,
})
if errors.Is(err, application.ErrInvalidInput) {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
strings.TrimPrefix(err.Error(), application.ErrInvalidInput.Error()+": "), requestID)
return
}
if errors.Is(err, domain.ErrNotFound) {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
"one or more members do not exist", requestID)
return
}
if err != nil {
response.WriteError(w, http.StatusServiceUnavailable, response.CodeUnavailable,
"service is temporarily unavailable", requestID)
return
}
response.WriteJSON(w, http.StatusCreated, dto.ChatFromDomain(chat), requestID)
}
@@ -0,0 +1,50 @@
package handlers
import (
"errors"
"net/http"
"strings"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
"github.com/google/uuid"
)
func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
"invalid chat_id uuid", requestID)
return
}
var request dto.CreateMessageRequest
if err := decodeJSON(r, &request); err != nil {
writeDecodeJSONError(w, requestID, err)
return
}
message, err := h.service.SendMessage(r.Context(), application.SendMessageCommand{
ActorID: currentUser.ID, ChatID: chatID, Text: request.Text,
})
if errors.Is(err, application.ErrInvalidInput) {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
strings.TrimPrefix(err.Error(), application.ErrInvalidInput.Error()+": "), requestID)
return
}
if errors.Is(err, domain.ErrNotFound) {
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", requestID)
return
}
if err != nil {
response.WriteError(w, http.StatusServiceUnavailable, response.CodeUnavailable,
"service is temporarily unavailable", requestID)
return
}
response.WriteJSON(w, http.StatusCreated, dto.MessageFromDomain(message), requestID)
}
@@ -0,0 +1,19 @@
package handlers
import (
"net/http"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
)
func (h *Handler) DeleteCurrentSession(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
tokenHash := middleware.GetCurrentSessionTokenHash(r.Context())
if err := h.service.DeleteSession(r.Context(), tokenHash); err != nil {
response.WriteError(w, http.StatusServiceUnavailable, response.CodeUnavailable,
"service is temporarily unavailable", requestID)
return
}
response.WriteJSON(w, http.StatusNoContent, nil, requestID)
}
@@ -0,0 +1,36 @@
package handlers
import (
"errors"
"net/http"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
"github.com/google/uuid"
)
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
"invalid chat_id uuid", requestID)
return
}
chat, err := h.service.GetChat(r.Context(), currentUser.ID, chatID)
if errors.Is(err, domain.ErrNotFound) {
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", requestID)
return
}
if err != nil {
response.WriteError(w, http.StatusServiceUnavailable, response.CodeUnavailable,
"service is temporarily unavailable", requestID)
return
}
response.WriteJSON(w, http.StatusOK, dto.ChatFromDomain(chat), requestID)
}
@@ -0,0 +1,15 @@
package handlers
import (
"net/http"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
)
func (h *Handler) GetMe(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
response.WriteJSON(w, http.StatusOK, dto.UserFromDomain(currentUser), requestID)
}
+4 -12
View File
@@ -12,7 +12,7 @@ import (
"time"
"unicode/utf8"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/transport/http/response"
)
@@ -30,20 +30,18 @@ type ReadinessChecker interface {
type Option func(*Handler)
type Handler struct {
store store.Repository
service *application.Service
readinessChecker ReadinessChecker
readinessTimeout time.Duration
sessionTTL time.Duration
}
func NewHandler(
repository store.Repository,
service *application.Service,
options ...Option,
) *Handler {
handler := &Handler{
store: repository,
service: service,
readinessTimeout: 2 * time.Second,
sessionTTL: time.Hour,
}
for _, option := range options {
@@ -63,12 +61,6 @@ func WithReadiness(
}
}
func WithSessionTTL(ttl time.Duration) Option {
return func(handler *Handler) {
handler.sessionTTL = ttl
}
}
func decodeJSON(r *http.Request, destination any) error {
mediaType, parameters, err := mime.ParseMediaType(
r.Header.Get("Content-Type"),
@@ -0,0 +1,32 @@
package handlers
import (
"errors"
"net/http"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
)
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
limit, cursor, ok := parsePagination(w, r, requestID)
if !ok {
return
}
page, err := h.service.ListChats(r.Context(), currentUser.ID, limit, cursor)
if errors.Is(err, application.ErrInvalidCursor) {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid cursor", requestID)
return
}
if err != nil {
response.WriteError(w, http.StatusServiceUnavailable, response.CodeUnavailable,
"service is temporarily unavailable", requestID)
return
}
response.WriteJSON(w, http.StatusOK, dto.ChatPageFromDomain(page), requestID)
}
@@ -0,0 +1,45 @@
package handlers
import (
"errors"
"net/http"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
"github.com/google/uuid"
)
func (h *Handler) GetMessages(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
"invalid chat_id uuid", requestID)
return
}
limit, cursor, ok := parsePagination(w, r, requestID)
if !ok {
return
}
page, err := h.service.ListMessages(r.Context(), currentUser.ID, chatID, limit, cursor)
if errors.Is(err, domain.ErrNotFound) {
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", requestID)
return
}
if errors.Is(err, application.ErrInvalidCursor) {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid cursor", requestID)
return
}
if err != nil {
response.WriteError(w, http.StatusServiceUnavailable, response.CodeUnavailable,
"service is temporarily unavailable", requestID)
return
}
response.WriteJSON(w, http.StatusOK, dto.MessagePageFromDomain(page), requestID)
}
@@ -1,159 +0,0 @@
package handlers
import (
"errors"
"net/http"
"strconv"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
"github.com/google/uuid"
)
type CreateMessageRequest struct {
Text string `json:"text"`
}
// CreateMessage отправляет сообщение в чат
func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", reqID)
return
}
var req CreateMessageRequest
if err := decodeJSON(r, &req); err != nil {
writeDecodeJSONError(w, reqID, err)
return
}
//не пустой, не только пробелы, до 4000 рун
if err := domain.ValidateMessageText(req.Text); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
//автор сообщения строго выводится из сессии (currentUser.ID)
msg, err := h.store.CreateMessage(
r.Context(),
chatID,
currentUser.ID,
req.Text,
)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
// чата нет/пользователь не участник -> 404
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", reqID)
return
}
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
reqID,
)
return
}
response.WriteJSON(w, http.StatusCreated, msg, reqID)
}
// GetMessages возвращает историю сообщений чата с пагинацией по курсору
func (h *Handler) GetMessages(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", reqID)
return
}
query := r.URL.Query()
limit := 50
if query.Has("limit") {
limitString := query.Get("limit")
parsedLimit, err := strconv.Atoi(limitString)
if err != nil || parsedLimit < 1 || parsedLimit > 100 {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"limit must be an integer between 1 and 100",
reqID,
)
return
}
limit = parsedLimit
}
cursor := query.Get("cursor")
if query.Has("cursor") && cursor == "" {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"cursor must not be empty",
reqID,
)
return
}
page, err := h.store.GetMessages(
r.Context(),
chatID,
currentUser.ID,
limit,
cursor,
)
if errors.Is(err, store.ErrNotFound) {
response.WriteError(
w,
http.StatusNotFound,
response.CodeNotFound,
"chat not found",
reqID,
)
return
}
if errors.Is(err, store.ErrInvalidCursor) {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
"invalid cursor",
reqID,
)
return
}
if err != nil {
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
reqID,
)
return
}
// сообщений нет, [] вместо null
if page.Items == nil {
page.Items = make([]domain.Message, 0)
}
response.WriteJSON(w, http.StatusOK, page, reqID)
}
@@ -0,0 +1,29 @@
package handlers
import (
"net/http"
"strconv"
"mtusi2026lab3/internal/transport/http/response"
)
func parsePagination(w http.ResponseWriter, r *http.Request, requestID string) (int, string, bool) {
query := r.URL.Query()
limit := 50
if query.Has("limit") {
parsed, err := strconv.Atoi(query.Get("limit"))
if err != nil || parsed < 1 || parsed > 100 {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
"limit must be an integer between 1 and 100", requestID)
return 0, "", false
}
limit = parsed
}
cursor := query.Get("cursor")
if query.Has("cursor") && cursor == "" {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest,
"cursor must not be empty", requestID)
return 0, "", false
}
return limit, cursor, true
}
+9 -96
View File
@@ -3,25 +3,16 @@ package handlers
import (
"errors"
"net/http"
"time"
"unicode/utf8"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/security"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
)
const basicChallenge = `Basic realm="messenger", charset="UTF-8"`
// dummyPasswordHash keeps the expensive Argon2id path for an unknown username.
// The all-zero digest is intentionally not a real user's credential; only the
// encoded parameters and lengths need to be valid for constant-cost checking.
const dummyPasswordHash = "$argon2id$v=19$m=19456,t=2,p=1$" +
"AAAAAAAAAAAAAAAAAAAAAA$" +
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
func (h *Handler) CreateSession(
w http.ResponseWriter,
r *http.Request,
@@ -35,32 +26,11 @@ func (h *Handler) CreateSession(
return
}
user, passwordHash, err := h.store.GetUserByUsername(
r.Context(),
username,
)
userNotFound := errors.Is(err, store.ErrNotFound)
if userNotFound {
passwordHash = dummyPasswordHash
}
if err != nil {
if !userNotFound {
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
requestID,
)
return
}
}
passwordMatches, err := security.VerifyPassword(
password,
passwordHash,
)
if err != nil {
session, err := h.service.CreateSession(r.Context(), application.CreateSessionCommand{
Username: username,
Password: password,
})
if errors.Is(err, application.ErrCredentialState) {
response.WriteError(
w,
http.StatusInternalServerError,
@@ -70,31 +40,11 @@ func (h *Handler) CreateSession(
)
return
}
if userNotFound || !passwordMatches {
if errors.Is(err, application.ErrInvalidCredentials) {
writeBasicUnauthorized(w, requestID)
return
}
token, tokenHash, err := security.GenerateSessionToken()
if err != nil {
response.WriteError(
w,
http.StatusInternalServerError,
response.CodeInternalError,
"failed to create session",
requestID,
)
return
}
expiresAt := time.Now().UTC().Add(h.sessionTTL)
if err := h.store.CreateSession(
r.Context(),
tokenHash,
user.ID,
expiresAt,
); err != nil {
response.WriteError(
w,
http.StatusServiceUnavailable,
@@ -105,50 +55,13 @@ func (h *Handler) CreateSession(
return
}
session := domain.Session{
Token: token,
TokenType: "Bearer",
ExpiresAt: expiresAt,
User: user,
}
response.WriteJSON(
w,
http.StatusCreated,
session,
dto.SessionFromDomain(session),
requestID,
)
}
func (h *Handler) DeleteCurrentSession(
w http.ResponseWriter,
r *http.Request,
) {
requestID := middleware.GetRequestID(r.Context())
tokenHash := middleware.GetCurrentSessionTokenHash(r.Context())
if err := h.store.DeleteSession(
r.Context(),
tokenHash,
); err != nil {
response.WriteError(
w,
http.StatusServiceUnavailable,
response.CodeUnavailable,
"service is temporarily unavailable",
requestID,
)
return
}
response.WriteJSON(
w,
http.StatusNoContent,
nil,
requestID,
)
}
func writeBasicUnauthorized(
w http.ResponseWriter,
requestID string,
+11 -59
View File
@@ -3,75 +3,39 @@ package handlers
import (
"errors"
"net/http"
"strings"
"mtusi2026lab3/internal/application"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/security"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/middleware"
"mtusi2026lab3/internal/transport/http/response"
)
type CreateUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
var request CreateUserRequest
var request dto.CreateUserRequest
if err := decodeJSON(r, &request); err != nil {
writeDecodeJSONError(w, requestID, err)
return
}
userCandidate := domain.User{
Username: request.Username,
DisplayName: request.DisplayName,
}
if err := userCandidate.Validate(); err != nil {
createdUser, err := h.service.CreateUser(r.Context(), application.CreateUserCommand{
Username: request.Username, DisplayName: request.DisplayName, Password: request.Password,
})
if errors.Is(err, application.ErrInvalidInput) {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
err.Error(),
strings.TrimPrefix(err.Error(), application.ErrInvalidInput.Error()+": "),
requestID,
)
return
}
if err := security.ValidatePassword(request.Password); err != nil {
response.WriteError(
w,
http.StatusBadRequest,
response.CodeInvalidRequest,
err.Error(),
requestID,
)
return
}
passwordHash, err := security.HashPassword(request.Password)
if err != nil {
response.WriteError(
w,
http.StatusInternalServerError,
response.CodeInternalError,
"failed to process password",
requestID,
)
return
}
createdUser, err := h.store.CreateUser(
r.Context(),
request.Username,
request.DisplayName,
passwordHash,
)
if errors.Is(err, store.ErrConflict) {
if errors.Is(err, domain.ErrConflict) {
response.WriteError(
w,
http.StatusConflict,
@@ -95,19 +59,7 @@ func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
response.WriteJSON(
w,
http.StatusCreated,
createdUser,
requestID,
)
}
func (h *Handler) GetMe(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
response.WriteJSON(
w,
http.StatusOK,
currentUser,
dto.UserFromDomain(createdUser),
requestID,
)
}
+6 -10
View File
@@ -7,8 +7,6 @@ import (
"strings"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/security"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/response"
)
@@ -20,10 +18,10 @@ const (
)
type SessionAuthenticator interface {
GetUserBySession(
Authenticate(
ctx context.Context,
tokenHash []byte,
) (domain.User, error)
token string,
) (domain.User, []byte, error)
}
func RequireAuth(
@@ -39,13 +37,11 @@ func RequireAuth(
return
}
tokenHash := security.HashSessionToken(token)
user, err := authenticator.GetUserBySession(
user, tokenHash, err := authenticator.Authenticate(
r.Context(),
tokenHash,
token,
)
if errors.Is(err, store.ErrNotFound) {
if errors.Is(err, domain.ErrNotFound) {
writeBearerUnauthorized(w, requestID)
return
}
+32
View File
@@ -0,0 +1,32 @@
package student_tests
import (
"time"
"mtusi2026lab3/internal/application"
)
const testCursorSigningKey = "student-tests-cursor-signing-key-at-least-32-bytes"
func newTestService(repository application.Repository, sessionTTL time.Duration) *application.Service {
if sessionTTL <= 0 {
sessionTTL = time.Hour
}
codec, err := application.NewCursorCodec(testCursorSigningKey)
if err != nil {
panic(err)
}
service, err := application.NewService(repository, codec, sessionTTL)
if err != nil {
panic(err)
}
return service
}
func newTestCursorCodec() *application.CursorCodec {
codec, err := application.NewCursorCodec(testCursorSigningKey)
if err != nil {
panic(err)
}
return codec
}
+11 -13
View File
@@ -10,9 +10,9 @@ import (
"testing"
"time"
"mtusi2026lab3/internal/domain"
store "mtusi2026lab3/internal/adapter/memory"
"mtusi2026lab3/internal/security"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/handlers"
"mtusi2026lab3/internal/transport/http/middleware"
)
@@ -26,21 +26,19 @@ func setupSessionTestServer(
t.Helper()
repository := store.NewMemoryRepository(store.NewMemoryStore())
handler := handlers.NewHandler(
repository,
handlers.WithSessionTTL(sessionTTL),
)
service := newTestService(repository, sessionTTL)
handler := handlers.NewHandler(service)
mux := http.NewServeMux()
mux.HandleFunc("POST /api/v1/users", handler.CreateUser)
mux.HandleFunc("POST /api/v1/auth/sessions", handler.CreateSession)
mux.HandleFunc(
"GET /api/v1/users/me",
middleware.RequireAuth(repository, handler.GetMe),
middleware.RequireAuth(service, handler.GetMe),
)
mux.HandleFunc(
"DELETE /api/v1/auth/sessions/current",
middleware.RequireAuth(repository, handler.DeleteCurrentSession),
middleware.RequireAuth(service, handler.DeleteCurrentSession),
)
var root http.Handler = mux
@@ -54,7 +52,7 @@ func registerSessionTestUser(
t *testing.T,
baseURL string,
username string,
) domain.User {
) dto.UserResponse {
t.Helper()
payload, err := json.Marshal(map[string]string{
@@ -81,7 +79,7 @@ func registerSessionTestUser(
t.Fatalf("expected registration status 201, got %d: %s", response.StatusCode, body)
}
var user domain.User
var user dto.UserResponse
if err := json.NewDecoder(response.Body).Decode(&user); err != nil {
t.Fatalf("decode registered user: %v", err)
}
@@ -184,7 +182,7 @@ func TestSessionAuthenticationLifecycle(t *testing.T) {
t.Fatalf("expected login status 201, got %d: %s", loginResponse.StatusCode, body)
}
var session domain.Session
var session dto.SessionResponse
if err := json.NewDecoder(loginResponse.Body).Decode(&session); err != nil {
t.Fatalf("decode session: %v", err)
}
@@ -253,7 +251,7 @@ func TestSessionAuthenticationLifecycle(t *testing.T) {
return
}
var currentUser domain.User
var currentUser dto.UserResponse
if err := json.NewDecoder(response.Body).Decode(&currentUser); err != nil {
t.Fatalf("decode current user: %v", err)
}
@@ -321,7 +319,7 @@ func TestSessionExpiry(t *testing.T) {
testPassword,
)
var session domain.Session
var session dto.SessionResponse
if err := json.NewDecoder(loginResponse.Body).Decode(&session); err != nil {
loginResponse.Body.Close()
t.Fatalf("decode session: %v", err)
+14 -9
View File
@@ -12,6 +12,7 @@ import (
"time"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/transport/http/dto"
)
func fetchCursorPage(
@@ -19,7 +20,7 @@ func fetchCursorPage(
baseURL, chatID, userID string,
limit int,
cursor string,
) domain.MessagePage {
) dto.MessagePageResponse {
t.Helper()
endpoint := fmt.Sprintf(
@@ -49,7 +50,7 @@ func fetchCursorPage(
t.Fatalf("expected 200, got %d: %s", res.StatusCode, body)
}
var page domain.MessagePage
var page dto.MessagePageResponse
if err := json.NewDecoder(res.Body).Decode(&page); err != nil {
t.Fatalf("decode message page: %v", err)
}
@@ -109,7 +110,7 @@ func TestCursorTraversalAfterConcurrentWrites(t *testing.T) {
seen := make(map[string]struct{}, expectedMessages)
duplicateCount := 0
var previous *domain.Message
var previous *dto.MessageResponse
firstOrderingViolation := ""
cursor := ""
pageCount := 0
@@ -267,7 +268,7 @@ func TestCursorTraversalDuringConcurrentWrites(t *testing.T) {
seen := make(map[string]struct{}, expectedTotal)
cursor := ""
var previous *domain.Message
var previous *dto.MessageResponse
const maxPageRequests = expectedTotal * 4
finished := false
@@ -320,11 +321,15 @@ func TestCursorTraversalDuringConcurrentWrites(t *testing.T) {
// NextCursor=nil.
if len(page.Items) > 0 {
last := page.Items[len(page.Items)-1]
cursor = domain.EncodeCursor(
last.CreatedAt,
last.ID,
chat.ID,
)
var encodeErr error
cursor, encodeErr = newTestCursorCodec().EncodeMessage(domain.MessageCursor{
CreatedAt: last.CreatedAt,
MessageID: last.ID,
ChatID: chat.ID,
})
if encodeErr != nil {
t.Fatalf("encode traversal cursor: %v", encodeErr)
}
}
select {
+22 -12
View File
@@ -12,9 +12,11 @@ import (
"sort"
"sync"
"testing"
"time"
store "mtusi2026lab3/internal/adapter/memory"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/store"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/handlers"
"mtusi2026lab3/internal/transport/http/middleware"
)
@@ -46,7 +48,7 @@ func requireLegacyAuth(
func setupTestServer() (*httptest.Server, *store.MemoryStore) {
memoryStore := store.NewMemoryStore()
repository := store.NewMemoryRepository(memoryStore)
handler := handlers.NewHandler(repository)
handler := handlers.NewHandler(newTestService(repository, time.Hour))
mux := http.NewServeMux()
mux.HandleFunc("POST /api/v1/users", handler.CreateUser)
@@ -199,7 +201,7 @@ func TestCursorPaginationMultiplePages(t *testing.T) {
req.Header.Set("X-User-Id", u.ID)
res, _ := http.DefaultClient.Do(req)
var page domain.MessagePage
var page dto.MessagePageResponse
body, _ := io.ReadAll(res.Body)
json.Unmarshal(body, &page)
res.Body.Close()
@@ -289,7 +291,7 @@ func TestChatCursorPaginationMultiplePages(t *testing.T) {
t.Fatalf("failed to list chats: %v", err)
}
var page domain.ChatPage
var page dto.ChatPageResponse
decodeErr := json.NewDecoder(res.Body).Decode(&page)
res.Body.Close()
@@ -391,7 +393,7 @@ func TestChatCursorValidation(t *testing.T) {
t.Fatalf("failed to request first page: %v", err)
}
var firstPage domain.ChatPage
var firstPage dto.ChatPageResponse
decodeErr := json.NewDecoder(firstResponse.Body).Decode(&firstPage)
firstResponse.Body.Close()
@@ -507,18 +509,18 @@ func TestConcurrent100MessagesFrom10Clients(t *testing.T) {
wg.Wait()
// должно быть 100 сообщений в чате
page, err := st.GetMessages(chat.ID, memberIDs[0], 200, "")
items, _, err := st.GetMessages(chat.ID, memberIDs[0], 200, nil)
if err != nil {
t.Fatalf("failed to get messages: %v", err)
}
if len(page.Items) != 100 {
t.Fatalf("RACE CONDITION DETECTED: expected exactly 100 messages, got %d", len(page.Items))
if len(items) != 100 {
t.Fatalf("RACE CONDITION DETECTED: expected exactly 100 messages, got %d", len(items))
}
// уникальность ID
seenIDs := make(map[string]bool)
for _, m := range page.Items {
for _, m := range items {
if seenIDs[m.ID] {
t.Fatalf("duplicate message ID found: %s", m.ID)
}
@@ -546,13 +548,21 @@ func TestForeignAndMalformedCursor(t *testing.T) {
st.CreateMessage(chatB.ID, u.ID, "Message 2 in B")
// Получаем валидный курсор из Чата А (запрашиваем 1 из 2)
pageA, err := st.GetMessages(chatA.ID, u.ID, 1, "")
if err != nil || pageA.NextCursor == nil {
itemsA, hasMore, err := st.GetMessages(chatA.ID, u.ID, 1, nil)
if err != nil || !hasMore || len(itemsA) != 1 {
t.Fatalf("expected next_cursor in Chat A, err: %v", err)
}
nextCursor, err := newTestCursorCodec().EncodeMessage(domain.MessageCursor{
CreatedAt: itemsA[0].CreatedAt,
MessageID: itemsA[0].ID,
ChatID: chatA.ID,
})
if err != nil {
t.Fatalf("encode test cursor: %v", err)
}
// 1. Пытаемся применить курсор от Чата А к Чату Б -> строго 400!
urlForeign := fmt.Sprintf("%s/api/v1/chats/%s/messages?cursor=%s", ts.URL, chatB.ID, *pageA.NextCursor)
urlForeign := fmt.Sprintf("%s/api/v1/chats/%s/messages?cursor=%s", ts.URL, chatB.ID, nextCursor)
reqForeign, _ := http.NewRequest(http.MethodGet, urlForeign, nil)
reqForeign.Header.Set("X-User-Id", u.ID)
resForeign, _ := http.DefaultClient.Do(reqForeign)