Files
mtusi2026lab4/internal/api/server.go
T
Mlvn fef1c30050 Заменить lab4 на aws-sdk S3-вложения, уровень 4 и трек 2 reconciler.
Единый бинарник с objectstore/reconcile, pinned MinIO при недоступности Docker Hub, автотесты и evidence на оценку 5.
2026-11-12 18:25:21 +03:00

768 lines
26 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Package api — HTTP-слой lab4 (lab3 + вложения в S3).
//
// Порядок обработки запроса:
// 1. X-Request-Id и X-Instance-Id на каждый ответ, включая ошибки;
// 2. журнал method/path/status без текста сообщений и без токена;
// 3. маршрут;
// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают.
//
// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL, Redis
// и S3: без них нельзя честно принять запись, узнать, кто делает запрос, или принять/отдать
// вложение (lab4: недоступный S3 → 503, балансировщик снимает реплику).
//
// POST сообщения требует Idempotency-Key; результат хранится в общей БД, а не в памяти реплики.
package api
import (
"bytes"
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"net/http"
"os"
"strconv"
"strings"
"sync/atomic"
"time"
"unicode/utf8"
"github.com/google/uuid"
"mtusi2026lab4/internal/objectstore"
"mtusi2026lab4/internal/session"
"mtusi2026lab4/internal/store"
)
type ctxKey int
const (
userKey ctxKey = iota
tokenKey
requestIDKey
)
const (
challengeBasic = `Basic realm="messenger", charset="UTF-8"`
challengeBearer = `Bearer realm="messenger"`
)
// Server связывает HTTP с PostgreSQL и Redis.
type Server struct {
Store *store.Store
Sessions *session.Store
Objects *objectstore.Store // приватный S3-bucket с оригиналами вложений
InstanceID string
ready atomic.Bool
// uploadSlots — семафор одновременных загрузок (ограничивает пик RAM, см. attachments.go).
uploadSlots chan struct{}
// AfterObjectPut — тестовый hook: вызывается после успешного PUT в S3 и до INSERT в PG.
// Позволяет в тестах смоделировать отказ «между S3 и БД». В проде всегда nil.
AfterObjectPut func(key string)
}
// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready.
// instanceID попадает в X-Instance-Id каждого ответа и стабилен на жизнь процесса.
func New(st *store.Store, sessions *session.Store, objects *objectstore.Store, instanceID string) *Server {
s := &Server{Store: st, Sessions: sessions, Objects: objects, InstanceID: instanceID}
s.uploadSlots = make(chan struct{}, 4) // значение по умолчанию; main задаёт UPLOAD_MAX_CONCURRENCY
s.ready.Store(true)
return s
}
// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready.
// HAProxy/Traefik с httpchk на /health/ready перестаёт слать трафик на эту реплику.
func (s *Server) BeginDrain() { s.ready.Store(false) }
// Handler собирает маршруты lab4.
func (s *Server) Handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", s.handleLive)
mux.HandleFunc("GET /health/ready", s.handleReady)
mux.HandleFunc("POST /api/v1/users", s.handleCreateUser)
mux.HandleFunc("POST /api/v1/auth/sessions", s.handleCreateSession)
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", s.requireUser(s.handleRevokeSession))
mux.HandleFunc("GET /api/v1/users/me", s.requireUser(s.handleMe))
mux.HandleFunc("POST /api/v1/chats", s.requireUser(s.handleCreateChat))
mux.HandleFunc("GET /api/v1/chats", s.requireUser(s.handleListChats))
mux.HandleFunc("GET /api/v1/chats/{chat_id}", s.requireUser(s.handleGetChat))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleCreateMessage))
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleListMessages))
// lab4: вложения. Загрузка — сырой binary (не multipart), метаданные и байты — через API.
mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", s.requireUser(s.handleUploadAttachment))
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", s.requireUser(s.handleGetAttachment))
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", s.requireUser(s.handleDownloadAttachment))
return s.withInstanceID(s.withRequestID(s.withAccessLog(mux)))
}
func (s *Server) handleLive(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) {
if !s.ready.Load() {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "service is shutting down")
return
}
// lab4: S3 — критичная зависимость обязательного синхронного пути (загрузка/скачивание).
// Недоступное хранилище → 503, чтобы LB не слал трафик на реплику, которая не может
// выполнить контракт; сообщения без вложений при этом тоже временно недоступны
// (осознанное упрощение: readiness один на реплику, см. REPORT).
if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil || s.Objects.Ping(r.Context()) != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
return
}
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) {
var body struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
if err := decodeStrict(r, &body); err != nil {
writeDecodeErr(w, r, err)
return
}
if !validUsername(body.Username) {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username")
return
}
display := strings.TrimSpace(body.DisplayName)
if display == "" || utf8.RuneCountInString(display) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name")
return
}
if n := utf8.RuneCountInString(body.Password); n < 12 || n > 128 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password")
return
}
u, err := s.Store.CreateUser(r.Context(), body.Username, display, body.Password)
if err != nil {
s.writeStoreErr(w, r, err, http.StatusConflict, "conflict", "username already taken")
return
}
writeJSON(w, http.StatusCreated, userDTO(u))
}
func (s *Server) handleCreateSession(w http.ResponseWriter, r *http.Request) {
// Контракт: только Basic, без JSON body. Любые байты в теле — 400, не тихий игнор.
rawBody, err := io.ReadAll(io.LimitReader(r.Body, 4096))
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid body")
return
}
if len(bytes.TrimSpace(rawBody)) != 0 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "session create must not have a body")
return
}
username, password, ok := parseBasic(r.Header.Get("Authorization"))
if !ok || !validUsername(username) {
writeAuthError(w, r, challengeBasic)
return
}
if n := utf8.RuneCountInString(password); n < 12 || n > 128 {
writeAuthError(w, r, challengeBasic)
return
}
u, err := s.Store.Authenticate(r.Context(), username, password)
if errors.Is(err, store.ErrNotFound) {
writeAuthError(w, r, challengeBasic)
return
}
if err != nil {
s.writeStoreErr(w, r, err, 0, "", "")
return
}
token, exp, err := s.Sessions.Issue(r.Context(), u.ID)
if err != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
return
}
writeJSON(w, http.StatusCreated, map[string]any{
"token": token,
"token_type": "Bearer",
"expires_at": formatTime(exp),
"user": userDTO(u),
})
}
func (s *Server) handleRevokeSession(w http.ResponseWriter, r *http.Request) {
token, _ := r.Context().Value(tokenKey).(string)
if err := s.Sessions.Revoke(r.Context(), token); err != nil {
if errors.Is(err, session.ErrUnauthorized) {
writeAuthError(w, r, challengeBearer)
return
}
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
return
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) {
u, err := s.Store.GetUser(r.Context(), userFrom(r))
if err != nil {
s.writeStoreErr(w, r, err, http.StatusUnauthorized, "unauthorized", "authentication required")
return
}
writeJSON(w, http.StatusOK, userDTO(u))
}
func (s *Server) handleCreateChat(w http.ResponseWriter, r *http.Request) {
var body struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
if err := decodeStrict(r, &body); err != nil {
writeDecodeErr(w, r, err)
return
}
title := strings.TrimSpace(body.Title)
if title == "" || utf8.RuneCountInString(title) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title")
return
}
if len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids")
return
}
uid := userFrom(r)
seen := make(map[uuid.UUID]struct{}, len(body.MemberIDs))
ids := make([]uuid.UUID, 0, len(body.MemberIDs))
callerPresent := false
for _, raw := range body.MemberIDs {
id, err := uuid.Parse(raw)
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member id")
return
}
if _, dup := seen[id]; dup {
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate member id")
return
}
seen[id] = struct{}{}
if id == uid {
callerPresent = true
}
ids = append(ids, id)
}
if !callerPresent {
writeError(w, r, http.StatusBadRequest, "invalid_request", "caller must be a member")
return
}
chat, err := s.Store.CreateChat(r.Context(), title, ids)
if errors.Is(err, store.ErrNotFound) {
writeError(w, r, http.StatusBadRequest, "invalid_request", "unknown member")
return
}
if err != nil {
s.writeStoreErr(w, r, err, 0, "", "")
return
}
writeJSON(w, http.StatusCreated, chatDTO(chat))
}
func (s *Server) handleListChats(w http.ResponseWriter, r *http.Request) {
uid := userFrom(r)
limit, after, err := parsePage(r, "chats:"+uid.String())
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
items, next, err := s.Store.ListChats(r.Context(), uid, limit, after)
if err != nil {
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
return
}
out := make([]any, len(items))
for i := range items {
out[i] = chatDTO(&items[i])
}
var cursor *store.PageCursor
if next != nil {
cursor = &store.PageCursor{Scope: "chats:" + uid.String(), CreatedAt: next.CreatedAt, ID: next.ID}
}
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
}
func (s *Server) handleGetChat(w http.ResponseWriter, r *http.Request) {
chatID, err := uuid.Parse(r.PathValue("chat_id"))
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
return
}
chat, err := s.Store.GetChat(r.Context(), chatID, userFrom(r))
if errors.Is(err, store.ErrNotFound) {
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
return
}
if err != nil {
s.writeStoreErr(w, r, err, 0, "", "")
return
}
writeJSON(w, http.StatusOK, chatDTO(chat))
}
func (s *Server) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
chatID, err := uuid.Parse(r.PathValue("chat_id"))
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
return
}
idemKey := r.Header.Get("Idempotency-Key")
if !validIdempotencyKey(idemKey) {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid or missing Idempotency-Key")
return
}
var body struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}
if err := decodeStrict(r, &body); err != nil {
writeDecodeErr(w, r, err)
return
}
// attachment_ids: 0–10 уникальных UUID, по умолчанию []. Отсутствующий ключ, null и []
// равны. UUID нормализуем (нижний регистр, канонический вид): иначе «ABC…» и «abc…»
// давали бы разные хэши идемпотентности и дубль в uniqueItems.
if len(body.AttachmentIDs) > 10 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "too many attachment_ids")
return
}
attachmentIDs := make([]uuid.UUID, 0, len(body.AttachmentIDs))
canonicalIDs := make([]string, 0, len(body.AttachmentIDs))
seenAtt := make(map[uuid.UUID]struct{}, len(body.AttachmentIDs))
for _, raw := range body.AttachmentIDs {
id, err := uuid.Parse(raw)
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id")
return
}
if _, dup := seenAtt[id]; dup {
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate attachment id")
return
}
seenAtt[id] = struct{}{}
attachmentIDs = append(attachmentIDs, id)
canonicalIDs = append(canonicalIDs, id.String())
}
// Непустота — по TrimSpace; длина и сохранение — по исходному тексту.
// Иначе пробелы по краям пропадают, а строка «пробел + 4000 букв» проходит как 4000.
// lab4: пустой текст допустим, если есть хотя бы одно вложение (сообщение «только файл»).
if utf8.RuneCountInString(body.Text) > 4000 ||
(strings.TrimSpace(body.Text) == "" && len(attachmentIDs) == 0) {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text")
return
}
path := "/api/v1/chats/" + chatID.String() + "/messages"
reqHash := idempotencyRequestHash(body.Text, canonicalIDs)
result, err := s.Store.CreateMessageIdempotent(
r.Context(), chatID, userFrom(r), body.Text, attachmentIDs,
http.MethodPost, path, idemKey, reqHash,
)
if errors.Is(err, store.ErrNotFound) {
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
return
}
if errors.Is(err, store.ErrIdempotencyConflict) {
writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body")
return
}
if errors.Is(err, store.ErrAttachmentNotReady) {
writeError(w, r, http.StatusConflict, "conflict", "attachment is not ready")
return
}
if err != nil {
s.writeStoreErr(w, r, err, 0, "", "")
return
}
writeJSON(w, http.StatusCreated, messageDTO(result.Message))
}
func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
chatID, err := uuid.Parse(r.PathValue("chat_id"))
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
return
}
scope := "chat:" + chatID.String()
limit, after, err := parsePage(r, scope)
if err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
items, next, err := s.Store.ListMessages(r.Context(), chatID, userFrom(r), limit, after)
if errors.Is(err, store.ErrNotFound) {
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
return
}
if err != nil {
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
return
}
out := make([]any, len(items))
for i := range items {
out[i] = messageDTO(&items[i])
}
var cursor *store.PageCursor
if next != nil {
cursor = &store.PageCursor{Scope: scope, CreatedAt: next.CreatedAt, ID: next.ID}
}
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
}
// requireUser принимает только Authorization: Bearer. X-User-Id не читается.
// Basic на бизнес-методе — тот же 401, но с Bearer-challenge, не с Basic.
func (s *Server) requireUser(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
header := r.Header.Get("Authorization")
if strings.HasPrefix(strings.ToLower(header), "basic ") {
writeAuthError(w, r, challengeBearer)
return
}
token, ok := parseBearer(header)
if !ok {
writeAuthError(w, r, challengeBearer)
return
}
uid, err := s.Sessions.Lookup(r.Context(), token)
if errors.Is(err, session.ErrUnauthorized) {
writeAuthError(w, r, challengeBearer)
return
}
if err != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
return
}
ctx := context.WithValue(r.Context(), userKey, uid)
ctx = context.WithValue(ctx, tokenKey, token)
next(w, r.WithContext(ctx))
}
}
func userFrom(r *http.Request) uuid.UUID {
id, _ := r.Context().Value(userKey).(uuid.UUID)
return id
}
func (s *Server) withRequestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rid := r.Header.Get("X-Request-Id")
if rid == "" {
rid = uuid.NewString()
}
w.Header().Set("X-Request-Id", rid)
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, rid)))
})
}
func (s *Server) withInstanceID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Instance-Id", s.InstanceID)
next.ServeHTTP(w, r)
})
}
// validIdempotencyKey — ASCII [A-Za-z0-9._:-]{1,128}.
func validIdempotencyKey(key string) bool {
if len(key) < 1 || len(key) > 128 {
return false
}
for i := 0; i < len(key); i++ {
c := key[i]
switch {
case c >= 'A' && c <= 'Z', c >= 'a' && c <= 'z', c >= '0' && c <= '9':
case c == '.', c == '_', c == ':', c == '-':
default:
return false
}
}
return true
}
// idempotencyRequestHash канонизирует тело: порядок ключей JSON не важен,
// отсутствующий attachment_ids равен []. Хэш — SHA-256 hex.
func idempotencyRequestHash(text string, attachmentIDs []string) string {
if attachmentIDs == nil {
attachmentIDs = []string{}
}
payload, _ := json.Marshal(struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}{Text: text, AttachmentIDs: attachmentIDs})
sum := sha256.Sum256(payload)
return hex.EncodeToString(sum[:])
}
type statusRecorder struct {
http.ResponseWriter
status int
}
func (s *statusRecorder) WriteHeader(code int) {
s.status = code
s.ResponseWriter.WriteHeader(code)
}
func (s *Server) withAccessLog(next http.Handler) http.Handler {
quiet := strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "0") || strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "false")
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
next.ServeHTTP(rec, r)
if quiet && rec.status < 400 {
return
}
if strings.HasPrefix(r.URL.Path, "/health/") && rec.status == http.StatusOK {
return
}
rid, _ := r.Context().Value(requestIDKey).(string)
// path без query: в cursor нет секрета, но и текста сообщения в логе быть не должно.
log.Printf("method=%s path=%s status=%d request_id=%s duration_ms=%d",
r.Method, r.URL.Path, rec.status, rid, time.Since(start).Milliseconds())
})
}
func parsePage(r *http.Request, expectedScope string) (int, *store.PageCursor, error) {
limit := 50
if raw := r.URL.Query().Get("limit"); raw != "" {
n, err := strconv.Atoi(raw)
if err != nil || n < 1 || n > 100 {
return 0, nil, fmt.Errorf("invalid limit")
}
limit = n
}
rawCursor := r.URL.Query().Get("cursor")
if rawCursor == "" {
return limit, nil, nil
}
cur, err := decodeCursor(rawCursor)
if err != nil || cur.Scope != expectedScope {
return 0, nil, fmt.Errorf("invalid cursor")
}
return limit, cur, nil
}
func encodeCursor(c *store.PageCursor) string {
payload := fmt.Sprintf("%s|%s|%s", c.Scope, c.CreatedAt.UTC().Format(time.RFC3339Nano), c.ID.String())
return base64.RawURLEncoding.EncodeToString([]byte(payload))
}
func decodeCursor(raw string) (*store.PageCursor, error) {
b, err := base64.RawURLEncoding.DecodeString(raw)
if err != nil {
return nil, err
}
parts := strings.SplitN(string(b), "|", 3)
if len(parts) != 3 {
return nil, fmt.Errorf("bad cursor")
}
ts, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return nil, err
}
id, err := uuid.Parse(parts[2])
if err != nil {
return nil, err
}
return &store.PageCursor{Scope: parts[0], CreatedAt: ts.UTC(), ID: id}, nil
}
func validUsername(s string) bool {
if len(s) < 3 || len(s) > 32 {
return false
}
for _, c := range s {
if (c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_' {
return false
}
}
return true
}
func decodeStrict(r *http.Request, dst any) error {
ct := r.Header.Get("Content-Type")
if ct != "" && !strings.HasPrefix(strings.ToLower(strings.TrimSpace(ct)), "application/json") {
return errUnsupported
}
// Читаем тело целиком: Decoder.More() не ловит хвост вида {"text":"x"}} —
// после одного объекта More()=false, а лишняя скобка всё равно остаётся.
raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
if err != nil {
return errMalformed
}
dec := json.NewDecoder(bytes.NewReader(raw))
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
return errMalformed
}
rest := bytes.TrimSpace(raw[dec.InputOffset():])
if len(rest) != 0 {
return errMalformed
}
return nil
}
var (
errUnsupported = errors.New("unsupported media type")
errMalformed = errors.New("malformed json")
)
func writeDecodeErr(w http.ResponseWriter, r *http.Request, err error) {
if errors.Is(err, errUnsupported) {
writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "unsupported media type")
return
}
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed json")
}
func parseBasic(header string) (string, string, bool) {
const prefix = "basic "
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
return "", "", false
}
raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):]))
if err != nil || !utf8.Valid(raw) {
return "", "", false
}
user, pass, ok := strings.Cut(string(raw), ":")
if !ok || user == "" {
return "", "", false
}
return user, pass, true
}
func parseBearer(header string) (string, bool) {
const prefix = "bearer "
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
return "", false
}
token := strings.TrimSpace(header[len(prefix):])
if token == "" || strings.Contains(token, " ") {
return "", false
}
return token, true
}
func userDTO(u *store.User) map[string]any {
return map[string]any{
"id": u.ID.String(),
"username": u.Username,
"display_name": u.DisplayName,
"created_at": formatTime(u.CreatedAt),
}
}
func chatDTO(c *store.Chat) map[string]any {
ids := make([]string, len(c.MemberIDs))
for i, id := range c.MemberIDs {
ids[i] = id.String()
}
return map[string]any{
"id": c.ID.String(),
"title": c.Title,
"member_ids": ids,
"created_at": formatTime(c.CreatedAt),
}
}
func messageDTO(m *store.Message) map[string]any {
// attachment_ids обязателен в ответе (контракт 1.4.0): всегда массив, не null.
ids := make([]string, len(m.AttachmentIDs))
for i, id := range m.AttachmentIDs {
ids[i] = id.String()
}
return map[string]any{
"id": m.ID.String(),
"chat_id": m.ChatID.String(),
"sender_id": m.SenderID.String(),
"text": m.Text,
"created_at": formatTime(m.CreatedAt),
"attachment_ids": ids,
}
}
func pageDTO(items []any, next *store.PageCursor) map[string]any {
var cursor any
if next != nil {
cursor = encodeCursor(next)
}
if items == nil {
items = []any{}
}
return map[string]any{"items": items, "next_cursor": cursor}
}
func formatTime(t time.Time) string {
return t.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z")
}
func writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
enc := json.NewEncoder(w)
enc.SetEscapeHTML(false)
_ = enc.Encode(v)
}
func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) {
rid, _ := r.Context().Value(requestIDKey).(string)
if rid == "" {
rid = w.Header().Get("X-Request-Id")
}
writeJSON(w, status, map[string]any{
"error": map[string]any{
"code": code,
"message": message,
"request_id": rid,
},
})
}
func writeAuthError(w http.ResponseWriter, r *http.Request, challenge string) {
w.Header().Set("WWW-Authenticate", challenge)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "authentication required")
}
// writeStoreErr прячет текст драйвера. fallbackStatus используется для ожидаемой доменной ошибки.
func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error, fallbackStatus int, fallbackCode, fallbackMessage string) {
switch {
case errors.Is(err, store.ErrUnavailable):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
case errors.Is(err, store.ErrIdempotencyConflict):
writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body")
case errors.Is(err, store.ErrConflict) && fallbackStatus != 0:
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
case errors.Is(err, store.ErrNotFound) && fallbackStatus != 0:
if fallbackCode == "unauthorized" {
writeAuthError(w, r, challengeBearer)
return
}
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
case errors.Is(err, store.ErrInvalidCursor):
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor")
default:
if errors.Is(err, store.ErrConflict) {
writeError(w, r, http.StatusConflict, "conflict", "username already taken")
return
}
// В лог — только тип, без SQL и без текста, который драйвер мог вложить в ошибку.
log.Printf("request_id=%s store_error_type=%T", requestID(r), err)
writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error")
}
}
func requestID(r *http.Request) string {
rid, _ := r.Context().Value(requestIDKey).(string)
return rid
}