Support for tags in cache interface

[kristos80]

First of all a big "thank you" to all code contributors.

Until recently I was using https://github.com/clue/reactphp-redis in order to create key value pairs in my application which was more than enough.

At some point I needed to implement a more sophisticated invalidation strategy for those keys (eg invalidate all database results from the same table if something is created/updated) which had as a result to go by https://github.com/WyriHaximus/reactphp-cache-redis which implements the https://github.com/reactphp/cache interface, but to my surprise I found out that tags are not supported.

I am not implying that support for tags is something trivial and easy to implement --especially in an asynchronous environment--, but it would be a really great feature.

Thanks again for all the effort you have put in this great project.

[WyriHaximus]

Hey @kristos80,

It is always great to hear someone using your packages. Had a quick look and I assume this is about Redis tags mentioned here, correct? https://redis.io/docs/stack/search/reference/tags/

Honestly, this sounds like a great feature to add, and I gladly add it to my packages. From a users POV how would you use this?

[kristos80]

Hi @WyriHaximus,

Thanks for getting back and believe me I cannot stretch enough how reactphp has helped me the last months with my project (I'll come back when I am done with a use case on how we are using reactphp to migrate a system from node.js to php).

About the feature, now. No, I am talking about Redis tags --in fact I didn't know about it until now--, but rather for a tagging system for invalidating cache items like PHP-Cache does: https://www.php-cache.com/en/latest/#tagging

For example the key react:cache:query-result-from-table-user-where-id-eq-1 is tagged with 2 tags: generic-query-result, table-user-query-result and the same goes for key react:cache:query-result-from-table-user-where-id-eq-2. I guess the key names are self-explanatory :)

Now, imagine that I've just updated the table users and I want to invalidate all keys that are associated (tagged) with that table, while leaving all other keys untacked. I need to instruct the cache pool to invalidate only the keys tagged under table-user-query-result.

So the cache pool would search for all the keys associated with that tag and delete them in its usual way.

In PHP-Cache the tagging doesn't happen in the set method (which seems unnatural for me tbh), but rather you have to declare a cache item, set its tags, ttl, etc and then save it to the pool:

$item = $pool->getItem('tobias');
$item->set('value')->setTags(['tag0', 'tag1'])
$pool->save($item);

In my project I have created a thin wrapper for your cache and have a set method as such: public function set(string $key, string $value, int $ttl = 3600, array $tags = []) where internally I call your set and at the same time I push to a redis list named after the tag the key that I've just set:

$this->redisCache->set($key, $value, $ttl);
foreach ($tags as $tag) {
  // Here tag can be normalized in order to avoid conflicts with other key names
  $this->redisClient->rpush($tag, $key);
}

In my wrapper I have a method as such:

public function invalidateTags(array $tags): void {
  foreach ($tags as $tag) {
	  $listLength = (int) \React\Async\await($this->redisClient->llen($tag));
	  if (! $listLength) {
		  continue;
	  }
  
	  $index = 0;
	  while($index < $listLength) {
		  $key = \React\Async\await($this->redisClient->lpop($tag));
		  $this->redisCache->delete($key);
		  $index++;
	  }
  
	  $this->redisClient->del($tag);
  }
}

I am not sure if that's an elegant or even a robust solution, but for now this is how I solve this need of mine, while being able if you update your library with a tagging system to adapt easily.

Thanks again for your time!

[SimonFrings]

Hey @kristos80, I agree this is a great feature idea and thanks for taking the time to properly address this 👍

Personally I'm not that familiar with cache tags, but I can see this being helpful to mark certain data items and quickly invalidate them via tags.

We're currently moving towards ReactPHP v3 and also released our plans for the Cache component in our roadmap ticket . We don't have specific plans yet to add tag support to our Cache component, we first want to focus on the most important features to make the jump from a v1 to a v3. I'm also interested if it makes sense to add this in Cache v3 (as the supported range of PHP versions doesn't include PHP 5 anymore, thus maybe less workarounds) or in the current v1 as well.

If you already have an idea for an implementation, we're also happy about pull requests. When contributing a new feature like this, it's important for us is that the pull request should not only focus on the implementation side of things, which is most often the "easy" part. We also have to make sure that any new additions are also covered by our test suite (unit tests) to confirm the suggested changes work as expected and it needs additional documentation on how to properly use it.