Ability to cache single policy (#605)

* Ability to cache single policy

* Add documentation

* Wip

* Resolve typo

* fix typo

* Test fix

* wip

Author: CaReS0107

docs-v2/content/en/performance/performance.md

@@ -23,6 +23,18 @@ In order to improve performance, Restify caches the policies. You simply have to
 
 The caching is tight to the current authenticated user so if another user is logged in, the cache will be hydrated for the new user once again.
 
+Restify allows individual caching at the policy level with specific configurations. To enable this, a contract `Cacheable` must be implemented at the policy level, which enforces the use of the `cache()` method.
+
+``` php
+class PostPolicy implements Cacheable
+{
+    public function cache(): ?CarbonInterface
+    {
+        return now()->addMinutes();
+    }
+```
+The `cache` method is expected to return a `CarbonInterface` or `null`. If `null` is returned, the current policy will `NOT` cached.
+
 ## Disable index meta
 
 Index meta are policy information related to what actions are allowed on a resource for a specific user. However, if you don't need this information, you can disable the index meta by setting the `restify.repositories.serialize_index_meta` property to `false` in the `restify.php` configuration file:

src/Cache/Cacheable.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Binaryk\LaravelRestify\Cache;
+
+use Carbon\CarbonInterface;
+
+interface Cacheable
+{
+    public function cache(): ?CarbonInterface;
+}

src/Cache/PolicyCache.php

@@ -3,8 +3,10 @@
 namespace Binaryk\LaravelRestify\Cache;
 
 use Closure;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Gate;
 use Illuminate\Support\Str;
 
 class PolicyCache
@@ -30,7 +32,7 @@ public static function keyForPolicyMethods(string $repositoryKey, string $policy
         return "restify.policy.$policyMethod.repository-$repositoryKey.resource-$modelKey.user-".$user?->getKey();
     }
 
-    public static function resolve(string $key, callable|Closure $data): mixed
+    public static function resolve(string $key, callable|Closure $data, Model $model): mixed
     {
         if (! static::enabled()) {
             return $data();
@@ -40,7 +42,17 @@ public static function resolve(string $key, callable|Closure $data): mixed
             return Cache::get($key);
         }
 
-        Cache::put($key, $data = $data(), config('restify.cache.policies.ttl', 60));
+        $policy = Gate::getPolicyFor($model);
+
+        $ttl = (method_exists($policy, 'cache') && $policy instanceof Cacheable)
+            ? $policy->cache()
+            : config('restify.cache.policies.ttl', 60);
+
+        if (is_null($ttl)) {
+            return $data;
+        }
+
+        Cache::put($key, $data = $data(), $ttl);
 
         return $data;
     }

src/Traits/AuthorizableModels.php

@@ -36,7 +36,7 @@ public static function authorizedToUseRepository(Request $request): bool
                 : false;
         };
 
-        return PolicyCache::resolve(PolicyCache::keyForAllowRestify(static::uriKey()), $resolver);
+        return PolicyCache::resolve(PolicyCache::keyForAllowRestify(static::uriKey()), $resolver, static::newModel());
     }
 
     /**
@@ -206,7 +206,8 @@ public function authorizedTo(Request $request, iterable|string $ability): bool
 
         return PolicyCache::resolve(
             PolicyCache::keyForPolicyMethods(static::uriKey(), $ability, $this->resource->getKey()),
-            fn () => Gate::check($ability, $this->resource)
+            fn () => Gate::check($ability, $this->resource),
+            $this->model(),
         );
     }
 

tests/Feature/AuthorizableModelsTest.php

@@ -2,15 +2,20 @@
 
 namespace Binaryk\LaravelRestify\Tests\Feature;
 
+use Binaryk\LaravelRestify\Cache\Cacheable;
+use Binaryk\LaravelRestify\Cache\PolicyCache;
 use Binaryk\LaravelRestify\Tests\Database\Factories\PostFactory;
 use Binaryk\LaravelRestify\Tests\Fixtures\Post\Post;
 use Binaryk\LaravelRestify\Tests\Fixtures\Post\PostPolicy;
 use Binaryk\LaravelRestify\Tests\Fixtures\Post\PostRepository;
 use Binaryk\LaravelRestify\Tests\Fixtures\User\User;
 use Binaryk\LaravelRestify\Tests\IntegrationTestCase;
+use Carbon\Carbon;
+use Carbon\CarbonInterface;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Gate;
+use Symfony\Component\ErrorHandler\ErrorHandler;
 
 class AuthorizableModelsTest extends IntegrationTestCase
 {
@@ -121,4 +126,46 @@ public function test_can_disable_policies_cache(): void
         $this->getJson(PostRepository::route())
             ->assertForbidden();
     }
+
+    public function test_can_enable_individual_policy_cache(): void
+    {
+        $this->freezeTime();
+
+        $this->partialMock(PostPolicy::class)
+            ->shouldReceive('show')
+            ->andReturn(true);
+
+        $this->partialMock(PostPolicy::class)
+            ->shouldReceive('cache')
+            ->once()
+            ->andReturn(now()->addMinutes(3));
+
+        Gate::policy(Post::class, PostPolicy::class);
+
+        /** @var Carbon $timeCached */
+        $timeCached = Gate::getPolicyFor(Post::class)
+            ->cache();
+
+        $this->assertInstanceOf(CarbonInterface::class, $timeCached);
+
+        $post = PostFactory::one();
+
+        $this->getJson(PostRepository::route())
+            ->assertOk();
+
+        $this->assertTrue(Cache::has(PolicyCache::keyForPolicyMethods('posts', 'show', $post->getKey())));
+
+        $this->partialMock(PostPolicy::class)
+            ->shouldReceive('show')
+            ->andReturn(false);
+
+        $this->getJson(PostRepository::route())
+            ->assertOk();
+
+        $this->assertTrue(Cache::get(PolicyCache::keyForPolicyMethods('posts', 'show', $post->getKey())));
+
+        $this->travelTo(now()->addMinutes(5));
+
+        $this->assertFalse(Cache::has(PolicyCache::keyForPolicyMethods('posts', 'show', $post->getKey())));
+    }
 }