Spatie Laravel Responsecache

https://github.com/spatie/laravel-responsecache
Admin
This Laravel package caches entire responses to speed up applications. It automatically caches...
Tokens:50,237
Snippets:541
Trust Score:10
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Hash Example: Simple GET Request

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Demonstrates the components and resulting hash for a basic GET request without query parameters. The hash is generated from the method, host, and path.

```text
GET /posts HTTP/1.1
Host: example.com

Components: responsecache-example.com-/posts-GET-
Hash: 7e3a1b2c4d5f6a8b9c0d1e2f3a4b5c6d
```

--------------------------------

### Hash Example: GET Request with Query Parameters

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Shows how query parameters are included in the hash generation for a GET request. The hash is derived from the method, host, path, and the full query string.

```text
GET /posts?page=2&sort=newest HTTP/1.1
Host: example.com

Components: responsecache-example.com-/posts?page=2&sort=newest-GET-
Hash: 4f2c8a1b3e5d7f9a2c4e6g8h0i1j2k3l
```

--------------------------------

### Facade Usage Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Demonstrates how to use the ResponseCache facade for common operations like clearing cache, getting cached responses, and caching new responses.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

// All methods available statically
ResponseCache::clear();
$cached = ResponseCache::getCachedResponseFor($request);
ResponseCache::cacheResponse($request, $response, 3600);
```

--------------------------------

### Install Package with Composer

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/installation-setup.md

Use this command to install the spatie/laravel-responsecache package into your Laravel project.

```bash
composer require spatie\/laravel-responsecache
```

--------------------------------

### Implement Custom Cache Profile

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/advanced-usage/custom-cache-profiles.md

Implement the `CacheProfile` interface to define custom logic for caching requests and responses. This example shows how to enable caching based on configuration, cache only GET and HEAD requests, cache successful responses, set a 30-minute cache lifetime, and differentiate cache entries per user.

```php
namespace App\CacheProfiles;

use Illuminate\Http\Request;
use Spatie\ResponseCache\CacheProfiles\CacheProfile;
use Symfony\Component\HttpFoundation\Response;

class CustomCacheProfile implements CacheProfile
{
    public function enabled(Request $request): bool
    {
        return config('responsecache.enabled');
    }

    public function shouldCacheRequest(Request $request): bool
    {
        // Only cache GET and HEAD requests
        return $request->isMethod('GET') || $request->isMethod('HEAD');
    }

    public function shouldCacheResponse(Response $response): bool
    {
        return $response->isSuccessful();
    }

    public function cacheLifetimeInSeconds(Request $request): int
    {
        return 30 * 60;
    }

    public function useCacheNameSuffix(Request $request): string
    {
        // Return a unique string per user (or empty for shared cache)
        return auth()->user()?->id ?? '';
    }
}
```

--------------------------------

### Development Environment Configuration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Example .env.local file for development environment settings. Caching is disabled, and debug mode is enabled.

```env
RESPONSE_CACHE_ENABLED=false
RESPONSE_CACHE_DRIVER=file
APP_DEBUG=true
```

--------------------------------

### Custom Serializer Implementation

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Serializer.md

Example of how to create a custom serializer by implementing the `Serializer` interface.

```APIDOC
## CustomSerializer

### Description
An example implementation of the `Serializer` interface for custom serialization logic.

### Methods
- `serialize(Response $response): string`
- `unserialize(string $serializedResponse): Response`

### Example Implementation
```php
namespace App\Serializers;

use Symfony\Component\HttpFoundation\Response;
use Spatie\ResponseCache\Serializers\Serializer;

class CustomSerializer implements Serializer
{
    public function serialize(Response $response): string
    {
        // Your custom serialization logic
        return base64_encode($response->getContent());
    }

    public function unserialize(string $serializedResponse): Response
    {
        // Your custom deserialization logic
        $content = base64_decode($serializedResponse);
        return new Response($content);
    }
}
```
```

--------------------------------

### FlexibleCache Attribute Usage Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/types.md

Example of applying the FlexibleCache attribute to a controller method to enable SWR caching with a 1-hour lifetime and 10-minute grace period.

```php
use Spatie\ResponseCache\Attributes\FlexibleCache;

class DashboardController
{
    #[FlexibleCache(lifetime: 3600, grace: 600)]
    public function index()
    {
        return view('dashboard', ['data' => $this->fetchData()]);
    }
}
```

--------------------------------

### CouldNotUnserialize Exception Handling Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Serializer.md

Demonstrates how to catch the CouldNotUnserialize exception during the unserialization process. This example shows logging the error message when deserialization fails.

```php
try {
    $response = $serializer->unserialize($invalidJson);
} catch (CouldNotUnserialize $e) {
    // Handle deserialization error
    Log::error('Cache deserialization failed: ' . $e->getMessage());
}
```

--------------------------------

### getNormalizedQueryString() Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Provides an example of how the getNormalizedQueryString method works. It removes ignored query parameters to ensure consistent cache keys.

```php
// Input: 'page=2&utm_source=google&utm_medium=cpc'
// Output: 'page=2'
```

--------------------------------

### Custom Serializer Implementation Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Serializer.md

Provides an example of creating a custom serializer by implementing the Serializer interface. This custom serializer uses base64 encoding for both serialization and deserialization of response content.

```php
namespace App\Serializers;

use Symfony\Component\HttpFoundation\Response;
use Spatie\ResponseCache\Serializers\Serializer;

class CustomSerializer implements Serializer
{
    public function serialize(Response $response): string
    {
        // Your custom serialization logic
        return base64_encode($response->getContent());
    }

    public function unserialize(string $serializedResponse): Response
    {
        // Your custom deserialization logic
        $content = base64_decode($serializedResponse);
        return new Response($content);
    }
}
```

--------------------------------

### Flexible Caching Strategy Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Implements a flexible caching strategy for a dashboard view, allowing for stale data while new data is being fetched.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

class DashboardController
{
    public function index()
    {
        $response = ResponseCache::flexible(
            'dashboard-' . auth()->id(),
            [3600, 5400],  // Fresh for 1 hour, stale for 30 minutes
            function () {
                return view('dashboard', [
                    'data' => $this->fetchDashboardData(),
                ]);
            },
            ['dashboard', 'user-specific']
        );

        return $response;
    }
}
```

--------------------------------

### Staging Environment Configuration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Example .env.staging file for staging environment settings. Caching is enabled with file driver, a lifetime of 1 hour, and specific bypass headers.

```env
RESPONSE_CACHE_ENABLED=true
RESPONSE_CACHE_DRIVER=redis
RESPONSE_CACHE_LIFETIME=3600
RESPONSE_CACHE_TAG=responsecache
CACHE_BYPASS_HEADER_NAME=X-Bypass-Cache
CACHE_BYPASS_HEADER_VALUE=staging-secret
APP_DEBUG=false
```

--------------------------------

### Basic Cache Operations Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Illustrates checking if caching is enabled, if a response is cached, and clearing the cache within a controller.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

class CacheController
{
    public function status()
    {
        // Check if caching is enabled
        if (!ResponseCache::enabled($request)) {
            return 'Caching disabled';
        }

        // Check if response cached
        if (ResponseCache::hasBeenCached($request)) {
            return 'Response is cached';
        }

        return 'Response not cached';
    }

    public function clearCache()
    {
        if (ResponseCache::clear()) {
            return 'Cache cleared successfully';
        }

        return 'Cache clearing failed';
    }
}
```

--------------------------------

### Usage of CacheConfiguration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/types.md

Example of instantiating CacheConfiguration with a specific lifetime and tags. This configuration is used to control how responses are cached.

```php
$config = new CacheConfiguration(
    lifetime: 3600,
    tags: ['posts', 'public']
);
```

--------------------------------

### DefaultHasher getHashFor() Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Illustrates the components and expected output for generating a cache hash using the DefaultHasher. It includes the prefix, host, normalized URI, method, and cache suffix.

```php
// GET /posts?page=2&utm_source=google
// Hash components: 'responsecache-example.com-/posts?page=2-GET-1'
// Result: 'd8a9c1b2e3f4a5b6c7d8e9f0a1b2c3d4'
```

--------------------------------

### Production Environment Configuration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Example .env.production file for production environment settings. Caching is enabled with redis driver, a lifetime of 24 hours, and specific bypass headers.

```env
RESPONSE_CACHE_ENABLED=true
RESPONSE_CACHE_DRIVER=redis
RESPONSE_CACHE_LIFETIME=86400
RESPONSE_CACHE_TAG=responsecache
CACHE_BYPASS_HEADER_NAME=X-Bypass-Cache
CACHE_BYPASS_HEADER_VALUE=production-secret-xyz
APP_DEBUG=false
```

--------------------------------

### JsonSerializer: Unserialize Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Serializer.md

Shows how to use the JsonSerializer to unserialize a JSON string back into an HTTP Response object. This example reconstructs a 'normal' response with content and status code.

```php
$json = '{"type":"normal","status":200,"headers":{},"content":"Hello World"}';
$response = $serializer->unserialize($json);

echo $response->getStatusCode();  // 200
echo $response->getContent();      // "Hello World"
```

--------------------------------

### Idempotent Replacer Logic Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Ensure your replacer logic is idempotent to prevent unintended side effects if called multiple times. The 'good' example includes a check to exit early if the content has already been replaced or is not applicable.

```php
// Good - idempotent
if (!str_contains($content, $placeholder)) {
    return;  // Already replaced or not applicable
}

// Bad - not idempotent
$content = str_replace($old, $new, $content);
// If called twice, may replace new value again
```

--------------------------------

### Custom Cache Profile Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Implement a custom cache profile by extending the base class to define specific logic for caching requests and determining cache lifetimes.

```php
// config/responsecache.php
'cache_profile' => \App\CacheProfiles\CustomProfile::class,

// app/CacheProfiles/CustomProfile.php
class CustomProfile extends BaseCacheProfile
{
    public function shouldCacheRequest(Request $request): bool
    {
        return $request->isMethod('GET') && !$request->user()?->is_admin;
    }

    public function cacheLifetimeInSeconds(Request $request): int
    {
        return $request->is('blog/*') ? 86400 : 3600;
    }
}
```

--------------------------------

### Using Dependency Injection for ResponseCache in a Service

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Recommended for services, this example demonstrates injecting the ResponseCache class directly into a service class constructor. This approach enhances testability and makes dependencies explicit.

```php
use Spatie\ResponseCache\ResponseCache;

class PostService
{
    public function __construct(private ResponseCache $cache) {}

    public function createPost(array $data)
    {
        // Testable and explicit
        $this->cache->clear(['posts']);
    }
}
```

--------------------------------

### Unique Placeholder Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Use unique placeholder strings that are unlikely to appear in normal content to avoid unintended replacements.

```php
// Good - unique placeholder
'<RESPONSECACHE_CSRF_TOKEN_HERE>'

// Less safe - could appear in content
'<token>'
'<!-- token -->'
```

--------------------------------

### Using ResponseCache Facade in a Controller

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Recommended for controllers, this example shows the concise usage of the ResponseCache facade for clearing cache entries. It offers a simple and readable way to interact with the caching system.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

class PostController
{
    public function store(Request $request)
    {
        // Simple and readable
        ResponseCache::clear(['posts']);
    }
}
```

--------------------------------

### Custom Serializer Configuration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Set up a custom serializer in config/responsecache.php to handle the serialization and deserialization of cached responses. This example uses gzcompress for compression.

```php
// config/responsecache.php
'serializer' => \App\Serializers\CompressedSerializer::class,
```

```php
// app/Serializers/CompressedSerializer.php
class CompressedSerializer implements Serializer
{
    public function serialize(Response $response): string
    {
        $json = json_encode([
            'status' => $response->getStatusCode(),
            'headers' => $response->headers->all(),
            'content' => $response->getContent(),
        ]);
        return gzcompress($json);
    }

    public function unserialize(string $serialized): Response
    {
        $json = gzuncompress($serialized);
        $data = json_decode($json, true);
        return new Response($data['content'], $data['status']);
    }
}
```

--------------------------------

### Get Response with Flexible/SWR Strategy

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Retrieves a response using a flexible strategy, allowing for stale-while-revalidate (SWR) behavior.

```php
ResponseCache::flexible(
    string $key,
    array $seconds,
    Closure $callback,
    array $tags = []
): Response
```

--------------------------------

### SkipCacheException for Real-time Updates

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/errors.md

This example shows how to throw a SkipCacheException when resource data needs real-time updates, preventing it from being cached and ensuring a fresh response is always generated.

```php
public function resource($id)
{
    $data = Data::find($id);

    if ($data->needs_real_time_updates) {
        throw new SkipCacheException(
            response()->json($data)
        );
    }

    return view('resource', ['data' => $data]);
}
```

--------------------------------

### CSRF Token Caching Example: After prepareResponseToCache

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Shows the HTML form after the CSRF token has been replaced with a placeholder during the caching process.

```html
<!-- Cached with placeholder -->
<form method="POST" action="/posts">
    <input type="hidden" name="_token" value="<laravel-responsecache-csrf-token-here>">
    <input type="text" name="title">
    <button>Create Post</button>
</form>
```

--------------------------------

### JsonSerializer: Serialize Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Serializer.md

Demonstrates how to use the JsonSerializer to serialize a standard HTTP response into a JSON string. This includes setting the response content, status, and headers.

```php
use Spatie\ResponseCache\Serializers\JsonSerializer;

$serializer = new JsonSerializer();
$response = new Response('Hello World', 200);
$response->headers->set('Content-Type', 'text/plain');

$json = $serializer->serialize($response);
// Result: {"type":"normal","status":200,"headers":{...},"content":"Hello World"}
```

--------------------------------

### ResponseCache Facade Usage

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Demonstrates how to use the ResponseCache facade statically to perform common caching operations like clearing, getting cached responses, and caching new responses.

```APIDOC
## ResponseCache Facade Usage

### Description
Provides static methods for interacting with the response caching service.

### Methods
- `clear()`: Clears the cache.
- `getCachedResponseFor(Request $request)`: Retrieves a cached response for a given request.
- `cacheResponse(Request $request, Response $response, ?int $lifetimeInSeconds = null)`: Caches a response for a specified duration.

### Example
```php
use Spatie\ResponseCache\Facades\ResponseCache;

ResponseCache::clear();
$cached = ResponseCache::getCachedResponseFor($request);
ResponseCache::cacheResponse($request, $response, 3600);
```
```

--------------------------------

### Hash Example: Request with Ignored Parameters

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Demonstrates how specific query parameters, like UTM tags, are ignored during hash generation. The hash is computed based on the path and relevant query parameters, excluding ignored ones.

```text
GET /products?category=electronics&utm_source=google HTTP/1.1
Host: example.com

// utm_source ignored
Components: responsecache-example.com-/products?category=electronics-GET-
Hash: 5a6b7c8d9e0f1g2h3i4j5k6l7m8n9o0p
```

--------------------------------

### Custom Replacer Implementation

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/advanced-usage/creating-a-replacer.md

Implement the `Replacer` interface to create a custom replacer. This example shows a `UserNameReplacer` that swaps the authenticated user's name with a placeholder.

```php
namespace App\Replacers;

use Spatie\ResponseCache\Replacers\Replacer;
use Symfony\Component\HttpFoundation\Response;

class UserNameReplacer implements Replacer
{
    protected string $placeholder = '<username-placeholder>';

    public function prepareResponseToCache(Response $response): void
    {
        $content = $response->getContent();

        if (! $content) {
            return;
        }

        $userName = auth()->user()?->name ?? 'Guest';

        $response->setContent(str_replace(
            $userName,
            $this->placeholder,
            $content,
        ));
    }

    public function replaceInCachedResponse(Response $response): void
    {
        $content = $response->getContent();

        if (! $content || ! str_contains($content, $this->placeholder)) {
            return;
        }

        $userName = auth()->user()?->name ?? 'Guest';

        $response->setContent(str_replace(
            $this->placeholder,
            $userName,
            $content,
        ));
    }
}
```

--------------------------------

### Get Cached Response

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/ResponseCache.md

Retrieves a cached response for a given request. Returns null if no cached response is found.

```php
ResponseCache::getCachedResponseFor($request);
```

--------------------------------

### Hash Example: Authenticated Request

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Illustrates hash generation for an authenticated request. The hash incorporates the user ID, derived from the authentication status, in addition to other request components.

```text
GET /dashboard HTTP/1.1
Host: example.com
Authorization: Bearer token...
User ID: 42

Components: responsecache-example.com-/dashboard-GET-42
Hash: 9k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z
```

--------------------------------

### Log Cache Clearing Start

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Log a message when cache clearing operations are about to begin. This snippet listens for the ClearingResponseCacheEvent, which is dispatched before any cache entries are removed.

```php
use Spatie\ResponseCache\Events\ClearingResponseCacheEvent;

// Log cache clearing
Event::listen(ClearingResponseCacheEvent::class, function () {
    Log::info('Cache clearing started');
});
```

--------------------------------

### Custom Cache Profile Implementation

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheProfile.md

Extends `BaseCacheProfile` to define custom caching rules for requests, responses, cache lifetimes, and cache name suffixes. This example demonstrates conditional caching based on request path, authentication status, HTTP method, and response success.

```php
namespace App\CacheProfiles;

use Illuminate\Http\Request;
use Spatie\ResponseCache\CacheProfiles\BaseCacheProfile;
use Symfony\Component\HttpFoundation\Response;

class CustomCacheProfile extends BaseCacheProfile
{
    public function shouldCacheRequest(Request $request): bool
    {
        // Don't cache admin routes
        if ($request->is('admin/*')) {
            return false;
        }

        // Don't cache authenticated admin users
        if (auth()->check() && auth()->user()->is_admin) {
            return false;
        }

        // Cache GET requests only
        return $request->isMethod('GET');
    }

    public function shouldCacheResponse(Response $response): bool
    {
        // Cache only successful responses
        return $response->isSuccessful();
    }

    public function cacheLifetimeInSeconds(Request $request): int
    {
        // Cache homepage longer
        if ($request->path() === '/') {
            return 86400; // 24 hours
        }

        // Standard cache time
        return 3600; // 1 hour
    }

    public function useCacheNameSuffix(Request $request): string
    {
        // Cache different versions per user role
        if (auth()->check()) {
            return auth()->user()->role;
        }

        return 'guest';
    }
}
```

--------------------------------

### Set Default Cache Lifetime

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Configure the default cache lifetime in seconds using the `RESPONSE_CACHE_LIFETIME` environment variable. Examples show setting a 1-hour or 1-day default.

```env
RESPONSE_CACHE_LIFETIME=3600
```

```env
RESPONSE_CACHE_LIFETIME=86400
```

--------------------------------

### Implement Custom RequestHasher Interface

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/advanced-usage/customizing-the-hasher.md

Create a class that implements the `RequestHasher` interface and define your custom hashing logic within the `getHashFor` method. This example uses `xxh128` to hash the full URL.

```php
namespace App\Hashers;

use Illuminate\Http\Request;
use Spatie\ResponseCache\Hasher\RequestHasher;

class CustomHasher implements RequestHasher
{
    public function getHashFor(Request $request): string
    {
        // Your hashing logic
        return hash('xxh128', $request->fullUrl());
    }
}
```

--------------------------------

### Implement Custom RequestHasher

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Implement the `RequestHasher` interface to define custom logic for generating cache keys. This example includes application-specific components, host, path, method, authentication status, and an API version parameter.

```php
namespace App\Hashers;

use Illuminate\Http\Request;
use Spatie\ResponseCache\Hasher\RequestHasher;

class CustomHasher implements RequestHasher
{
    public function getHashFor(Request $request): string
    {
        // Include custom components
        $components = [
            'app',
            $request->getHost(),
            $request->getPath(),
            $request->getMethod(),
            auth()->id() ?? 'guest',
            $request->get('version'),  // API version
        ];

        return hash('sha256', implode('-', $components));
    }
}
```

--------------------------------

### Usage of FlexibleCacheConfiguration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/types.md

Demonstrates creating a FlexibleCacheConfiguration with defined fresh lifetime, grace period, and tags. This configuration enables SWR caching strategies.

```php
$config = new FlexibleCacheConfiguration(
    lifetime: 3600,      // Fresh for 1 hour
    grace: 300,          // Stale for 5 more minutes
    tags: ['dashboard']
);
```

--------------------------------

### Publish Configuration File

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/installation-setup.md

Run this Artisan command to publish the response cache configuration file to your project.

```bash
php artisan vendor:publish --tag="responsecache-config"
```

--------------------------------

### Get Cached Response

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Retrieves a cached response for a given request and tags, if available.

```php
ResponseCache::getCachedResponseFor(Request $request, array $tags = []): ?Response
```

--------------------------------

### withParameters()

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheItemSelector.md

Adds query parameters (for GET) or request body (for POST/PUT/PATCH) to the request. Inherited from AbstractRequestBuilder.

```APIDOC
## withParameters()

### Description
Adds query parameters (for GET) or request body (for POST/PUT/PATCH) to request.

### Method
`withParameters(array $parameters): static`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **$parameters** (array) - Required - Parameters to add to the request.

### Returns
`static` — This builder instance for method chaining.
```

--------------------------------

### Use Cache Configuration Classes

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/INDEX.md

Instantiate `CacheConfiguration` or `FlexibleCacheConfiguration` objects to programmatically define caching parameters.

```php
CacheConfiguration(lifetime: ?int, tags: array)
FlexibleCacheConfiguration(lifetime: int, grace: int, tags: array)
```

--------------------------------

### Invalidate Post Cache After Update Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheItemSelector.md

Demonstrates how to invalidate the cache for a specific post and its listing after a successful update operation.

```php
use Spatie
esponseCache
esponseCache;

class PostController extends Controller
{
    public function update(Request $request, Post $post)
    {
        $post->update($request->validated());

        // Invalidate cache for this post and list
        ResponseCache::selectCachedItems()
            ->forUrls(['/posts', '/posts/' . $post->id])
            ->usingTags('posts')
            ->forget();

        return redirect('/posts/' . $post->id);
    }
}
```

--------------------------------

### Full Configuration File Structure

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

This is the complete structure of the response cache configuration file. It shows all available options and their default values.

```php
<?php

return [
    // Global enable/disable flag
    'enabled' => env('RESPONSE_CACHE_ENABLED', true),

    // Cache storage and lifetime settings
    'cache' => [
        'store' => env('RESPONSE_CACHE_DRIVER', 'file'),
        'lifetime_in_seconds' => (int) env('RESPONSE_CACHE_LIFETIME', 60 * 60 * 24 * 7),
        'tag' => env('RESPONSE_CACHE_TAG', ''),
    ],

    // Cache bypass header configuration
    'bypass' => [
        'header_name' => env('CACHE_BYPASS_HEADER_NAME'),
        'header_value' => env('CACHE_BYPASS_HEADER_VALUE'),
    ],

    // Debug mode headers and settings
    'debug' => [
        'enabled' => env('APP_DEBUG', false),
        'cache_time_header_name' => 'X-Cache-Time',
        'cache_status_header_name' => 'X-Cache-Status',
        'cache_age_header_name' => 'X-Cache-Age',
        'cache_key_header_name' => 'X-Cache-Key',
    ],

    // Query parameters to ignore when generating cache keys
    'ignored_query_parameters' => [
        'utm_source',
        'utm_medium',
        'utm_campaign',
        'utm_term',
        'utm_content',
        'gclid',
        'fbclid',
    ],

    // Default cache profile class
    'cache_profile' => CacheAllSuccessfulGetRequests::class,

    // Request hasher class for cache key generation
    'hasher' => DefaultHasher::class,

    // Response serializer class for caching
    'serializer' => JsonSerializer::class,

    // Replacers for dynamic content handling
    'replacers' => [
        CsrfTokenReplacer::class,
    ],
];

```

--------------------------------

### Selective Cache Invalidation Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Demonstrates how to invalidate specific cache entries for posts and related lists after an update or delete operation.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

class PostController
{
    public function update(Request $request, Post $post)
    {
        $post->update($request->validated());

        // Clear cache for this post and list
        ResponseCache::forget([
            '/posts',
            '/posts/' . $post->id,
        ]);

        return redirect('/posts/' . $post->id);
    }

    public function delete(Post $post)
    {
        $post->delete();

        // Clear post-related caches
        ResponseCache::forget('/posts', ['posts']);

        return redirect('/posts');
    }
}
```

--------------------------------

### Custom Replacers Configuration

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Define custom replacer classes in config/responsecache.php to modify dynamic content in cached responses. This example replaces timestamps.

```php
// config/responsecache.php
'replacers' => [
    CsrfTokenReplacer::class,
    \App\Replacers\TimestampReplacer::class,
],
```

```php
// app/Replacers/TimestampReplacer.php
class TimestampReplacer implements Replacer
{
    public function prepareResponseToCache(Response $response): void
    {
        // Replace current timestamp with placeholder
        $content = str_replace(
            now()->toDateTimeString(),
            '<!-- TIMESTAMP_PLACEHOLDER -->',
            $response->getContent()
        );
        $response->setContent($content);
    }

    public function replaceInCachedResponse(Response $response): void
    {
        // Restore placeholder with current timestamp
        $content = str_replace(
            '<!-- TIMESTAMP_PLACEHOLDER -->',
            now()->toDateTimeString(),
            $response->getContent()
        );
        $response->setContent($content);
    }
}
```

--------------------------------

### Facade vs. Direct Usage of selectCachedItems

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheItemSelector.md

Demonstrates the equivalent usage of `selectCachedItems` via the ResponseCache facade and direct instantiation of the class. Both methods achieve the same result of targeting cache entries for invalidation.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

// Facade method
ResponseCache::selectCachedItems()
    ->forUrls('/posts')
    ->forget();

// Equivalent direct usage
app(ResponseCache::class)->selectCachedItems()
    ->forUrls('/posts')
    ->forget();
```

--------------------------------

### Basic Flexible Cache Middleware

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/basic-usage/flexible-caching.md

Apply flexible caching to a route with a 1-hour lifetime and a 5-minute grace period. This ensures instant responses for up to an hour, and continues serving stale data for 5 minutes while refreshing.

```php
use Spatie\ResponseCache\Middlewares\FlexibleCacheResponse;

Route::get('/api/posts', [PostController::class, 'index'])
    ->middleware(FlexibleCacheResponse::for(lifetime: hours(1), grace: minutes(5)));
```

--------------------------------

### Configure Cache Store Driver

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/configuration.md

Specify the cache driver using the `RESPONSE_CACHE_DRIVER` environment variable. Recommended drivers for production are 'redis' or 'memcached'.

```env
RESPONSE_CACHE_DRIVER=redis
```

--------------------------------

### CSRF Token Caching Example: Original HTML

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Illustrates the original HTML form containing a hidden CSRF token input field.

```html
<!-- Original HTML with CSRF token -->
<form method="POST" action="/posts">
    <input type="hidden" name="_token" value="abc123def456">
    <input type="text" name="title">
    <button>Create Post</button>
</form>
```

--------------------------------

### Configuration for Ignored Query Parameters

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/RequestHasher.md

Shows how to configure which query parameters should be ignored when generating cache keys. This ensures URLs with different tracking parameters are treated as identical for caching purposes.

```php
'ignored_query_parameters' => [
    'utm_source',
    'utm_medium',
    'utm_campaign',
    'gclid',
    'fbclid',
    'custom_tracking_param',
],
```

--------------------------------

### Multiple Endpoints with Different Timings

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/FlexibleCacheResponse.md

Demonstrates setting different cache lifetimes and grace periods for multiple API endpoints based on their data update frequency.

```php
// Realtime data, short fresh window
Route::middleware(FlexibleCacheResponse::for(60, 30))
    ->get('/live-stats', [StatsController::class, 'live']);

// Daily data, long fresh window
Route::middleware(FlexibleCacheResponse::for(86400, 3600))
    ->get('/daily-report', [ReportController::class, 'daily']);

// Historical data, very long fresh window
Route::middleware(FlexibleCacheResponse::for(604800, 86400))
    ->get('/historical', [HistoryController::class, 'index']);
```

--------------------------------

### Log Cache Misses

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Log details about requests that result in a cache miss. This example listens for the CacheMissedEvent and logs the request path and method.

```php
use Spatie\ResponseCache\Events\CacheMissedEvent;

// Log cache misses
Event::listen(CacheMissedEvent::class, function (CacheMissedEvent $event) {
    Log::info('Cache miss', [
        'path' => $event->request->getPathInfo(),
        'method' => $event->request->getMethod(),
    ]);
});
```

--------------------------------

### CSRF Token Caching Example: After replaceInCachedResponse

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Depicts the HTML form after the placeholder has been replaced with a new, current CSRF token when serving the cached response.

```html
<!-- Served with new token -->
<form method="POST" action="/posts">
    <input type="hidden" name="_token" value="xyz789abc123">
    <input type="text" name="title">
    <button>Create Post</button>
</form>
```

--------------------------------

### Run Package Tests

Source: https://github.com/spatie/laravel-responsecache/blob/main/README.md

Execute the test suite for the laravel-responsecache package using Composer. Ensure all tests pass to verify package integrity.

```bash
composer test
```

--------------------------------

### Listen for ClearedResponseCacheEvent

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Register listeners for the ClearedResponseCacheEvent to perform actions after the cache has been successfully cleared. Examples include logging, releasing locks, or sending notifications.

```php
use Spatie\ResponseCache\Events\ClearedResponseCacheEvent;

// Log successful cache clear
Event::listen(ClearedResponseCacheEvent::class, function () {
    Log::info('Cache cleared successfully');
});

// Release clearing lock
Event::listen(ClearedResponseCacheEvent::class, function () {
    Cache::forget('cache.clearing');
});

// Send success notification
Event::listen(ClearedResponseCacheEvent::class, function () {
    Notification::send(User::admins(), new CacheClearedNotification());
});
```

--------------------------------

### Add Parameters to Request

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheItemSelector.md

Adds query parameters (for GET requests) or request body (for POST/PUT/PATCH requests) to the request used for cache key generation.

```php
public function withParameters(array $parameters): static
```

--------------------------------

### Handle Request with Flexible Cache

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/FlexibleCacheResponse.md

The `handle()` method is the HTTP middleware request handler that implements the SWR strategy with background refresh. It checks for attributes, caching status, delegates to `handleFlexibleCache()`, applies replacers, adds debug headers, and dispatches events.

```php
$response = $middleware->handle($request, function($req) {
    return response('Dashboard data');
});
```

--------------------------------

### Method Chaining with ResponseCache Facade

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Demonstrates method chaining for multiple `forget` operations on the ResponseCache facade. This allows for a more compact way to clear multiple cache entries in a single call.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

ResponseCache::forget('/posts')
    ->forget('/articles')
    ->forget('/comments');

// Equivalent to
ResponseCache::forget(['/posts', '/articles', '/comments']);
```

--------------------------------

### Track Cache Miss Metrics

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Increment metrics for cache misses, associating them with the route. This example uses the CacheMissedEvent to track how often endpoints are not found in the cache.

```php
use Spatie\ResponseCache\Events\CacheMissedEvent;

// Track which endpoints need caching
Event::listen(CacheMissedEvent::class, function (CacheMissedEvent $event) {
    Metrics::increment('cache.misses', 1, [
        'route' => $event->request->getPathInfo(),
    ]);
});
```

--------------------------------

### usingSuffix()

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheItemSelector.md

Uses a specific cache name suffix instead of deriving from auth state. Inherited from AbstractRequestBuilder.

```APIDOC
## usingSuffix()

### Description
Uses a specific cache name suffix instead of deriving from auth state.

### Method
`usingSuffix(string $cacheNameSuffix): static`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **$cacheNameSuffix** (string) - Required - The cache name suffix to use.

### Returns
`static` — This builder instance for method chaining.
```

--------------------------------

### Create CacheResponse Middleware String

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheResponse.md

Use the `for()` static method to create a middleware string with caching configuration for route groups. You can specify cache lifetime in seconds or as a CarbonInterval, and optionally add tags for cache invalidation.

```php
use Spatie\ResponseCache\Middlewares\CacheResponse;
use Illuminate\Support\Carbon;

// Cache for 10 minutes
Route::middleware(CacheResponse::for(600))->group(function () {
    Route::get('/posts', [PostController::class, 'index']);
});

// Using CarbonInterval
Route::middleware(CacheResponse::for(Carbon::now()->addHours(2)))->group(function () {
    Route::get('/articles', [ArticleController::class, 'index']);
});

// Cache with tags
Route::middleware(CacheResponse::for(lifetime: 3600, tags: ['posts', 'public']))->group(function () {
    Route::get('/posts', [PostController::class, 'index']);
});
```

--------------------------------

### Track Cache Hit Metrics

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Increment metrics for cache hits, associating them with the route. This example shows how to use ResponseCacheHitEvent to send data to a metrics system.

```php
use Spatie\ResponseCache\Events\ResponseCacheHitEvent;

// Track cache hit metrics
Event::listen(ResponseCacheHitEvent::class, function (ResponseCacheHitEvent $event) {
    Metrics::increment('cache.hits', 1, [
        'route' => $event->request->getPathInfo(),
    ]);
});
```

--------------------------------

### Multiple Routes with Different Lifetimes

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheResponse.md

Demonstrates applying different cache lifetimes to distinct routes within a Laravel application.

```php
Route::middleware(CacheResponse::for(3600))
    ->get('/posts', [PostController::class, 'index']);

Route::middleware(CacheResponse::for(600))
    ->get('/posts/{id}', [PostController::class, 'show']);
```

--------------------------------

### Configure Cache Storage Settings

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/INDEX.md

Define cache storage details, including the driver (e.g., 'file', 'redis'), lifetime in seconds, and optional tag, within the `cache` configuration array in `config/responsecache.php`.

```php
// config/responsecache.php
'cache' => [
    'store' => env('RESPONSE_CACHE_DRIVER', 'file'),  // redis, memcached, etc.
    'lifetime_in_seconds' => 604800,  // 7 days
    'tag' => env('RESPONSE_CACHE_TAG', ''),
],
```

--------------------------------

### withPostMethod()

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheItemSelector.md

Sets the HTTP method to POST for cache key generation. Inherited from AbstractRequestBuilder.

```APIDOC
## withPostMethod()

### Description
Sets HTTP method to POST for cache key generation.

### Method
`withPostMethod(): static`

### Parameters
None

### Returns
`static` — This builder instance for method chaining.
```

--------------------------------

### Environment-Specific Caching Control

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheProfile.md

Implement the `enabled` method to conditionally enable or disable caching based on the application environment. This example disables caching in local development environments.

```php
class EnvAwareCacheProfile extends BaseCacheProfile
{
    public function enabled(Request $request): bool
    {
        // Disable caching in development
        if (app()->isLocal()) {
            return false;
        }

        return config('responsecache.enabled');
    }
}
```

--------------------------------

### Usage with ResponseCache

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Serializer.md

Demonstrates how ResponseCache automatically handles serialization and deserialization of responses.

```php
// Serialization happens automatically
ResponseCache::cacheResponse($request, $response);

// Deserialization happens automatically
$cachedResponse = ResponseCache::getCachedResponseFor($request);
```

--------------------------------

### Configure FlexibleCacheResponse Middleware

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/FlexibleCacheResponse.md

Use the static `for()` method to create a middleware string with flexible caching configuration for route groups. This allows specifying lifetime, grace period, and tags for cache invalidation.

```php
use Spatie\ResponseCache\Middlewares\FlexibleCacheResponse;
use Carbon\CarbonInterval;

// Fresh for 1 hour, stale allowed for 5 more minutes
Route::middleware(FlexibleCacheResponse::for(3600, 300))->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
});

// Using CarbonInterval
Route::middleware(FlexibleCacheResponse::for(
    lifetime: CarbonInterval::hours(1),
    grace: CarbonInterval::minutes(5)
))->group(function () {
    Route::get('/stats', [StatsController::class, 'index']);
});

// With tags
Route::middleware(FlexibleCacheResponse::for(
    lifetime: 3600,
    grace: 300,
    tags: ['dashboard', 'realtime']
))->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
});
```

--------------------------------

### Prevent Operations During Cache Clear

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Set a temporary lock to prevent other operations while cache clearing is in progress. This example uses the ClearingResponseCacheEvent to establish a short-term cache lock.

```php
use Spatie\ResponseCache\Events\ClearingResponseCacheEvent;

// Disable other operations during clear
Event::listen(ClearingResponseCacheEvent::class, function () {
    Cache::put('cache.clearing', true, 60);  // Lock for 1 minute
});
```

--------------------------------

### Update Config Access After ResponseCache v8.0.0 Restructure

Source: https://github.com/spatie/laravel-responsecache/blob/main/UPGRADING.md

Provides examples of how to update code references to configuration values after the config structure reorganization in Laravel ResponseCache v8.0.0.

```php
- `config('responsecache.cache_lifetime_in_seconds')` → `config('responsecache.cache.lifetime_in_seconds')`
- `config('responsecache.cache_store')` → `config('responsecache.cache.store')`
- `config('responsecache.add_cache_time_header')` → `config('responsecache.debug.enabled')`
- `config('responsecache.cache_bypass_header.name')` → `config('responsecache.bypass.header_name')`
```

--------------------------------

### NoCache Attribute Usage Example

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/types.md

Demonstrates using the NoCache attribute on controller methods to ensure their responses are never cached. This is useful for actions like storing or destroying resources.

```php
use Spatie\ResponseCache\Attributes\NoCache;

class PostController
{
    #[NoCache]
    public function store(StorePostRequest $request)
    {
        // This response will never be cached
        Post::create($request->validated());
        return redirect('/posts');
    }

    #[NoCache]
    public function destroy(Post $post)
    {
        // Destructions are never cached
        $post->delete();
        return redirect('/posts');
    }
}
```

--------------------------------

### Advanced Cache Selection and Forgetting

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Shows how to select specific cached items based on URLs and tags, and then forget them, for user-specific cache clearing.

```php
use Spatie\ResponseCache\Facades\ResponseCache;

class AdminController
{
    public function clearUserCaches(User $user)
    {
        ResponseCache::selectCachedItems()
            ->forUrls([
                '/user/' . $user->id,
                '/user/' . $user->id . '/profile',
                '/user/' . $user->id . '/settings',
            ])
            ->usingTags('user-specific')
            ->forget();

        return 'User cache cleared';
    }
}
```

--------------------------------

### Graceful Degradation for Dynamic Content Replacement

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Implement checks to ensure dynamic content and placeholders exist before attempting replacement. This prevents errors and unnecessary operations.

```php
public function prepareResponseToCache(Response $response): void
{
    $content = $response->getContent();
    if (!$content) return;

    $value = get_current_value();
    if (!$value) return;  // No value to replace

    if (!str_contains($content, $value)) {
        return;  // Value not in content, nothing to do
    }

    $response->setContent(str_replace($value, $placeholder, $content));
}
```

--------------------------------

### Cache Entire Response for a Specific Duration

Source: https://github.com/spatie/laravel-responsecache/blob/main/README.md

Use this middleware to cache all successful GET requests within a group for a defined period. This is useful for routes where content does not change frequently.

```php
use Spatie\ResponseCache\Middlewares\CacheResponse;

Route::middleware(CacheResponse::for(minutes(10)))->group(function () {
    Route::get('/posts', [PostController::class, 'index']);
    Route::get('/posts/{post}', [PostController::class, 'show']);
});
```

--------------------------------

### Group Routes with Flexible Cache Middleware

Source: https://github.com/spatie/laravel-responsecache/blob/main/docs/basic-usage/flexible-caching.md

Apply a common flexible caching configuration to a group of routes. This simplifies configuration for multiple routes that share the same caching requirements.

```php
use Spatie\ResponseCache\Middlewares\FlexibleCacheResponse;

Route::middleware(FlexibleCacheResponse::for(lifetime: minutes(1), grace: minutes(5)))->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::get('/stats', [StatsController::class, 'index']);
});
```

--------------------------------

### Monitoring Cache Deserialization Issues with Sentry and Log

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/errors.md

This snippet illustrates how to monitor for cache deserialization failures using a try-catch block, capturing exceptions with Sentry, and logging detailed error information.

```php
class ResponseCacheMonitoring
{
    public function monitor()
    {
        try {
            $cached = ResponseCache::getCachedResponseFor($request);
        } catch (CouldNotUnserialize $e) {
            Sentry::captureException($e);
            Log::error('Cache deserialization failed', [
                'path' => $request->getPathInfo(),
                'error' => $e->getMessage(),
            ]);
        }
    }
}
```

--------------------------------

### Monitor Slow Responses on Cache Miss

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Events.md

Register a timer to measure the duration of response generation when a cache miss occurs. This snippet uses the CacheMissedEvent to capture the start time and path.

```php
use Spatie\ResponseCache\Events\CacheMissedEvent;

// Monitor slow responses
Event::listen(CacheMissedEvent::class, function (CacheMissedEvent $event) {
    $timer = microtime(true);
    
    // Register timer to measure response generation
    app()->make('cache.miss.timer', [
        'path' => $event->request->getPathInfo(),
        'start' => $timer,
    ]);
});
```

--------------------------------

### Usage of Cache Attribute on Controller Methods

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/types.md

Examples of applying the Cache attribute to controller methods to configure caching for specific endpoints. This allows fine-grained control over caching behavior per method.

```php
use Spatie\ResponseCache\Attributes\Cache;

class PostController
{
    #[Cache(lifetime: 3600, tags: ['posts'])]
    public function index()
    {
        return view('posts.index', ['posts' => Post::all()]);
    }

    #[Cache(lifetime: 600)]
    public function show(Post $post)
    {
        return view('posts.show', ['post' => $post]);
    }
}
```

--------------------------------

### Replacer Interface: prepareResponseToCache Method

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Defines the method signature for preparing a response before it is cached. Implementations should replace dynamic content with placeholders.

```php
public function prepareResponseToCache(Response $response): void
```

--------------------------------

### Custom Error Handling for Cache Deserialization

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/errors.md

Provides an example of custom error handling for the CouldNotUnserialize exception, including logging the error, clearing the specific cache entry, and generating a fresh response.

```php
use Spatie\ResponseCache\Exceptions\CouldNotUnserialize;

try {
    $response = ResponseCache::getCachedResponseFor($request);
} catch (CouldNotUnserialize $e) {
    Log::warning('Cache corruption detected', [
        'error' => $e->getMessage(),
        'request' => $request->getPathInfo(),
    ]);
    
    // Clear the specific cache entry
    ResponseCache::forget($request->getPathInfo());
    
    // Generate fresh response
    return $controller->response();
}
```

--------------------------------

### Performance Optimization for Replacers

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Replacer.md

Optimize replacer performance by minimizing unnecessary string operations. The 'good' example demonstrates an early exit strategy, performing replacements only when needed, which is more efficient than always executing string replacements.

```php
// Good - early exit
$content = $response->getContent();
if (!$content) return;
if (!str_contains($content, $token)) return;
// Only do replacement if needed

// Less efficient
$content = $response->getContent();
$content = str_replace($old, $new, $content);  // Unnecessary work
```

--------------------------------

### Basic Route Caching

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/CacheResponse.md

Apply the CacheResponse middleware to a single route for a specified lifetime in seconds.

```php
Route::middleware(CacheResponse::for(600))
    ->get('/posts', [PostController::class, 'index']);
```

--------------------------------

### Usage of HttpMethod Enum

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/types.md

Demonstrates how to use the HttpMethod enum to check the current request method. Ensure the enum is imported before use.

```php
use Spatie\ResponseCache\Enums\HttpMethod;

if ($request->isMethod(HttpMethod::Get->value)) {
    // Handle GET request
}
```

--------------------------------

### Facade Accessor Method

Source: https://github.com/spatie/laravel-responsecache/blob/main/_autodocs/api-reference/Facades.md

Shows the accessor method that defines the container binding name for the ResponseCache facade.

```php
protected static function getFacadeAccessor(): string
{
    return 'responsecache';
}
```
Tokens:
Raw