add request coalescing and caching to reduce api calls

- add request coalescer to prevent duplicate in-flight requests
- coalesce version api calls (FindLatestVersion, ListAllVersions)
- add caching to servers api (5 minute ttl)
- reduces redundant api calls from frontend

Author: Arch Dev

internal/patch/coalesce.go

@@ -0,0 +1,56 @@
+package patch
+
+import (
+	"sync"
+)
+
+// RequestCoalescer prevents duplicate in-flight requests
+type RequestCoalescer struct {
+	mu    sync.Mutex
+	calls map[string]*call
+}
+
+type call struct {
+	wg  sync.WaitGroup
+	val interface{}
+	err error
+}
+
+func NewRequestCoalescer() *RequestCoalescer {
+	return &RequestCoalescer{
+		calls: make(map[string]*call),
+	}
+}
+
+// Do executes the given function only once for the given key at a time.
+// If multiple goroutines call Do with the same key, only one will execute fn,
+// and the others will wait for the result.
+func (c *RequestCoalescer) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
+	c.mu.Lock()
+	if existing, ok := c.calls[key]; ok {
+		// Another request is in flight, wait for it
+		c.mu.Unlock()
+		existing.wg.Wait()
+		return existing.val, existing.err
+	}
+
+	// Create new call
+	newCall := &call{}
+	newCall.wg.Add(1)
+	c.calls[key] = newCall
+	c.mu.Unlock()
+
+	// Execute the function
+	newCall.val, newCall.err = fn()
+
+	// Clean up and notify waiters
+	c.mu.Lock()
+	delete(c.calls, key)
+	c.mu.Unlock()
+	newCall.wg.Done()
+
+	return newCall.val, newCall.err
+}
+
+// Global coalescer for version API calls
+var versionCoalescer = NewRequestCoalescer()

internal/patch/version.go

@@ -109,10 +109,17 @@ func FindLatestVersion(branch string) (int, error) {
 		return cached.LatestVersion, cached.Error
 	}
 
-	result := findLatestVersion(branch)
-	versionCache.setLatest(key, &result)
+	// Use coalescer to prevent duplicate in-flight requests
+	result, err := versionCoalescer.Do("latest:"+key, func() (interface{}, error) {
+		r := findLatestVersion(branch)
+		versionCache.setLatest(key, &r)
+		return r.LatestVersion, r.Error
+	})
 
-	return result.LatestVersion, result.Error
+	if err != nil {
+		return 0, err
+	}
+	return result.(int), nil
 }
 
 func ListAllVersions(branch string) ([]int, error) {
@@ -122,10 +129,17 @@ func ListAllVersions(branch string) ([]int, error) {
 		return cached.Versions, cached.Error
 	}
 
-	result := listAllVersions(branch)
-	versionCache.setAllVersions(key, &result)
+	// Use coalescer to prevent duplicate in-flight requests
+	result, err := versionCoalescer.Do("all:"+key, func() (interface{}, error) {
+		r := listAllVersions(branch)
+		versionCache.setAllVersions(key, &r)
+		return r.Versions, r.Error
+	})
 
-	return result.Versions, result.Error
+	if err != nil {
+		return nil, err
+	}
+	return result.([]int), nil
 }
 
 func ClearVersionCache() {

internal/service/servers_service.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"sync"
 	"time"
 )
 
@@ -24,15 +25,30 @@ type ServerWithUrls struct {
 
 type ServersService struct {
 	apiBaseURL string
+	cache      []ServerWithUrls
+	cacheTime  time.Time
+	cacheMu    sync.RWMutex
+	cacheTTL   time.Duration
 }
 
 func NewServersService() *ServersService {
 	return &ServersService{
 		apiBaseURL: "https://api.hylauncher.fun",
+		cacheTTL:   5 * time.Minute,
 	}
 }
 
 func (s *ServersService) FetchServers() ([]ServerWithUrls, error) {
+	// Check cache first
+	s.cacheMu.RLock()
+	if s.cache != nil && time.Since(s.cacheTime) < s.cacheTTL {
+		cached := s.cache
+		s.cacheMu.RUnlock()
+		return cached, nil
+	}
+	s.cacheMu.RUnlock()
+
+	// Fetch from API
 	client := &http.Client{
 		Timeout: 10 * time.Second,
 	}
@@ -61,6 +77,12 @@ func (s *ServersService) FetchServers() ([]ServerWithUrls, error) {
 		}
 	}
 
+	// Update cache
+	s.cacheMu.Lock()
+	s.cache = result
+	s.cacheTime = time.Now()
+	s.cacheMu.Unlock()
+
 	return result, nil
 }