node build fixed

seanime-2.9.10/internal/plugin/storage.go

@@ -0,0 +1,631 @@
+package plugin
+
+import (
+	"encoding/json"
+	"errors"
+	"seanime/internal/database/models"
+	"seanime/internal/extension"
+	goja_util "seanime/internal/util/goja"
+	"seanime/internal/util/result"
+	"strings"
+
+	"github.com/dop251/goja"
+	"github.com/rs/zerolog"
+	"gorm.io/gorm"
+)
+
+// Storage is used to store data for an extension.
+// A new instance is created for each extension.
+type Storage struct {
+	ctx             *AppContextImpl
+	ext             *extension.Extension
+	logger          *zerolog.Logger
+	runtime         *goja.Runtime
+	pluginDataCache *result.Map[string, *models.PluginData] // Cache to avoid repeated database calls
+	keyDataCache    *result.Map[string, interface{}]        // Cache to avoid repeated database calls
+	keySubscribers  *result.Map[string, []chan interface{}] // Subscribers for key changes
+	scheduler       *goja_util.Scheduler
+}
+
+var (
+	ErrDatabaseNotInitialized = errors.New("database is not initialized")
+)
+
+// BindStorage binds the storage API to the Goja runtime.
+// Permissions need to be checked by the caller.
+// Permissions needed: storage
+func (a *AppContextImpl) BindStorage(vm *goja.Runtime, logger *zerolog.Logger, ext *extension.Extension, scheduler *goja_util.Scheduler) *Storage {
+	storageLogger := logger.With().Str("id", ext.ID).Logger()
+	storage := &Storage{
+		ctx:             a,
+		ext:             ext,
+		logger:          &storageLogger,
+		runtime:         vm,
+		pluginDataCache: result.NewResultMap[string, *models.PluginData](),
+		keyDataCache:    result.NewResultMap[string, interface{}](),
+		keySubscribers:  result.NewResultMap[string, []chan interface{}](),
+		scheduler:       scheduler,
+	}
+	storageObj := vm.NewObject()
+	_ = storageObj.Set("get", storage.Get)
+	_ = storageObj.Set("set", storage.Set)
+	_ = storageObj.Set("remove", storage.Delete)
+	_ = storageObj.Set("drop", storage.Drop)
+	_ = storageObj.Set("clear", storage.Clear)
+	_ = storageObj.Set("keys", storage.Keys)
+	_ = storageObj.Set("has", storage.Has)
+	_ = storageObj.Set("watch", storage.Watch)
+	_ = vm.Set("$storage", storageObj)
+
+	return storage
+}
+
+// Stop closes all subscriber channels.
+func (s *Storage) Stop() {
+	s.keySubscribers.Range(func(key string, subscribers []chan interface{}) bool {
+		for _, ch := range subscribers {
+			close(ch)
+		}
+		return true
+	})
+	s.keySubscribers.Clear()
+}
+
+// getDB returns the database instance or an error if not initialized
+func (s *Storage) getDB() (*gorm.DB, error) {
+	db, ok := s.ctx.database.Get()
+	if !ok {
+		return nil, ErrDatabaseNotInitialized
+	}
+	return db.Gorm(), nil
+}
+
+// getPluginData retrieves the plugin data from the database
+// If createIfNotExists is true, it will create an empty record if none exists
+func (s *Storage) getPluginData(createIfNotExists bool) (*models.PluginData, error) {
+	// Check cache first
+	if cachedData, ok := s.pluginDataCache.Get(s.ext.ID); ok {
+		return cachedData, nil
+	}
+
+	db, err := s.getDB()
+	if err != nil {
+		return nil, err
+	}
+
+	var pluginData models.PluginData
+	if err := db.Where("plugin_id = ?", s.ext.ID).First(&pluginData).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) && createIfNotExists {
+			// Create empty data structure
+			baseData := make(map[string]interface{})
+			baseDataMarshaled, err := json.Marshal(baseData)
+			if err != nil {
+				return nil, err
+			}
+
+			newPluginData := &models.PluginData{
+				PluginID: s.ext.ID,
+				Data:     baseDataMarshaled,
+			}
+
+			if err := db.Create(newPluginData).Error; err != nil {
+				return nil, err
+			}
+
+			// Cache the new plugin data
+			s.pluginDataCache.Set(s.ext.ID, newPluginData)
+			return newPluginData, nil
+		}
+		return nil, err
+	}
+
+	// Cache the plugin data
+	s.pluginDataCache.Set(s.ext.ID, &pluginData)
+	return &pluginData, nil
+}
+
+// getDataMap unmarshals the plugin data into a map
+func (s *Storage) getDataMap(pluginData *models.PluginData) (map[string]interface{}, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal(pluginData.Data, &data); err != nil {
+		return make(map[string]interface{}), err
+	}
+	return data, nil
+}
+
+// saveDataMap marshals and saves the data map to the database
+func (s *Storage) saveDataMap(pluginData *models.PluginData, data map[string]interface{}) error {
+	marshaled, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	pluginData.Data = marshaled
+
+	db, err := s.getDB()
+	if err != nil {
+		return err
+	}
+
+	err = db.Save(pluginData).Error
+	if err != nil {
+		return err
+	}
+
+	// Update the cache
+	s.pluginDataCache.Set(s.ext.ID, pluginData)
+
+	s.keyDataCache.Clear()
+
+	return nil
+}
+
+// getNestedValue retrieves a value from a nested map using dot notation
+func getNestedValue(data map[string]interface{}, path string) interface{} {
+	if !strings.Contains(path, ".") {
+		return data[path]
+	}
+
+	parts := strings.Split(path, ".")
+	current := data
+
+	// Navigate through all parts except the last one
+	for i := 0; i < len(parts)-1; i++ {
+		part := parts[i]
+		next, ok := current[part]
+		if !ok {
+			return nil
+		}
+
+		// Try to convert to map for next level
+		nextMap, ok := next.(map[string]interface{})
+		if !ok {
+			// Try to convert from unmarshaled JSON
+			jsonMap, ok := next.(map[string]interface{})
+			if !ok {
+				return nil
+			}
+			nextMap = jsonMap
+		}
+
+		current = nextMap
+	}
+
+	// Return the value at the final part
+	return current[parts[len(parts)-1]]
+}
+
+// setNestedValue sets a value in a nested map using dot notation
+// It creates intermediate maps as needed
+func setNestedValue(data map[string]interface{}, path string, value interface{}) {
+	if !strings.Contains(path, ".") {
+		data[path] = value
+		return
+	}
+
+	parts := strings.Split(path, ".")
+	current := data
+
+	// Navigate and create intermediate maps as needed
+	for i := 0; i < len(parts)-1; i++ {
+		part := parts[i]
+		next, ok := current[part]
+		if !ok {
+			// Create new map if key doesn't exist
+			next = make(map[string]interface{})
+			current[part] = next
+		}
+
+		// Try to convert to map for next level
+		nextMap, ok := next.(map[string]interface{})
+		if !ok {
+			// Try to convert from unmarshaled JSON
+			jsonMap, ok := next.(map[string]interface{})
+			if !ok {
+				// Replace with a new map if not convertible
+				nextMap = make(map[string]interface{})
+				current[part] = nextMap
+			} else {
+				nextMap = jsonMap
+				current[part] = nextMap
+			}
+		}
+
+		current = nextMap
+	}
+
+	// Set the value at the final part
+	current[parts[len(parts)-1]] = value
+}
+
+// deleteNestedValue deletes a value from a nested map using dot notation
+// Returns true if the key was found and deleted
+func deleteNestedValue(data map[string]interface{}, path string) bool {
+	if !strings.Contains(path, ".") {
+		_, exists := data[path]
+		if exists {
+			delete(data, path)
+			return true
+		}
+		return false
+	}
+
+	parts := strings.Split(path, ".")
+	current := data
+
+	// Navigate through all parts except the last one
+	for i := 0; i < len(parts)-1; i++ {
+		part := parts[i]
+		next, ok := current[part]
+		if !ok {
+			return false
+		}
+
+		// Try to convert to map for next level
+		nextMap, ok := next.(map[string]interface{})
+		if !ok {
+			// Try to convert from unmarshaled JSON
+			jsonMap, ok := next.(map[string]interface{})
+			if !ok {
+				return false
+			}
+			nextMap = jsonMap
+		}
+
+		current = nextMap
+	}
+
+	// Delete the value at the final part
+	lastPart := parts[len(parts)-1]
+	_, exists := current[lastPart]
+	if exists {
+		delete(current, lastPart)
+		return true
+	}
+	return false
+}
+
+// hasNestedKey checks if a nested key exists using dot notation
+func hasNestedKey(data map[string]interface{}, path string) bool {
+	if !strings.Contains(path, ".") {
+		_, exists := data[path]
+		return exists
+	}
+
+	parts := strings.Split(path, ".")
+	current := data
+
+	// Navigate through all parts except the last one
+	for i := 0; i < len(parts)-1; i++ {
+		part := parts[i]
+		next, ok := current[part]
+		if !ok {
+			return false
+		}
+
+		// Try to convert to map for next level
+		nextMap, ok := next.(map[string]interface{})
+		if !ok {
+			// Try to convert from unmarshaled JSON
+			jsonMap, ok := next.(map[string]interface{})
+			if !ok {
+				return false
+			}
+			nextMap = jsonMap
+		}
+
+		current = nextMap
+	}
+
+	// Check if the final key exists
+	_, exists := current[parts[len(parts)-1]]
+	return exists
+}
+
+// getAllKeys recursively gets all keys from a nested map using dot notation
+func getAllKeys(data map[string]interface{}, prefix string) []string {
+	keys := make([]string, 0)
+
+	for key, value := range data {
+		fullKey := key
+		if prefix != "" {
+			fullKey = prefix + "." + key
+		}
+
+		keys = append(keys, fullKey)
+
+		// If value is a map, recursively get its keys
+		if nestedMap, ok := value.(map[string]interface{}); ok {
+			nestedKeys := getAllKeys(nestedMap, fullKey)
+			keys = append(keys, nestedKeys...)
+		}
+	}
+
+	return keys
+}
+
+// notifyKeyAndParents sends notifications to subscribers of the given key and its parent keys
+// If the value is nil, it indicates the key was deleted
+func (s *Storage) notifyKeyAndParents(key string, value interface{}, data map[string]interface{}) {
+	// Notify direct subscribers of this key
+	if subscribers, ok := s.keySubscribers.Get(key); ok {
+		for _, ch := range subscribers {
+			// Non-blocking send to avoid deadlocks
+			select {
+			case ch <- value:
+			default:
+				// Channel is full or closed, skip
+			}
+		}
+	}
+
+	// Also notify parent key subscribers if this is a nested key
+	if strings.Contains(key, ".") {
+		parts := strings.Split(key, ".")
+		for i := 1; i < len(parts); i++ {
+			parentKey := strings.Join(parts[:i], ".")
+			if subscribers, ok := s.keySubscribers.Get(parentKey); ok {
+				// Get the current parent value
+				parentValue := getNestedValue(data, parentKey)
+				for _, ch := range subscribers {
+					// Non-blocking send to avoid deadlocks
+					select {
+					case ch <- parentValue:
+					default:
+						// Channel is full or closed, skip
+					}
+				}
+			}
+		}
+	}
+}
+
+func (s *Storage) Watch(key string, callback goja.Callable) goja.Value {
+	s.logger.Trace().Msgf("plugin: Watching key %s", key)
+
+	// Create a channel to receive updates
+	updateCh := make(chan interface{}, 100)
+
+	// Add this channel to the subscribers for this key
+	subscribers := []chan interface{}{}
+	if existingSubscribers, ok := s.keySubscribers.Get(key); ok {
+		subscribers = existingSubscribers
+	}
+	subscribers = append(subscribers, updateCh)
+	s.keySubscribers.Set(key, subscribers)
+
+	// Start a goroutine to listen for updates
+	go func() {
+		for value := range updateCh {
+			// Call the callback with the new value
+			s.scheduler.ScheduleAsync(func() error {
+				_, err := callback(goja.Undefined(), s.runtime.ToValue(value))
+				if err != nil {
+					s.logger.Error().Err(err).Msgf("plugin: Error calling watch callback for key %s", key)
+				}
+				return nil
+			})
+		}
+	}()
+
+	// Check if the key currently exists and immediately send its value
+	// This allows watchers to get the current value right away
+	currentValue, _ := s.Get(key)
+	if currentValue != nil {
+		// Use non-blocking send
+		select {
+		case updateCh <- currentValue:
+		default:
+			// Channel is full, skip
+		}
+	}
+
+	// Return a function that can be used to cancel the watch
+	cancelFn := func() {
+		close(updateCh)
+		// Remove this specific channel from subscribers
+		if existingSubscribers, ok := s.keySubscribers.Get(key); ok {
+			newSubscribers := make([]chan interface{}, 0, len(existingSubscribers)-1)
+			for _, ch := range existingSubscribers {
+				if ch != updateCh {
+					newSubscribers = append(newSubscribers, ch)
+				}
+			}
+
+			if len(newSubscribers) > 0 {
+				s.keySubscribers.Set(key, newSubscribers)
+			} else {
+				s.keySubscribers.Delete(key)
+			}
+		}
+	}
+
+	return s.runtime.ToValue(cancelFn)
+}
+
+func (s *Storage) Delete(key string) error {
+	s.logger.Trace().Msgf("plugin: Deleting key %s", key)
+
+	// Remove from key cache
+	s.keyDataCache.Delete(key)
+
+	pluginData, err := s.getPluginData(false)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		return err
+	}
+
+	data, err := s.getDataMap(pluginData)
+	if err != nil {
+		return err
+	}
+
+	// Notify subscribers that the key was deleted
+	s.notifyKeyAndParents(key, nil, data)
+
+	if deleteNestedValue(data, key) {
+		return s.saveDataMap(pluginData, data)
+	}
+
+	return nil
+}
+
+func (s *Storage) Drop() error {
+	s.logger.Trace().Msg("plugin: Dropping storage")
+
+	// // Close all subscriber channels
+	// s.keySubscribers.Range(func(key string, subscribers []chan interface{}) bool {
+	// 	for _, ch := range subscribers {
+	// 		close(ch)
+	// 	}
+	// 	return true
+	// })
+	// s.keySubscribers.Clear()
+
+	// Clear caches
+	s.pluginDataCache.Clear()
+	s.keyDataCache.Clear()
+
+	db, err := s.getDB()
+	if err != nil {
+		return err
+	}
+
+	return db.Where("plugin_id = ?", s.ext.ID).Delete(&models.PluginData{}).Error
+}
+
+func (s *Storage) Clear() error {
+	s.logger.Trace().Msg("plugin: Clearing storage")
+
+	// Clear key cache
+	s.keyDataCache.Clear()
+
+	pluginData, err := s.getPluginData(true)
+	if err != nil {
+		return err
+	}
+
+	// Get all keys before clearing
+	data, err := s.getDataMap(pluginData)
+	if err != nil {
+		return err
+	}
+
+	// Get all keys to notify subscribers
+	keys := getAllKeys(data, "")
+
+	// Create empty data map
+	cleanData := make(map[string]interface{})
+
+	// Save the empty data first
+	if err := s.saveDataMap(pluginData, cleanData); err != nil {
+		return err
+	}
+
+	// Notify all subscribers that their keys were cleared
+	for _, key := range keys {
+		s.notifyKeyAndParents(key, nil, cleanData)
+	}
+
+	return nil
+}
+
+func (s *Storage) Keys() ([]string, error) {
+	pluginData, err := s.getPluginData(false)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return []string{}, nil
+		}
+		return nil, err
+	}
+
+	data, err := s.getDataMap(pluginData)
+	if err != nil {
+		return nil, err
+	}
+
+	return getAllKeys(data, ""), nil
+}
+
+func (s *Storage) Has(key string) (bool, error) {
+	// Check key cache first
+	if s.keyDataCache.Has(key) {
+		return true, nil
+	}
+
+	pluginData, err := s.getPluginData(false)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	data, err := s.getDataMap(pluginData)
+	if err != nil {
+		return false, err
+	}
+
+	exists := hasNestedKey(data, key)
+
+	// If key exists, we can also cache its value for future Get calls
+	if exists {
+		value := getNestedValue(data, key)
+		if value != nil {
+			s.keyDataCache.Set(key, value)
+		}
+	}
+
+	return exists, nil
+}
+
+func (s *Storage) Get(key string) (interface{}, error) {
+	// Check key cache first
+	if cachedValue, ok := s.keyDataCache.Get(key); ok {
+		return cachedValue, nil
+	}
+
+	pluginData, err := s.getPluginData(true)
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := s.getDataMap(pluginData)
+	if err != nil {
+		return nil, err
+	}
+
+	value := getNestedValue(data, key)
+
+	// Cache the value
+	if value != nil {
+		s.keyDataCache.Set(key, value)
+	}
+
+	return value, nil
+}
+
+func (s *Storage) Set(key string, value interface{}) error {
+	s.logger.Trace().Msgf("plugin: Setting key %s", key)
+	pluginData, err := s.getPluginData(true)
+	if err != nil {
+		return err
+	}
+
+	data, err := s.getDataMap(pluginData)
+	if err != nil {
+		data = make(map[string]interface{})
+	}
+
+	setNestedValue(data, key, value)
+
+	// Update key cache
+	s.keyDataCache.Set(key, value)
+
+	// Notify subscribers
+	s.notifyKeyAndParents(key, value, data)
+
+	return s.saveDataMap(pluginData, data)
+}