initial public relay build repo

internal/retention/retention.go

@@ -0,0 +1,96 @@
+// Package retention prunes old CHAT messages (kinds 9/10) so the event store
+// does not grow without bound. Group-management and addressable metadata events
+// (9007/9000/9001/9021/9022, 39000-39002) are NEVER pruned — they define
+// membership and must survive to be replayed on boot.
+package retention
+
+import (
+	"log"
+	"slices"
+	"time"
+
+	"fiatjaf.com/nostr"
+	"fiatjaf.com/nostr/eventstore"
+)
+
+// Config controls what the retention sweeper deletes.
+type Config struct {
+	// MaxAge: chat messages older than this are deleted. Zero disables age pruning.
+	MaxAge time.Duration
+	// MaxMessages: keep at most this many chat messages (newest kept). Zero
+	// disables count pruning.
+	MaxMessages int
+	// Interval between sweeps.
+	Interval time.Duration
+}
+
+// chatKinds are the only kinds eligible for retention pruning.
+var chatKinds = []nostr.Kind{
+	nostr.KindSimpleGroupChatMessage,
+	nostr.KindSimpleGroupThreadedReply,
+}
+
+// Sweep runs a single retention pass and returns the number of events deleted.
+// `now` is injected so the logic is deterministically testable.
+func Sweep(store eventstore.Store, cfg Config, now time.Time) int {
+	// Collect all chat events (newest-first from the store).
+	var chats []nostr.Event
+	for evt := range store.QueryEvents(nostr.Filter{Kinds: chatKinds}, 1_000_000) {
+		chats = append(chats, evt)
+	}
+	// Sort newest-first so index >= MaxMessages are the surplus oldest ones.
+	slices.SortFunc(chats, nostr.CompareEventReverse)
+
+	cutoff := nostr.Timestamp(0)
+	if cfg.MaxAge > 0 {
+		cutoff = nostr.Timestamp(now.Add(-cfg.MaxAge).Unix())
+	}
+
+	deleted := 0
+	for i, evt := range chats {
+		tooOld := cfg.MaxAge > 0 && evt.CreatedAt < cutoff
+		surplus := cfg.MaxMessages > 0 && i >= cfg.MaxMessages
+		if tooOld || surplus {
+			if err := store.DeleteEvent(evt.ID); err == nil {
+				deleted++
+			}
+		}
+	}
+	return deleted
+}
+
+// Start launches a background sweeper. It is a no-op (returns a no-op stop) when
+// neither limit is configured. The returned stop function halts it.
+func Start(store eventstore.Store, cfg Config) (stop func()) {
+	if cfg.MaxAge == 0 && cfg.MaxMessages == 0 {
+		log.Println("retention disabled (no RELAY_RETENTION_* limits set)")
+		return func() {}
+	}
+	if cfg.Interval == 0 {
+		cfg.Interval = time.Hour
+	}
+
+	done := make(chan struct{})
+	go func() {
+		// Sweep once at startup, then on the interval.
+		if n := Sweep(store, cfg, time.Now()); n > 0 {
+			log.Printf("retention: pruned %d old chat message(s)", n)
+		}
+		ticker := time.NewTicker(cfg.Interval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-done:
+				return
+			case <-ticker.C:
+				if n := Sweep(store, cfg, time.Now()); n > 0 {
+					log.Printf("retention: pruned %d old chat message(s)", n)
+				}
+			}
+		}
+	}()
+
+	log.Printf("retention enabled (maxAge=%s maxMessages=%d interval=%s)",
+		cfg.MaxAge, cfg.MaxMessages, cfg.Interval)
+	return func() { close(done) }
+}