implement caching

LICENSE

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <https://unlicense.org>

relay/Dockerfile

@@ -8,7 +8,7 @@
 
 ################################################################################
 # Create a stage for building the application.
-ARG GO_VERSION=1.24.0
+ARG GO_VERSION=1.23.4
 FROM --platform=$BUILDPLATFORM golang:${GO_VERSION} AS build
 WORKDIR /src
 

relay/cache/cache.go

@@ -8,13 +8,11 @@ import (
 type item struct {
 	value      interface{}
 	expiration int64
-	staleTime  int64
 }
 
 type Cache struct {
 	items map[string]item
 	mu    sync.RWMutex
-	refreshing sync.Map
 }
 
 func New() *Cache {
@@ -29,68 +27,35 @@ func (c *Cache) Set(key string, value interface{}, duration time.Duration) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
-	now := time.Now().UnixNano()
 	c.items[key] = item{
 		value:      value,
-		expiration: now + duration.Nanoseconds(),
-		staleTime:  now + (duration * 2).Nanoseconds(), // Stale time is double the normal duration
+		expiration: time.Now().Add(duration).UnixNano(),
 	}
 }
 
 func (c *Cache) Get(key string) (interface{}, bool) {
 	c.mu.RLock()
-	item, exists := c.items[key]
-	c.mu.RUnlock()
+	defer c.mu.RUnlock()
 
+	item, exists := c.items[key]
 	if !exists {
 		return nil, false
 	}
 
-	now := time.Now().UnixNano()
-	if now > item.staleTime {
+	if time.Now().UnixNano() > item.expiration {
 		return nil, false
 	}
 
 	return item.value, true
 }
 
-func (c *Cache) GetOrRefresh(key string, refreshFn func() (interface{}, error), duration time.Duration) (interface{}, bool) {
-	// Try to get from cache first
-	if value, exists := c.Get(key); exists {
-		now := time.Now().UnixNano()
-		item := c.items[key]
-
-		// If the value is expired but not stale, trigger refresh in background
-		if now > item.expiration && now <= item.staleTime {
-			if _, loading := c.refreshing.LoadOrStore(key, true); !loading {
-				go func() {
-					defer c.refreshing.Delete(key)
-					if newValue, err := refreshFn(); err == nil {
-						c.Set(key, newValue, duration)
-					}
-				}()
-			}
-		}
-		return value, true
-	}
-
-	// If no value exists, do a blocking refresh
-	value, err := refreshFn()
-	if err != nil {
-		return nil, false
-	}
-
-	c.Set(key, value, duration)
-	return value, true
-}
-
 func (c *Cache) startCleanup() {
 	ticker := time.NewTicker(time.Minute)
 	for range ticker.C {
 		c.mu.Lock()
 		now := time.Now().UnixNano()
 		for k, v := range c.items {
-			if now > v.staleTime {
+			if now > v.expiration {
 				delete(c.items, k)
 			}
 		}

relay/main.go

@@ -33,8 +33,6 @@ func main() {
 	relay.Info.PubKey = getEnv("RELAY_PUBKEY", "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798")
 	relay.Info.Description = getEnv("RELAY_DESCRIPTION", "LUMINA Relay")
 	relay.Info.Icon = getEnv("RELAY_ICON", "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fliquipedia.net%2Fcommons%2Fimages%2F3%2F35%2FSCProbe.jpg&f=1&nofb=1&ipt=0cbbfef25bce41da63d910e86c3c343e6c3b9d63194ca9755351bb7c2efa3359&ipo=images")
-	relay.Info.Software = "lumina-relay"
-	relay.Info.Version = "0.1.0"
 
 	// Print relay information
 	fmt.Printf("Name: %s\n", relay.Info.Name)

relay/trending/kinds.go

@@ -23,7 +23,12 @@ var (
 	cacheDuration = 5 * time.Minute
 )
 
-func fetchTrendingKind20(db *sql.DB) ([]Post, error) {
+// GetTrendingKind20 returns the top 20 trending posts of kind 20 from the last 24 hours
+func GetTrendingKind20(db *sql.DB) ([]Post, error) {
+	if cached, ok := trendingCache.Get("trending_kind_20"); ok {
+		return cached.([]Post), nil
+	}
+
 	query := `
 		WITH reactions AS (
 			SELECT 
@@ -71,17 +76,6 @@ func fetchTrendingKind20(db *sql.DB) ([]Post, error) {
 		trendingPosts = append(trendingPosts, post)
 	}
 
+	trendingCache.Set("trending_kind_20", trendingPosts, cacheDuration)
 	return trendingPosts, nil
 }
-
-func GetTrendingKind20(db *sql.DB) ([]Post, error) {
-	posts, exists := trendingCache.GetOrRefresh("trending_kind_20", func() (interface{}, error) {
-		return fetchTrendingKind20(db)
-	}, cacheDuration)
-
-	if !exists {
-		return nil, nil
-	}
-
-	return posts.([]Post), nil
-}