{message.text}
diff --git a/.gitignore b/.gitignore index b5a7189..5e6fc45 100644 --- a/.gitignore +++ b/.gitignore @@ -24,6 +24,10 @@ target/ bin/ obj/ coverage/ +.vite/ +*.tsbuildinfo +*.test +*.out *.log .DS_Store .idea/ diff --git a/Dockerfile b/Dockerfile index 399c36b..c34078a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -6,7 +6,7 @@ COPY go.mod go.sum ./ RUN go mod download -COPY src ./src +COPY src/backend ./src/backend RUN CGO_ENABLED=0 \ GOOS=linux \ @@ -14,7 +14,7 @@ RUN CGO_ENABLED=0 \ -trimpath \ -ldflags="-s -w" \ -o /out/messenger \ - ./src + ./src/backend FROM debian:12.15-slim diff --git a/Makefile b/Makefile index 9ecb223..696bb74 100644 --- a/Makefile +++ b/Makefile @@ -1,26 +1,47 @@ -PYTHON ?= python3 -BASE_URL ?= http://localhost:8080 -CA_FILE ?= +PYTHON ?= python3 +BASE_URL ?= http://localhost:8080 +CA_FILE ?= ACTION_SCRIPT ?= +COMPOSE = docker compose --env-file .env TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help app-up app-down app-logs check validate test test-backend load test-persistence help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "app-up: build and start API, database and frontend (http://localhost:5173)" + @echo "app-down: stop the application and keep PostgreSQL data" + @echo "app-logs: follow service logs" + @echo "check: offline contract structure" + @echo "validate: full OpenAPI validation (install requirements-dev.txt first)" + @echo "test: public API smoke test (run app-up first)" + @echo "test-backend: Go tests with PostgreSQL and race detection in isolated schemas" + @echo "test-persistence ACTION_SCRIPT=scripts/restart.sh: restart API and DB, verify saved data and session (run app-up first)" + @echo "load: synthetic API writes" -check: - $(PYTHON) scripts/check_contract.py +app-up: + $(COMPOSE) up -d --build --wait -validate: - $(PYTHON) scripts/validate_openapi.py +app-down: + $(COMPOSE) down +app-logs: + $(COMPOSE) logs -f + +check: + $(PYTHON) scripts/check_contract.py + +validate: + $(PYTHON) scripts/validate_openapi.py + test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) -load: - $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) - -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) +test-backend: + $(COMPOSE) --profile test run --build --rm backend-tests + +load: + $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) + +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) diff --git a/compose.yaml b/compose.yaml index 32630e1..6beb20b 100644 --- a/compose.yaml +++ b/compose.yaml @@ -29,6 +29,35 @@ services: interval: 5s timeout: 3s retries: 20 + backend-tests: + profiles: ["test"] + build: + context: . + target: builder + environment: + TEST_DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}?sslmode=disable + depends_on: + db: + condition: service_healthy + command: ["go", "test", "-race", "-count=1", "-v", "./src/backend/..."] + frontend: + build: + context: ./src/frontend + environment: + API_PROXY_TARGET: http://api:8080 + ports: + - "127.0.0.1:5173:5173" + volumes: + - ./src/frontend:/app + - /app/node_modules + depends_on: + api: + condition: service_healthy + healthcheck: + test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:5173/').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"] + interval: 5s + timeout: 3s + retries: 20 volumes: postgres_data: diff --git a/go.mod b/go.mod index ff02335..21aef4b 100644 --- a/go.mod +++ b/go.mod @@ -18,5 +18,6 @@ require ( github.com/jackc/puddle/v2 v2.2.1 // indirect go.uber.org/atomic v1.7.0 // indirect golang.org/x/sync v0.5.0 // indirect + golang.org/x/sys v0.19.0 // indirect golang.org/x/text v0.14.0 // indirect ) diff --git a/src/backend/handlers/chat_http.go b/src/backend/handlers/chat_http.go new file mode 100644 index 0000000..ef5edf8 --- /dev/null +++ b/src/backend/handlers/chat_http.go @@ -0,0 +1,128 @@ +package handlers + +import ( + "net/http" + "strings" + + "github.com/google/uuid" + "messenger/src/backend/services" +) + +type createChatRequest struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` +} + +func createChatHandler(chats *services.ChatService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodPost { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + userID, ok := requestUserID(w, r, requestID) + if !ok { + return + } + if !strings.HasPrefix(r.Header.Get("Content-Type"), "application/json") { + writeError(w, 415, "unsupported_media_type", "content type must be application/json", requestID) + return + } + var request createChatRequest + if err := decodeJSONBody(r, &request); err != nil { + writeError(w, 400, "invalid_request", "invalid JSON body", requestID) + return + } + chat, err := chats.Create(r.Context(), userID, request.Title, request.MemberIDs) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 201, chat) + } +} + +func getChatHandler(chats *services.ChatService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodGet { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + userID, ok := requestUserID(w, r, requestID) + if !ok { + return + } + chatID := strings.TrimPrefix(r.URL.Path, "/api/v1/chats/") + if chatID == "" || strings.Contains(chatID, "/") { + writeError(w, 400, "invalid_request", "invalid chat id", requestID) + return + } + if _, err := uuid.Parse(chatID); err != nil { + writeError(w, 400, "invalid_request", "invalid chat id", requestID) + return + } + chat, err := chats.Get(r.Context(), userID, chatID) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 200, chat) + } +} + +func listChatsHandler(chats *services.ChatService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodGet { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + userID, ok := requestUserID(w, r, requestID) + if !ok { + return + } + limit, cursor, ok := pageParams(w, r, requestID) + if !ok { + return + } + page, err := chats.List(r.Context(), userID, limit, cursor) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 200, page) + } +} + +func chatCollectionHandler(chats *services.ChatService) http.HandlerFunc { + create := createChatHandler(chats) + list := listChatsHandler(chats) + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet { + list(w, r) + } else { + create(w, r) + } + } +} + +func chatSubresourceHandler(chats *services.ChatService, messages *services.MessageService) http.HandlerFunc { + get := getChatHandler(chats) + createMessage := createMessageHandler(chats, messages) + listMessages := listMessagesHandler(chats, messages) + return func(w http.ResponseWriter, r *http.Request) { + if strings.HasSuffix(r.URL.Path, "/messages") { + if r.Method == http.MethodGet { + listMessages(w, r) + } else { + createMessage(w, r) + } + return + } + get(w, r) + } +} diff --git a/src/backend/handlers/http.go b/src/backend/handlers/http.go new file mode 100644 index 0000000..aed7daa --- /dev/null +++ b/src/backend/handlers/http.go @@ -0,0 +1,143 @@ +package handlers + +import ( + "context" + "crypto/rand" + "encoding/hex" + "encoding/json" + "errors" + "log" + "net/http" + "strconv" + "time" + + "messenger/src/backend/services" +) + +type healthResponse struct { + Status string `json:"status"` +} +type apiError struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} +type errorResponse struct { + Error apiError `json:"error"` +} + +func newRequestID() string { + bytes := make([]byte, 16) + if _, err := rand.Read(bytes); err != nil { + return "request-id-generation-failed" + } + return hex.EncodeToString(bytes) +} + +func writeError(w http.ResponseWriter, status int, code, message, requestID string) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + response := errorResponse{Error: apiError{Code: code, Message: message, RequestID: requestID}} + if err := json.NewEncoder(w).Encode(response); err != nil { + log.Printf("failed to encode error response: %v", err) + } +} + +func writeServiceError(w http.ResponseWriter, err error, requestID string) { + var invalid services.InvalidInput + switch { + case errors.As(err, &invalid): + writeError(w, 400, "invalid_request", invalid.Message, requestID) + case errors.Is(err, services.ErrConflict): + writeError(w, 409, "conflict", "username is already taken", requestID) + case errors.Is(err, services.ErrUnknownUser): + writeError(w, 401, "unauthorized", "unknown user", requestID) + case errors.Is(err, services.ErrChatNotFound): + writeError(w, 404, "not_found", "chat not found", requestID) + default: + writeError(w, 503, "unavailable", "database unavailable", requestID) + } +} + +func writeJSON(w http.ResponseWriter, status int, value any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + if err := json.NewEncoder(w).Encode(value); err != nil { + log.Printf("failed to encode response: %v", err) + } +} + +func requestUserID(w http.ResponseWriter, r *http.Request, requestID string) (string, bool) { + id := currentUserID(r) + if id == "" { + writeError(w, 401, "unauthorized", "valid Bearer session is required", requestID) + return "", false + } + return id, true +} + +func pageParams(w http.ResponseWriter, r *http.Request, requestID string) (int, string, bool) { + limit := 50 + if values, exists := r.URL.Query()["limit"]; exists { + if len(values) != 1 || values[0] == "" { + writeError(w, 400, "invalid_request", "invalid limit", requestID) + return 0, "", false + } + parsed, err := strconv.Atoi(values[0]) + if err != nil { + writeError(w, 400, "invalid_request", "limit must be between 1 and 100", requestID) + return 0, "", false + } + limit = parsed + } + var cursor string + if values, exists := r.URL.Query()["cursor"]; exists { + if len(values) != 1 || values[0] == "" { + writeError(w, 400, "invalid_request", "invalid cursor", requestID) + return 0, "", false + } + cursor = values[0] + } + return limit, cursor, true +} + +func healthHandler(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodGet { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + writeJSON(w, 200, healthResponse{"ok"}) +} + +func readyHandler(health *services.HealthService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodGet { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + defer cancel() + if err := health.Ready(ctx); err != nil { + writeError(w, 503, "unavailable", "database unavailable", requestID) + return + } + writeJSON(w, 200, healthResponse{"ok"}) + } +} + +func NewRouter(health *services.HealthService, users *services.UserService, sessions *services.SessionService, chats *services.ChatService, messages *services.MessageService) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("/health/live", healthHandler) + mux.HandleFunc("/health/ready", readyHandler(health)) + mux.Handle("/api/v1/users", createUserHandler(users)) + mux.Handle("/api/v1/auth/sessions", sessionHandler(sessions)) + mux.Handle("/api/v1/auth/sessions/current", authRequired(sessions, logoutHandler(sessions))) + mux.Handle("/api/v1/users/me", authRequired(sessions, currentUserHandler(users))) + mux.Handle("/api/v1/chats", authRequired(sessions, chatCollectionHandler(chats))) + mux.Handle("/api/v1/chats/", authRequired(sessions, chatSubresourceHandler(chats, messages))) + return mux +} diff --git a/src/backend/handlers/message_http.go b/src/backend/handlers/message_http.go new file mode 100644 index 0000000..576d684 --- /dev/null +++ b/src/backend/handlers/message_http.go @@ -0,0 +1,105 @@ +package handlers + +import ( + "net/http" + "strings" + + "github.com/google/uuid" + "messenger/src/backend/services" +) + +type createMessageRequest struct { + Text string `json:"text"` +} + +func messageChatID(path string) (string, bool) { + const prefix = "/api/v1/chats/" + const suffix = "/messages" + if !strings.HasPrefix(path, prefix) || !strings.HasSuffix(path, suffix) { + return "", false + } + chatID := strings.TrimSuffix(strings.TrimPrefix(path, prefix), suffix) + if chatID == "" || strings.Contains(chatID, "/") { + return "", false + } + return chatID, true +} + +func createMessageHandler(chats *services.ChatService, messages *services.MessageService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodPost { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + userID, ok := requestUserID(w, r, requestID) + if !ok { + return + } + chatID, ok := messageChatID(r.URL.Path) + if !ok { + writeError(w, 400, "invalid_request", "invalid chat id", requestID) + return + } + if _, err := uuid.Parse(chatID); err != nil { + writeError(w, 400, "invalid_request", "invalid chat id", requestID) + return + } + chat, err := chats.Get(r.Context(), userID, chatID) + if err != nil { + writeServiceError(w, err, requestID) + return + } + if !strings.HasPrefix(r.Header.Get("Content-Type"), "application/json") { + writeError(w, 415, "unsupported_media_type", "content type must be application/json", requestID) + return + } + var request createMessageRequest + if err := decodeJSONBody(r, &request); err != nil { + writeError(w, 400, "invalid_request", "invalid JSON body", requestID) + return + } + message, err := messages.Create(r.Context(), userID, chat, request.Text) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 201, message) + } +} + +func listMessagesHandler(chats *services.ChatService, messages *services.MessageService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodGet { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + userID, ok := requestUserID(w, r, requestID) + if !ok { + return + } + chatID, ok := messageChatID(r.URL.Path) + if !ok { + writeError(w, 400, "invalid_request", "invalid chat id", requestID) + return + } + chat, err := chats.Get(r.Context(), userID, chatID) + if err != nil { + writeServiceError(w, err, requestID) + return + } + limit, cursor, ok := pageParams(w, r, requestID) + if !ok { + return + } + page, err := messages.List(r.Context(), userID, chat, limit, cursor) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 200, page) + } +} diff --git a/src/backend/handlers/session.go b/src/backend/handlers/session.go new file mode 100644 index 0000000..b965db1 --- /dev/null +++ b/src/backend/handlers/session.go @@ -0,0 +1,98 @@ +package handlers + +import ( + "context" + "errors" + "net/http" + "strings" + "time" + + "messenger/src/backend/services" +) + +type authenticatedUserKey struct{} + +func currentUserID(r *http.Request) string { + id, _ := r.Context().Value(authenticatedUserKey{}).(string) + return id +} + +func authRequired(sessions *services.SessionService, next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + authorization := r.Header.Get("Authorization") + if !strings.HasPrefix(authorization, "Bearer ") || strings.TrimSpace(strings.TrimPrefix(authorization, "Bearer ")) == "" { + unauthorized(w, "Bearer", newRequestID()) + return + } + user, err := sessions.User(r.Context(), strings.TrimPrefix(authorization, "Bearer ")) + if errors.Is(err, services.ErrInvalidSession) { + unauthorized(w, "Bearer", newRequestID()) + return + } + if err != nil { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + writeError(w, 503, "unavailable", "database unavailable", requestID) + return + } + next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), authenticatedUserKey{}, user.ID))) + }) +} + +func unauthorized(w http.ResponseWriter, scheme, requestID string) { + w.Header().Set("X-Request-Id", requestID) + if scheme == "Basic" { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + } else { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + } + writeError(w, 401, "unauthorized", "invalid credentials", requestID) +} + +func sessionHandler(sessions *services.SessionService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodPost { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + username, password, ok := r.BasicAuth() + if !ok || r.ContentLength > 0 { + unauthorized(w, "Basic", requestID) + return + } + user, token, expires, valid, err := sessions.Login(r.Context(), username, password) + if err != nil { + writeError(w, 503, "unavailable", "database unavailable", requestID) + return + } + if !valid { + unauthorized(w, "Basic", requestID) + return + } + writeJSON(w, 201, struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt time.Time `json:"expires_at"` + User any `json:"user"` + }{token, "Bearer", expires, user}) + } +} + +func logoutHandler(sessions *services.SessionService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodDelete { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + token := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ") + if err := sessions.Revoke(r.Context(), token); err != nil { + writeError(w, 503, "unavailable", "database unavailable", requestID) + return + } + w.WriteHeader(204) + } +} diff --git a/src/backend/handlers/user_http.go b/src/backend/handlers/user_http.go new file mode 100644 index 0000000..e298f48 --- /dev/null +++ b/src/backend/handlers/user_http.go @@ -0,0 +1,80 @@ +package handlers + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + + "messenger/src/backend/services" +) + +type createUserRequest struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` +} + +func decodeJSONBody(r *http.Request, destination any) error { + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + if err := decoder.Decode(destination); err != nil { + return err + } + var extra any + if err := decoder.Decode(&extra); err != io.EOF { + if err != nil { + return err + } + return fmt.Errorf("more than one JSON value") + } + return nil +} + +func createUserHandler(users *services.UserService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodPost { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + if !strings.HasPrefix(r.Header.Get("Content-Type"), "application/json") { + writeError(w, 415, "unsupported_media_type", "content type must be application/json", requestID) + return + } + var request createUserRequest + if err := decodeJSONBody(r, &request); err != nil { + writeError(w, 400, "invalid_request", "invalid JSON body", requestID) + return + } + user, err := users.Create(r.Context(), request.Username, request.DisplayName, request.Password) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 201, user) + } +} + +func currentUserHandler(users *services.UserService) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + requestID := newRequestID() + w.Header().Set("X-Request-Id", requestID) + if r.Method != http.MethodGet { + writeError(w, 405, "method_not_allowed", "method not allowed", requestID) + return + } + userID, ok := requestUserID(w, r, requestID) + if !ok { + return + } + user, err := users.Get(r.Context(), userID) + if err != nil { + writeServiceError(w, err, requestID) + return + } + writeJSON(w, 200, user) + } +} diff --git a/src/backend/main.go b/src/backend/main.go new file mode 100644 index 0000000..010dd4d --- /dev/null +++ b/src/backend/main.go @@ -0,0 +1,122 @@ +package main + +import ( + "context" + "errors" + "log" + "messenger/src/backend/handlers" + "messenger/src/backend/repositories" + "messenger/src/backend/services" + "net" + "net/http" + "os" + "os/signal" + "syscall" + "time" +) + +func serverAddress() string { + host := os.Getenv("APP_HOST") + if host == "" { + host = "0.0.0.0" + } + + port := os.Getenv("APP_PORT") + if port == "" { + port = "8080" + } + + return net.JoinHostPort(host, port) +} + +func main() { + if len(os.Args) > 1 { + if len(os.Args) == 2 && os.Args[1] == "healthcheck" { + client := http.Client{Timeout: 2 * time.Second} + response, err := client.Get("http://127.0.0.1:8080/health/ready") + if err != nil { + os.Exit(1) + } + response.Body.Close() + if response.StatusCode != http.StatusOK { + os.Exit(1) + } + return + } + if len(os.Args) != 3 || os.Args[1] != "migrate" || (os.Args[2] != "up" && os.Args[2] != "down") { + log.Fatal("usage: messenger migrate up|down") + } + url, err := repositories.DatabaseURL() + if err != nil { + log.Fatal(err) + } + if err = repositories.RunMigrations(url, os.Args[2]); err != nil { + log.Fatal(err) + } + log.Printf("migration %s complete", os.Args[2]) + return + } + ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) + db, err := repositories.OpenDatabase(ctx) + cancel() + if err != nil { + log.Fatalf("database initialization failed: %v", err) + } + defer db.Close() + userStore := repositories.NewUserStore(db) + chatStore := repositories.NewChatStore(db) + messageStore := repositories.NewMessageStore(db) + ttl, err := services.SessionTTL() + if err != nil { + log.Fatal(err) + } + userService := services.NewUserService(userStore) + sessionService := services.NewSessionService(userService, repositories.NewSessionStore(db), ttl) + chatService := services.NewChatService(chatStore) + messageService := services.NewMessageService(messageStore) + mux := handlers.NewRouter(services.NewHealthService(repositories.NewHealthStore(db)), userService, sessionService, chatService, messageService) + + server := &http.Server{ + Addr: serverAddress(), + Handler: mux, + } + + shutdownContext, stop := signal.NotifyContext( + context.Background(), + os.Interrupt, + syscall.SIGTERM, + ) + defer stop() + + serverErrors := make(chan error, 1) + + go func() { + log.Printf("server is listening on %s", server.Addr) + + if err := server.ListenAndServe(); err != nil && + !errors.Is(err, http.ErrServerClosed) { + serverErrors <- err + } + }() + + select { + case err := <-serverErrors: + log.Printf("server error: %v", err) + + case <-shutdownContext.Done(): + log.Printf("shutdown signal received") + + shutdownDeadline, cancel := context.WithTimeout( + context.Background(), + 10*time.Second, + ) + defer cancel() + + if err := server.Shutdown(shutdownDeadline); err != nil { + log.Printf("graceful shutdown failed: %v", err) + return + } + + log.Printf("server stopped gracefully") + } +} diff --git a/src/chat.go b/src/backend/repositories/chat.go similarity index 80% rename from src/chat.go rename to src/backend/repositories/chat.go index d760178..fd45d46 100644 --- a/src/chat.go +++ b/src/backend/repositories/chat.go @@ -1,4 +1,4 @@ -package main +package repositories import ( "context" @@ -16,17 +16,17 @@ type Chat struct { CreatedAt time.Time `json:"created_at"` } -type chatStore struct { +type ChatStore struct { db *pgxpool.Pool } -func newChatStore(db *pgxpool.Pool) *chatStore { - return &chatStore{db: db} +func NewChatStore(db *pgxpool.Pool) *ChatStore { + return &ChatStore{db: db} } -var errUnknownMember = errors.New("unknown member") +var ErrUnknownMember = errors.New("unknown member") -func (s *chatStore) create(ctx context.Context, title string, memberIDs []string) (Chat, error) { +func (s *ChatStore) Create(ctx context.Context, title string, memberIDs []string) (Chat, error) { membersCopy := append([]string(nil), memberIDs...) chat := Chat{ ID: uuid.New().String(), @@ -46,7 +46,7 @@ func (s *chatStore) create(ctx context.Context, title string, memberIDs []string return Chat{}, err } if !exists { - return Chat{}, errUnknownMember + return Chat{}, ErrUnknownMember } } if _, err = tx.Exec(ctx, "INSERT INTO chats(id,title,created_at) VALUES($1,$2,$3)", chat.ID, title, chat.CreatedAt); err != nil { @@ -63,7 +63,7 @@ func (s *chatStore) create(ctx context.Context, title string, memberIDs []string return chat, nil } -func (s *chatStore) getByID(ctx context.Context, id string) (Chat, error) { +func (s *ChatStore) GetByID(ctx context.Context, id string) (Chat, error) { var chat Chat err := s.db.QueryRow(ctx, "SELECT id,title,created_at FROM chats WHERE id=$1", id).Scan(&chat.ID, &chat.Title, &chat.CreatedAt) if err != nil { @@ -85,17 +85,7 @@ func (s *chatStore) getByID(ctx context.Context, id string) (Chat, error) { return chat, rows.Err() } -func (s *chatStore) isMember(chat Chat, userID string) bool { - for _, memberID := range chat.MemberIDs { - if memberID == userID { - return true - } - } - - return false -} - -func (s *chatStore) listPageForUser(ctx context.Context, userID string, cursor *chatCursor, limit int) ([]Chat, bool, error) { +func (s *ChatStore) ListPageForUser(ctx context.Context, userID string, cursor *ChatCursor, limit int) ([]Chat, bool, error) { afterTime := time.Time{} afterID := "00000000-0000-0000-0000-000000000000" if cursor != nil { @@ -123,7 +113,7 @@ func (s *chatStore) listPageForUser(ctx context.Context, userID string, cursor * chats = chats[:limit] } for i := range chats { - chat, err := s.getByID(ctx, chats[i].ID) + chat, err := s.GetByID(ctx, chats[i].ID) if err != nil { return nil, false, err } diff --git a/src/backend/repositories/cursor.go b/src/backend/repositories/cursor.go new file mode 100644 index 0000000..05f3f7d --- /dev/null +++ b/src/backend/repositories/cursor.go @@ -0,0 +1,15 @@ +package repositories + +import "time" + +type ChatCursor struct { + UserID string `json:"user_id"` + CreatedAt time.Time `json:"created_at"` + ChatID string `json:"chat_id"` +} + +type MessageCursor struct { + ChatID string `json:"chat_id"` + CreatedAt time.Time `json:"created_at"` + MessageID string `json:"message_id"` +} diff --git a/src/database.go b/src/backend/repositories/database.go similarity index 78% rename from src/database.go rename to src/backend/repositories/database.go index 42ce63e..0ac06f8 100644 --- a/src/database.go +++ b/src/backend/repositories/database.go @@ -1,4 +1,4 @@ -package main +package repositories import ( "context" @@ -12,7 +12,6 @@ import ( "github.com/golang-migrate/migrate/v4" pgxmigrate "github.com/golang-migrate/migrate/v4/database/pgx/v5" "github.com/golang-migrate/migrate/v4/source/iofs" - "github.com/jackc/pgx/v5/pgconn" "github.com/jackc/pgx/v5/pgxpool" _ "github.com/jackc/pgx/v5/stdlib" ) @@ -20,7 +19,7 @@ import ( //go:embed migrations/*.sql var migrationFiles embed.FS -func databaseURL() (string, error) { +func DatabaseURL() (string, error) { if path := os.Getenv("DATABASE_URL_FILE"); path != "" { data, err := os.ReadFile(path) if err != nil { @@ -34,8 +33,8 @@ func databaseURL() (string, error) { return "", errors.New("DATABASE_URL_FILE or DATABASE_URL is required") } -func openDatabase(ctx context.Context) (*pgxpool.Pool, error) { - url, err := databaseURL() +func OpenDatabase(ctx context.Context) (*pgxpool.Pool, error) { + url, err := DatabaseURL() if err != nil { return nil, err } @@ -53,16 +52,16 @@ func openDatabase(ctx context.Context) (*pgxpool.Pool, error) { db.Close() return nil, err } - if err = runMigrations(url, "up"); err != nil { + if err = RunMigrations(url, "up"); err != nil { db.Close() return nil, err } return db, nil } -// runMigrations uses versioned up/down SQL embedded in the API binary. +// RunMigrations uses versioned up/down SQL embedded in the API binary. // "down" rolls back exactly one version and is an explicit operator command. -func runMigrations(url, direction string) error { +func RunMigrations(url, direction string) error { source, err := iofs.New(migrationFiles, "migrations") if err != nil { return err @@ -92,8 +91,3 @@ func runMigrations(url, direction string) error { } return err } - -func uniqueViolation(err error) bool { - var pgerr *pgconn.PgError - return errors.As(err, &pgerr) && pgerr.Code == "23505" -} diff --git a/src/backend/repositories/errors.go b/src/backend/repositories/errors.go new file mode 100644 index 0000000..6741083 --- /dev/null +++ b/src/backend/repositories/errors.go @@ -0,0 +1,21 @@ +package repositories + +import ( + "errors" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" +) + +func NotFound(err error) bool { + return errors.Is(err, pgx.ErrNoRows) +} + +func CheckViolation(err error) bool { + var pgerr *pgconn.PgError + return errors.As(err, &pgerr) && pgerr.Code == "23514" +} + +func UniqueViolation(err error) bool { + var pgerr *pgconn.PgError + return errors.As(err, &pgerr) && pgerr.Code == "23505" +} diff --git a/src/backend/repositories/health.go b/src/backend/repositories/health.go new file mode 100644 index 0000000..693a3b9 --- /dev/null +++ b/src/backend/repositories/health.go @@ -0,0 +1,19 @@ +package repositories + +import ( + "context" + + "github.com/jackc/pgx/v5/pgxpool" +) + +type HealthStore struct { + db *pgxpool.Pool +} + +func NewHealthStore(db *pgxpool.Pool) *HealthStore { + return &HealthStore{db: db} +} + +func (s *HealthStore) Ping(ctx context.Context) error { + return s.db.Ping(ctx) +} diff --git a/src/message.go b/src/backend/repositories/message.go similarity index 73% rename from src/message.go rename to src/backend/repositories/message.go index ac812bb..eb05b50 100644 --- a/src/message.go +++ b/src/backend/repositories/message.go @@ -1,4 +1,4 @@ -package main +package repositories import ( "context" @@ -16,15 +16,15 @@ type Message struct { CreatedAt time.Time `json:"created_at"` } -type messageStore struct { +type MessageStore struct { db *pgxpool.Pool } -func newMessageStore(db *pgxpool.Pool) *messageStore { - return &messageStore{db: db} +func NewMessageStore(db *pgxpool.Pool) *MessageStore { + return &MessageStore{db: db} } -func (s *messageStore) create( +func (s *MessageStore) Create( ctx context.Context, chatID string, senderID string, @@ -42,23 +42,10 @@ func (s *messageStore) create( return message, err } -func messageLess(left Message, right Message) bool { - if left.CreatedAt.Equal(right.CreatedAt) { - return left.ID < right.ID - } - - return left.CreatedAt.Before(right.CreatedAt) -} - -func messageAfterCursor(message Message, cursor messageCursor) bool { - return message.CreatedAt.After(cursor.CreatedAt) || - (message.CreatedAt.Equal(cursor.CreatedAt) && message.ID > cursor.MessageID) -} - -func (s *messageStore) listPageByChat( +func (s *MessageStore) ListPageByChat( ctx context.Context, chatID string, - cursor *messageCursor, + cursor *MessageCursor, limit int, ) ([]Message, bool, error) { afterTime := time.Time{} diff --git a/src/migrations/000001_initial.down.sql b/src/backend/repositories/migrations/000001_initial.down.sql similarity index 100% rename from src/migrations/000001_initial.down.sql rename to src/backend/repositories/migrations/000001_initial.down.sql diff --git a/src/migrations/000001_initial.up.sql b/src/backend/repositories/migrations/000001_initial.up.sql similarity index 100% rename from src/migrations/000001_initial.up.sql rename to src/backend/repositories/migrations/000001_initial.up.sql diff --git a/src/backend/repositories/session.go b/src/backend/repositories/session.go new file mode 100644 index 0000000..469e50f --- /dev/null +++ b/src/backend/repositories/session.go @@ -0,0 +1,32 @@ +package repositories + +import ( + "context" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +type SessionStore struct { + db *pgxpool.Pool +} + +func NewSessionStore(db *pgxpool.Pool) *SessionStore { + return &SessionStore{db: db} +} + +func (s *SessionStore) Create(ctx context.Context, tokenHash []byte, userID string, expires time.Time) error { + _, err := s.db.Exec(ctx, "INSERT INTO sessions(token_hash,user_id,expires_at) VALUES($1,$2,$3)", tokenHash, userID, expires) + return err +} + +func (s *SessionStore) User(ctx context.Context, tokenHash []byte) (User, error) { + var user User + err := s.db.QueryRow(ctx, `SELECT u.id,u.username,u.display_name,u.created_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=$1 AND s.expires_at>now()`, tokenHash).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt) + return user, err +} + +func (s *SessionStore) Revoke(ctx context.Context, tokenHash []byte) error { + _, err := s.db.Exec(ctx, "DELETE FROM sessions WHERE token_hash=$1", tokenHash) + return err +} diff --git a/src/backend/repositories/user.go b/src/backend/repositories/user.go new file mode 100644 index 0000000..d71b6aa --- /dev/null +++ b/src/backend/repositories/user.go @@ -0,0 +1,57 @@ +package repositories + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +type UserStore struct { + db *pgxpool.Pool +} + +func NewUserStore(db *pgxpool.Pool) *UserStore { + return &UserStore{db: db} +} + +func (s *UserStore) Create(ctx context.Context, username, displayName string, passwordHash []byte) (User, error) { + user := User{ + ID: uuid.New().String(), + Username: username, + DisplayName: displayName, + CreatedAt: time.Now().UTC().Truncate(time.Microsecond), + } + + _, err := s.db.Exec(ctx, "INSERT INTO users(id,username,display_name,password_hash,created_at) VALUES($1,$2,$3,$4,$5)", user.ID, user.Username, user.DisplayName, passwordHash, user.CreatedAt) + return user, err +} + +func (s *UserStore) GetByID(ctx context.Context, id string) (User, error) { + var user User + err := s.db.QueryRow(ctx, "SELECT id,username,display_name,created_at FROM users WHERE id=$1", id).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt) + return user, err +} + +func (s *UserStore) GetCredentials(ctx context.Context, username string) (User, []byte, error) { + var user User + var packedHash []byte + err := s.db.QueryRow(ctx, "SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=$1", username).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt, &packedHash) + if errors.Is(err, pgx.ErrNoRows) { + return User{}, nil, nil + } + if err != nil { + return User{}, nil, err + } + return user, packedHash, nil +} diff --git a/src/backend/services/chat.go b/src/backend/services/chat.go new file mode 100644 index 0000000..2c947fc --- /dev/null +++ b/src/backend/services/chat.go @@ -0,0 +1,134 @@ +package services + +import ( + "context" + "encoding/base64" + "encoding/json" + "errors" + "strconv" + "strings" + "unicode/utf8" + + "github.com/google/uuid" + "messenger/src/backend/repositories" +) + +type ChatPage struct { + Items []repositories.Chat `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type ChatService struct { + chats *repositories.ChatStore +} + +func NewChatService(chats *repositories.ChatStore) *ChatService { + return &ChatService{chats: chats} +} + +func ChatHasMember(chat repositories.Chat, userID string) bool { + for _, memberID := range chat.MemberIDs { + if memberID == userID { + return true + } + } + return false +} + +func (s *ChatService) Create(ctx context.Context, currentUserID, title string, memberIDs []string) (repositories.Chat, error) { + if strings.TrimSpace(title) == "" { + return repositories.Chat{}, InvalidInput{"title must not be blank"} + } + if utf8.RuneCountInString(title) > 100 { + return repositories.Chat{}, InvalidInput{"title is too long"} + } + if len(memberIDs) == 0 || len(memberIDs) > 100 { + return repositories.Chat{}, InvalidInput{"member_ids must contain from 1 to 100 users"} + } + seen := make(map[string]struct{}, len(memberIDs)) + for _, memberID := range memberIDs { + if _, err := uuid.Parse(memberID); err != nil { + return repositories.Chat{}, InvalidInput{"member_ids must contain valid UUIDs"} + } + if _, exists := seen[memberID]; exists { + return repositories.Chat{}, InvalidInput{"member_ids must not contain duplicates"} + } + seen[memberID] = struct{}{} + } + if _, exists := seen[currentUserID]; !exists { + return repositories.Chat{}, InvalidInput{"current user must be a chat member"} + } + chat, err := s.chats.Create(ctx, title, memberIDs) + if errors.Is(err, repositories.ErrUnknownMember) { + return repositories.Chat{}, InvalidInput{"all members must be existing users"} + } + return chat, err +} + +func (s *ChatService) Get(ctx context.Context, currentUserID, chatID string) (repositories.Chat, error) { + chat, err := s.chats.GetByID(ctx, chatID) + if repositories.NotFound(err) { + return repositories.Chat{}, ErrChatNotFound + } + if err != nil { + return repositories.Chat{}, err + } + if !ChatHasMember(chat, currentUserID) { + return repositories.Chat{}, ErrChatNotFound + } + return chat, nil +} + +func EncodeChatCursor(cursor repositories.ChatCursor) (string, error) { + data, err := json.Marshal(cursor) + if err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(data), nil +} + +func DecodeChatCursor(value string) (repositories.ChatCursor, error) { + data, err := base64.RawURLEncoding.DecodeString(value) + if err != nil { + return repositories.ChatCursor{}, err + } + var cursor repositories.ChatCursor + if err := json.Unmarshal(data, &cursor); err != nil { + return repositories.ChatCursor{}, err + } + if cursor.UserID == "" || cursor.ChatID == "" || cursor.CreatedAt.IsZero() { + return repositories.ChatCursor{}, strconv.ErrSyntax + } + return cursor, nil +} + +func (s *ChatService) List(ctx context.Context, userID string, limit int, cursorToken string) (ChatPage, error) { + if limit < 1 || limit > 100 { + return ChatPage{}, InvalidInput{"limit must be between 1 and 100"} + } + var cursor *repositories.ChatCursor + if cursorToken != "" { + decoded, err := DecodeChatCursor(cursorToken) + if err != nil || decoded.UserID != userID { + return ChatPage{}, InvalidInput{"invalid cursor"} + } + cursor = &decoded + } + items, more, err := s.chats.ListPageForUser(ctx, userID, cursor, limit) + if err != nil { + return ChatPage{}, err + } + page := ChatPage{Items: items} + if page.Items == nil { + page.Items = []repositories.Chat{} + } + if more { + last := items[len(items)-1] + next, err := EncodeChatCursor(repositories.ChatCursor{UserID: userID, CreatedAt: last.CreatedAt, ChatID: last.ID}) + if err != nil { + return ChatPage{}, err + } + page.NextCursor = &next + } + return page, nil +} diff --git a/src/backend/services/errors.go b/src/backend/services/errors.go new file mode 100644 index 0000000..aa5d632 --- /dev/null +++ b/src/backend/services/errors.go @@ -0,0 +1,16 @@ +package services + +import "errors" + +var ( + ErrConflict = errors.New("conflict") + ErrUnknownUser = errors.New("unknown user") + ErrChatNotFound = errors.New("chat not found") + ErrInvalidSession = errors.New("invalid session") +) + +type InvalidInput struct { + Message string +} + +func (e InvalidInput) Error() string { return e.Message } diff --git a/src/backend/services/health.go b/src/backend/services/health.go new file mode 100644 index 0000000..8c2c55a --- /dev/null +++ b/src/backend/services/health.go @@ -0,0 +1,19 @@ +package services + +import ( + "context" + + "messenger/src/backend/repositories" +) + +type HealthService struct { + health *repositories.HealthStore +} + +func NewHealthService(health *repositories.HealthStore) *HealthService { + return &HealthService{health: health} +} + +func (s *HealthService) Ready(ctx context.Context) error { + return s.health.Ping(ctx) +} diff --git a/src/backend/services/message.go b/src/backend/services/message.go new file mode 100644 index 0000000..0364ca3 --- /dev/null +++ b/src/backend/services/message.go @@ -0,0 +1,107 @@ +package services + +import ( + "context" + "encoding/base64" + "encoding/json" + "strconv" + "strings" + "unicode/utf8" + + "messenger/src/backend/repositories" +) + +type MessagePage struct { + Items []repositories.Message `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type MessageService struct { + messages *repositories.MessageStore +} + +func NewMessageService(messages *repositories.MessageStore) *MessageService { + return &MessageService{messages: messages} +} + +func (s *MessageService) Create(ctx context.Context, userID string, chat repositories.Chat, text string) (repositories.Message, error) { + if !ChatHasMember(chat, userID) { + return repositories.Message{}, ErrChatNotFound + } + if strings.TrimSpace(text) == "" { + return repositories.Message{}, InvalidInput{"text must not be blank"} + } + if utf8.RuneCountInString(text) > 4000 { + return repositories.Message{}, InvalidInput{"text is too long"} + } + return s.messages.Create(ctx, chat.ID, userID, text) +} + +func MessageLess(left, right repositories.Message) bool { + if left.CreatedAt.Equal(right.CreatedAt) { + return left.ID < right.ID + } + return left.CreatedAt.Before(right.CreatedAt) +} + +func MessageAfterCursor(message repositories.Message, cursor repositories.MessageCursor) bool { + return message.CreatedAt.After(cursor.CreatedAt) || + (message.CreatedAt.Equal(cursor.CreatedAt) && message.ID > cursor.MessageID) +} + +func EncodeMessageCursor(cursor repositories.MessageCursor) (string, error) { + data, err := json.Marshal(cursor) + if err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(data), nil +} + +func DecodeMessageCursor(value string) (repositories.MessageCursor, error) { + data, err := base64.RawURLEncoding.DecodeString(value) + if err != nil { + return repositories.MessageCursor{}, err + } + var cursor repositories.MessageCursor + if err := json.Unmarshal(data, &cursor); err != nil { + return repositories.MessageCursor{}, err + } + if cursor.ChatID == "" || cursor.MessageID == "" || cursor.CreatedAt.IsZero() { + return repositories.MessageCursor{}, strconv.ErrSyntax + } + return cursor, nil +} + +func (s *MessageService) List(ctx context.Context, userID string, chat repositories.Chat, limit int, cursorToken string) (MessagePage, error) { + if !ChatHasMember(chat, userID) { + return MessagePage{}, ErrChatNotFound + } + if limit < 1 || limit > 100 { + return MessagePage{}, InvalidInput{"limit must be between 1 and 100"} + } + var cursor *repositories.MessageCursor + if cursorToken != "" { + decoded, err := DecodeMessageCursor(cursorToken) + if err != nil || decoded.ChatID != chat.ID { + return MessagePage{}, InvalidInput{"invalid cursor"} + } + cursor = &decoded + } + items, more, err := s.messages.ListPageByChat(ctx, chat.ID, cursor, limit) + if err != nil { + return MessagePage{}, err + } + page := MessagePage{Items: items} + if page.Items == nil { + page.Items = []repositories.Message{} + } + if more { + last := items[len(items)-1] + next, err := EncodeMessageCursor(repositories.MessageCursor{ChatID: chat.ID, CreatedAt: last.CreatedAt, MessageID: last.ID}) + if err != nil { + return MessagePage{}, err + } + page.NextCursor = &next + } + return page, nil +} diff --git a/src/backend/services/password.go b/src/backend/services/password.go new file mode 100644 index 0000000..94201a3 --- /dev/null +++ b/src/backend/services/password.go @@ -0,0 +1,59 @@ +package services + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "errors" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +const ( + argonMemory uint32 = 64 * 1024 + argonIterations uint32 = 3 + argonParallelism uint8 = 2 + passwordSaltSize = 16 + passwordHashSize = 32 +) + +// HashPassword stores the salt and Argon2id parameters in one PHC-encoded value. +func HashPassword(password string) ([]byte, error) { + salt := make([]byte, passwordSaltSize) + if _, err := rand.Read(salt); err != nil { + return nil, err + } + hash := argon2.IDKey([]byte(password), salt, argonIterations, argonMemory, argonParallelism, passwordHashSize) + encoded := fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, argonMemory, argonIterations, argonParallelism, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(hash), + ) + return []byte(encoded), nil +} + +func VerifyPassword(password string, encoded []byte) (bool, error) { + parts := strings.Split(string(encoded), "$") + if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" || parts[2] != fmt.Sprintf("v=%d", argon2.Version) { + return false, errors.New("invalid password hash format") + } + var memory, iterations uint32 + var parallelism uint8 + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, ¶llelism); err != nil || + fmt.Sprintf("m=%d,t=%d,p=%d", memory, iterations, parallelism) != parts[3] || + memory < 8*1024 || memory > 128*1024 || iterations < 1 || iterations > 10 || parallelism < 1 || parallelism > 8 { + return false, errors.New("invalid password hash parameters") + } + salt, err := base64.RawStdEncoding.Strict().DecodeString(parts[4]) + if err != nil || len(salt) != passwordSaltSize { + return false, errors.New("invalid password salt") + } + expected, err := base64.RawStdEncoding.Strict().DecodeString(parts[5]) + if err != nil || len(expected) != passwordHashSize { + return false, errors.New("invalid password hash") + } + actual := argon2.IDKey([]byte(password), salt, iterations, memory, parallelism, passwordHashSize) + return subtle.ConstantTimeCompare(expected, actual) == 1, nil +} diff --git a/src/backend/services/session.go b/src/backend/services/session.go new file mode 100644 index 0000000..b93a13b --- /dev/null +++ b/src/backend/services/session.go @@ -0,0 +1,76 @@ +package services + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/hex" + "errors" + "os" + "strconv" + "time" + + "messenger/src/backend/repositories" +) + +type SessionService struct { + users *UserService + sessions *repositories.SessionStore + ttl time.Duration +} + +func SessionTTL() (time.Duration, error) { + value := os.Getenv("SESSION_TTL_SECONDS") + if value == "" { + return time.Hour, nil + } + seconds, err := strconv.Atoi(value) + if err != nil || seconds < 1 { + return 0, errors.New("invalid SESSION_TTL_SECONDS") + } + return time.Duration(seconds) * time.Second, nil +} + +func NewSessionService(users *UserService, sessions *repositories.SessionStore, ttl time.Duration) *SessionService { + return &SessionService{users: users, sessions: sessions, ttl: ttl} +} + +func (s *SessionService) Login(ctx context.Context, username, password string) (repositories.User, string, time.Time, bool, error) { + user, valid, err := s.users.Authenticate(ctx, username, password) + if err != nil || !valid { + return repositories.User{}, "", time.Time{}, valid, err + } + token, expires, err := s.CreateForUser(ctx, user.ID) + if err != nil { + return repositories.User{}, "", time.Time{}, false, err + } + return user, token, expires, true, nil +} + +func (s *SessionService) CreateForUser(ctx context.Context, userID string) (string, time.Time, error) { + raw := make([]byte, 32) + if _, err := rand.Read(raw); err != nil { + return "", time.Time{}, err + } + token := hex.EncodeToString(raw) + hash := sha256.Sum256([]byte(token)) + expires := time.Now().UTC().Add(s.ttl).Truncate(time.Microsecond) + if err := s.sessions.Create(ctx, hash[:], userID, expires); err != nil { + return "", time.Time{}, err + } + return token, expires, nil +} + +func (s *SessionService) User(ctx context.Context, token string) (repositories.User, error) { + hash := sha256.Sum256([]byte(token)) + user, err := s.sessions.User(ctx, hash[:]) + if repositories.NotFound(err) { + return repositories.User{}, ErrInvalidSession + } + return user, err +} + +func (s *SessionService) Revoke(ctx context.Context, token string) error { + hash := sha256.Sum256([]byte(token)) + return s.sessions.Revoke(ctx, hash[:]) +} diff --git a/src/backend/services/user.go b/src/backend/services/user.go new file mode 100644 index 0000000..950baf1 --- /dev/null +++ b/src/backend/services/user.go @@ -0,0 +1,70 @@ +package services + +import ( + "context" + "regexp" + "strings" + "unicode/utf8" + + "messenger/src/backend/repositories" +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +type UserService struct { + users *repositories.UserStore +} + +func NewUserService(users *repositories.UserStore) *UserService { + return &UserService{users: users} +} + +func (s *UserService) Create(ctx context.Context, username, displayName, password string) (repositories.User, error) { + if !usernamePattern.MatchString(username) { + return repositories.User{}, InvalidInput{"username must contain 3-32 lowercase latin letters, digits or underscores"} + } + if strings.TrimSpace(displayName) == "" { + return repositories.User{}, InvalidInput{"display_name must not be blank"} + } + if utf8.RuneCountInString(displayName) > 100 { + return repositories.User{}, InvalidInput{"display_name is too long"} + } + if strings.TrimSpace(password) == "" || utf8.RuneCountInString(password) < 12 || utf8.RuneCountInString(password) > 128 { + return repositories.User{}, InvalidInput{"password must contain 12-128 characters"} + } + hash, err := HashPassword(password) + if err != nil { + return repositories.User{}, err + } + user, err := s.users.Create(ctx, username, displayName, hash) + if repositories.UniqueViolation(err) { + return repositories.User{}, ErrConflict + } + if repositories.CheckViolation(err) { + return repositories.User{}, InvalidInput{"invalid user fields"} + } + return user, err +} + +func (s *UserService) Get(ctx context.Context, id string) (repositories.User, error) { + user, err := s.users.GetByID(ctx, id) + if repositories.NotFound(err) { + return repositories.User{}, ErrUnknownUser + } + return user, err +} + +func (s *UserService) Authenticate(ctx context.Context, username, password string) (repositories.User, bool, error) { + if !usernamePattern.MatchString(username) || utf8.RuneCountInString(password) < 12 || utf8.RuneCountInString(password) > 128 { + return repositories.User{}, false, nil + } + user, packedHash, err := s.users.GetCredentials(ctx, username) + if err != nil || packedHash == nil { + return repositories.User{}, false, err + } + valid, err := VerifyPassword(password, packedHash) + if err != nil { + return repositories.User{}, false, err + } + return user, valid, nil +} diff --git a/src/backend/tests/concurrency_test.go b/src/backend/tests/concurrency_test.go new file mode 100644 index 0000000..b0204e9 --- /dev/null +++ b/src/backend/tests/concurrency_test.go @@ -0,0 +1,217 @@ +package tests + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "messenger/src/backend/repositories" + "net/http" + "net/http/httptest" + "strconv" + "sync" + "testing" +) + +func TestConcurrentMessageCreation(t *testing.T) { + fixture := newTestFixture(t) + userStore, chatStore := fixture.users, fixture.chats + + const clientsCount = 10 + const messagesPerClient = 10 + const expectedMessages = clientsCount * messagesPerClient + + memberIDs := make([]string, 0, clientsCount) + users := make([]User, 0, clientsCount) + + for i := range clientsCount { + user, created := createTestUser(t, userStore, + "user"+strconv.Itoa(i), + "Пользователь "+strconv.Itoa(i), + ) + + if !created { + t.Fatalf("failed to create test user %d", i) + } + + users = append(users, user) + memberIDs = append(memberIDs, user.ID) + } + + chat := createTestChat(t, chatStore, + "Конкурентный чат", + memberIDs, + ) + + server := httptest.NewServer(fixture.router) + defer server.Close() + + client := server.Client() + tokens := make([]string, clientsCount) + for i, user := range users { + request := httptest.NewRequest(http.MethodGet, "/", nil) + authorizeTestRequest(t, fixture, request, user.ID) + tokens[i] = request.Header.Get("Authorization") + } + + var waitGroup sync.WaitGroup + messageIDs := make(chan string, expectedMessages) + errors := make(chan error, expectedMessages) + + for clientIndex := range clientsCount { + waitGroup.Add(1) + + go func(index int) { + defer waitGroup.Done() + + for messageIndex := range messagesPerClient { + body := fmt.Appendf(nil, + `{"text":"client-%d message-%d"}`, + index, + messageIndex, + ) + + request, err := http.NewRequest( + http.MethodPost, + server.URL+"/api/v1/chats/"+chat.ID+"/messages", + bytes.NewReader(body), + ) + if err != nil { + errors <- fmt.Errorf( + "client %d: create request: %w", + index, + err, + ) + continue + } + + request.Header.Set("Content-Type", "application/json") + request.Header.Set("Authorization", tokens[index]) + + response, err := client.Do(request) + if err != nil { + errors <- fmt.Errorf( + "client %d: send request: %w", + index, + err, + ) + continue + } + + responseBody, readErr := io.ReadAll(response.Body) + response.Body.Close() + + if readErr != nil { + errors <- fmt.Errorf( + "client %d: read response: %w", + index, + readErr, + ) + continue + } + + if response.StatusCode != http.StatusCreated { + errors <- fmt.Errorf( + "client %d: expected status %d, got %d; body: %s", + index, + http.StatusCreated, + response.StatusCode, + string(responseBody), + ) + continue + } + + var message repositories.Message + + if err := json.Unmarshal(responseBody, &message); err != nil { + errors <- fmt.Errorf( + "client %d: decode response: %w", + index, + err, + ) + continue + } + + if message.ID == "" { + errors <- fmt.Errorf( + "client %d: response contains empty message ID", + index, + ) + continue + } + + messageIDs <- message.ID + } + }(clientIndex) + } + + waitGroup.Wait() + + close(errors) + close(messageIDs) + + for err := range errors { + t.Error(err) + } + + createdIDs := make(map[string]bool) + + for messageID := range messageIDs { + if createdIDs[messageID] { + t.Fatalf("duplicate message ID returned: %s", messageID) + } + + createdIDs[messageID] = true + } + + if len(createdIDs) != expectedMessages { + t.Fatalf( + "expected %d unique created messages, got %d", + expectedMessages, + len(createdIDs), + ) + } + + // Дополнительно проверяем историю через HTTP API. + request, err := http.NewRequest( + http.MethodGet, + server.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=100", + nil, + ) + if err != nil { + t.Fatalf("create history request: %v", err) + } + + request.Header.Set("Authorization", tokens[0]) + + response, err := client.Do(request) + if err != nil { + t.Fatalf("request message history: %v", err) + } + defer response.Body.Close() + + if response.StatusCode != http.StatusOK { + body, _ := io.ReadAll(response.Body) + + t.Fatalf( + "expected history status %d, got %d; body: %s", + http.StatusOK, + response.StatusCode, + string(body), + ) + } + + var page messagePage + + if err := json.NewDecoder(response.Body).Decode(&page); err != nil { + t.Fatalf("decode message history: %v", err) + } + + if len(page.Items) != expectedMessages { + t.Fatalf( + "expected %d messages in history, got %d", + expectedMessages, + len(page.Items), + ) + } +} diff --git a/src/backend/tests/integration_test.go b/src/backend/tests/integration_test.go new file mode 100644 index 0000000..1563102 --- /dev/null +++ b/src/backend/tests/integration_test.go @@ -0,0 +1,67 @@ +package tests + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "testing" +) + +func TestMessengerWorkflow(t *testing.T) { + router := newTestFixture(t).router + + call := func(method, path, body, auth string, expected int) map[string]any { + t.Helper() + request := httptest.NewRequest(method, path, bytes.NewBufferString(body)) + if body != "" { + request.Header.Set("Content-Type", "application/json") + } + if auth != "" { + request.Header.Set("Authorization", auth) + } + response := httptest.NewRecorder() + router.ServeHTTP(response, request) + if response.Code != expected { + t.Fatalf("%s %s: status %d, want %d: %s", method, path, response.Code, expected, response.Body.String()) + } + if response.Header().Get("X-Request-Id") == "" { + t.Fatalf("%s %s: missing request ID", method, path) + } + if response.Code == http.StatusNoContent { + return nil + } + var result map[string]any + if err := json.Unmarshal(response.Body.Bytes(), &result); err != nil { + t.Fatal(err) + } + return result + } + + user := call("POST", "/api/v1/users", `{"username":"alice","display_name":"Алиса","password":"lab2-test-password"}`, "", 201) + userID := user["id"].(string) + basic := "Basic " + base64.StdEncoding.EncodeToString([]byte("alice:lab2-test-password")) + session := call("POST", "/api/v1/auth/sessions", "", basic, 201) + bearer := "Bearer " + session["token"].(string) + call("GET", "/api/v1/users/me", "", bearer, 200) + chat := call("POST", "/api/v1/chats", `{"title":"Тестовый чат","member_ids":["`+userID+`"]}`, bearer, 201) + chatID := chat["id"].(string) + path := "/api/v1/chats/" + chatID + "/messages" + for i := 0; i < 3; i++ { + call("POST", path, `{"text":"message"}`, bearer, 201) + } + page1 := call("GET", path+"?limit=2", "", bearer, 200) + first := page1["items"].([]any) + if len(first) != 2 || page1["next_cursor"] == nil { + t.Fatalf("unexpected first page: %v", page1) + } + page2 := call("GET", path+"?limit=2&cursor="+url.QueryEscape(page1["next_cursor"].(string)), "", bearer, 200) + second := page2["items"].([]any) + if len(second) != 1 || page2["next_cursor"] != nil || first[0].(map[string]any)["id"] == second[0].(map[string]any)["id"] { + t.Fatalf("unexpected second page: %v", page2) + } + call("DELETE", "/api/v1/auth/sessions/current", "", bearer, 204) + call("GET", "/api/v1/users/me", "", bearer, 401) +} diff --git a/src/backend/tests/message_handler_test.go b/src/backend/tests/message_handler_test.go new file mode 100644 index 0000000..b5c6958 --- /dev/null +++ b/src/backend/tests/message_handler_test.go @@ -0,0 +1,276 @@ +package tests + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" +) + +func TestCreateMessageBlankText(t *testing.T) { + fixture := newTestFixture(t) + userStore, chatStore, messageStore := fixture.users, fixture.chats, fixture.messages + + user, created := createTestUser(t, userStore, "alice", "Алиса") + if !created { + t.Fatal("expected user to be created") + } + + chat := createTestChat(t, chatStore, + "Тестовый чат", + []string{user.ID}, + ) + + handler := fixture.router + + request := httptest.NewRequest( + http.MethodPost, + "/api/v1/chats/"+chat.ID+"/messages", + strings.NewReader(`{"text":" \t\n"}`), + ) + request.Header.Set("Content-Type", "application/json") + authorizeTestRequest(t, fixture, request, user.ID) + + response := httptest.NewRecorder() + + handler.ServeHTTP(response, request) + + if response.Code != http.StatusBadRequest { + t.Fatalf( + "expected status %d, got %d; body: %s", + http.StatusBadRequest, + response.Code, + response.Body.String(), + ) + } + + if response.Header().Get("X-Request-Id") == "" { + t.Fatal("expected non-empty X-Request-Id header") + } + + if !strings.Contains( + response.Body.String(), + `"code":"invalid_request"`, + ) { + t.Fatalf( + "expected invalid_request error code, got body: %s", + response.Body.String(), + ) + } + + messages := listTestMessages(t, messageStore, chat.ID) + + if len(messages) != 0 { + t.Fatalf( + "expected no messages to be stored, got %d", + len(messages), + ) + } +} +func TestCreateMessageFromChatOutsider(t *testing.T) { + fixture := newTestFixture(t) + userStore, chatStore, messageStore := fixture.users, fixture.chats, fixture.messages + + alice, created := createTestUser(t, userStore, "alice", "Алиса") + if !created { + t.Fatal("expected Alice to be created") + } + + bob, created := createTestUser(t, userStore, "bob", "Боб") + if !created { + t.Fatal("expected Bob to be created") + } + + chat := createTestChat(t, chatStore, + "Чат Алисы", + []string{alice.ID}, + ) + + handler := fixture.router + + request := httptest.NewRequest( + http.MethodPost, + "/api/v1/chats/"+chat.ID+"/messages", + strings.NewReader(`{"text":"Сообщение чужому чату"}`), + ) + request.Header.Set("Content-Type", "application/json") + authorizeTestRequest(t, fixture, request, bob.ID) + + response := httptest.NewRecorder() + + handler.ServeHTTP(response, request) + + if response.Code != http.StatusNotFound { + t.Fatalf( + "expected status %d, got %d; body: %s", + http.StatusNotFound, + response.Code, + response.Body.String(), + ) + } + + if response.Header().Get("X-Request-Id") == "" { + t.Fatal("expected non-empty X-Request-Id header") + } + + if !strings.Contains( + response.Body.String(), + `"code":"not_found"`, + ) { + t.Fatalf( + "expected not_found error code, got body: %s", + response.Body.String(), + ) + } + + messages := listTestMessages(t, messageStore, chat.ID) + + if len(messages) != 0 { + t.Fatalf( + "expected no messages to be stored, got %d", + len(messages), + ) + } +} +func TestListMessagesPagination(t *testing.T) { + fixture := newTestFixture(t) + userStore, chatStore, messageStore := fixture.users, fixture.chats, fixture.messages + + user, created := createTestUser(t, userStore, "alice", "Алиса") + if !created { + t.Fatal("expected user to be created") + } + + chat := createTestChat(t, chatStore, + "Тестовый чат", + []string{user.ID}, + ) + + first := createTestMessage(t, messageStore, chat.ID, user.ID, "Первое сообщение") + second := createTestMessage(t, messageStore, chat.ID, user.ID, "Второе сообщение") + third := createTestMessage(t, messageStore, chat.ID, user.ID, "Третье сообщение") + + expectedIDs := map[string]bool{ + first.ID: true, + second.ID: true, + third.ID: true, + } + + handler := fixture.router + + // Запрашиваем только два сообщения из трёх. + firstRequest := httptest.NewRequest( + http.MethodGet, + "/api/v1/chats/"+chat.ID+"/messages?limit=2", + nil, + ) + authorizeTestRequest(t, fixture, firstRequest, user.ID) + + firstResponse := httptest.NewRecorder() + + handler.ServeHTTP(firstResponse, firstRequest) + + if firstResponse.Code != http.StatusOK { + t.Fatalf( + "expected first page status %d, got %d; body: %s", + http.StatusOK, + firstResponse.Code, + firstResponse.Body.String(), + ) + } + + var firstPage messagePage + + if err := json.NewDecoder(firstResponse.Body).Decode(&firstPage); err != nil { + t.Fatalf("failed to decode first page: %v", err) + } + + if len(firstPage.Items) != 2 { + t.Fatalf( + "expected 2 messages on first page, got %d", + len(firstPage.Items), + ) + } + + if firstPage.NextCursor == nil || *firstPage.NextCursor == "" { + t.Fatal("expected non-empty next cursor on first page") + } + + // Проверяем, что сообщения на первой странице уникальны + // и принадлежат исходному набору. + seenIDs := make(map[string]bool) + + for _, message := range firstPage.Items { + if !expectedIDs[message.ID] { + t.Fatalf("unexpected message ID on first page: %s", message.ID) + } + + if seenIDs[message.ID] { + t.Fatalf("duplicate message on first page: %s", message.ID) + } + + seenIDs[message.ID] = true + } + + // Используем cursor первой страницы для получения второй. + secondRequest := httptest.NewRequest( + http.MethodGet, + "/api/v1/chats/"+chat.ID+"/messages?limit=2&cursor="+ + url.QueryEscape(*firstPage.NextCursor), + nil, + ) + authorizeTestRequest(t, fixture, secondRequest, user.ID) + + secondResponse := httptest.NewRecorder() + + handler.ServeHTTP(secondResponse, secondRequest) + + if secondResponse.Code != http.StatusOK { + t.Fatalf( + "expected second page status %d, got %d; body: %s", + http.StatusOK, + secondResponse.Code, + secondResponse.Body.String(), + ) + } + + var secondPage messagePage + + if err := json.NewDecoder(secondResponse.Body).Decode(&secondPage); err != nil { + t.Fatalf("failed to decode second page: %v", err) + } + + if len(secondPage.Items) != 1 { + t.Fatalf( + "expected 1 message on second page, got %d", + len(secondPage.Items), + ) + } + + if secondPage.NextCursor != nil { + t.Fatalf("expected second page to be final, got cursor %q", *secondPage.NextCursor) + } + + // Проверяем, что вторая страница не повторяет первую. + for _, message := range secondPage.Items { + if seenIDs[message.ID] { + t.Fatalf("message repeated on second page: %s", message.ID) + } + + if !expectedIDs[message.ID] { + t.Fatalf("unexpected message ID on second page: %s", message.ID) + } + + seenIDs[message.ID] = true + } + + if len(seenIDs) != len(expectedIDs) { + t.Fatalf( + "pagination lost messages: expected %d unique messages, got %d", + len(expectedIDs), + len(seenIDs), + ) + } +} diff --git a/src/backend/tests/message_store_test.go b/src/backend/tests/message_store_test.go new file mode 100644 index 0000000..3d8c2c5 --- /dev/null +++ b/src/backend/tests/message_store_test.go @@ -0,0 +1,69 @@ +package tests + +import ( + "context" + "messenger/src/backend/services" + "testing" + "time" + + "github.com/google/uuid" +) + +func TestMessageLessUsesIDForEqualTimestamps(t *testing.T) { + createdAt := time.Date(2026, 9, 18, 12, 0, 0, 0, time.UTC) + first := Message{ID: "a", CreatedAt: createdAt} + second := Message{ID: "b", CreatedAt: createdAt} + if !services.MessageLess(first, second) || services.MessageLess(second, first) { + t.Fatal("equal timestamps must be ordered by ID") + } +} + +func TestListPageByChatUsesCursorAndLimit(t *testing.T) { + f := newTestFixture(t) + user, _ := createTestUser(t, f.users, "alice", "Алиса") + chat := createTestChat(t, f.chats, "Пагинация", []string{user.ID}) + other := createTestChat(t, f.chats, "Другой чат", []string{user.ID}) + createTestMessage(t, f.messages, other.ID, user.ID, "Не должно попасть в страницу") + createdAt := time.Date(2026, 9, 18, 12, 0, 0, 0, time.UTC) + ids := []string{ + "00000000-0000-4000-8000-000000000001", "00000000-0000-4000-8000-000000000002", + "00000000-0000-4000-8000-000000000003", "00000000-0000-4000-8000-000000000004", + } + // Insert in reverse order to exercise SQL ordering, including equal timestamps. + for i := len(ids) - 1; i >= 0; i-- { + at := createdAt + if i > 1 { + at = at.Add(time.Duration(i-1) * time.Second) + } + _, err := f.db.Exec(context.Background(), "INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES($1,$2,$3,$4,$5)", ids[i], chat.ID, user.ID, "message", at) + if err != nil { + t.Fatal(err) + } + } + first, more, err := f.messages.ListPageByChat(context.Background(), chat.ID, nil, 2) + if err != nil { + t.Fatal(err) + } + if !more || len(first) != 2 || first[0].ID != ids[0] || first[1].ID != ids[1] { + t.Fatalf("unexpected first page: %v, more=%v", first, more) + } + cursor := &messageCursor{ChatID: chat.ID, CreatedAt: first[1].CreatedAt, MessageID: first[1].ID} + second, more, err := f.messages.ListPageByChat(context.Background(), chat.ID, cursor, 2) + if err != nil { + t.Fatal(err) + } + if more || len(second) != 2 || second[0].ID != ids[2] || second[1].ID != ids[3] { + t.Fatalf("unexpected second page: %v, more=%v", second, more) + } +} + +func TestListPageByChatReturnsNonNilEmptyPage(t *testing.T) { + f := newTestFixture(t) + page, more, err := f.messages.ListPageByChat(context.Background(), uuid.NewString(), nil, 100) + if err != nil { + t.Fatal(err) + } + if page == nil || len(page) != 0 || more { + t.Fatalf("unexpected empty page: %v, more=%v", page, more) + } +} diff --git a/src/backend/tests/security_test.go b/src/backend/tests/security_test.go new file mode 100644 index 0000000..2c0a40e --- /dev/null +++ b/src/backend/tests/security_test.go @@ -0,0 +1,79 @@ +package tests + +import ( + "bytes" + "context" + "messenger/src/backend/handlers" + "messenger/src/backend/services" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +func TestPasswordKDFUsesSaltAndFullUTF8Password(t *testing.T) { + password := "длинный-пароль-с-эмодзи-🔒-0123456789" + first, err := services.HashPassword(password) + if err != nil { + t.Fatal(err) + } + second, err := services.HashPassword(password) + if err != nil { + t.Fatal(err) + } + if !bytes.HasPrefix(first, []byte("$argon2id$v=19$m=65536,t=3,p=2$")) || bytes.Equal(first, second) { + t.Fatal("password hashes must use Argon2id with independent salts") + } + valid, err := services.VerifyPassword(password, first) + if err != nil { + t.Fatal(err) + } + invalid, err := services.VerifyPassword(password+"другое", first) + if err != nil { + t.Fatal(err) + } + if !valid || invalid { + t.Fatal("Argon2id verification lost the full UTF-8 password") + } + if _, err := services.VerifyPassword(password, bytes.Repeat([]byte{1}, 64)); err == nil { + t.Fatal("legacy scrypt hash must not be accepted") + } +} + +func TestStoredPasswordUsesArgon2id(t *testing.T) { + fixture := newTestFixture(t) + user, _ := createTestUser(t, fixture.users, "alice", "Алиса") + var stored []byte + if err := fixture.db.QueryRow(context.Background(), "SELECT password_hash FROM users WHERE id=$1", user.ID).Scan(&stored); err != nil { + t.Fatal(err) + } + if !bytes.HasPrefix(stored, []byte("$argon2id$")) { + t.Fatalf("unexpected stored password hash format: %q", stored) + } +} + +func TestBearerRequiredIgnoresXUserID(t *testing.T) { + handler := handlers.NewRouter(nil, nil, nil, nil, nil) + request := httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil) + request.Header.Set("X-User-Id", "11111111-1111-4111-8111-111111111111") + response := httptest.NewRecorder() + handler.ServeHTTP(response, request) + if response.Code != 401 || response.Header().Get("WWW-Authenticate") != `Bearer realm="messenger"` { + t.Fatalf("unexpected response: %d %v", response.Code, response.Header()) + } +} + +func TestMessageCursorPreservesPosition(t *testing.T) { + original := messageCursor{ChatID: "11111111-1111-4111-8111-111111111111", CreatedAt: time.Date(2026, 9, 23, 10, 0, 0, 123000, time.UTC), MessageID: "22222222-2222-4222-8222-222222222222"} + token, err := services.EncodeMessageCursor(original) + if err != nil { + t.Fatal(err) + } + decoded, err := services.DecodeMessageCursor(token) + if err != nil { + t.Fatal(err) + } + if decoded != original { + t.Fatalf("cursor changed: %+v", decoded) + } +} diff --git a/src/backend/tests/test_fixture_test.go b/src/backend/tests/test_fixture_test.go new file mode 100644 index 0000000..ebf150a --- /dev/null +++ b/src/backend/tests/test_fixture_test.go @@ -0,0 +1,123 @@ +package tests + +import ( + "context" + "messenger/src/backend/handlers" + "messenger/src/backend/repositories" + "messenger/src/backend/services" + "net/http" + "os" + "strings" + "testing" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +type testFixture struct { + db *pgxpool.Pool + users *repositories.UserStore + chats *repositories.ChatStore + messages *repositories.MessageStore + sessions *services.SessionService + router http.Handler +} + +// Each test owns a new schema; public application tables are never modified. +func newTestFixture(t *testing.T) *testFixture { + t.Helper() + url := os.Getenv("TEST_DATABASE_URL") + if url == "" { + t.Skip("PostgreSQL tests: run make test-backend, or set TEST_DATABASE_URL") + } + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + admin, err := pgxpool.New(ctx, url) + if err != nil { + t.Fatal(err) + } + t.Cleanup(admin.Close) + schema := "test_" + strings.ReplaceAll(uuid.NewString(), "-", "") + identifier := pgx.Identifier{schema}.Sanitize() + if _, err = admin.Exec(ctx, "CREATE SCHEMA "+identifier); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if _, err := admin.Exec(ctx, "DROP SCHEMA "+identifier+" CASCADE"); err != nil { + t.Errorf("cleanup test schema: %v", err) + } + }) + cfg, err := pgxpool.ParseConfig(url) + if err != nil { + t.Fatal(err) + } + cfg.ConnConfig.RuntimeParams["search_path"] = schema + db, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + t.Fatal(err) + } + t.Cleanup(db.Close) + ddl, err := os.ReadFile("../repositories/migrations/000001_initial.up.sql") + if err != nil { + t.Fatal(err) + } + if _, err = db.Exec(ctx, string(ddl)); err != nil { + t.Fatal(err) + } + users := repositories.NewUserStore(db) + chats := repositories.NewChatStore(db) + messages := repositories.NewMessageStore(db) + userService := services.NewUserService(users) + sessions := services.NewSessionService(userService, repositories.NewSessionStore(db), time.Hour) + router := handlers.NewRouter(services.NewHealthService(repositories.NewHealthStore(db)), userService, sessions, services.NewChatService(chats), services.NewMessageService(messages)) + return &testFixture{db, users, chats, messages, sessions, router} +} + +func createTestUser(t *testing.T, store *repositories.UserStore, username, name string) (repositories.User, bool) { + t.Helper() + user, err := services.NewUserService(store).Create(context.Background(), username, name, "lab2-test-password") + if err != nil { + t.Fatal(err) + } + return user, true +} + +func createTestChat(t *testing.T, store *repositories.ChatStore, title string, members []string) repositories.Chat { + t.Helper() + chat, err := store.Create(context.Background(), title, members) + if err != nil { + t.Fatal(err) + } + return chat +} + +func createTestMessage(t *testing.T, store *repositories.MessageStore, chatID, userID, text string) repositories.Message { + t.Helper() + message, err := store.Create(context.Background(), chatID, userID, text) + if err != nil { + t.Fatal(err) + } + return message +} + +func listTestMessages(t *testing.T, store *repositories.MessageStore, chatID string) []repositories.Message { + t.Helper() + items, _, err := store.ListPageByChat(context.Background(), chatID, nil, 100) + if err != nil { + t.Fatal(err) + } + return items +} + +func authorizeTestRequest(t *testing.T, fixture *testFixture, request *http.Request, userID string) { + t.Helper() + token, _, err := fixture.sessions.CreateForUser(request.Context(), userID) + if err != nil { + t.Fatal(err) + } + request.Header.Set("Authorization", "Bearer "+token) +} diff --git a/src/backend/tests/types_test.go b/src/backend/tests/types_test.go new file mode 100644 index 0000000..25e6b75 --- /dev/null +++ b/src/backend/tests/types_test.go @@ -0,0 +1,12 @@ +package tests + +import ( + "messenger/src/backend/repositories" + "messenger/src/backend/services" +) + +type User = repositories.User +type Chat = repositories.Chat +type Message = repositories.Message +type messagePage = services.MessagePage +type messageCursor = repositories.MessageCursor diff --git a/src/backend/tests/user_handler_test.go b/src/backend/tests/user_handler_test.go new file mode 100644 index 0000000..2e22fee --- /dev/null +++ b/src/backend/tests/user_handler_test.go @@ -0,0 +1,137 @@ +package tests + +import ( + "context" + "messenger/src/backend/handlers" + "messenger/src/backend/repositories" + "messenger/src/backend/services" + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +func TestCreateUserInvalidJSON(t *testing.T) { + store := repositories.NewUserStore(nil) + handler := handlers.NewRouter(nil, services.NewUserService(store), nil, nil, nil) + + request := httptest.NewRequest( + http.MethodPost, + "/api/v1/users", + strings.NewReader(`{"username":`), + ) + request.Header.Set("Content-Type", "application/json") + + response := httptest.NewRecorder() + + handler.ServeHTTP(response, request) + + if response.Code != http.StatusBadRequest { + t.Fatalf( + "expected status %d, got %d; body: %s", + http.StatusBadRequest, + response.Code, + response.Body.String(), + ) + } + + if response.Header().Get("Content-Type") != "application/json" { + t.Fatalf( + "expected Content-Type application/json, got %q", + response.Header().Get("Content-Type"), + ) + } + + if response.Header().Get("X-Request-Id") == "" { + t.Fatal("expected non-empty X-Request-Id header") + } + + body := response.Body.String() + + if !strings.Contains(body, `"code":"invalid_request"`) { + t.Fatalf( + "expected invalid_request error code, got body: %s", + body, + ) + } + + if !strings.Contains(body, "request_id") { + t.Fatalf( + "expected request_id in error body, got body: %s", + body, + ) + } +} + +func TestCreateUserDuplicateUsername(t *testing.T) { + fixture := newTestFixture(t) + handler := fixture.router + + firstRequest := httptest.NewRequest( + http.MethodPost, + "/api/v1/users", + strings.NewReader(`{ + "username": "alice", + "display_name": "Алиса", "password": "lab2-test-password" + }`), + ) + firstRequest.Header.Set("Content-Type", "application/json") + + firstResponse := httptest.NewRecorder() + + handler.ServeHTTP(firstResponse, firstRequest) + + if firstResponse.Code != http.StatusCreated { + t.Fatalf( + "expected first request status %d, got %d; body: %s", + http.StatusCreated, + firstResponse.Code, + firstResponse.Body.String(), + ) + } + + secondRequest := httptest.NewRequest( + http.MethodPost, + "/api/v1/users", + strings.NewReader(`{ + "username": "alice", + "display_name": "Другая Алиса", "password": "lab2-test-password" + }`), + ) + secondRequest.Header.Set("Content-Type", "application/json") + + secondResponse := httptest.NewRecorder() + + handler.ServeHTTP(secondResponse, secondRequest) + + if secondResponse.Code != http.StatusConflict { + t.Fatalf( + "expected duplicate username status %d, got %d; body: %s", + http.StatusConflict, + secondResponse.Code, + secondResponse.Body.String(), + ) + } + + if secondResponse.Header().Get("X-Request-Id") == "" { + t.Fatal("expected non-empty X-Request-Id header") + } + + if !strings.Contains( + secondResponse.Body.String(), + `"code":"conflict"`, + ) { + t.Fatalf( + "expected conflict error code, got body: %s", + secondResponse.Body.String(), + ) + } + + var count int + if err := fixture.db.QueryRow(context.Background(), "SELECT count(*) FROM users").Scan(&count); err != nil { + t.Fatal(err) + } + if count != 1 { + t.Fatalf("expected one user, got %d", count) + } +} diff --git a/src/chat_get_handler.go b/src/chat_get_handler.go deleted file mode 100644 index 3d50489..0000000 --- a/src/chat_get_handler.go +++ /dev/null @@ -1,105 +0,0 @@ -package main - -import ( - "encoding/json" - "log" - "net/http" - "strings" - - "github.com/google/uuid" -) - -func getChatHandler( - userStore *userStore, - chatStore *chatStore, -) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - requestID := newRequestID() - w.Header().Set("X-Request-Id", requestID) - - if r.Method != http.MethodGet { - writeError( - w, - http.StatusMethodNotAllowed, - "method_not_allowed", - "method not allowed", - requestID, - ) - return - } - - currentUserID := currentUserID(r) - - if currentUserID == "" { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "valid Bearer session is required", - requestID, - ) - return - } - - if _, err := userStore.getByID(r.Context(), currentUserID); err != nil { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "unknown user", - requestID, - ) - return - } - - chatID := strings.TrimPrefix( - r.URL.Path, - "/api/v1/chats/", - ) - - if chatID == "" || strings.Contains(chatID, "/") { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "invalid chat id", - requestID, - ) - return - } - - if _, err := uuid.Parse(chatID); err != nil { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "invalid chat id", - requestID, - ) - return - } - - chat, err := chatStore.getByID(r.Context(), chatID) - - if err != nil || !chatStore.isMember(chat, currentUserID) { - // Для неизвестного и чужого чата используется одинаковый 404. - // Это не раскрывает постороннему пользователю наличие чата. - writeError( - w, - http.StatusNotFound, - "not_found", - "chat not found", - requestID, - ) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - - if err := json.NewEncoder(w).Encode(chat); err != nil { - log.Printf("failed to encode chat response: %v", err) - return - } - } -} diff --git a/src/chat_handler.go b/src/chat_handler.go deleted file mode 100644 index 7460c89..0000000 --- a/src/chat_handler.go +++ /dev/null @@ -1,194 +0,0 @@ -package main - -import ( - "encoding/json" - "errors" - "log" - "net/http" - "strings" - "unicode/utf8" - - "github.com/google/uuid" -) - -type createChatRequest struct { - Title string `json:"title"` - MemberIDs []string `json:"member_ids"` -} - -func createChatHandler( - userStore *userStore, - chatStore *chatStore, -) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - requestID := newRequestID() - w.Header().Set("X-Request-Id", requestID) - - if r.Method != http.MethodPost { - writeError( - w, - http.StatusMethodNotAllowed, - "method_not_allowed", - "method not allowed", - requestID, - ) - return - } - - currentUserID := currentUserID(r) - - if currentUserID == "" { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "valid Bearer session is required", - requestID, - ) - return - } - - if _, err := userStore.getByID(r.Context(), currentUserID); err != nil { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "unknown user", - requestID, - ) - return - } - - if !strings.HasPrefix( - r.Header.Get("Content-Type"), - "application/json", - ) { - writeError( - w, - http.StatusUnsupportedMediaType, - "unsupported_media_type", - "content type must be application/json", - requestID, - ) - return - } - - var request createChatRequest - - if err := decodeJSONBody(r, &request); err != nil { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "invalid JSON body", - requestID, - ) - return - } - - if strings.TrimSpace(request.Title) == "" { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "title must not be blank", - requestID, - ) - return - } - - if utf8.RuneCountInString(request.Title) > 100 { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "title is too long", - requestID, - ) - return - } - - if len(request.MemberIDs) == 0 || len(request.MemberIDs) > 100 { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "member_ids must contain from 1 to 100 users", - requestID, - ) - return - } - - seenMembers := make(map[string]struct{}) - - for _, memberID := range request.MemberIDs { - if _, err := uuid.Parse(memberID); err != nil { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "member_ids must contain valid UUIDs", - requestID, - ) - return - } - - if _, duplicate := seenMembers[memberID]; duplicate { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "member_ids must not contain duplicates", - requestID, - ) - return - } - - seenMembers[memberID] = struct{}{} - - if _, err := userStore.getByID(r.Context(), memberID); err != nil { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "all members must be existing users", - requestID, - ) - return - } - } - - if _, included := seenMembers[currentUserID]; !included { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "current user must be a chat member", - requestID, - ) - return - } - - chat, err := chatStore.create( - r.Context(), - request.Title, - request.MemberIDs, - ) - if errors.Is(err, errUnknownMember) { - writeError(w, 400, "invalid_request", "all members must be existing users", requestID) - return - } - if err != nil { - writeError(w, 503, "unavailable", "database unavailable", requestID) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusCreated) - - if err := json.NewEncoder(w).Encode(chat); err != nil { - log.Printf("failed to encode chat response: %v", err) - return - } - } -} diff --git a/src/chat_list_handler.go b/src/chat_list_handler.go deleted file mode 100644 index fafe591..0000000 --- a/src/chat_list_handler.go +++ /dev/null @@ -1,219 +0,0 @@ -package main - -import ( - "encoding/base64" - "encoding/json" - "net/http" - "strconv" - "time" -) - -type chatPage struct { - Items []Chat `json:"items"` - NextCursor *string `json:"next_cursor"` -} - -type chatCursor struct { - UserID string `json:"user_id"` - CreatedAt time.Time `json:"created_at"` - ChatID string `json:"chat_id"` -} - -func encodeChatCursor(cursor chatCursor) (string, error) { - data, err := json.Marshal(cursor) - if err != nil { - return "", err - } - - return base64.RawURLEncoding.EncodeToString(data), nil -} - -func decodeChatCursor(value string) (chatCursor, error) { - data, err := base64.RawURLEncoding.DecodeString(value) - if err != nil { - return chatCursor{}, err - } - - var cursor chatCursor - - if err := json.Unmarshal(data, &cursor); err != nil { - return chatCursor{}, err - } - - if cursor.UserID == "" || - cursor.ChatID == "" || - cursor.CreatedAt.IsZero() { - return chatCursor{}, strconv.ErrSyntax - } - - return cursor, nil -} - -func listChatsHandler( - userStore *userStore, - chatStore *chatStore, -) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - requestID := newRequestID() - w.Header().Set("X-Request-Id", requestID) - - if r.Method != http.MethodGet { - writeError( - w, - http.StatusMethodNotAllowed, - "method_not_allowed", - "method not allowed", - requestID, - ) - return - } - - currentUserID := currentUserID(r) - - if currentUserID == "" { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "valid Bearer session is required", - requestID, - ) - return - } - - if _, err := userStore.getByID(r.Context(), currentUserID); err != nil { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "unknown user", - requestID, - ) - return - } - - limit := 50 - - if values, exists := r.URL.Query()["limit"]; exists { - if len(values) != 1 || values[0] == "" { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "invalid limit", - requestID, - ) - return - } - - parsedLimit, err := strconv.Atoi(values[0]) - if err != nil || parsedLimit < 1 || parsedLimit > 100 { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "limit must be between 1 and 100", - requestID, - ) - return - } - - limit = parsedLimit - } - - var cursor *chatCursor - - if values, exists := r.URL.Query()["cursor"]; exists { - if len(values) != 1 || values[0] == "" { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "invalid cursor", - requestID, - ) - return - } - - decoded, err := decodeChatCursor(values[0]) - if err != nil || decoded.UserID != currentUserID { - writeError( - w, - http.StatusBadRequest, - "invalid_request", - "invalid cursor", - requestID, - ) - return - } - - cursor = &decoded - } - - pageItems, hasMore, err := chatStore.listPageForUser(r.Context(), currentUserID, cursor, limit) - if err != nil { - writeError(w, 503, "unavailable", "database unavailable", requestID) - return - } - - page := chatPage{ - Items: pageItems, - NextCursor: nil, - } - - if hasMore { - last := pageItems[len(pageItems)-1] - - nextCursor, err := encodeChatCursor(chatCursor{ - UserID: currentUserID, - CreatedAt: last.CreatedAt, - ChatID: last.ID, - }) - - if err != nil { - writeError( - w, - http.StatusInternalServerError, - "internal_error", - "internal server error", - requestID, - ) - return - } - - page.NextCursor = &nextCursor - } - - if page.Items == nil { - page.Items = make([]Chat, 0) - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - - if err := json.NewEncoder(w).Encode(page); err != nil { - return - } - } -} - -func chatCollectionHandler( - userStore *userStore, - chatStore *chatStore, -) http.HandlerFunc { - createHandler := createChatHandler(userStore, chatStore) - listHandler := listChatsHandler(userStore, chatStore) - - return func(w http.ResponseWriter, r *http.Request) { - switch r.Method { - case http.MethodPost: - createHandler(w, r) - case http.MethodGet: - listHandler(w, r) - default: - // Передаём обработку createHandler, чтобы получить - // единый JSON-формат ошибки. - createHandler(w, r) - } - } -} diff --git a/src/chat_subresource_handler.go b/src/chat_subresource_handler.go deleted file mode 100644 index 0f5dfee..0000000 --- a/src/chat_subresource_handler.go +++ /dev/null @@ -1,41 +0,0 @@ -package main - -import ( - "net/http" - "strings" -) - -func chatSubresourceHandler( - userStore *userStore, - chatStore *chatStore, - messageStore *messageStore, -) http.HandlerFunc { - getChat := getChatHandler(userStore, chatStore) - createMessage := createMessageHandler( - userStore, - chatStore, - messageStore, - ) - listMessages := listMessagesHandler( - userStore, - chatStore, - messageStore, - ) - - return func(w http.ResponseWriter, r *http.Request) { - if strings.HasSuffix(r.URL.Path, "/messages") { - switch r.Method { - case http.MethodPost: - createMessage(w, r) - case http.MethodGet: - listMessages(w, r) - default: - createMessage(w, r) - } - - return - } - - getChat(w, r) - } -} diff --git a/src/current_user_handler.go b/src/current_user_handler.go deleted file mode 100644 index f96f74e..0000000 --- a/src/current_user_handler.go +++ /dev/null @@ -1,58 +0,0 @@ -package main - -import ( - "encoding/json" - "log" - "net/http" -) - -func currentUserHandler(store *userStore) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - requestID := newRequestID() - w.Header().Set("X-Request-Id", requestID) - - if r.Method != http.MethodGet { - writeError( - w, - http.StatusMethodNotAllowed, - "method_not_allowed", - "method not allowed", - requestID, - ) - return - } - - userID := currentUserID(r) - - if userID == "" { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "valid Bearer session is required", - requestID, - ) - return - } - - user, err := store.getByID(r.Context(), userID) - if err != nil { - writeError( - w, - http.StatusUnauthorized, - "unauthorized", - "unknown user", - requestID, - ) - return - } - - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - - if err := json.NewEncoder(w).Encode(user); err != nil { - log.Printf("failed to encode user response: %v", err) - return - } - } -} diff --git a/src/frontend/.dockerignore b/src/frontend/.dockerignore new file mode 100644 index 0000000..f06235c --- /dev/null +++ b/src/frontend/.dockerignore @@ -0,0 +1,2 @@ +node_modules +dist diff --git a/src/frontend/.gitignore b/src/frontend/.gitignore new file mode 100644 index 0000000..c605a04 --- /dev/null +++ b/src/frontend/.gitignore @@ -0,0 +1,8 @@ +node_modules/ +dist/ +.vite/ +*.tsbuildinfo +*.local +.env +.env.* +!.env.example diff --git a/src/frontend/Dockerfile b/src/frontend/Dockerfile new file mode 100644 index 0000000..e0503fd --- /dev/null +++ b/src/frontend/Dockerfile @@ -0,0 +1,12 @@ +FROM node:22-bookworm-slim + +WORKDIR /app + +COPY package.json package-lock.json ./ +RUN npm ci + +COPY . . + +EXPOSE 5173 + +CMD ["npm", "run", "dev"] diff --git a/src/frontend/index.html b/src/frontend/index.html new file mode 100644 index 0000000..84dd5c3 --- /dev/null +++ b/src/frontend/index.html @@ -0,0 +1,12 @@ + + +
+ + +{id}{id === user.id ? " · вы" : ""})}Загрузка…
: messages.failed ?Не удалось загрузить сообщения
: !messages.items.length &&Нет сообщений
} + {messages.items.map((message) =>{message.text}