platform: modularize api/gui, add docs-tests-web foundation, and refresh root config

selective-vpn-api/app/events_handlers.go

@@ -1,111 +1,32 @@
 package app
 
 import (
-	"encoding/json"
-	"fmt"
-	"io"
 	"net/http"
-	"strconv"
-	"strings"
+	eventstreampkg "selective-vpn-api/app/eventstream"
 	"time"
 )
 
-// ---------------------------------------------------------------------
-// events (SSE)
-// ---------------------------------------------------------------------
-
-// EN: Server-Sent Events transport with replay support via Last-Event-ID/since,
-// EN: heartbeat pings, and periodic polling of the in-memory event buffer.
-// RU: Транспорт Server-Sent Events с поддержкой реплея через Last-Event-ID/since,
-// RU: heartbeat-пингами и периодическим опросом in-memory буфера событий.
-
-// ---------------------------------------------------------------------
-// SSE helpers
-// ---------------------------------------------------------------------
-
 func parseSinceID(r *http.Request) int64 {
-	sinceStr := strings.TrimSpace(r.URL.Query().Get("since"))
-	if sinceStr == "" {
-		sinceStr = strings.TrimSpace(r.Header.Get("Last-Event-ID"))
-	}
-	if sinceStr == "" {
-		return 0
-	}
-	if v, err := strconv.ParseInt(sinceStr, 10, 64); err == nil && v >= 0 {
-		return v
-	}
-	return 0
+	return eventstreampkg.ParseSinceID(r)
 }
 
-// ---------------------------------------------------------------------
-// SSE stream handler
-// ---------------------------------------------------------------------
-
 func handleEventsStream(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	flusher, ok := w.(http.Flusher)
-	if !ok {
-		http.Error(w, "streaming unsupported", http.StatusBadRequest)
-		return
-	}
-
-	w.Header().Set("Content-Type", "text/event-stream")
-	w.Header().Set("Cache-Control", "no-cache")
-	w.Header().Set("Connection", "keep-alive")
-
-	ctx := r.Context()
-	since := parseSinceID(r)
-
-	send := func(ev Event) error {
-		payload, err := json.Marshal(ev)
-		if err != nil {
-			return err
-		}
-		if _, err := fmt.Fprintf(w, "id: %d\nevent: %s\ndata: %s\n\n", ev.ID, ev.Kind, string(payload)); err != nil {
-			return err
-		}
-		flusher.Flush()
-		return nil
-	}
-
-	// initial replay
-	for _, ev := range events.since(since) {
-		if err := send(ev); err != nil {
-			return
-		}
-		since = ev.ID
-	}
-
-	// polling loop; lightweight for localhost
-	pollEvery := 500 * time.Millisecond
 	heartbeat := time.Duration(envInt("SVPN_EVENTS_HEARTBEAT_SEC", defaultHeartbeatSeconds)) * time.Second
-	pollTicker := time.NewTicker(pollEvery)
-	pingTicker := time.NewTicker(heartbeat)
-	defer pollTicker.Stop()
-	defer pingTicker.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-pingTicker.C:
-			_, _ = io.WriteString(w, ": ping\n\n")
-			flusher.Flush()
-		case <-pollTicker.C:
-			evs := events.since(since)
-			if len(evs) == 0 {
-				continue
+	eventstreampkg.Serve(
+		w,
+		r,
+		500*time.Millisecond,
+		heartbeat,
+		func(since int64) []eventstreampkg.Event {
+			raw := events.since(since)
+			if len(raw) == 0 {
+				return nil
 			}
-			for _, ev := range evs {
-				if err := send(ev); err != nil {
-					return
-				}
-				since = ev.ID
+			out := make([]eventstreampkg.Event, 0, len(raw))
+			for _, ev := range raw {
+				out = append(out, eventstreampkg.Event{ID: ev.ID, Kind: ev.Kind, Data: ev})
 			}
-		}
-	}
+			return out
+		},
+	)
 }