From 2f279a1715f13d8ad8ff7d13686ca66c0dea2d8a Mon Sep 17 00:00:00 2001 From: kk10 Date: Fri, 2 Oct 2026 11:45:26 +0300 Subject: [PATCH] chore: port lab 1 solution --- .env.example | 5 + Dockerfile | 21 +++ Makefile | 2 + cmd/server/main.go | 18 +++ docker-compose.yml | 12 ++ go.mod | 9 ++ go.sum | 6 + internal/app/app.go | 75 +++++++++ internal/app/healthcheck.go | 46 ++++++ internal/app/router.go | 53 +++++++ internal/config/config.go | 80 ++++++++++ internal/dto/chat.go | 49 ++++++ internal/dto/error.go | 25 +++ internal/dto/health.go | 5 + internal/dto/message.go | 46 ++++++ internal/dto/user.go | 37 +++++ internal/handler/chat.go | 168 ++++++++++++++++++++ internal/handler/error.go | 27 ++++ internal/handler/health.go | 17 +++ internal/handler/message.go | 142 +++++++++++++++++ internal/handler/user.go | 102 +++++++++++++ internal/httpx/pagination.go | 34 +++++ internal/httpx/request.go | 29 ++++ internal/httpx/response.go | 24 +++ internal/logger/logger.go | 14 ++ internal/middleware/auth.go | 65 ++++++++ internal/middleware/concurrency.go | 41 +++++ internal/middleware/logging.go | 49 ++++++ internal/middleware/request_id.go | 30 ++++ internal/model/chat.go | 14 ++ internal/model/message.go | 15 ++ internal/model/user.go | 14 ++ internal/service/chat.go | 109 +++++++++++++ internal/service/cursor.go | 40 +++++ internal/service/message.go | 87 +++++++++++ internal/service/user.go | 47 ++++++ internal/store/memory.go | 236 +++++++++++++++++++++++++++++ student-tests/contract_test.go | 135 +++++++++++++++++ student-tests/helpers_test.go | 198 ++++++++++++++++++++++++ student-tests/load_test.go | 138 +++++++++++++++++ student-tests/race_test.go | 100 ++++++++++++ student.mk | 17 +++ web/swagger/index.html | 21 +++ 43 files changed, 2402 insertions(+) create mode 100644 Dockerfile create mode 100644 cmd/server/main.go create mode 100644 docker-compose.yml create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/app/app.go create mode 100644 internal/app/healthcheck.go create mode 100644 internal/app/router.go create mode 100644 internal/config/config.go create mode 100644 internal/dto/chat.go create mode 100644 internal/dto/error.go create mode 100644 internal/dto/health.go create mode 100644 internal/dto/message.go create mode 100644 internal/dto/user.go create mode 100644 internal/handler/chat.go create mode 100644 internal/handler/error.go create mode 100644 internal/handler/health.go create mode 100644 internal/handler/message.go create mode 100644 internal/handler/user.go create mode 100644 internal/httpx/pagination.go create mode 100644 internal/httpx/request.go create mode 100644 internal/httpx/response.go create mode 100644 internal/logger/logger.go create mode 100644 internal/middleware/auth.go create mode 100644 internal/middleware/concurrency.go create mode 100644 internal/middleware/logging.go create mode 100644 internal/middleware/request_id.go create mode 100644 internal/model/chat.go create mode 100644 internal/model/message.go create mode 100644 internal/model/user.go create mode 100644 internal/service/chat.go create mode 100644 internal/service/cursor.go create mode 100644 internal/service/message.go create mode 100644 internal/service/user.go create mode 100644 internal/store/memory.go create mode 100644 student-tests/contract_test.go create mode 100644 student-tests/helpers_test.go create mode 100644 student-tests/load_test.go create mode 100644 student-tests/race_test.go create mode 100644 student.mk create mode 100644 web/swagger/index.html diff --git a/.env.example b/.env.example index 714c807..32b5e23 100644 --- a/.env.example +++ b/.env.example @@ -3,6 +3,11 @@ APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab + +MAX_INFLIGHT_REQUESTS=0 + +LOG_LEVEL=INFO + SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..d44495b --- /dev/null +++ b/Dockerfile @@ -0,0 +1,21 @@ +FROM golang:1.25.0 AS build +WORKDIR /src + +COPY go.mod go.sum ./ +RUN go mod download + +COPY . . +RUN CGO_ENABLED=0 GOOS=linux go build -o /out/server ./cmd/server + +FROM gcr.io/distroless/static-debian12:nonroot +WORKDIR /app +COPY --from=build /out/server . +COPY contracts ./contracts +COPY web/swagger ./web/swagger + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD ["/app/server", "healthcheck"] + +ENTRYPOINT ["/app/server"] diff --git a/Makefile b/Makefile index 9ecb223..93b05a5 100644 --- a/Makefile +++ b/Makefile @@ -24,3 +24,5 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +-include student.mk diff --git a/cmd/server/main.go b/cmd/server/main.go new file mode 100644 index 0000000..e4032d4 --- /dev/null +++ b/cmd/server/main.go @@ -0,0 +1,18 @@ +package main + +import ( + "log" + "os" + + "mtusi2026-messenger/internal/app" +) + +func main() { + if len(os.Args) > 1 && os.Args[1] == "healthcheck" { + os.Exit(app.Healthcheck()) + } + + if err := app.Run(); err != nil { + log.Fatal(err) + } +} diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..08adff4 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,12 @@ +services: + messenger: + build: + context: . + dockerfile: Dockerfile + image: mtusi-messenger:lab1 + container_name: mtusi-messenger-lab1 + ports: + - "127.0.0.1:8080:${APP_PORT}" + env_file: + - .env + restart: unless-stopped diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..1930f28 --- /dev/null +++ b/go.mod @@ -0,0 +1,9 @@ +module mtusi2026-messenger + +go 1.25.0 + +require ( + github.com/go-chi/chi/v5 v5.3.2 + github.com/google/uuid v1.6.0 + github.com/joho/godotenv v1.5.1 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..02c7523 --- /dev/null +++ b/go.sum @@ -0,0 +1,6 @@ +github.com/go-chi/chi/v5 v5.3.2 h1:5YQkICvTCSZ25hoRsyJazN0scjzKGiu4VAUc7H1o1nY= +github.com/go-chi/chi/v5 v5.3.2/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= diff --git a/internal/app/app.go b/internal/app/app.go new file mode 100644 index 0000000..0fdbc87 --- /dev/null +++ b/internal/app/app.go @@ -0,0 +1,75 @@ +package app + +import ( + "context" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "github.com/joho/godotenv" + + "mtusi2026-messenger/internal/config" + "mtusi2026-messenger/internal/logger" + "mtusi2026-messenger/internal/service" + "mtusi2026-messenger/internal/store" +) + +func Run() error { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + return err + } + + cfg := config.Load() + + log := logger.New(cfg.Logging.Level) + + memory := store.New() + + userService := service.NewUserService(memory) + chatService := service.NewChatService(memory) + messageService := service.NewMessageService(memory) + + router := NewRouter(log, cfg.Server.MaxInflightRequests, userService, chatService, messageService) + + server := &http.Server{ + Addr: cfg.Server.Host + ":" + cfg.Server.Port, + Handler: router, + } + + serverErrors := make(chan error, 1) + + go func() { + log.Info("server starting", "addr", server.Addr) + serverErrors <- server.ListenAndServe() + }() + + signalCh := make(chan os.Signal, 1) + signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM) + defer signal.Stop(signalCh) + + select { + case err := <-serverErrors: + if err == http.ErrServerClosed { + return nil + } + + log.Error("server failed", "error", err) + return err + + case sig := <-signalCh: + log.Info("shutdown signal received", "signal", sig.String()) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + if err := server.Shutdown(ctx); err != nil { + log.Error("server shutdown failed", "error", err) + return err + } + + log.Info("server stopped") + return nil + } +} diff --git a/internal/app/healthcheck.go b/internal/app/healthcheck.go new file mode 100644 index 0000000..6cab927 --- /dev/null +++ b/internal/app/healthcheck.go @@ -0,0 +1,46 @@ +package app + +import ( + "context" + "fmt" + "net/http" + "os" + "time" + + "mtusi2026-messenger/internal/config" + + "github.com/joho/godotenv" +) + +func Healthcheck() int { + if err := godotenv.Load(); err != nil && !os.IsNotExist(err) { + fmt.Fprintln(os.Stderr, "healthcheck: load env:", err) + return 1 + } + + cfg := config.Load() + url := fmt.Sprintf("http://localhost:%s/health/ready", cfg.Server.Port) + + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) + if err != nil { + fmt.Fprintln(os.Stderr, "healthcheck: build request:", err) + return 1 + } + + resp, err := http.DefaultClient.Do(req) + if err != nil { + fmt.Fprintln(os.Stderr, "healthcheck: request failed:", err) + return 1 + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + fmt.Fprintln(os.Stderr, "healthcheck: unexpected status", resp.StatusCode) + return 1 + } + + return 0 +} diff --git a/internal/app/router.go b/internal/app/router.go new file mode 100644 index 0000000..0120396 --- /dev/null +++ b/internal/app/router.go @@ -0,0 +1,53 @@ +package app + +import ( + "log/slog" + "net/http" + + "github.com/go-chi/chi/v5" + + "mtusi2026-messenger/internal/handler" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +func NewRouter( + log *slog.Logger, + maxInflightRequests int, + userService *service.UserService, + chatService *service.ChatService, + messageService *service.MessageService, +) http.Handler { + router := chi.NewRouter() + + userHandler := handler.NewUserHandler(userService) + chatHandler := handler.NewChatHandler(chatService) + messageHandler := handler.NewMessageHandler(messageService) + + router.Use(middleware.RequestID) + router.Use(middleware.Logging(log)) + router.Use(middleware.ConcurrencyLimit(maxInflightRequests)) + + router.Get("/health/live", handler.Health) + router.Get("/health/ready", handler.Health) + + router.Post("/api/v1/users", userHandler.Create) + + router.Group(func(r chi.Router) { + r.Use(middleware.Auth(userService)) + + r.Get("/api/v1/users/me", userHandler.Me) + + r.Post("/api/v1/chats", chatHandler.Create) + r.Get("/api/v1/chats", chatHandler.List) + r.Get("/api/v1/chats/{chat_id}", chatHandler.Get) + + r.Post("/api/v1/chats/{chat_id}/messages", messageHandler.Create) + r.Get("/api/v1/chats/{chat_id}/messages", messageHandler.List) + }) + + router.Handle("/swagger/*", http.StripPrefix("/swagger/", http.FileServer(http.Dir("web/swagger")))) + router.Handle("/contracts/*", http.StripPrefix("/contracts/", http.FileServer(http.Dir("contracts")))) + + return router +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 0000000..710eb9b --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,80 @@ +package config + +import ( + "log" + "log/slog" + "os" + "strconv" +) + +type Config struct { + Server ServerConfig + Logging LoggingConfig +} + +type ServerConfig struct { + Host string + Port string + MaxInflightRequests int +} + +type LoggingConfig struct { + Level slog.Level +} + +func Load() Config { + return Config{ + Server: ServerConfig{ + Host: getEnv("APP_HOST", "0.0.0.0"), + Port: getEnv("APP_PORT", "8080"), + MaxInflightRequests: getEnvNonNegativeInt("MAX_INFLIGHT_REQUESTS", 0), + }, + + Logging: LoggingConfig{ + Level: getEnvLogLevel("LOG_LEVEL", slog.LevelInfo), + }, + } +} +func getEnv(key, def string) string { + value := os.Getenv(key) + if value == "" { + return def + } + + return value +} + +func getEnvNonNegativeInt(key string, def int) int { + v := os.Getenv(key) + if v == "" { + return def + } + + value, err := strconv.Atoi(v) + if err != nil || value < 0 { + log.Printf("invalid non-negative int for %s=%q, using default %d", key, v, def) + return def + } + + return value +} + +func getEnvLogLevel(key string, def slog.Level) slog.Level { + v := os.Getenv(key) + + switch v { + case "DEBUG": + return slog.LevelDebug + case "INFO": + return slog.LevelInfo + case "WARN": + return slog.LevelWarn + case "ERROR": + return slog.LevelError + case "": + return def + default: + log.Printf("invalid log level for %s=%q, using default %s", key, v, def) + return def + } +} diff --git a/internal/dto/chat.go b/internal/dto/chat.go new file mode 100644 index 0000000..904b7de --- /dev/null +++ b/internal/dto/chat.go @@ -0,0 +1,49 @@ +package dto + +import ( + "mtusi2026-messenger/internal/model" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" +) + +type CreateChatRequest struct { + Title string `json:"title"` + MemberIDs []uuid.UUID `json:"member_ids"` +} + +type ChatResponse struct { + ID uuid.UUID `json:"id"` + Title string `json:"title"` + MemberIDs []uuid.UUID `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +type ChatPageResponse struct { + Items []ChatResponse `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +func (r CreateChatRequest) Validate() bool { + titleLen := utf8.RuneCountInString(r.Title) + if strings.TrimSpace(r.Title) == "" || titleLen > 100 { + return false + } + + if len(r.MemberIDs) < 1 || len(r.MemberIDs) > 100 { + return false + } + + return true +} + +func ToChatResponse(c model.Chat) ChatResponse { + return ChatResponse{ + ID: c.ID, + Title: c.Title, + MemberIDs: c.MemberIDs, + CreatedAt: c.CreatedAt, + } +} diff --git a/internal/dto/error.go b/internal/dto/error.go new file mode 100644 index 0000000..3a46305 --- /dev/null +++ b/internal/dto/error.go @@ -0,0 +1,25 @@ +package dto + +type ErrorCode string + +const ( + ErrorCodeInvalidRequest ErrorCode = "invalid_request" + ErrorCodeUnauthorized ErrorCode = "unauthorized" + ErrorCodeNotFound ErrorCode = "not_found" + ErrorCodeConflict ErrorCode = "conflict" + ErrorCodePayloadTooLarge ErrorCode = "payload_too_large" + ErrorCodeUnsupportedMediaType ErrorCode = "unsupported_media_type" + ErrorCodeRateLimited ErrorCode = "rate_limited" + ErrorCodeUnavailable ErrorCode = "unavailable" + ErrorCodeInternalError ErrorCode = "internal_error" +) + +type ErrorResponse struct { + Error Error `json:"error"` +} + +type Error struct { + Code ErrorCode `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} diff --git a/internal/dto/health.go b/internal/dto/health.go new file mode 100644 index 0000000..8bb3503 --- /dev/null +++ b/internal/dto/health.go @@ -0,0 +1,5 @@ +package dto + +type HealthResponse struct { + Status string `json:"status"` +} diff --git a/internal/dto/message.go b/internal/dto/message.go new file mode 100644 index 0000000..0997a29 --- /dev/null +++ b/internal/dto/message.go @@ -0,0 +1,46 @@ +package dto + +import ( + "mtusi2026-messenger/internal/model" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" +) + +type CreateMessageRequest struct { + Text string `json:"text"` +} + +type MessageResponse struct { + ID uuid.UUID `json:"id"` + ChatID uuid.UUID `json:"chat_id"` + SenderID uuid.UUID `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 (r CreateMessageRequest) Validate() bool { + textLen := utf8.RuneCountInString(r.Text) + if strings.TrimSpace(r.Text) == "" || textLen > 4000 { + return false + } + + return true +} + +func ToMessageResponse(m model.Message) MessageResponse { + return MessageResponse{ + ID: m.ID, + ChatID: m.ChatID, + SenderID: m.SenderID, + Text: m.Text, + CreatedAt: m.CreatedAt, + } +} diff --git a/internal/dto/user.go b/internal/dto/user.go new file mode 100644 index 0000000..dfe826b --- /dev/null +++ b/internal/dto/user.go @@ -0,0 +1,37 @@ +package dto + +import ( + "regexp" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +type CreateUserRequest struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` +} + +type UserResponse struct { + ID uuid.UUID `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +func (r CreateUserRequest) Validate() bool { + if !usernamePattern.MatchString(r.Username) { + return false + } + + displayNameLength := utf8.RuneCountInString(r.DisplayName) + if strings.TrimSpace(r.DisplayName) == "" || displayNameLength > 100 { + return false + } + + return true +} diff --git a/internal/handler/chat.go b/internal/handler/chat.go new file mode 100644 index 0000000..24a9178 --- /dev/null +++ b/internal/handler/chat.go @@ -0,0 +1,168 @@ +package handler + +import ( + "errors" + "net/http" + + "github.com/go-chi/chi/v5" + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type ChatHandler struct { + service *service.ChatService +} + +func NewChatHandler(service *service.ChatService) *ChatHandler { + return &ChatHandler{service: service} +} + +func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + var req dto.CreateChatRequest + if !httpx.DecodeJSONBody(w, r, requestID, &req) { + return + } + + if !req.Validate() { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid request body", + requestID, + ) + return + } + + chat, err := h.service.Create(userID, req.Title, req.MemberIDs) + switch { + case errors.Is(err, service.ErrNotChatMember): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "caller must be a member of member_ids", + requestID, + ) + return + case errors.Is(err, service.ErrDuplicateMember): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "member_ids contains duplicates", + requestID, + ) + return + case errors.Is(err, service.ErrUnknownMember): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "member_ids contains unknown user", + requestID, + ) + return + case err != nil: + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.ToChatResponse(chat)) +} + +func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid chat_id", + requestID, + ) + return + } + + chat, err := h.service.Get(userID, chatID) + switch { + case errors.Is(err, service.ErrChatNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "chat not found", + requestID, + ) + return + case err != nil: + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + httpx.WriteJSON(w, http.StatusOK, dto.ToChatResponse(chat)) +} + +func (h *ChatHandler) List(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + limit, cursor, ok := httpx.ParsePagination(w, r, requestID) + if !ok { + return + } + + chats, nextCursor, err := h.service.List(userID, limit, cursor) + switch { + case errors.Is(err, service.ErrInvalidCursor): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid cursor", + requestID, + ) + return + case err != nil: + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + items := make([]dto.ChatResponse, 0, len(chats)) + for _, c := range chats { + items = append(items, dto.ToChatResponse(c)) + } + + httpx.WriteJSON(w, http.StatusOK, dto.ChatPageResponse{ + Items: items, + NextCursor: nextCursor, + }) +} diff --git a/internal/handler/error.go b/internal/handler/error.go new file mode 100644 index 0000000..34bb0bb --- /dev/null +++ b/internal/handler/error.go @@ -0,0 +1,27 @@ +package handler + +import ( + "encoding/json" + "net/http" + + "mtusi2026-messenger/internal/dto" +) + +func WriteError( + w http.ResponseWriter, + status int, + code dto.ErrorCode, + message string, + requestID string, +) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + + _ = json.NewEncoder(w).Encode(dto.ErrorResponse{ + Error: dto.Error{ + Code: code, + Message: message, + RequestID: requestID, + }, + }) +} diff --git a/internal/handler/health.go b/internal/handler/health.go new file mode 100644 index 0000000..b6e0812 --- /dev/null +++ b/internal/handler/health.go @@ -0,0 +1,17 @@ +package handler + +import ( + "encoding/json" + "net/http" + + "mtusi2026-messenger/internal/dto" +) + +func Health(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + + _ = json.NewEncoder(w).Encode(dto.HealthResponse{ + Status: "ok", + }) +} diff --git a/internal/handler/message.go b/internal/handler/message.go new file mode 100644 index 0000000..191590e --- /dev/null +++ b/internal/handler/message.go @@ -0,0 +1,142 @@ +package handler + +import ( + "errors" + "net/http" + + "github.com/go-chi/chi/v5" + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type MessageHandler struct { + service *service.MessageService +} + +func NewMessageHandler(service *service.MessageService) *MessageHandler { + return &MessageHandler{service: service} +} + +func (h *MessageHandler) Create(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid chat_id", + requestID, + ) + return + } + + var req dto.CreateMessageRequest + if !httpx.DecodeJSONBody(w, r, requestID, &req) { + return + } + + if !req.Validate() { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid request body", + requestID, + ) + return + } + + message, err := h.service.Create(userID, chatID, req.Text) + switch { + case errors.Is(err, service.ErrMessageChatNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "chat not found", + requestID, + ) + return + case err != nil: + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.ToMessageResponse(message)) +} + +func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + chatID, err := uuid.Parse(chi.URLParam(r, "chat_id")) + if err != nil { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid chat_id", + requestID, + ) + return + } + + limit, cursor, ok := httpx.ParsePagination(w, r, requestID) + if !ok { + return + } + + messages, nextCursor, err := h.service.List(userID, chatID, limit, cursor) + switch { + case errors.Is(err, service.ErrMessageChatNotFound): + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "chat not found", + requestID, + ) + return + case errors.Is(err, service.ErrInvalidCursor): + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid cursor", + requestID, + ) + return + case err != nil: + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + items := make([]dto.MessageResponse, 0, len(messages)) + for _, m := range messages { + items = append(items, dto.ToMessageResponse(m)) + } + + httpx.WriteJSON(w, http.StatusOK, dto.MessagePageResponse{ + Items: items, + NextCursor: nextCursor, + }) +} diff --git a/internal/handler/user.go b/internal/handler/user.go new file mode 100644 index 0000000..0a16309 --- /dev/null +++ b/internal/handler/user.go @@ -0,0 +1,102 @@ +package handler + +import ( + "errors" + "net/http" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/middleware" + "mtusi2026-messenger/internal/service" +) + +type UserHandler struct { + service *service.UserService +} + +func NewUserHandler(service *service.UserService) *UserHandler { + return &UserHandler{service: service} +} + +func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + + var req dto.CreateUserRequest + if !httpx.DecodeJSONBody(w, r, requestID, &req) { + return + } + + if !req.Validate() { + httpx.WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "invalid request body", + requestID, + ) + return + } + + user, err := h.service.Create(req.Username, req.DisplayName) + if errors.Is(err, service.ErrUsernameTaken) { + httpx.WriteError( + w, + http.StatusConflict, + dto.ErrorCodeConflict, + "username already taken", + requestID, + ) + return + } + if err != nil { + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + httpx.WriteJSON(w, http.StatusCreated, dto.UserResponse{ + ID: user.ID, + Username: user.Username, + DisplayName: user.DisplayName, + CreatedAt: user.CreatedAt, + }) +} + +func (h *UserHandler) Me(w http.ResponseWriter, r *http.Request) { + requestID := middleware.GetRequestID(r.Context()) + userID := middleware.GetUserID(r.Context()) + + user, err := h.service.GetByID(userID) + if errors.Is(err, service.ErrUserNotFound) { + httpx.WriteError( + w, + http.StatusNotFound, + dto.ErrorCodeNotFound, + "user not found", + requestID, + ) + return + } + if err != nil { + httpx.WriteError( + w, + http.StatusInternalServerError, + dto.ErrorCodeInternalError, + "internal server error", + requestID, + ) + return + } + + httpx.WriteJSON(w, http.StatusOK, dto.UserResponse{ + ID: user.ID, + Username: user.Username, + DisplayName: user.DisplayName, + CreatedAt: user.CreatedAt, + }) +} diff --git a/internal/httpx/pagination.go b/internal/httpx/pagination.go new file mode 100644 index 0000000..2e7e022 --- /dev/null +++ b/internal/httpx/pagination.go @@ -0,0 +1,34 @@ +package httpx + +import ( + "net/http" + "strconv" + + "mtusi2026-messenger/internal/dto" +) + +func ParsePagination(w http.ResponseWriter, r *http.Request, requestID string) (limit int, cursor *string, ok bool) { + q := r.URL.Query() + + limit = 50 + if raw := q.Get("limit"); raw != "" { + v, err := strconv.Atoi(raw) + if err != nil || v < 1 || v > 100 { + WriteError( + w, + http.StatusBadRequest, + dto.ErrorCodeInvalidRequest, + "limit must be an integer between 1 and 100", + requestID, + ) + return 0, nil, false + } + limit = v + } + + if raw := q.Get("cursor"); raw != "" { + cursor = &raw + } + + return limit, cursor, true +} diff --git a/internal/httpx/request.go b/internal/httpx/request.go new file mode 100644 index 0000000..7a376e4 --- /dev/null +++ b/internal/httpx/request.go @@ -0,0 +1,29 @@ +package httpx + +import ( + "encoding/json" + "mime" + "net/http" + + "mtusi2026-messenger/internal/dto" +) + +func DecodeJSONBody(w http.ResponseWriter, r *http.Request, requestID string, dst any) bool { + if ct := r.Header.Get("Content-Type"); ct != "" { + mt, _, err := mime.ParseMediaType(ct) + if err != nil || mt != "application/json" { + WriteError(w, http.StatusUnsupportedMediaType, dto.ErrorCodeUnsupportedMediaType, "expected application/json", requestID) + return false + } + } + + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + + if err := decoder.Decode(dst); err != nil { + WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID) + return false + } + + return true +} diff --git a/internal/httpx/response.go b/internal/httpx/response.go new file mode 100644 index 0000000..9a12f0b --- /dev/null +++ b/internal/httpx/response.go @@ -0,0 +1,24 @@ +package httpx + +import ( + "encoding/json" + "net/http" + + "mtusi2026-messenger/internal/dto" +) + +func WriteJSON(w http.ResponseWriter, status int, body any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(body) +} + +func WriteError(w http.ResponseWriter, status int, code dto.ErrorCode, message, requestID string) { + WriteJSON(w, status, dto.ErrorResponse{ + Error: dto.Error{ + Code: code, + Message: message, + RequestID: requestID, + }, + }) +} diff --git a/internal/logger/logger.go b/internal/logger/logger.go new file mode 100644 index 0000000..89ce600 --- /dev/null +++ b/internal/logger/logger.go @@ -0,0 +1,14 @@ +package logger + +import ( + "log/slog" + "os" +) + +func New(level slog.Level) *slog.Logger { + return slog.New( + slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ + Level: level, + }), + ) +} diff --git a/internal/middleware/auth.go b/internal/middleware/auth.go new file mode 100644 index 0000000..38cc7da --- /dev/null +++ b/internal/middleware/auth.go @@ -0,0 +1,65 @@ +package middleware + +import ( + "context" + "net/http" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" + "mtusi2026-messenger/internal/service" +) + +type userIDContextKey struct{} + +func Auth(userService *service.UserService) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + requestID := GetRequestID(r.Context()) + + raw := r.Header.Get("X-User-Id") + if raw == "" { + httpx.WriteError( + w, + http.StatusUnauthorized, + dto.ErrorCodeUnauthorized, + "missing X-User-Id header", + requestID, + ) + return + } + + userID, err := uuid.Parse(raw) + if err != nil { + httpx.WriteError( + w, + http.StatusUnauthorized, + dto.ErrorCodeUnauthorized, + "invalid X-User-Id header", + requestID, + ) + return + } + + if _, err := userService.GetByID(userID); err != nil { + httpx.WriteError( + w, + http.StatusUnauthorized, + dto.ErrorCodeUnauthorized, + "unknown user", + requestID, + ) + return + } + + ctx := context.WithValue(r.Context(), userIDContextKey{}, userID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +func GetUserID(ctx context.Context) uuid.UUID { + id, _ := ctx.Value(userIDContextKey{}).(uuid.UUID) + return id +} diff --git a/internal/middleware/concurrency.go b/internal/middleware/concurrency.go new file mode 100644 index 0000000..631f4bc --- /dev/null +++ b/internal/middleware/concurrency.go @@ -0,0 +1,41 @@ +package middleware + +import ( + "net/http" + + "mtusi2026-messenger/internal/dto" + "mtusi2026-messenger/internal/httpx" +) + +func ConcurrencyLimit(max int) func(http.Handler) http.Handler { + if max <= 0 { + return func(next http.Handler) http.Handler { + return next + } + } + + slots := make(chan struct{}, max) + + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + select { + case slots <- struct{}{}: + defer func() { + <-slots + }() + + next.ServeHTTP(w, r) + + default: + w.Header().Set("Retry-After", "1") + httpx.WriteError( + w, + http.StatusTooManyRequests, + dto.ErrorCodeRateLimited, + "too many requests", + GetRequestID(r.Context()), + ) + } + }) + } +} diff --git a/internal/middleware/logging.go b/internal/middleware/logging.go new file mode 100644 index 0000000..ab28a61 --- /dev/null +++ b/internal/middleware/logging.go @@ -0,0 +1,49 @@ +package middleware + +import ( + "log/slog" + "net/http" + "time" +) + +type responseWriter struct { + http.ResponseWriter + status int +} + +func (w *responseWriter) WriteHeader(status int) { + w.status = status + w.ResponseWriter.WriteHeader(status) +} + +func Logging(log *slog.Logger) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + + writer := &responseWriter{ + ResponseWriter: w, + status: http.StatusOK, + } + + next.ServeHTTP(writer, r) + + level := slog.LevelInfo + + switch { + case writer.status >= 500: + level = slog.LevelError + case writer.status >= 400: + level = slog.LevelWarn + } + + log.Log(r.Context(), level, "http request", + "request_id", GetRequestID(r.Context()), + "method", r.Method, + "path", r.URL.Path, + "status", writer.status, + "duration_ms", time.Since(start).Milliseconds(), + ) + }) + } +} diff --git a/internal/middleware/request_id.go b/internal/middleware/request_id.go new file mode 100644 index 0000000..d62808b --- /dev/null +++ b/internal/middleware/request_id.go @@ -0,0 +1,30 @@ +package middleware + +import ( + "context" + "net/http" + + "github.com/google/uuid" +) + +type requestIDContextKey struct{} + +func RequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + requestID := r.Header.Get("X-Request-Id") + + if requestID == "" { + requestID = uuid.NewString() + } + + w.Header().Set("X-Request-Id", requestID) + + ctx := context.WithValue(r.Context(), requestIDContextKey{}, requestID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func GetRequestID(ctx context.Context) string { + id, _ := ctx.Value(requestIDContextKey{}).(string) + return id +} diff --git a/internal/model/chat.go b/internal/model/chat.go new file mode 100644 index 0000000..2c47c49 --- /dev/null +++ b/internal/model/chat.go @@ -0,0 +1,14 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type Chat struct { + ID uuid.UUID + Title string + MemberIDs []uuid.UUID + CreatedAt time.Time +} diff --git a/internal/model/message.go b/internal/model/message.go new file mode 100644 index 0000000..5c2cf5f --- /dev/null +++ b/internal/model/message.go @@ -0,0 +1,15 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type Message struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + CreatedAt time.Time +} diff --git a/internal/model/user.go b/internal/model/user.go new file mode 100644 index 0000000..dc7eff1 --- /dev/null +++ b/internal/model/user.go @@ -0,0 +1,14 @@ +package model + +import ( + "time" + + "github.com/google/uuid" +) + +type User struct { + ID uuid.UUID + Username string + DisplayName string + CreatedAt time.Time +} diff --git a/internal/service/chat.go b/internal/service/chat.go new file mode 100644 index 0000000..a6f20ba --- /dev/null +++ b/internal/service/chat.go @@ -0,0 +1,109 @@ +package service + +import ( + "errors" + "slices" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/store" +) + +var ( + ErrChatNotFound = errors.New("chat not found") + ErrNotChatMember = errors.New("caller must be a member of member_ids") + ErrDuplicateMember = errors.New("member_ids contains duplicates") + ErrUnknownMember = errors.New("member_ids contains unknown user") +) + +type ChatService struct { + store *store.Memory +} + +func NewChatService(store *store.Memory) *ChatService { + return &ChatService{store: store} +} + +func (s *ChatService) Create( + userID uuid.UUID, + title string, + memberIDs []uuid.UUID, +) (model.Chat, error) { + if !slices.Contains(memberIDs, userID) { + return model.Chat{}, ErrNotChatMember + } + + chat, err := s.store.CreateChat(title, memberIDs) + switch { + case errors.Is(err, store.ErrDuplicateMember): + return model.Chat{}, ErrDuplicateMember + case errors.Is(err, store.ErrUnknownMember): + return model.Chat{}, ErrUnknownMember + case err != nil: + return model.Chat{}, err + } + + return chat, nil +} + +func (s *ChatService) Get( + userID uuid.UUID, + chatID uuid.UUID, +) (model.Chat, error) { + chat, err := s.store.GetChat(chatID, userID) + if errors.Is(err, store.ErrNotFound) { + return model.Chat{}, ErrChatNotFound + } + if err != nil { + return model.Chat{}, err + } + + return chat, nil +} + +func (s *ChatService) List( + userID uuid.UUID, + limit int, + cursor *string, +) ([]model.Chat, *string, error) { + var afterCreatedAt *time.Time + var afterID *uuid.UUID + + if cursor != nil { + decoded, err := decodeCursor(*cursor) + if err != nil { + return nil, nil, ErrInvalidCursor + } + + afterCreatedAt = &decoded.CreatedAt + afterID = &decoded.ID + } + + chats, hasMore, err := s.store.ListChats( + userID, + afterCreatedAt, + afterID, + limit, + ) + if errors.Is(err, store.ErrInvalidCursor) { + return nil, nil, ErrInvalidCursor + } + if err != nil { + return nil, nil, err + } + + var next *string + if hasMore && len(chats) > 0 { + last := chats[len(chats)-1] + + c := encodeCursor(Cursor{ + CreatedAt: last.CreatedAt, + ID: last.ID, + }) + next = &c + } + + return chats, next, nil +} diff --git a/internal/service/cursor.go b/internal/service/cursor.go new file mode 100644 index 0000000..b727bd1 --- /dev/null +++ b/internal/service/cursor.go @@ -0,0 +1,40 @@ +package service + +import ( + "encoding/base64" + "encoding/json" + "errors" + "time" + + "github.com/google/uuid" +) + +var ErrInvalidCursor = errors.New("invalid cursor") + +type Cursor struct { + CreatedAt time.Time `json:"created_at"` + ID uuid.UUID `json:"id"` +} + +func encodeCursor(cursor Cursor) string { + data, _ := json.Marshal(cursor) + return base64.RawURLEncoding.EncodeToString(data) +} + +func decodeCursor(raw string) (Cursor, error) { + data, err := base64.RawURLEncoding.DecodeString(raw) + if err != nil { + return Cursor{}, ErrInvalidCursor + } + + var cursor Cursor + if err := json.Unmarshal(data, &cursor); err != nil { + return Cursor{}, ErrInvalidCursor + } + + if cursor.ID == uuid.Nil || cursor.CreatedAt.IsZero() { + return Cursor{}, ErrInvalidCursor + } + + return cursor, nil +} diff --git a/internal/service/message.go b/internal/service/message.go new file mode 100644 index 0000000..93cb2f7 --- /dev/null +++ b/internal/service/message.go @@ -0,0 +1,87 @@ +package service + +import ( + "errors" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/store" +) + +var ErrMessageChatNotFound = errors.New("chat not found") + +type MessageService struct { + store *store.Memory +} + +func NewMessageService(store *store.Memory) *MessageService { + return &MessageService{store: store} +} + +func (s *MessageService) Create( + userID uuid.UUID, + chatID uuid.UUID, + text string, +) (model.Message, error) { + message, err := s.store.CreateMessage(chatID, userID, text) + if errors.Is(err, store.ErrNotFound) { + return model.Message{}, ErrMessageChatNotFound + } + if err != nil { + return model.Message{}, err + } + + return message, nil +} + +func (s *MessageService) List( + userID uuid.UUID, + chatID uuid.UUID, + limit int, + cursor *string, +) ([]model.Message, *string, error) { + var afterCreatedAt *time.Time + var afterID *uuid.UUID + + if cursor != nil { + decoded, err := decodeCursor(*cursor) + if err != nil { + return nil, nil, ErrInvalidCursor + } + + afterCreatedAt = &decoded.CreatedAt + afterID = &decoded.ID + } + + messages, hasMore, err := s.store.ListMessages( + chatID, + userID, + afterCreatedAt, + afterID, + limit, + ) + if errors.Is(err, store.ErrNotFound) { + return nil, nil, ErrMessageChatNotFound + } + if errors.Is(err, store.ErrInvalidCursor) { + return nil, nil, ErrInvalidCursor + } + if err != nil { + return nil, nil, err + } + + var next *string + if hasMore && len(messages) > 0 { + last := messages[len(messages)-1] + + c := encodeCursor(Cursor{ + CreatedAt: last.CreatedAt, + ID: last.ID, + }) + next = &c + } + + return messages, next, nil +} diff --git a/internal/service/user.go b/internal/service/user.go new file mode 100644 index 0000000..140d4cc --- /dev/null +++ b/internal/service/user.go @@ -0,0 +1,47 @@ +package service + +import ( + "errors" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/model" + "mtusi2026-messenger/internal/store" +) + +var ( + ErrUserNotFound = errors.New("user not found") + ErrUsernameTaken = errors.New("username already taken") +) + +type UserService struct { + store *store.Memory +} + +func NewUserService(store *store.Memory) *UserService { + return &UserService{store: store} +} + +func (s *UserService) Create(username, displayName string) (model.User, error) { + user, err := s.store.CreateUser(username, displayName) + if errors.Is(err, store.ErrConflict) { + return model.User{}, ErrUsernameTaken + } + if err != nil { + return model.User{}, err + } + + return user, nil +} + +func (s *UserService) GetByID(id uuid.UUID) (model.User, error) { + user, err := s.store.GetUser(id) + if errors.Is(err, store.ErrNotFound) { + return model.User{}, ErrUserNotFound + } + if err != nil { + return model.User{}, err + } + + return user, nil +} diff --git a/internal/store/memory.go b/internal/store/memory.go new file mode 100644 index 0000000..8783c0e --- /dev/null +++ b/internal/store/memory.go @@ -0,0 +1,236 @@ +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 +} diff --git a/student-tests/contract_test.go b/student-tests/contract_test.go new file mode 100644 index 0000000..08535e8 --- /dev/null +++ b/student-tests/contract_test.go @@ -0,0 +1,135 @@ +//go:build contract + +package studenttests_test + +import ( + "encoding/json" + "net/http" + "net/url" + "strconv" + "testing" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" +) + +func TestInvalidJSON(t *testing.T) { + resp := doRequest(t, http.MethodPost, "/api/v1/users", uuid.Nil, []byte(`{"username": "broken",`)) + requireStatus(t, resp, http.StatusBadRequest) + + var apiErr dto.ErrorResponse + mustDecode(t, resp, &apiErr) + + if apiErr.Error.Code != dto.ErrorCodeInvalidRequest { + t.Errorf("expected code %q, got %q", dto.ErrorCodeInvalidRequest, apiErr.Error.Code) + } +} + +func TestForeignChat(t *testing.T) { + user1 := createUser(t) + user2 := createUser(t) + user3 := createUser(t) + + chat := createChat(t, user1, user1.ID, user2.ID) + + resp := doRequest(t, http.MethodGet, "/api/v1/chats/"+chat.ID.String(), user3.ID, nil) + requireStatus(t, resp, http.StatusNotFound) + + resp = sendMessage(t, user3, chat.ID, "should not land") + requireStatus(t, resp, http.StatusNotFound) +} + +func TestEmptyMessage(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + for _, text := range []string{"", " ", "\t\n"} { + resp := sendMessage(t, user, chat.ID, text) + requireStatus(t, resp, http.StatusBadRequest) + } +} + +func TestDuplicateUsername(t *testing.T) { + user := createUser(t) + + body, err := json.Marshal(map[string]string{ + "username": user.Username, + "display_name": "Someone else", + }) + if err != nil { + t.Fatalf("marshal body: %v", err) + } + + resp := doRequest(t, http.MethodPost, "/api/v1/users", uuid.Nil, body) + requireStatus(t, resp, http.StatusConflict) + + var apiErr dto.ErrorResponse + mustDecode(t, resp, &apiErr) + + if apiErr.Error.Code != dto.ErrorCodeConflict { + t.Errorf("expected code %q, got %q", dto.ErrorCodeConflict, apiErr.Error.Code) + } +} + +func TestPagination(t *testing.T) { + user := createUser(t) + chat := createChat(t, user, user.ID) + + const total = 25 + const pageSize = 4 + + sent := make(map[string]bool, total) + for i := 0; i < total; i++ { + resp := sendMessage(t, user, chat.ID, "msg") + requireStatus(t, resp, http.StatusCreated) + + var msg dto.MessageResponse + mustDecode(t, resp, &msg) + sent[msg.ID.String()] = true + } + + seen := make(map[string]bool, total) + cursor := "" + pages := 0 + + for { + path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=" + strconv.Itoa(pageSize) + if cursor != "" { + path += "&cursor=" + url.QueryEscape(cursor) + } + + resp := doRequest(t, http.MethodGet, path, user.ID, nil) + requireStatus(t, resp, http.StatusOK) + + var page dto.MessagePageResponse + mustDecode(t, resp, &page) + pages++ + + for _, msg := range page.Items { + id := msg.ID.String() + if seen[id] { + t.Fatalf("duplicate message id across pages: %s", id) + } + seen[id] = true + } + + if page.NextCursor == nil { + break + } + cursor = *page.NextCursor + + if pages > total { + t.Fatalf("too many pages: got %d, expected at most %d", pages, total) + } + } + + if len(seen) != total { + t.Fatalf("expected %d unique messages across all pages, got %d", total, len(seen)) + } + for id := range sent { + if !seen[id] { + t.Fatalf("message %s sent but never seen while paginating", id) + } + } +} diff --git a/student-tests/helpers_test.go b/student-tests/helpers_test.go new file mode 100644 index 0000000..4e32c05 --- /dev/null +++ b/student-tests/helpers_test.go @@ -0,0 +1,198 @@ +package studenttests_test + +import ( + "bytes" + "encoding/json" + "flag" + "fmt" + "io" + "net/http" + "strings" + "testing" + "time" + + "github.com/google/uuid" + + "mtusi2026-messenger/internal/dto" +) + +var baseURL = flag.String("base-url", "http://127.0.0.1:8080", "base URL of the running server") + +var httpClient = &http.Client{ + Timeout: 10 * time.Second, + Transport: &http.Transport{ + MaxIdleConns: 200, + IdleConnTimeout: 30 * time.Second, + MaxIdleConnsPerHost: 200, + MaxConnsPerHost: 200, + }, +} + +func doRequest(t *testing.T, method, path string, actorID uuid.UUID, body []byte) *http.Response { + t.Helper() + + req, err := http.NewRequest(method, *baseURL+path, bytes.NewReader(body)) + if err != nil { + t.Fatalf("build request: %v", err) + } + + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + + if actorID != uuid.Nil { + req.Header.Set("X-User-Id", actorID.String()) + } + + resp, err := httpClient.Do(req) + if err != nil { + t.Fatalf("%s %s: request failed: %v", method, path, err) + } + + return resp +} + +func mustDecode(t *testing.T, resp *http.Response, dst any) { + t.Helper() + defer resp.Body.Close() + + data, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatalf("read body: %v", err) + } + + if err := json.Unmarshal(data, dst); err != nil { + t.Fatalf("decode body %q: %v", data, err) + } +} + +func requireStatus(t *testing.T, resp *http.Response, expected int) { + t.Helper() + + if resp.StatusCode != expected { + data, _ := io.ReadAll(resp.Body) + resp.Body.Close() + + t.Fatalf( + "expected status %d, got %d, body: %s", + expected, + resp.StatusCode, + data, + ) + } + + if resp.Header.Get("X-Request-Id") == "" { + t.Errorf("missing X-Request-Id header") + } +} + +func createUser(t *testing.T) dto.UserResponse { + t.Helper() + + username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12] + + body, err := json.Marshal(map[string]string{ + "username": username, + "display_name": "Test " + username, + }) + if err != nil { + t.Fatalf("marshal user: %v", err) + } + + resp := doRequest( + t, + http.MethodPost, + "/api/v1/users", + uuid.Nil, + body, + ) + + requireStatus(t, resp, http.StatusCreated) + + var u dto.UserResponse + mustDecode(t, resp, &u) + + return u +} + +func createChat( + t *testing.T, + creator dto.UserResponse, + memberIDs ...uuid.UUID, +) dto.ChatResponse { + t.Helper() + + body, err := json.Marshal(map[string]any{ + "title": "Test chat " + uuid.NewString()[:8], + "member_ids": memberIDs, + }) + if err != nil { + t.Fatalf("marshal chat: %v", err) + } + + resp := doRequest( + t, + http.MethodPost, + "/api/v1/chats", + creator.ID, + body, + ) + + requireStatus(t, resp, http.StatusCreated) + + var c dto.ChatResponse + mustDecode(t, resp, &c) + + return c +} + +func sendMessage( + t *testing.T, + actor dto.UserResponse, + chatID uuid.UUID, + text string, +) *http.Response { + t.Helper() + + body, err := json.Marshal(map[string]string{ + "text": text, + }) + if err != nil { + t.Fatalf("marshal message: %v", err) + } + + return doRequest( + t, + http.MethodPost, + fmt.Sprintf("/api/v1/chats/%v/messages", chatID.String()), + actor.ID, + body, + ) +} + +func sendLoadMessage( + actor dto.UserResponse, + chatID uuid.UUID, + text string, +) (*http.Response, error) { + body, err := json.Marshal(map[string]string{ + "text": text, + }) + if err != nil { + return nil, err + } + + req, err := http.NewRequest( + http.MethodPost, + *baseURL+"/api/v1/chats/"+chatID.String()+"/messages", + bytes.NewReader(body), + ) + if err != nil { + return nil, err + } + + req.Header.Set("Content-Type", "application/json") + req.Header.Set("X-User-Id", actor.ID.String()) + + return httpClient.Do(req) +} diff --git a/student-tests/load_test.go b/student-tests/load_test.go new file mode 100644 index 0000000..f7b0904 --- /dev/null +++ b/student-tests/load_test.go @@ -0,0 +1,138 @@ +//go:build load + +package studenttests_test + +import ( + "flag" + "io" + "net/http" + "sort" + "sync" + "sync/atomic" + "testing" + "time" +) + +var ( + workers = flag.Int("workers", 20, "number of concurrent workers") + duration = flag.Duration("duration", 5*time.Second, "test duration") + rate = flag.Int("rate", 20, "maximum requests per second per worker") +) + +func TestLoad(t *testing.T) { + var ( + statuses = make(map[int]int64) + requestErrors int64 + latencies []time.Duration + statusMu sync.Mutex + latencyMu sync.Mutex + wg sync.WaitGroup + ) + + user1 := createUser(t) + user2 := createUser(t) + chat := createChat(t, user1, user1.ID, user2.ID) + + start := time.Now() + deadline := start.Add(*duration) + + interval := time.Second / time.Duration(*rate) + + for worker := 0; worker < *workers; worker++ { + wg.Add(1) + + go func(workerID int) { + defer wg.Done() + + actor := user1 + if workerID%2 == 1 { + actor = user2 + } + + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for time.Now().Before(deadline) { + <-ticker.C + + if time.Now().After(deadline) { + return + } + + requestStart := time.Now() + + resp, err := sendLoadMessage( + actor, + chat.ID, + "load-msg", + ) + + latency := time.Since(requestStart) + + if err != nil { + if atomic.CompareAndSwapInt64(&requestErrors, 0, 1) { + t.Logf("first transport error: %v", err) + } + atomic.AddInt64(&requestErrors, 1) + continue + } + + statusMu.Lock() + statuses[resp.StatusCode]++ + statusMu.Unlock() + + if resp.StatusCode == http.StatusCreated { + latencyMu.Lock() + latencies = append(latencies, latency) + latencyMu.Unlock() + } + + io.Copy(io.Discard, resp.Body) + resp.Body.Close() + } + }(worker) + } + + wg.Wait() + + elapsed := time.Since(start) + + var total int64 + for _, count := range statuses { + total += count + } + total += requestErrors + + t.Logf("duration: %.3fs", elapsed.Seconds()) + t.Logf("workers: %d", *workers) + t.Logf("rate per worker: %d req/s", *rate) + t.Logf("target rate: %d req/s", *workers**rate) + t.Logf("total requests: %d", total) + + for status, count := range statuses { + t.Logf("HTTP %d: %d", status, count) + } + + t.Logf("request errors: %d", requestErrors) + + successful := statuses[http.StatusCreated] + + t.Logf("successful RPS: %.2f", + float64(successful)/elapsed.Seconds(), + ) + + if len(latencies) > 0 { + sort.Slice(latencies, func(i, j int) bool { + return latencies[i] < latencies[j] + }) + + t.Logf("successful latency p50: %s", percentile(latencies, 0.50)) + t.Logf("successful latency p95: %s", percentile(latencies, 0.95)) + t.Logf("successful latency p99: %s", percentile(latencies, 0.99)) + } +} + +func percentile(values []time.Duration, p float64) time.Duration { + index := int(float64(len(values)-1) * p) + return values[index] +} diff --git a/student-tests/race_test.go b/student-tests/race_test.go new file mode 100644 index 0000000..67d1768 --- /dev/null +++ b/student-tests/race_test.go @@ -0,0 +1,100 @@ +//go:build race + +package studenttests_test + +import ( + "net/http" + "sync" + "testing" + + "mtusi2026-messenger/internal/dto" +) + +func TestConcurrentMessages(t *testing.T) { + const clients = 10 + const messagesPerClient = 10 + const total = clients * messagesPerClient + + user1 := createUser(t) + user2 := createUser(t) + chat := createChat(t, user1, user1.ID, user2.ID) + + var wg sync.WaitGroup + var mu sync.Mutex + sentIDs := make(map[string]bool, total) + + start := make(chan struct{}) + + for worker := 0; worker < clients; worker++ { + wg.Add(1) + + go func(workerID int) { + defer wg.Done() + + actor := user1 + if workerID%2 == 1 { + actor = user2 + } + + <-start + + for i := 0; i < messagesPerClient; i++ { + resp := sendMessage(t, actor, chat.ID, "race-msg") + if resp.StatusCode != http.StatusCreated { + t.Errorf("worker %d msg %d: expected 201, got %d", workerID, i, resp.StatusCode) + resp.Body.Close() + continue + } + + var m dto.MessageResponse + mustDecode(t, resp, &m) + + mu.Lock() + sentIDs[m.ID.String()] = true + mu.Unlock() + } + }(worker) + } + + close(start) + wg.Wait() + + if t.Failed() { + t.Fatal("one or more send requests failed, see errors above") + } + + if len(sentIDs) != total { + t.Fatalf("expected %d successful sends, got %d unique ids", total, len(sentIDs)) + } + + seen := make(map[string]bool, total) + + path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=100" + resp := doRequest(t, http.MethodGet, path, user1.ID, nil) + requireStatus(t, resp, http.StatusOK) + + var page dto.MessagePageResponse + mustDecode(t, resp, &page) + + if page.NextCursor != nil { + t.Fatalf("expected next_cursor to be nil, history may contain more than %d messages", total) + } + + for _, msg := range page.Items { + id := msg.ID.String() + if seen[id] { + t.Fatalf("duplicate message id in history: %s", id) + } + if !sentIDs[id] { + t.Fatalf("message %s in history was never sent by this test", id) + } + seen[id] = true + } + + if len(seen) != total { + t.Fatalf("expected exactly %d unique messages in history, got %d", total, len(seen)) + } + + t.Logf("PASS: %d concurrent clients sent %d messages, exactly %d unique messages persisted", + clients, total, len(seen)) +} diff --git a/student.mk b/student.mk new file mode 100644 index 0000000..8de59f0 --- /dev/null +++ b/student.mk @@ -0,0 +1,17 @@ +LOAD_ARGS = $(if $(LOAD_WORKERS),-workers=$(LOAD_WORKERS),) \ + $(if $(LOAD_DURATION),-duration=$(LOAD_DURATION),) \ + $(if $(LOAD_RATE),-rate=$(LOAD_RATE),) + +.PHONY: help-go contract-go race-go load-go + +help-go: + @echo "contract-go: student contract tests; race-go: concurrency test with -race; load-go: Go load test" + +contract-go: + go test -tags=contract ./student-tests/... -v -args -base-url=$(BASE_URL) + +race-go: + go test -tags=race ./student-tests/... -race -v -args -base-url=$(BASE_URL) + +load-go: + go test -tags=load ./student-tests/... -v -args -base-url=$(BASE_URL) $(LOAD_ARGS) diff --git a/web/swagger/index.html b/web/swagger/index.html new file mode 100644 index 0000000..c498b1b --- /dev/null +++ b/web/swagger/index.html @@ -0,0 +1,21 @@ + + + + + MTUSI Messenger API + + + +
+ + + + + \ No newline at end of file