Hallucinate a direct and cached esi apis

esi/cached.go

@@ -0,0 +1,128 @@
+package esi
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	logger "git.site.quack-lab.dev/dave/cylogger"
+)
+
+// CacheEntry represents a cached API response
+type CacheEntry struct {
+	ID       uint      `gorm:"primaryKey"`
+	URLHash  string    `gorm:"uniqueIndex"`
+	Response string    `gorm:"type:text"`
+	CachedAt time.Time `gorm:"index"`
+}
+
+// CachedESI implements ESIInterface with caching
+type CachedESI struct {
+	direct ESIInterface
+	db     interface {
+		GetCacheEntry(urlHash string) (*CacheEntry, error)
+		SaveCacheEntry(entry *CacheEntry) error
+	}
+}
+
+// NewCachedESI creates a new CachedESI instance
+func NewCachedESI(direct ESIInterface, db interface {
+	GetCacheEntry(urlHash string) (*CacheEntry, error)
+	SaveCacheEntry(entry *CacheEntry) error
+}) *CachedESI {
+	return &CachedESI{
+		direct: direct,
+		db:     db,
+	}
+}
+
+// GetCharacterPlanets retrieves a list of planets for a character with caching
+func (c *CachedESI) GetCharacterPlanets(ctx context.Context, characterID int, accessToken string) ([]Planet, error) {
+	url := fmt.Sprintf("/v1/characters/%d/planets/", characterID)
+	result, err := func() (interface{}, error) {
+		var fetchFunc func() (interface{}, error) = func() (interface{}, error) {
+			return c.direct.GetCharacterPlanets(ctx, characterID, accessToken)
+		}
+		return c.getCachedResponse(url, fetchFunc)
+	}()
+	if err != nil {
+		return nil, err
+	}
+	return result.([]Planet), nil
+}
+
+// GetPlanetDetails retrieves detailed information about a specific planet with caching
+func (c *CachedESI) GetPlanetDetails(ctx context.Context, characterID, planetID int, accessToken string) (*PlanetDetail, error) {
+	url := fmt.Sprintf("/v3/characters/%d/planets/%d/", characterID, planetID)
+	result, err := func() (interface{}, error) {
+		var fetchFunc func() (interface{}, error) = func() (interface{}, error) {
+			return c.direct.GetPlanetDetails(ctx, characterID, planetID, accessToken)
+		}
+		return c.getCachedResponse(url, fetchFunc)
+	}()
+	if err != nil {
+		return nil, err
+	}
+	return result.(*PlanetDetail), nil
+}
+
+// getCachedResponse handles caching logic
+func (c *CachedESI) getCachedResponse(url string, fetchFunc func() (interface{}, error)) (interface{}, error) {
+	// Generate cache key
+	hash := sha256.Sum256([]byte(url))
+	urlHash := hex.EncodeToString(hash[:])
+
+	// Check cache using the interface
+	cacheEntry, err := c.db.GetCacheEntry(urlHash)
+	if err == nil {
+		// Check if cache is still valid
+		cacheValidity, _ := time.ParseDuration("10m") // Default 10 minutes
+		if time.Since(cacheEntry.CachedAt) < cacheValidity {
+			logger.Debug("Cache hit for URL: %s", url)
+			// Parse cached response based on URL pattern
+			if url[len(url)-1:] == "/" {
+				// Planets endpoint
+				var planets []Planet
+				if err := json.Unmarshal([]byte(cacheEntry.Response), &planets); err == nil {
+					return planets, nil
+				}
+			} else {
+				// Planet details endpoint
+				var planetDetail PlanetDetail
+				if err := json.Unmarshal([]byte(cacheEntry.Response), &planetDetail); err == nil {
+					return &planetDetail, nil
+				}
+			}
+		}
+	}
+
+	// Cache miss or invalid, fetch from API
+	logger.Debug("Cache miss for URL: %s", url)
+	result, err := fetchFunc()
+	if err != nil {
+		return nil, err
+	}
+
+	// Store in cache
+	responseBytes, err := json.Marshal(result)
+	if err != nil {
+		logger.Warning("Failed to marshal response for caching: %v", err)
+		return result, nil
+	}
+
+	cacheEntry = CacheEntry{
+		URLHash:  urlHash,
+		Response: string(responseBytes),
+		CachedAt: time.Now(),
+	}
+
+	if err := c.db.SaveCacheEntry(&cacheEntry); err != nil {
+		logger.Warning("Failed to cache response: %v", err)
+	}
+
+	logger.Debug("Cached response for URL: %s", url)
+	return result, nil
+}