feat(cache): add management commands (#29)

gorillamoe · web-flow · commit 11b361a8639a · 2025-10-04T21:15:48.000+02:00
diff --git a/cmd/kuba/cache.go b/cmd/kuba/cache.go
@@ -2,6 +2,7 @@ package kuba
 
 import (
 	"fmt"
+	"os"
 	"path/filepath"
 	"strings"
 
@@ -12,6 +13,7 @@ import (
 
 var (
 	cachePath    string
+	cacheName    string
 	cacheEnv     string
 	cacheVerbose bool
 )
@@ -50,11 +52,15 @@ var cacheClearCmd = &cobra.Command{
 	Short: "Clear cached secrets",
 	Long: `Clear cached secrets.
 
-By default, clears all cached secrets. Use --path to clear secrets for a specific
-kuba.yaml file, or --env to clear secrets for a specific environment.`,
+By default, clears secrets from ./kuba.yaml in the current directory. Use filters to clear specific entries:
+- --path: Clear secrets for a specific kuba.yaml file (defaults to ./kuba.yaml)
+- --env: Clear secrets for a specific kuba environment
+- --name: Clear secrets for a specific environment name
+- --all: Clear all cached secrets from all paths
+- --expired: Clear only expired secrets`,
 	Args: cobra.NoArgs,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return runCacheClear()
+		return runCacheClear(cmd)
 	},
 }
 
@@ -68,6 +74,25 @@ var cacheStatsCmd = &cobra.Command{
 	},
 }
 
+var cacheExpireCmd = &cobra.Command{
+	Use:   "expire",
+	Short: "Set expiry time for cached secrets",
+	Long: `Set expiry time for cached secrets.
+
+This command allows you to update the expiry time for existing cache entries.
+You can filter by path, env, or name, and set a new expiry time using
+human-readable format (e.g., "2w", "1d", "72h", "1y").
+
+Examples:
+  kuba cache expire --path kuba.yaml --ttl 2w
+  kuba cache expire --name production --ttl 1d
+  kuba cache expire --env staging --ttl 72h`,
+	Args: cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runCacheExpire(cmd)
+	},
+}
+
 var configCacheCmd = &cobra.Command{
 	Use:   "cache",
 	Short: "Configure cache settings",
@@ -91,16 +116,22 @@ func init() {
 	cacheCmd.AddCommand(cacheListCmd)
 	cacheCmd.AddCommand(cacheClearCmd)
 	cacheCmd.AddCommand(cacheStatsCmd)
+	cacheCmd.AddCommand(cacheExpireCmd)
 
 	// Global flags for cache commands
 	cacheCmd.PersistentFlags().StringVarP(&cachePath, "path", "p", "", "Path to kuba.yaml file")
-	cacheCmd.PersistentFlags().StringVarP(&cacheEnv, "env", "e", "", "Environment name")
+	cacheCmd.PersistentFlags().StringVarP(&cacheEnv, "env", "e", "", "Kuba environment name")
+	cacheCmd.PersistentFlags().StringVarP(&cacheName, "name", "n", "", "Environment name")
 	cacheCmd.PersistentFlags().BoolVarP(&cacheVerbose, "verbose", "v", false, "Verbose output")
 
 	// Cache clear flags
 	cacheClearCmd.Flags().Bool("all", false, "Clear all cached secrets")
 	cacheClearCmd.Flags().Bool("expired", false, "Clear only expired secrets")
 
+	// Cache expire flags
+	cacheExpireCmd.Flags().String("ttl", "", "Set new expiry time (e.g., 2w, 1d, 72h, 1y)")
+	cacheExpireCmd.MarkFlagRequired("ttl")
+
 	// Cache config flags (moved to config command)
 	configCacheCmd.Flags().Bool("enable", false, "Enable caching")
 	configCacheCmd.Flags().Bool("disable", false, "Disable caching")
@@ -200,52 +231,64 @@ func runCacheList() error {
 	return nil
 }
 
-func runCacheClear() error {
-	// Load global config
-	globalConfig, err := config.LoadGlobalConfig()
-	if err != nil {
-		return fmt.Errorf("failed to load global config: %w", err)
-	}
-
-	// Convert to cache types
-	cacheGlobalConfig := &cache.GlobalConfig{
-		Cache: cache.CacheConfig{
-			Enabled: globalConfig.Cache.Enabled,
-			TTL:     globalConfig.Cache.TTL,
-		},
-	}
+func runCacheClear(cmd *cobra.Command) error {
+	// Get flags
+	all, _ := cmd.Flags().GetBool("all")
+	expired, _ := cmd.Flags().GetBool("expired")
 
-	// Initialize cache manager
-	manager, err := cache.NewManager(cacheGlobalConfig)
+	// Initialize cache
+	cacheInstance, err := cache.NewCache()
 	if err != nil {
-		return fmt.Errorf("failed to initialize cache manager: %w", err)
+		return fmt.Errorf("failed to initialize cache: %w", err)
 	}
-	defer manager.Close()
+	defer cacheInstance.Close()
 
-	if !manager.IsEnabled() {
-		fmt.Println("Caching is disabled.")
-		return nil
+	// Set default path if not provided
+	pathToUse := cachePath
+	if pathToUse == "" {
+		// Get current working directory
+		cwd, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("failed to get current working directory: %w", err)
+		}
+		pathToUse = filepath.Join(cwd, "kuba.yaml")
 	}
 
 	// Determine what to clear
-	if cachePath != "" && cacheEnv != "" {
-		// Clear specific environment
-		if err := manager.ClearByEnvironment(cachePath, cacheEnv); err != nil {
-			return fmt.Errorf("failed to clear cache for environment: %w", err)
-		}
-		fmt.Printf("Cleared cache for environment '%s' in %s\n", cacheEnv, cachePath)
-	} else if cachePath != "" {
-		// Clear specific path
-		if err := manager.ClearByPath(cachePath); err != nil {
-			return fmt.Errorf("failed to clear cache for path: %w", err)
-		}
-		fmt.Printf("Cleared cache for %s\n", cachePath)
-	} else {
+	var count int
+	if all {
 		// Clear all
-		if err := manager.Clear(); err != nil {
+		if err := cacheInstance.Clear(); err != nil {
 			return fmt.Errorf("failed to clear cache: %w", err)
 		}
 		fmt.Println("Cleared all cached secrets.")
+	} else {
+		// Clear filtered entries
+		count, err = cacheInstance.ClearFiltered(pathToUse, cacheEnv, cacheName, expired)
+		if err != nil {
+			return fmt.Errorf("failed to clear cache entries: %w", err)
+		}
+
+		// Show results
+		fmt.Printf("Cleared %d cache entries\n", count)
+
+		// Show filters used
+		filters := []string{}
+		if pathToUse != "" {
+			filters = append(filters, fmt.Sprintf("path=%s", pathToUse))
+		}
+		if cacheEnv != "" {
+			filters = append(filters, fmt.Sprintf("env=%s", cacheEnv))
+		}
+		if cacheName != "" {
+			filters = append(filters, fmt.Sprintf("name=%s", cacheName))
+		}
+		if expired {
+			filters = append(filters, "expired=true")
+		}
+		if len(filters) > 0 {
+			fmt.Printf("Filters applied: %s\n", strings.Join(filters, ", "))
+		}
 	}
 
 	return nil
@@ -362,6 +405,56 @@ func runCacheConfigWithCmd(cmd *cobra.Command) error {
 	return nil
 }
 
+func runCacheExpire(cmd *cobra.Command) error {
+	// Get TTL from flag
+	ttlStr, _ := cmd.Flags().GetString("ttl")
+	if ttlStr == "" {
+		return fmt.Errorf("--ttl is required")
+	}
+
+	// Parse TTL
+	duration, _, err := cache.ParseDuration(ttlStr)
+	if err != nil {
+		return fmt.Errorf("invalid TTL format: %w", err)
+	}
+
+	// Initialize cache
+	cacheInstance, err := cache.NewCache()
+	if err != nil {
+		return fmt.Errorf("failed to initialize cache: %w", err)
+	}
+	defer cacheInstance.Close()
+
+	// Update expiry for filtered entries
+	count, err := cacheInstance.UpdateExpiry(cachePath, cacheEnv, cacheName, duration)
+	if err != nil {
+		return fmt.Errorf("failed to update cache expiry: %w", err)
+	}
+
+	// Show results
+	fmt.Printf("Updated expiry for %d cache entries\n", count)
+	fmt.Printf("New TTL: %s\n", duration)
+
+	// Show filters used
+	filters := []string{}
+	if cachePath != "" {
+		filters = append(filters, fmt.Sprintf("path=%s", cachePath))
+	}
+	if cacheEnv != "" {
+		filters = append(filters, fmt.Sprintf("env=%s", cacheEnv))
+	}
+	if cacheName != "" {
+		filters = append(filters, fmt.Sprintf("name=%s", cacheName))
+	}
+	if len(filters) > 0 {
+		fmt.Printf("Filters applied: %s\n", strings.Join(filters, ", "))
+	} else {
+		fmt.Println("Applied to all cache entries")
+	}
+
+	return nil
+}
+
 // maskSecret masks a secret value for display
 func maskSecret(value string) string {
 	if len(value) == 0 {
diff --git a/internal/lib/cache/cache.go b/internal/lib/cache/cache.go
@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"time"
 
 	_ "github.com/mattn/go-sqlite3"
@@ -192,6 +193,115 @@ func (c *Cache) List() ([]CacheEntry, error) {
 	return entries, nil
 }
 
+// ClearFiltered clears cache entries based on filters
+func (c *Cache) ClearFiltered(path, kubaEnv, env string, expiredOnly bool) (int, error) {
+	logger := log.NewLogger()
+
+	// Build WHERE clause based on filters
+	var conditions []string
+	var args []interface{}
+	argIndex := 1
+
+	if path != "" {
+		conditions = append(conditions, fmt.Sprintf("path = $%d", argIndex))
+		args = append(args, path)
+		argIndex++
+	}
+
+	if kubaEnv != "" {
+		conditions = append(conditions, fmt.Sprintf("kuba_env = $%d", argIndex))
+		args = append(args, kubaEnv)
+		argIndex++
+	}
+
+	if env != "" {
+		conditions = append(conditions, fmt.Sprintf("env = $%d", argIndex))
+		args = append(args, env)
+		argIndex++
+	}
+
+	if expiredOnly {
+		conditions = append(conditions, fmt.Sprintf("expires_at < $%d", argIndex))
+		args = append(args, time.Now())
+		argIndex++
+	}
+
+	// Build query
+	whereClause := ""
+	if len(conditions) > 0 {
+		whereClause = "WHERE " + strings.Join(conditions, " AND ")
+	}
+
+	query := fmt.Sprintf("DELETE FROM secrets %s", whereClause)
+
+	result, err := c.db.Exec(query, args...)
+	if err != nil {
+		return 0, fmt.Errorf("failed to clear cache entries: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	logger.Debug("Cleared cache entries", "count", rowsAffected, "path", path, "kuba_env", kubaEnv, "env", env, "expired_only", expiredOnly)
+	return int(rowsAffected), nil
+}
+
+// UpdateExpiry updates the expiry time for cache entries based on filters
+func (c *Cache) UpdateExpiry(path, kubaEnv, env string, newTTL time.Duration) (int, error) {
+	logger := log.NewLogger()
+
+	// Build WHERE clause based on filters
+	var conditions []string
+	var args []interface{}
+	argIndex := 1
+
+	if path != "" {
+		conditions = append(conditions, fmt.Sprintf("path = $%d", argIndex))
+		args = append(args, path)
+		argIndex++
+	}
+
+	if kubaEnv != "" {
+		conditions = append(conditions, fmt.Sprintf("kuba_env = $%d", argIndex))
+		args = append(args, kubaEnv)
+		argIndex++
+	}
+
+	if env != "" {
+		conditions = append(conditions, fmt.Sprintf("env = $%d", argIndex))
+		args = append(args, env)
+		argIndex++
+	}
+
+	// Build query - set new expiry time to now + TTL
+	newExpiryTime := time.Now().Add(newTTL)
+	conditions = append(conditions, fmt.Sprintf("expires_at = $%d", argIndex))
+	args = append(args, newExpiryTime)
+	argIndex++
+
+	whereClause := ""
+	if len(conditions) > 1 { // More than just the expiry condition
+		whereClause = "WHERE " + strings.Join(conditions[:len(conditions)-1], " AND ")
+	}
+
+	query := fmt.Sprintf("UPDATE secrets SET expires_at = $%d %s", argIndex, whereClause)
+
+	result, err := c.db.Exec(query, args...)
+	if err != nil {
+		return 0, fmt.Errorf("failed to update cache expiry: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	logger.Debug("Updated cache expiry", "count", rowsAffected, "path", path, "kuba_env", kubaEnv, "env", env, "new_ttl", newTTL, "new_expiry", newExpiryTime)
+	return int(rowsAffected), nil
+}
+
 // getCacheDir returns the cache directory path
 func getCacheDir() (string, error) {
 	homeDir, err := os.UserHomeDir()
