package api import ( "context" "errors" "log/slog" "net/http" "strings" "time" "github.com/google/uuid" "mtusi-messenger/internal/apperr" "mtusi-messenger/internal/auth" "mtusi-messenger/internal/model" ) type ctxKey int const ( ctxRequestID ctxKey = iota ctxUser ctxToken ) func requestIDMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { id := r.Header.Get("X-Request-Id") if id == "" { id = uuid.NewString() } w.Header().Set("X-Request-Id", id) next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxRequestID, id))) }) } func instanceIDMiddleware(instanceID string, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("X-Instance-Id", instanceID) next.ServeHTTP(w, r) }) } func requestID(r *http.Request) string { if id, ok := r.Context().Value(ctxRequestID).(string); ok && id != "" { return id } return "unknown" } type statusWriter struct { http.ResponseWriter status int } func (s *statusWriter) WriteHeader(code int) { s.status = code s.ResponseWriter.WriteHeader(code) } func loggingMiddleware(log *slog.Logger, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() sw := &statusWriter{ResponseWriter: w, status: http.StatusOK} next.ServeHTTP(sw, r) log.Info("http", "method", r.Method, "path", r.URL.Path, "status", sw.status, "dur_ms", time.Since(start).Milliseconds(), "request_id", requestID(r), ) }) } func recoverMiddleware(log *slog.Logger, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { defer func() { if rec := recover(); rec != nil { log.Error("panic recovered", "path", r.URL.Path, "request_id", requestID(r)) apperr.Write(w, requestID(r), apperr.Internal("internal error")) } }() next.ServeHTTP(w, r) }) } // Binary transfers get a longer budget than JSON requests. func timeoutMiddleware(d, binary time.Duration, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { limit := d if strings.Contains(r.URL.Path, "/attachments") { limit = binary } ctx, cancel := context.WithTimeout(r.Context(), limit) defer cancel() next.ServeHTTP(w, r.WithContext(ctx)) }) } const bearerChallenge = `Bearer realm="messenger"` func unauthorizedBearer(w http.ResponseWriter, r *http.Request) { w.Header().Set("WWW-Authenticate", bearerChallenge) apperr.Write(w, requestID(r), apperr.Unauthorized("valid Bearer session token is required")) } func bearerToken(r *http.Request) (string, bool) { scheme, token, ok := strings.Cut(r.Header.Get("Authorization"), " ") if !ok || !strings.EqualFold(scheme, "Bearer") { return "", false } token = strings.TrimSpace(token) if token == "" || len(token) > 256 { return "", false } return token, true } func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { token, ok := bearerToken(r) if !ok { unauthorizedBearer(w, r) return } user, err := s.sessions.Resolve(r.Context(), token) if errors.Is(err, auth.ErrInvalidSession) { unauthorizedBearer(w, r) return } if err != nil { s.storeError(w, r, err) return } ctx := context.WithValue(r.Context(), ctxUser, user) ctx = context.WithValue(ctx, ctxToken, token) next.ServeHTTP(w, r.WithContext(ctx)) } } func currentUser(r *http.Request) *model.User { return r.Context().Value(ctxUser).(*model.User) } func currentToken(r *http.Request) string { return r.Context().Value(ctxToken).(string) }