app/static/examples/config.example.yml

@@ -74,9 +74,9 @@ rate_limit:
       burst: 50
 
 event_purge:
-  enabled: false # Toggle to enable/disable event purging
+  enabled: true # Toggle to enable/disable event purging
   keep_interval_hours: 24 # Number of hours to keep events before purging
-  purge_interval_minutes: 240 # Interval in minutes for running the purge
+  purge_interval_minutes: 1 # Interval in minutes for running the purge
   purge_by_category: # Configure purging based on categories
     regular: true
     replaceable: false

config/Whitelist.go

@@ -10,92 +10,86 @@ import (
 
 // CheckWhitelist checks if an event meets the whitelist criteria.
 func CheckWhitelist(evt nostr.Event) (bool, string) {
-	whitelistCfg := GetWhitelistConfig()
+    whitelistCfg := GetWhitelistConfig()
-	if whitelistCfg == nil {
+    if whitelistCfg == nil {
-		return false, "Internal server error: whitelist configuration is missing"
+        return false, "Internal server error: whitelist configuration is missing"
-	}
+    }
 
-	// Check if the event's kind is whitelisted
+    // Check if the event's kind is whitelisted
-	if whitelistCfg.KindWhitelist.Enabled && !IsKindWhitelisted(evt.Kind) {
+    if whitelistCfg.KindWhitelist.Enabled && !IsKindWhitelisted(evt.Kind) {
-		return false, "not allowed: event kind is not whitelisted"
+        return false, "not allowed: event kind is not whitelisted"
-	}
+    }
 
-	// Check if the event's pubkey is whitelisted
+    // Check if the event's pubkey is whitelisted
-	if whitelistCfg.PubkeyWhitelist.Enabled && !IsPubKeyWhitelisted(evt.PubKey, false) {
+    if whitelistCfg.PubkeyWhitelist.Enabled && !IsPubKeyWhitelisted(evt.PubKey) {
-		return false, "not allowed: pubkey or npub is not whitelisted"
+        return false, "not allowed: pubkey or npub is not whitelisted"
-	}
+    }
 
-	return true, ""
+    return true, ""
 }
 
 // IsPubKeyWhitelisted checks if a pubkey or npub is whitelisted, considering pubkeys from domains.
-// The `forPurge` flag indicates if the check is for purging purposes.
+func IsPubKeyWhitelisted(pubKey string) bool {
-func IsPubKeyWhitelisted(pubKey string, forPurge bool) bool {
+    cfg := GetWhitelistConfig()
-	cfg := GetWhitelistConfig()
+    if cfg == nil || !cfg.PubkeyWhitelist.Enabled {
-	if cfg == nil {
+        return true // Whitelisting is not enforced if the configuration is missing or disabled
-		return false // No configuration means no whitelisting.
+    }
-	}
 
-	// If the whitelist is disabled but this check is for purging, we still evaluate it.
+    // Check statically defined pubkeys
-	if !cfg.PubkeyWhitelist.Enabled && !forPurge {
+    for _, whitelistedKey := range cfg.PubkeyWhitelist.Pubkeys {
-		return true // Whitelisting is not enforced for posting if disabled.
+        if pubKey == whitelistedKey {
-	}
+            return true
+        }
+    }
 
-	// Check statically defined pubkeys
+    // Check statically defined npubs after decoding them to pubkeys
-	for _, whitelistedKey := range cfg.PubkeyWhitelist.Pubkeys {
+    for _, npub := range cfg.PubkeyWhitelist.Npubs {
-		if pubKey == whitelistedKey {
+        decodedPubKey, err := utils.DecodeNpub(npub)
-			return true
+        if err != nil {
-		}
+            log.Printf("Error decoding npub: %v", err)
-	}
+            continue
+        }
+        if pubKey == decodedPubKey {
+            return true
+        }
+    }
 
-	// Check statically defined npubs after decoding them to pubkeys
+    // Fetch and check pubkeys from domains if domain whitelisting is enabled
-	for _, npub := range cfg.PubkeyWhitelist.Npubs {
+    if cfg.DomainWhitelist.Enabled {
-		decodedPubKey, err := utils.DecodeNpub(npub)
+        domains := cfg.DomainWhitelist.Domains
-		if err != nil {
+        pubkeys, err := utils.FetchPubkeysFromDomains(domains)
-			log.Printf("Error decoding npub: %v", err)
+        if err != nil {
-			continue
+            log.Printf("Error fetching pubkeys from domains: %v", err)
-		}
+            return false // Consider returning true or handling based on your application's needs
-		if pubKey == decodedPubKey {
+        }
-			return true
-		}
-	}
 
-	// Fetch and check pubkeys from domains if domain whitelisting is enabled
+        for _, domainPubKey := range pubkeys {
-	if cfg.DomainWhitelist.Enabled {
+            if pubKey == domainPubKey {
-		domains := cfg.DomainWhitelist.Domains
+                return true
-		pubkeys, err := utils.FetchPubkeysFromDomains(domains)
+            }
-		if err != nil {
+        }
-			log.Printf("Error fetching pubkeys from domains: %v", err)
+    }
-			return false // Consider errors as non-whitelisted for purging
-		}
 
-		for _, domainPubKey := range pubkeys {
+    return false
-			if pubKey == domainPubKey {
-				return true
-			}
-		}
-	}
-
-	return false // Not whitelisted
 }
 
 // Check if a kind is whitelisted
 func IsKindWhitelisted(kind int) bool {
-	cfg := GetWhitelistConfig()
+    cfg := GetWhitelistConfig()
-	if !cfg.KindWhitelist.Enabled {
+    if !cfg.KindWhitelist.Enabled {
-		return true
+        return true
-	}
+    }
 
-	for _, whitelistedKindStr := range cfg.KindWhitelist.Kinds {
+    for _, whitelistedKindStr := range cfg.KindWhitelist.Kinds {
-		whitelistedKind, err := strconv.Atoi(whitelistedKindStr)
+        whitelistedKind, err := strconv.Atoi(whitelistedKindStr)
-		if err != nil {
+        if err != nil {
-			fmt.Println("Error converting whitelisted kind to int:", err)
+            fmt.Println("Error converting whitelisted kind to int:", err)
-			continue
+            continue
-		}
+        }
-		if kind == whitelistedKind {
+        if kind == whitelistedKind {
-			return true
+            return true
-		}
+        }
-	}
+    }
 
-	return false
+    return false
-}
+}

server/db/mongo/purgeEvents.go

@@ -21,14 +21,8 @@ func PurgeOldEvents(cfg *types.EventPurgeConfig) {
 	}
 
 	client := GetClient()
-
+	cutoff := time.Now().Add(-time.Duration(cfg.KeepIntervalHours) * time.Hour).Unix()
-	// Calculate the cutoff time
-	currentTime := time.Now().Unix()
-	cutoff := currentTime - int64(cfg.KeepIntervalHours*3600) // Convert hours to seconds
-
 	var collectionsToPurge []string
-	totalPurged := 0
-	totalKept := 0
 
 	// Determine collections to purge
 	if cfg.PurgeByKindEnabled {
@@ -36,6 +30,7 @@ func PurgeOldEvents(cfg *types.EventPurgeConfig) {
 			collectionsToPurge = append(collectionsToPurge, "event-kind"+strconv.Itoa(kind))
 		}
 	} else {
+		// If `purge_by_kind_enabled` is false, add all potential event kinds or find dynamically
 		collectionsToPurge = getAllEventCollections(client)
 	}
 
@@ -54,45 +49,27 @@ func PurgeOldEvents(cfg *types.EventPurgeConfig) {
 			var evt nostr.Event
 			if err := cursor.Decode(&evt); err != nil {
 				log.Printf("Error decoding event from %s: %v", collectionName, err)
-				totalKept++
 				continue
 			}
 
-			// Debug log to check created_at and cutoff
+			// Skip if the pubkey is whitelisted
-			//log.Printf("Processing event ID: %s, pubkey: %s, created_at: %d, cutoff: %d", evt.ID, evt.PubKey, evt.CreatedAt, cutoff)
+			if cfg.ExcludeWhitelisted && config.IsPubKeyWhitelisted(evt.PubKey) {
-
+				log.Printf("Skipping purging for whitelisted event ID: %s, pubkey: %s", evt.ID, evt.PubKey)
-			// If the event is not older than the cutoff, mark it as kept
-			if evt.CreatedAt >= cutoff {
-				totalKept++
 				continue
 			}
 
-			// Skip purging if the pubkey is whitelisted
+			// Check if purging by category is enabled and if the event matches the allowed category
-			if cfg.ExcludeWhitelisted && config.IsPubKeyWhitelisted(evt.PubKey, true) {
-				//log.Printf("Event ID: %s is kept because the pubkey is whitelisted.", evt.ID)
-				totalKept++
-				continue
-			}
-
-			// Check if purging by category is enabled and matches the event's category
 			category := utils.DetermineEventCategory(evt.Kind)
-			if purge, exists := cfg.PurgeByCategory[category]; !exists || !purge {
+			if purge, exists := cfg.PurgeByCategory[category]; exists && purge {
-				totalKept++
+				_, err := collection.DeleteOne(context.TODO(), bson.M{"id": evt.ID})
-				continue
+				if err != nil {
-			}
+					log.Printf("Error purging event ID %s from %s: %v", evt.ID, collectionName, err)
-
+				} else {
-			// Proceed to delete the event
+					log.Printf("Purged event ID: %s from %s", evt.ID, collectionName)
-			_, err = collection.DeleteOne(context.TODO(), bson.M{"id": evt.ID})
+				}
-			if err != nil {
-				log.Printf("Error purging event ID %s from %s: %v", evt.ID, collectionName, err)
-				totalKept++
-			} else {
-				totalPurged++
 			}
 		}
 	}
-
-	log.Printf("Purging completed: Total events purged = %d, Total events kept = %d", totalPurged, totalKept)
 }
 
 // getAllEventCollections returns a list of all event collections if purging all kinds.
@@ -120,6 +97,6 @@ func ScheduleEventPurging(cfg *types.ServerConfig) {
 
 	for range ticker.C {
 		PurgeOldEvents(&cfg.EventPurge)
-		//log.Println("Scheduled purging completed.")
+		log.Println("Scheduled purging completed.")
 	}
 }