- Optimize settings retrieval with runtime and per-class config caching.

- Add `clearSettingsCache` method to handle clearing runtime and Redis cache.
- Update README with Redis request counting instructions.

Author: djabdou50

README.md

@@ -283,6 +283,18 @@ class User extends Model
 }
 
 ```
+## Counting redis requests
+```
+docker compose exec redis redis-cli monitor | grep -E '"(GET|SET|DEL)"' | grep "model_settings" | awk '{
+    if ($0 ~ /"GET"/) get++;
+    else if ($0 ~ /"SET"/) set++;
+    else if ($0 ~ /"DEL"/) del++;
+    total++;
+    printf "\rGET: %d, SET: %d, DEL: %d, TOTAL: %d", get, set, del, total;
+}' 
+```
+
+
 
 ## Changelog <a name="changelog"></a>
 Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

src/Traits/HasSettingsTable.php

@@ -8,61 +8,121 @@
 use Illuminate\Database\Eloquent\Relations\MorphOne;
 use Illuminate\Support\Facades\Cache;
 
-/**
- * Trait HasSettingsTable
- * @package Glorand\Model\Settings\Traits
- * @property ModelSettings $modelSettings
- * @property array $settings
- * @method morphOne($model, $name)
- */
 trait HasSettingsTable
 {
     use HasSettings;
 
+    protected $settingsRuntimeCache = null;
+    protected $settingsManagerInstance = null;
+    protected static $configCache = [];
+
     /**
-     * @return \Glorand\Model\Settings\Contracts\SettingsManagerContract
+     * Returns a settings manager instance for the model, creating one if necessary.
+     * @return SettingsManagerContract
      * @throws \Glorand\Model\Settings\Exceptions\ModelSettingsException
      */
     public function settings(): SettingsManagerContract
     {
-        return new TableSettingsManager($this);
+        if ($this->settingsManagerInstance === null) {
+            $this->settingsManagerInstance = new TableSettingsManager($this);
+        }
+
+        return $this->settingsManagerInstance;
     }
 
     /**
+     * Retrieves the settings value for the model, optionally using a cache.
      * @return array
      */
     public function getSettingsValue(): array
     {
-        if (config('model_settings.settings_table_use_cache')) {
-            return Cache::rememberForever($this->getSettingsCacheKey(), function () {
-                return $this->__getSettingsValue();
-            });
+        // Runtime cache = ZERO Redis calls after first access
+        if ($this->settingsRuntimeCache !== null) {
+            return $this->settingsRuntimeCache;
+        }
+
+        // Cache config lookup once per class (not per instance)
+        if (!isset(static::$configCache['use_cache'])) {
+            static::$configCache['use_cache'] = config('model_settings.settings_table_use_cache');
+        }
+
+        if (static::$configCache['use_cache']) {
+            // Only 1 Redis call per request
+            $this->settingsRuntimeCache = Cache::rememberForever(
+                $this->getSettingsCacheKey(),
+                fn() => $this->__getSettingsValue()
+            );
+        } else {
+            $this->settingsRuntimeCache = $this->__getSettingsValue();
         }
 
-        return $this->__getSettingsValue();
+        return $this->settingsRuntimeCache;
     }
 
+    /**
+     * Retrieves the settings value for the model.
+     * @return array
+     */
     private function __getSettingsValue(): array
     {
-        if ($modelSettings = $this->modelSettings()->first()) {
-            return $modelSettings->settings;
+        // Eager loading support (prevents N+1)
+        if ($this->relationLoaded('modelSettings')) {
+            $modelSettings = $this->getRelation('modelSettings');
+            return $modelSettings ? $modelSettings->settings : [];
         }
 
-        return [];
+        $modelSettings = $this->modelSettings()
+            ->select('settings', 'model_id', 'model_type')
+            ->first();
+
+        return $modelSettings ? $modelSettings->settings : [];
     }
 
     /**
-     * @return \Illuminate\Database\Eloquent\Relations\MorphOne
+     * Define an inverse one-to-one or many relationship.
+     * @return MorphOne
      */
     public function modelSettings(): MorphOne
     {
         return $this->morphOne(ModelSettings::class, 'model');
     }
 
+    /**
+     * Retrieves the cache key for settings associated with the model.
+     *
+     * This method ensures that a consistent cache key is generated for
+     * the model's settings by utilizing a shared static configuration
+     * for the cache prefix and combining it with the table name and
+     * primary key of the current model instance.
+     *
+     * @return string The generated cache key for the model's settings.
+     */
     public function getSettingsCacheKey(): string
     {
-        return config('model_settings.settings_table_cache_prefix') . $this->getTable() . '::' . $this->getKey();
+        // Static config cache shared across all instances
+        if (!isset(static::$configCache['cache_prefix'])) {
+            static::$configCache['cache_prefix'] = config('model_settings.settings_table_cache_prefix');
+        }
+
+        return static::$configCache['cache_prefix'] . $this->getTable() . '::' . $this->getKey();
+    }
+
+    /**
+     * Clears the runtime cache and optionally the cache for the model's settings.'
+     * @return void
+     */
+    public function clearSettingsCache(): void
+    {
+        $this->settingsRuntimeCache = null;
+
+        if (static::$configCache['use_cache'] ?? config('model_settings.settings_table_use_cache')) {
+            Cache::forget($this->getSettingsCacheKey());
+        }
     }
 
+    /**
+     * Retrieves the name of the database table associated with the model.
+     * @return string
+     */
     abstract public function getTable();
 }