Speed up a Laravel app by caching the entire response

Overview

Social Card of Laravel Response Cache

Speed up an app by caching the entire response

Latest Version on Packagist MIT Licensed Psalm Total Downloads

This Laravel package can cache an entire response. By default it will cache all successful get-requests that return text based content (such as html and json) for a week. This could potentially speed up the response quite considerably.

So the first time a request comes in the package will save the response before sending it to the users. When the same request comes in again we're not going through the entire application but just respond with the saved response.

Are you a visual learner? Then watch this video that covers how you can use laravel-responsecache and how it works under the hood.

Support us

We invest a lot of resources into creating best in class open source packages. You can support us by buying one of our paid products.

We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on our contact page. We publish all received postcards on our virtual postcard wall.

Installation

If you're using PHP 7, install v6.x of this package.

You can install the package via composer:

composer require spatie/laravel-responsecache

The package will automatically register itself.

You can publish the config file with:

php artisan vendor:publish --provider="Spatie\ResponseCache\ResponseCacheServiceProvider"

This is the contents of the published config file:

// config/responsecache.php

return [
    /*
     * Determine if the response cache middleware should be enabled.
     */
    'enabled' => env('RESPONSE_CACHE_ENABLED', true),

    /*
     *  The given class will determinate if a request should be cached. The
     *  default class will cache all successful GET-requests.
     *
     *  You can provide your own class given that it implements the
     *  CacheProfile interface.
     */
    'cache_profile' => Spatie\ResponseCache\CacheProfiles\CacheAllSuccessfulGetRequests::class,

    /*
     * When using the default CacheRequestFilter this setting controls the
     * default number of seconds responses must be cached.
     */
    'cache_lifetime_in_seconds' => env('RESPONSE_CACHE_LIFETIME', 60 * 60 * 24 * 7),

    /*
     * This setting determines if a http header named with the cache time
     * should be added to a cached response. This can be handy when
     * debugging.
     */
    'add_cache_time_header' => env('APP_DEBUG', true),

    /*
     * This setting determines the name of the http header that contains
     * the time at which the response was cached
     */
    'cache_time_header_name' => env('RESPONSE_CACHE_HEADER_NAME', 'laravel-responsecache'),

    /*
     * Here you may define the cache store that should be used to store
     * requests. This can be the name of any store that is
     * configured in app/config/cache.php
     */
    'cache_store' => env('RESPONSE_CACHE_DRIVER', 'file'),

    /*
     * Here you may define replacers that dynamically replace content from the response.
     * Each replacer must implement the Replacer interface.
     */
    'replacers' => [
        \Spatie\ResponseCache\Replacers\CsrfTokenReplacer::class,
    ],

    /*
     * If the cache driver you configured supports tags, you may specify a tag name
     * here. All responses will be tagged. When clearing the responsecache only
     * items with that tag will be flushed.
     *
     * You may use a string or an array here.
     */
    'cache_tag' => '',

    /*
     * This class is responsible for generating a hash for a request. This hash
     * is used as a key to look up a cached response.
     */
    'hasher' => \Spatie\ResponseCache\Hasher\DefaultHasher::class,

    /*
     * This class serializes cache data and expands it.
     * Serialization can save the data to be returned in an appropriate form.
     */
    'serializer' => \Spatie\ResponseCache\Serializer\DefaultSerializer::class,
];

And finally you should install the provided middlewares \Spatie\ResponseCache\Middlewares\CacheResponse::class and \Spatie\ResponseCache\Middlewares\DoNotCacheResponse in the http kernel.

// app/Http/Kernel.php

...

protected $middlewareGroups = [
   'web' => [
       ...
       \Spatie\ResponseCache\Middlewares\CacheResponse::class,
   ],

...

protected $routeMiddleware = [
   ...
   'doNotCacheResponse' => \Spatie\ResponseCache\Middlewares\DoNotCacheResponse::class,
];

Usage

Basic usage

By default, the package will cache all successful get-requests for a week. Logged in users will each have their own separate cache. If this behaviour is what you need, you're done: installing the ResponseCacheServerProvider was enough.

Clearing the cache

Manually

The entire cache can be cleared with:

ResponseCache::clear();

This will clear everything from the cache store specified in the config-file.

Using a console command

The same can be accomplished by issuing this artisan command:

php artisan responsecache:clear

Using model events

You can leverage model events to clear the cache whenever a model is saved or deleted. Here's an example.

namespace App\Traits;

use Spatie\ResponseCache\Facades\ResponseCache;

trait ClearsResponseCache
{
    public static function bootClearsResponseCache()
    {
        self::created(function () {
            ResponseCache::clear();
        });

        self::updated(function () {
            ResponseCache::clear();
        });

        self::deleted(function () {
            ResponseCache::clear();
        });
    }
}

Forget one or several specific URI(s)

You can forget specific URIs with:

// Forget one URI
ResponseCache::forget('/some-uri');

// Forget several URIs
ResponseCache::forget(['/some-uri', '/other-uri']);

// Alternatively
ResponseCache::forget('/some-uri', '/other-uri');

The forget method only works when you're not using a cacheNameSuffix in your cache profile.

Preventing a request from being cached

Requests can be ignored by using the doNotCacheResponse-middleware. This middleware can be assigned to routes and controllers.

Using the middleware are route could be exempt from being cached.

// app/Http/routes.php

Route::get('/auth/logout', ['middleware' => 'doNotCacheResponse', 'uses' => 'AuthController@getLogout']);

Alternatively, you can add the middleware to a controller:

class UserController extends Controller
{
    public function __construct()
    {
        $this->middleware('doNotCacheResponse', ['only' => ['fooAction', 'barAction']]);
    }
}

Creating a custom cache profile

To determine which requests should be cached, and for how long, a cache profile class is used. The default class that handles these questions is Spatie\ResponseCache\CacheProfiles\CacheAllSuccessfulGetRequests.

You can create your own cache profile class by implementing the Spatie\ResponseCache\CacheProfiles\CacheProfile-interface. Let's take a look at the interface:

interface CacheProfile
{
    /*
     * Determine if the response cache middleware should be enabled.
     */
    public function enabled(Request $request): bool;

    /*
     * Determine if the given request should be cached.
     */
    public function shouldCacheRequest(Request $request): bool;

    /*
     * Determine if the given response should be cached.
     */
    public function shouldCacheResponse(Response $response): bool;

    /*
     * Return the time when the cache must be invalidated.
     */
    public function cacheRequestUntil(Request $request): DateTime;

    /**
     * Return a string to differentiate this request from others.
     *
     * For example: if you want a different cache per user you could return the id of
     * the logged in user.
     *
     * @param \Illuminate\Http\Request $request
     *
     * @return mixed
     */
    public function useCacheNameSuffix(Request $request);
}

Caching specific routes

Instead of registering the cacheResponse middleware globally, you can also register it as route middleware.

protected $routeMiddleware = [
   ...
   'cacheResponse' => \Spatie\ResponseCache\Middlewares\CacheResponse::class,
];

When using the route middleware you can specify the number of seconds these routes should be cached:

// cache this route for 5 minutes
Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:300');

// cache all these routes for 10 minutes
Route::group(function() {
   Route::get('/another-special-snowflake', 'AnotherSnowflakeController@index');

   Route::get('/yet-another-special-snowflake', 'YetAnotherSnowflakeController@index');
})->middleware('cacheResponse:600');

Using tags

If the cache driver you configured supports tags, you can specify a list of tags when applying the middleware.

// add a "foo" tag to this route with a 300 second lifetime
Route::get('/test1', 'SnowflakeController@index')->middleware('cacheResponse:300,foo');

// add a "bar" tag to this route
Route::get('/test2', 'SnowflakeController@index')->middleware('cacheResponse:bar');

// add both "foo" and "bar" tags to these routes
Route::group(function() {
   Route::get('/test3', 'AnotherSnowflakeController@index');

   Route::get('/test4', 'YetAnotherSnowflakeController@index');
})->middleware('cacheResponse:foo,bar');

Clearing tagged content

You can clear responses which are assigned a tag or list of tags. For example, this statement would remove the '/test3' and '/test4' routes above:

ResponseCache::clear(['foo', 'bar']);

In contrast, this statement would remove only the '/test2' route:

ResponseCache::clear(['bar']);

Note that this uses Laravel's built in cache tags functionality, meaning routes can also be cleared in the usual way:

Cache::tags('special')->flush();

Events

There are several events you can use to monitor and debug response caching in your application.

ResponseCacheHit

Spatie\ResponseCache\Events\ResponseCacheHit

This event is fired when a request passes through the ResponseCache middleware and a cached response was found and returned.

CacheMissed

Spatie\ResponseCache\Events\CacheMissed

This event is fired when a request passes through the ResponseCache middleware but no cached response was found or returned.

ClearingResponseCache and ClearedResponseCache

Spatie\ResponseCache\Events\ClearingResponseCache

Spatie\ResponseCache\Events\ClearedResponseCache

These events are fired respectively when the responsecache:clear is started and finished.

Creating a Replacer

To replace cached content by dynamic content, you can create a replacer. By default we add a CsrfTokenReplacer in the config file.

You can create your own replacers by implementing the Spatie\ResponseCache\Replacers\Replacer-interface. Let's take a look at the interface:

interface Replacer
{
    /*
     * Prepare the initial response before it gets cached.
     *
     * For example: replace a generated csrf_token by '<csrf-token-here>' that you can
     * replace with its dynamic counterpart when the cached response is returned.
     */
    public function prepareResponseToCache(Response $response): void;

    /*
     * Replace any data you want in the cached response before it gets
     * sent to the browser.
     *
     * For example: replace '<csrf-token-here>' by a call to csrf_token()
     */
    public function replaceInCachedResponse(Response $response): void;
}

Afterwards you can define your replacer in the responsecache.php config file:

/*
 * Here you may define replacers that dynamically replace content from the response.
 * Each replacer must implement the Replacer interface.
 */
'replacers' => [
    \Spatie\ResponseCache\Replacers\CsrfTokenReplacer::class,
],

Customizing the serializer

A serializer is responsible from serializing a response so it can be stored in the cache. It is also responsible for rebuilding the response from the cache.

The default serializer Spatie\ResponseCache\Serializer\DefaultSerializer will just work in most cases.

If you have some special serialization needs you can specify a custom serializer in the serializer key of the config file. Any class that implements Spatie\ResponseCache\Serializers\Serializer can be used. This is how that interface looks like:

namespace Spatie\ResponseCache\Serializers;

use Symfony\Component\HttpFoundation\Response;

interface Serializer
{
    public function serialize(Response $response): string;

    public function unserialize(string $serializedResponse): Response;
}

Testing

You can run the tests with:

composer test

Alternatives

Changelog

Please see CHANGELOG for more information what has changed recently.

Contributing

Please see CONTRIBUTING for details.

Security

If you discover any security related issues, please email [email protected] instead of using the issue tracker.

Credits

And a special thanks to Caneco for the logo

License

The MIT License (MIT). Please see License File for more information.

Comments
  • Add cache bypass header

    Add cache bypass header

    👋 hi!

    What do you think of adding a way of bypassing the cache?

    Our use case is that we want to monitor the performance of parts of our app, and we want to get data for both cached and non cached responses. We'd actually add this header in Oh Dear.

    I was working on adding this functionality to our custom ResponseCacheProfile and wondered if others might find it useful too.

    opened by fgilio 8
  • feat: cache url tagging

    feat: cache url tagging

    I needed this functionality for one of my applications, so I've re-implemented the suggestion in #159 with the feedback in #211

    I've fixed a couple of issues flagged in the last PR, switched the tests to use the array cache driver (which supports tagging and removes the redis requirement).

    Thanks to jpnut for the tests :D

    opened by atymic 8
  • Refresh csrf token on cached responses

    Refresh csrf token on cached responses

    Hi spatie,

    as I am regularly using your open source efforts and want to contribute to open source, too, I may have figured out a way to refresh csrf tokens on cached responses. Inspired by the blogpost https://christoph-rumpel.com/2018/03/laravel-response-caching-and-csp by @christophrumpel, I found a way to update the token.

    One requirement though: It works only on the blade views, as the token has to be set as a meta tag within the html header like this:

    <meta name="csrf-token" content="{{ csrf_token() }}">

    This allows the CacheResponse-Middleware to get the cached csrf_token with Regex and replace all of its appearances in the cached html with a fresh one. But maybe there is a better and more robust solution to that.

    I've added a simple test to verify that feature.

    Hopefully this is fine like that, but if I did not meet your standards, please let me know, so I can maybe improve it or at least may know, what I could have done better.

    Cheers,

    Chris

    next major version 
    opened by addorange 7
  • add special handling for file responses, fixes #66

    add special handling for file responses, fixes #66

    Add a check if the response to serialize is an instance of BinaryFileResponse. If true the type will be set accordingly.

    On unserialize the response object will be created based on the given type. Default value for $type is set to RESPONSE_TYPE_NORMAL.

    opened by fetzi 4
  • Catch CouldNotUnserialize exception and continue returning a response

    Catch CouldNotUnserialize exception and continue returning a response

    • Removes hasBeenCached which adds an extra unnecessary hit on the cache.
    • Catches CouldNotUnserialize and logs it, instead of throwing to the User and continues with an uncached response.

    Reference issue #342

    opened by roberttolton 3
  • Support datetime modifier syntax for cache lifetime

    Support datetime modifier syntax for cache lifetime

    Closes #267

    This PR adds a new syntax for cache lifetime:

    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:5mins');
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:2hours');
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:1week');
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:tomorrow');
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:noon');
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:midnight');
    // and even
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:last day of this month');
    Route::get('/my-special-snowflake', 'SnowflakeController@index')->middleware('cacheResponse:first monday of January 2020');
    

    UPDATE1: I see a problem: it's possible to omit lifetime option and use multiple tags:

    ->middleware('cacheResponse:foo,bar')
    

    Currently I don't know a good backward compatible solution.


    UPDATE2: Currently I think that the best option it to use \Illuminate\Http\Middleware\SetCacheHeaders- like syntax for options:

    // \Illuminate\Http\Middleware\SetCacheHeaders usage example:
    Route::get('/', HomeController::class)->middleware('cache.headers:no-cache;max-age=300;etag');
    
    // CacheResponse usage example:
    Route::get('/', HomeController::class)->middleware('responseCache:ttl=1hour;tags=foo,bar');
    

    But it's BC (unless someone wants to write a good options parser and support it). I think we can implement it as a new middleware in addition to exiting 2 and deprecate existing CacheResponse and remove it in next major release.

    Another feature that we can implement using this syntax: specify profile as another option:

    // use default profile:
    Route::get('/', HomeController::class)->middleware('responseCache:ttl=1hour;tags=foo&bar');
    
    // specify profile explicitly:
    Route::get('/', HomeController::class)->middleware('responseCache:ttl=1hour;tags=foo&bar;profile=guests-only');
    

    The only problem is usage of , as delimiter for tags: we need to replace it by something else in order to don't break middleware params parsing by Laravel. Possible options:

    • &
    • |
    • +
    • (fullwidth comma) 👎 Could you please provide some feedback on proposed syntax and feature so I will implement it only if we'll merge it. Thanks a lot!
    opened by lptn 3
  • Added CacheAutoUpdater trait for use in eloquent models

    Added CacheAutoUpdater trait for use in eloquent models

    Scenario: I installed this excellent package on a client's website where he writes on his blog. A day later he calls me because he created a new post and it is not displayed on his blog, nor on the home page (latest post widget).

    Solution: hook the eloquent events to empty the cache every time the client create, update or delete a post.

    P.S: do I need to write some test? it's just an implementation of eloquent bootable traits capabilities. If you think the CacheAutoUpdater name it does not match with the package API just help me with a better name suggestion.

    opened by emilianotisato 3
  • Add replacers to inject dynamic content

    Add replacers to inject dynamic content

    This PR introduces the following things:

    • A new replacers function on the CacheProfile interface
    • Replacers will be called before caching a page
    • After returning a cached response, the replacer will be called again and the old value will be replaced with the new value
    • The BaseCacheProfile implements this for the csrf_token
    • Updates the docs

    Breaking change because the interface has changed.

    opened by riasvdv 3
  • Included host for creating request hash

    Included host for creating request hash

    I have a project running on multiple domains per locale. This fixes the incorrect caching for such cases. For instance, example.org/u/1 and de.example.org/u/1 should be cached separately.

    opened by iSerter 3
  • Option to use cache store tags

    Option to use cache store tags

    If store_tags option is present, response cache will try to use tags. Of course driver must support tags and by default it is null.

    To avoid configuring used cache twice (setting store, and selected tags) I injected ResponseCacheRepository using method injection of the Flush command.

    opened by dam1r89 3
  • Dispatch clear events when using facade

    Dispatch clear events when using facade

    Hello folks!

    First of all, thank you all for creating this package.

    Currently, I'm working in a application that uses the Spatie\ResponseCache\Facades\ResponseCache@clear to clear the response cache, and I need perform some work when the cache is cleared. At the moment, the Spatie\ResponseCache\Events\ClearedResponseCache and Spatie\ResponseCache\Events\ClearingResponseCache events are dispatched only when clearing the cache using the responsecache:clear artisan command, so I can't listen to this events when using the package facade.

    This PR adds this two events to the clear method in Spatie\ResponseCache\ResponseCache class.

    PS.: I want to add tests but I'm not sure in which Test I'd do it.

    opened by mateusjunges 2
Releases(7.4.4)
  • 7.4.4(Nov 25, 2022)

    What's Changed

    • Refactor tests to pest by @AyoobMH in https://github.com/spatie/laravel-responsecache/pull/418
    • Add PHP 8.2 Support to tests workflow by @patinthehat in https://github.com/spatie/laravel-responsecache/pull/421
    • Add Dependabot Automation by @patinthehat in https://github.com/spatie/laravel-responsecache/pull/420
    • Bump actions/checkout from 2 to 3 by @dependabot in https://github.com/spatie/laravel-responsecache/pull/423
    • Bump stefanzweifel/git-auto-commit-action from 2.3.0 to 4.15.4 by @dependabot in https://github.com/spatie/laravel-responsecache/pull/422
    • Catch CouldNotUnserialize exception and continue returning a response by @roberttolton in https://github.com/spatie/laravel-responsecache/pull/408

    New Contributors

    • @AyoobMH made their first contribution in https://github.com/spatie/laravel-responsecache/pull/418
    • @dependabot made their first contribution in https://github.com/spatie/laravel-responsecache/pull/423
    • @roberttolton made their first contribution in https://github.com/spatie/laravel-responsecache/pull/408

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.4.3...7.4.4

    Source code(tar.gz)
    Source code(zip)
  • 7.4.3(Sep 24, 2022)

    What's Changed

    • Dispatch clear events when using facade by @mateusjunges in https://github.com/spatie/laravel-responsecache/pull/413

    New Contributors

    • @mateusjunges made their first contribution in https://github.com/spatie/laravel-responsecache/pull/413

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.4.2...7.4.3

    Source code(tar.gz)
    Source code(zip)
  • 7.4.2(Sep 2, 2022)

    What's Changed

    • Always prepend app url to requests by @apeisa in https://github.com/spatie/laravel-responsecache/pull/409

    New Contributors

    • @apeisa made their first contribution in https://github.com/spatie/laravel-responsecache/pull/409

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.4.1...7.4.2

    Source code(tar.gz)
    Source code(zip)
  • 7.4.1(Aug 9, 2022)

    What's Changed

    • Cache bypass header now also prevents an already cached response from being returned by @fgilio in https://github.com/spatie/laravel-responsecache/pull/407

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.4.0...7.4.1

    Source code(tar.gz)
    Source code(zip)
  • 7.4.0(Aug 1, 2022)

    What's Changed

    • Add cache bypass header by @fgilio in https://github.com/spatie/laravel-responsecache/pull/406

    New Contributors

    • @fgilio made their first contribution in https://github.com/spatie/laravel-responsecache/pull/406

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.3.1...7.4.0

    Source code(tar.gz)
    Source code(zip)
  • 7.3.1(May 30, 2022)

    What's Changed

    • Handle missed cache gracefully by @antennaio in https://github.com/spatie/laravel-responsecache/pull/383

    New Contributors

    • @antennaio made their first contribution in https://github.com/spatie/laravel-responsecache/pull/383

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.3.0...7.3.1

    Source code(tar.gz)
    Source code(zip)
  • 7.3.0(May 16, 2022)

    What's Changed

    • Add option to output cache age header by @it-can in https://github.com/spatie/laravel-responsecache/pull/385

    New Contributors

    • @it-can made their first contribution in https://github.com/spatie/laravel-responsecache/pull/385

    Full Changelog: https://github.com/spatie/laravel-responsecache/compare/7.2.0...7.3.0

    Source code(tar.gz)
    Source code(zip)
  • 7.2.0(Jan 13, 2022)

  • 7.1.0(Apr 27, 2021)

  • 7.0.1(Apr 13, 2021)

  • 7.0.0(Apr 2, 2021)

  • 6.6.9(Mar 30, 2021)

  • 6.6.8(Jan 25, 2021)

  • 6.6.7(Nov 28, 2020)

  • 6.6.5(Sep 22, 2020)

  • 6.6.3(Aug 22, 2020)

  • 6.6.2(Jun 3, 2020)

  • 6.6.1(Apr 22, 2020)

  • 6.2.1(Mar 6, 2020)

  • 6.6.0(Mar 2, 2020)

  • 6.5.0(Mar 2, 2020)

  • 6.4.0(Dec 1, 2019)

  • 6.1.1(Aug 7, 2019)

  • 6.0.1(Jul 9, 2019)

  • 6.0.0(May 20, 2019)

    • added support for replacers
    • you can now swap out RequestHasher in favour of a custom one
    • CacheAllSuccessfulGetRequests will only cache responses of which the content type starts with text
    • removed deprecated Flush command
    • \Spatie\ResponseCache\ResponseCacheFacade has been removed
    • dropped support for carbon v1
    • dropped support for PHP 7.2
    Source code(tar.gz)
    Source code(zip)
Owner
Spatie
Webdesign agency based in Antwerp, Belgium
Spatie
Caching extension for the Intervention Image Class

Intervention Image Cache Intervention Image Cache extends the Intervention Image Class package to be capable of image caching functionality. The libra

null 616 Dec 30, 2022
A simple HTML minifier for Laravel 5, 6 & 7.

Laravel HTMLMin Laravel HTMLMin is currently maintained by Raza Mehdi, and is a simple HTML minifier for Laravel. It utilises Mr Clay's Minify package

null 1k Jan 4, 2023
A minimal package to help you make your laravel application cleaner and faster.

Laravel Widgetize ?? ?? "cleaner code" ➕ "easy caching" ?? ?? Built with ❤️ for every smart laravel developer ?? Introduction What is a widget object

Iman 883 Dec 28, 2022
Stash makes it easy to speed up your code by caching the results of expensive functions or code

Stash - A PHP Caching Library Stash makes it easy to speed up your code by caching the results of expensive functions or code. Certain actions, like d

Tedious Developments 943 Dec 15, 2022
[READ-ONLY] Easy to use Caching library with support for multiple caching backends. This repo is a split of the main code that can be found in https://github.com/cakephp/cakephp

CakePHP Caching Library The Cache library provides a Cache service locator for interfacing with multiple caching backends using a simple to use interf

CakePHP 49 Sep 28, 2022
Caching implementation with a variety of storage options, as well as codified caching strategies for callbacks, classes, and output

laminas-cache Laminas\Cache provides a general cache system for PHP. The Laminas\Cache component is able to cache different patterns (class, object, o

Laminas Project 69 Jan 7, 2023
This Magento extension provides a Real Full Page Caching for Magento powered by Varnish with support of Session-Based information caching (Cart, Customer Accounts, ...) via ESI includes

This Magento extension provides a Real Full Page Caching (FPC) for Magento powered by Varnish with support of Session-Based information caching (Cart, Customer Accounts, ...) via ESI includes

Hugues Alary 95 Feb 11, 2022
pedre-response is a standard structure of json response

PedreResponse It's very important to use same structure for responses in large projects that PedreResponse package can do it for you. PedreResponse is

Pedram Rezaei 2 Dec 22, 2021
PHP Simple Response, XML, JSON,... auto response with accept in request's header

simple-response Simple package to handle response properly in your API. This package does not include any dependency. Install Via Composer $ composer

Phuong Danh 3 Dec 8, 2021
Snuffleupagus is a PHP 7+ and 8+ module designed to drastically raise the cost of attacks against websites, by killing entire bug classes

Snuffleupagus is a PHP 7+ and 8+ module designed to drastically raise the cost of attacks against websites, by killing entire bug classes

Julien Voisin 625 Jan 3, 2023
This app is to measure the hand and eye co-ordination speed based on the score generated taken from Database

CoOrdinationSpeedTest Website link: https://skyward-punctures.000webhostapp.com/ Try this only when you are a psychiatrist ?? ?? This app runs as php

MANOJKUMAAR GOWDA 1 Jan 12, 2022
Easily capture every incoming request and the corresponding outgoing response in your Laravel app.

Easily capture every incoming request and the corresponding outgoing response in your Laravel app. This package is designed to work only with the Lara

Mark Townsend 22 Nov 15, 2022
Rapidly speed up your Laravel workflow with generators

Fast Workflow in Laravel With Custom Generators This Laravel package provides a variety of generators to speed up your development process. These gene

Jeffrey Way 22 Oct 28, 2022
Laracademy Generators - is a tool set that helps speed up the development process of a Laravel application.

Laracademy Generators Laracademy Generators - is a tool set that helps speed up the development process of a Laravel application. Author(s): Laracadem

Laracademy 320 Dec 24, 2022
A Laravel package to speed up deployment by skipping asset compilation whenever possible.

Airdrop for Laravel Read the full docs at hammerstone.dev/airdrop/docs. Hammerstone Airdrop for Laravel is a package that speeds up your deploys by sk

Hammerstone 160 Nov 24, 2022
This package provides a high performance HTTP server to speed up your Laravel/Lumen application based on Swoole.

This package provides a high performance HTTP server to speed up your Laravel/Lumen application based on Swoole.

Swoole Taiwan 3.9k Jan 8, 2023
Run laravel with workman ,1 artisan command, 10x speed up

Laraman Run laravel with workman , 1 artisan command, 10x speed up Installation Via Composer # install package composer require itinysun/laraman # i

null 13 Jun 3, 2023
`phplint` is a tool that can speed up linting of php files by running several lint processes at once.

`phplint` is a tool that can speed up linting of php files by running several lint processes at once.

安正超 887 Dec 30, 2022
Flysystem storage with local metadata storage for speed and manageability.

Laravel Filer This project was started to scratch my itch on our growing Laravel site: Metadata for all files is stored in a local repository - Suppor

Nick Vahalik 16 May 23, 2022