Merge branch 'feat/fields-with-relationships' of github.com:BinarCode/laravel-restify into feat/fields-with-relationships

Author: binaryk

config/restify.php

@@ -203,7 +203,7 @@
             /*
             | Default cache tags for all repositories. Individual repositories
             | can add their own tags in addition to these.
-            | 
+            |
             | Note: Cache tags are only used if the cache store supports them.
             | Database and file cache stores do not support tagging.
             | Redis and Memcached stores support tagging.

src/Repositories/Concerns/InteractsWithCache.php

@@ -4,7 +4,6 @@
 
 use Binaryk\LaravelRestify\Http\Requests\RestifyRequest;
 use Illuminate\Support\Facades\Cache;
-use Illuminate\Support\Str;
 
 trait InteractsWithCache
 {
@@ -74,7 +73,7 @@ public function generateIndexCacheKey(RestifyRequest $request): string
 
         // Add user context for authorization-sensitive data
         if ($user = $request->user()) {
-            $keyParts[] = 'user_' . $user->getAuthIdentifier();
+            $keyParts[] = 'user_'.$user->getAuthIdentifier();
         } else {
             $keyParts[] = 'guest';
         }
@@ -84,11 +83,11 @@ public function generateIndexCacheKey(RestifyRequest $request): string
             try {
                 $latest = $this->model()::latest($this->model()->getUpdatedAtColumn())->first();
                 if ($latest) {
-                    $keyParts[] = 'v_' . $latest->{$this->model()->getUpdatedAtColumn()}->timestamp;
+                    $keyParts[] = 'v_'.$latest->{$this->model()->getUpdatedAtColumn()}->timestamp;
                 }
             } catch (\Exception $e) {
                 // Fallback to current timestamp if query fails
-                $keyParts[] = 'v_' . now()->timestamp;
+                $keyParts[] = 'v_'.now()->timestamp;
             }
         }
 
@@ -169,6 +168,7 @@ public static function clearCache(): void
         // If cache tags are used and supported, flush by tags
         if (! empty(static::$cacheTags) && static::cacheStoreSupportsTagging($store)) {
             $store->tags(static::$cacheTags)->flush();
+
             return;
         }
 
@@ -192,18 +192,20 @@ public static function clearCache(): void
             }
 
             $storage->setValue($store, $storageArray);
+
             return;
         }
 
         // For Redis and other drivers that support pattern deletion
         if (method_exists($store->getStore(), 'getRedis')) {
             try {
-                $pattern = 'restify:repository:' . static::uriKey() . ':*';
+                $pattern = 'restify:repository:'.static::uriKey().':*';
                 $store->getStore()->getRedis()->eval(
                     "return redis.call('del', unpack(redis.call('keys', ARGV[1])))",
                     0,
                     $pattern
                 );
+
                 return;
             } catch (\Exception $e) {
                 // Continue to fallback
@@ -271,6 +273,7 @@ public static function cacheStoreSupportsTagging($store): bool
         try {
             // Create a test tagged cache entry (without storing anything)
             $store->tags(['test'])->getStore();
+
             return true;
         } catch (\Exception $e) {
             // If it throws an exception about tagging not being supported, return false

src/Repositories/Repository.php

@@ -221,7 +221,7 @@ protected static function boot(): void
     {
         // Boot all traits that have a bootTrait method
         foreach (class_uses_recursive(static::class) as $trait) {
-            $method = 'boot' . class_basename($trait);
+            $method = 'boot'.class_basename($trait);
             if (method_exists(static::class, $method)) {
                 static::$method();
             }

tests/Feature/CacheIntegrationTest.php

@@ -24,23 +24,23 @@ protected function tearDown(): void
     {
         // Clear cache after each test
         Cache::flush();
-        
+
         parent::tearDown();
     }
 
     public function test_it_does_not_cache_by_default_in_tests()
     {
         // Ensure we're in testing environment
         $this->assertEquals('testing', app()->environment());
-        
+
         // Make request
         $response = $this->getJson('/api/restify/posts');
         $response->assertOk();
-        
+
         // Make another request - should not be cached
         $response2 = $this->getJson('/api/restify/posts');
         $response2->assertOk();
-        
+
         // Verify cache is empty (no cache keys should exist)
         $this->assertEmpty($this->getCacheKeys());
     }
@@ -50,11 +50,11 @@ public function test_it_can_enable_cache_in_tests_with_config()
         // Enable caching in tests
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make request
         $response = $this->getJson('/api/restify/posts');
         $response->assertOk();
-        
+
         // Verify cache key was created
         $this->assertNotEmpty($this->getCacheKeys());
     }
@@ -64,11 +64,11 @@ public function test_it_respects_global_cache_disabled_setting()
         // Disable caching globally
         config(['restify.repositories.cache.enabled' => false]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make request
         $response = $this->getJson('/api/restify/posts');
         $response->assertOk();
-        
+
         // Verify no cache key was created
         $this->assertEmpty($this->getCacheKeys());
     }
@@ -77,19 +77,19 @@ public function test_it_generates_different_cache_keys_for_different_parameters(
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Clear any existing cache
         Cache::flush();
-        
+
         // Make request with different parameters
         $this->getJson('/api/restify/posts?search=test');
         $keys1 = $this->getCacheKeys();
-        
+
         Cache::flush();
-        
+
         $this->getJson('/api/restify/posts?search=different');
         $keys2 = $this->getCacheKeys();
-        
+
         // Keys should be different for different search terms
         $this->assertNotEquals($keys1, $keys2);
     }
@@ -98,19 +98,19 @@ public function test_it_generates_different_cache_keys_for_different_users()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make request as first user
         $this->authenticate();
         $this->getJson('/api/restify/posts');
         $keys1 = $this->getCacheKeys();
-        
+
         Cache::flush();
-        
+
         // Make request as different user
         $this->authenticate(\Binaryk\LaravelRestify\Tests\Fixtures\User\User::factory()->create());
         $this->getJson('/api/restify/posts');
         $keys2 = $this->getCacheKeys();
-        
+
         // Keys should be different for different users
         $this->assertNotEquals($keys1, $keys2);
     }
@@ -119,15 +119,15 @@ public function test_it_can_clear_cache_programmatically()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make request to populate cache
         $this->getJson('/api/restify/posts');
         $this->assertNotEmpty($this->getCacheKeys());
-        
+
         // Clear cache using Laravel's flush for simplicity in tests
         // In production, the repository's clearCache method would be more targeted
         Cache::flush();
-        
+
         // Verify cache is cleared
         $this->assertEmpty($this->getCacheKeys());
     }
@@ -136,20 +136,20 @@ public function test_it_caches_responses_when_enabled()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make first request
         $response1 = $this->getJson('/api/restify/posts');
         $response1->assertOk();
         $data1 = $response1->json();
-        
+
         // Verify cache was created
         $this->assertNotEmpty($this->getCacheKeys());
-        
+
         // Make second request - should get cached response
         $response2 = $this->getJson('/api/restify/posts');
         $response2->assertOk();
         $data2 = $response2->json();
-        
+
         // Data should be identical
         $this->assertEquals($data1, $data2);
     }
@@ -158,22 +158,22 @@ public function test_it_respects_repository_specific_cache_settings()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Disable cache for specific repository
         PostRepository::disableCache();
-        
+
         // Make request
         $this->getJson('/api/restify/posts');
-        
+
         // Verify no cache key was created
         $this->assertEmpty($this->getCacheKeys());
-        
+
         // Re-enable cache
         PostRepository::enableCache();
-        
+
         // Make request
         $this->getJson('/api/restify/posts');
-        
+
         // Verify cache key was created
         $this->assertNotEmpty($this->getCacheKeys());
     }
@@ -182,16 +182,16 @@ public function test_it_includes_pagination_in_cache_key()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make request with different page numbers
         $this->getJson('/api/restify/posts?page=1');
         $keys1 = $this->getCacheKeys();
-        
+
         Cache::flush();
-        
+
         $this->getJson('/api/restify/posts?page=2');
         $keys2 = $this->getCacheKeys();
-        
+
         // Keys should be different for different pages
         $this->assertNotEquals($keys1, $keys2);
     }
@@ -200,16 +200,16 @@ public function test_it_includes_filters_in_cache_key()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Make request with filters
         $this->getJson('/api/restify/posts?title=test');
         $keys1 = $this->getCacheKeys();
-        
+
         Cache::flush();
-        
+
         $this->getJson('/api/restify/posts?title=different');
         $keys2 = $this->getCacheKeys();
-        
+
         // Keys should be different for different filters
         $this->assertNotEquals($keys1, $keys2);
     }
@@ -218,16 +218,16 @@ public function test_it_can_set_custom_cache_ttl()
     {
         config(['restify.repositories.cache.enabled' => true]);
         config(['restify.repositories.cache.enable_in_tests' => true]);
-        
+
         // Set custom TTL
         PostRepository::cacheTtl(60); // 1 minute
-        
+
         // Make request
         $this->getJson('/api/restify/posts');
-        
+
         // Verify cache exists
         $this->assertNotEmpty($this->getCacheKeys());
-        
+
         // Verify TTL is set (this is hard to test precisely without time manipulation)
         // We'll just verify the cache exists for now
     }
@@ -238,34 +238,35 @@ public function test_it_can_set_custom_cache_ttl()
     protected function getCacheKeys(): array
     {
         $store = Cache::getStore();
-        
+
         if (method_exists($store, 'getRedis')) {
             try {
                 $redis = $store->getRedis();
+
                 return $redis->keys('*restify*') ?: [];
             } catch (\Exception $e) {
                 // Fall back for non-Redis stores
             }
         }
-        
+
         // For array store (used in tests), we need to inspect the internal array
         if (get_class($store) === 'Illuminate\Cache\ArrayStore') {
             $reflection = new \ReflectionClass($store);
             $storage = $reflection->getProperty('storage');
             $storage->setAccessible(true);
             $storageArray = $storage->getValue($store);
-            
+
             return array_filter(array_keys($storageArray), function ($key) {
                 return str_contains($key, 'restify');
             });
         }
-        
+
         // Fallback - check for typical patterns (with error handling for database stores)
         $patterns = [
             'restify:repository:posts:index',
-            'laravel_cache:restify:repository:posts:index'
+            'laravel_cache:restify:repository:posts:index',
         ];
-        
+
         try {
             foreach ($patterns as $pattern) {
                 if (Cache::has($pattern)) {
@@ -276,7 +277,7 @@ protected function getCacheKeys(): array
             // Silently fail if cache store doesn't exist (e.g., database cache table missing)
             return [];
         }
-        
+
         return [];
     }
-}
+}