refactor(plugin): move cache logic from Lua to Go layer

Simplify the caching mechanism by moving the cache logic for the Available hook from the Lua layer to the Go layer. This improves maintainability and reduces complexity in the Lua code. The cache duration and behavior remain consistent with the previous implementation.

Author: bytemain

.gitignore

@@ -5,5 +5,6 @@
 
 coverage.out
 **/available.cache
+**/.available.cache
 
 vfox

internal/plugin/luai/plugin.go

@@ -3,12 +3,9 @@ package luai
 import (
 	"errors"
 	"fmt"
-	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/version-fox/vfox/internal/base"
-	"github.com/version-fox/vfox/internal/cache"
 	"github.com/version-fox/vfox/internal/config"
 	"github.com/version-fox/vfox/internal/logger"
 	"github.com/version-fox/vfox/internal/util"
@@ -237,91 +234,10 @@ func CreateLuaPlugin(pluginDirPath string, config *config.Config, runtimeVersion
 	}
 
 	source := &LuaPlugin{
-		vm:        vm,
-		pluginObj: PLUGIN,
-
+		vm:         vm,
+		pluginObj:  PLUGIN,
 		PluginInfo: pluginInfo,
 	}
 
-	// wrap Available hook with Cache.
-	if source.HasFunction("Available") {
-		targetHook := PLUGIN.RawGetString("Available")
-		source.pluginObj.RawSetString("Available", vm.Instance.NewFunction(func(L *lua.LState) int {
-			ctxTable := L.CheckTable(2)
-
-			cachePath := filepath.Join(pluginDirPath, "available.cache")
-			invokeAvailableHook := func() int {
-				logger.Debugf("Calling the original Available hook. \n")
-				table, err := vm.CallFunction(targetHook, PLUGIN, ctxTable)
-				if err != nil {
-					L.RaiseError(err.Error())
-					return 0
-				}
-				if util.FileExists(cachePath) {
-					logger.Debugf("Removing the old cache file: %s \n", cachePath)
-					_ = os.Remove(cachePath)
-				}
-				L.Push(table)
-				return 1
-			}
-
-			logger.Debugf("Available hook cache duration: %v\n", config.Cache.AvailableHookDuration)
-			// Cache is disabled
-			if config.Cache.AvailableHookDuration == 0 {
-				return invokeAvailableHook()
-			}
-
-			ctx := &base.AvailableHookCtx{}
-			if err := Unmarshal(ctxTable, ctx); err != nil {
-				L.RaiseError(err.Error())
-				return 0
-			}
-
-			cacheKey := strings.Join(ctx.Args, "##")
-			if cacheKey == "" {
-				cacheKey = "empty"
-			}
-			fileCache, err := cache.NewFileCache(cachePath)
-			if err != nil {
-				return invokeAvailableHook()
-			}
-			cacheValue, ok := fileCache.Get(cacheKey)
-			logger.Debugf("Available hook cache key: %s, hit: %v \n", cacheKey, ok)
-			if ok {
-				var hookResult []map[string]interface{}
-				if err = cacheValue.Unmarshal(&hookResult); err != nil {
-					return invokeAvailableHook()
-				}
-				table, err := Marshal(L, hookResult)
-				if err != nil {
-					return invokeAvailableHook()
-				}
-				L.Push(table)
-				return 1
-			} else {
-				table, err := vm.CallFunction(targetHook, PLUGIN, ctxTable)
-				if err != nil {
-					L.RaiseError(err.Error())
-					return 0
-				}
-				if table == nil || table.Type() == lua.LTNil {
-					fileCache.Set(cacheKey, nil, cache.ExpireTime(config.Cache.AvailableHookDuration))
-					_ = fileCache.Close()
-				} else {
-					var hookResult []map[string]interface{}
-					if err = Unmarshal(table, &hookResult); err == nil {
-						if value, err := cache.NewValue(hookResult); err == nil {
-							fileCache.Set(cacheKey, value, cache.ExpireTime(config.Cache.AvailableHookDuration))
-							_ = fileCache.Close()
-						}
-					}
-				}
-				L.Push(table)
-				return 1
-			}
-
-		}))
-
-	}
 	return source, nil
 }

internal/plugin/plugin.go

@@ -19,9 +19,11 @@ package plugin
 import (
 	"fmt"
 	"path/filepath"
+	"strings"
 
 	"github.com/pterm/pterm"
 	"github.com/version-fox/vfox/internal/base"
+	"github.com/version-fox/vfox/internal/cache"
 	"github.com/version-fox/vfox/internal/config"
 	"github.com/version-fox/vfox/internal/env"
 	"github.com/version-fox/vfox/internal/logger"
@@ -55,7 +57,8 @@ func isValidName(name string) bool {
 }
 
 type PluginWrapper struct {
-	impl base.Plugin
+	impl   base.Plugin
+	config config.Config
 
 	// plugin source path
 	Path string
@@ -92,8 +95,8 @@ func (l *PluginWrapper) validate() error {
 func (l *PluginWrapper) Close() {
 	l.impl.Close()
 }
-
-func (l *PluginWrapper) Available(args []string) ([]*base.Package, error) {
+func (l *PluginWrapper) invokeAvailable(args []string) ([]*base.Package, error) {
+	logger.Debug("Calling Available hook")
 	ctx := base.AvailableHookCtx{
 		Args: args,
 	}
@@ -108,6 +111,51 @@ func (l *PluginWrapper) Available(args []string) ([]*base.Package, error) {
 	return base.CreatePackages(l.Name, *result), nil
 }
 
+func (l *PluginWrapper) Available(args []string) ([]*base.Package, error) {
+	cachePath := filepath.Join(l.Path, ".available.cache")
+	cacheDuration := l.config.Cache.AvailableHookDuration
+	logger.Debugf("Available hook cache duration: %v\n", cacheDuration)
+
+	// Cache is disabled
+	if cacheDuration == 0 {
+		return l.invokeAvailable(args)
+	}
+
+	cacheKey := strings.Join(args, "##")
+	if cacheKey == "" {
+		cacheKey = "empty"
+	}
+
+	fileCache, err := cache.NewFileCache(cachePath)
+	if err == nil {
+		cacheValue, ok := fileCache.Get(cacheKey)
+		logger.Debugf("Available hook cache key: %s, hit: %+v \n", cacheKey, ok)
+		if ok {
+			var hookResult []*base.Package
+			if err = cacheValue.Unmarshal(&hookResult); err == nil {
+				return hookResult, nil
+			}
+		}
+	}
+
+	result, err := l.invokeAvailable(args)
+	if err != nil {
+		return result, err
+	}
+
+	if result == nil {
+		fileCache.Set(cacheKey, nil, cache.ExpireTime(cacheDuration))
+	}
+
+	if value, err := cache.NewValue(result); err == nil {
+		logger.Debugf("Available hook cache set\n")
+		fileCache.Set(cacheKey, value, cache.ExpireTime(cacheDuration))
+		_ = fileCache.Close()
+	}
+
+	return result, nil
+}
+
 func (l *PluginWrapper) PreInstall(version base.Version) (*base.Package, error) {
 	ctx := base.PreInstallHookCtx{
 		Version: version,
@@ -317,6 +365,7 @@ func NewLuaPlugin(pluginDirPath string, config *config.Config, runtimeVersion st
 		impl:       plugin2,
 		Path:       pluginDirPath,
 		PluginInfo: plugin2.PluginInfo,
+		config:     *config,
 	}
 
 	if err = source.validate(); err != nil {