Tag based invalidation

[cupofjoakim]

Picking up from #120. That was on the old cache-manager and closed without anything landing. The rewrite has hooks and L1/L2 now, which I think gets around Bryan's "not generic enough" concern.

Use case is content caches: one upstream entity referenced by many cache entries, need to purge all of them when it changes. Right now that means walking the dependency graph or maintaining a Redis SET by hand. Same thing Symfony's TagAwareAdapter and Next.js revalidateTag do.

await cache.set(key, value, {tags: ['entity:42']})
await cache.invalidateTag('entity:42')

The BEFORE_SET / AFTER_SET hooks look like the right spot. Tag index can just be cache entries under a reserved prefix, no adapter changes. Would need to clear both primary and secondary, and probably go through sync for multi-instance.

Happy to PR if you're up for it.

[jaredwray]

@cupofjoakim - I like the idea behind this where we build in a tag service into cacheable that if you tag a key we then keep an object in the KV store such as tag_entity:42 that lists all the keys. I don't know if I would do it on cache-manager first as that code is a bit more complex. Here are my initial thoughts:

Something like this...

await cache.set('page:/products', html, {
  ttl: '10m',
  tags: ['entity:42', 'collection:products'],
});

await cache.invalidateTag('entity:42');

We will build primitives in @cacheable/utils so we can handle cacheable and cache-manager (future) off the same code base.

import { CacheTagService } from '@cacheable/utils';

const tagService = new CacheTagService({
  store: keyv,
});

await tagService.setKeyTags('page:/products', ['entity:42']);

const fresh = await tagService.isKeyFresh('page:/products');

const keys = await tagService.invalidateTag('entity:42');

the core service should look like this:

export class CacheTagService {
  constructor(options: CacheTagServiceOptions);

  setKeyTags(
    key: string,
    tags: string[],
    options?: CacheTagSetOptions,
  ): Promise<void>;

  removeKey(key: string): Promise<void>;

  isKeyFresh(key: string): Promise<boolean>;

  getKeysByTag(tag: string): Promise<string[]>;

  invalidateTag(tag: string): Promise<string[]>;

  invalidateTags(tags: string[]): Promise<string[]>;
}

thinking the keys would be something like:

--<library>--tags--:<namespace>:<tag>

// this would look like
--cacheable--tags--:default:entity:42

let me know what you think?

[cupofjoakim]

I like it! Just to clarify: with isKeyFresh in the API, invalidateTag (and plural) would do a version bump rather than eager deleteMany?

You'd know the perf tradeoffs better than me, but my read is that lazy wins: invalidate becomes O(1) INCR on the tag counter instead of O(N) scan-and-delete, at the cost of one extra isKeyFresh round-trip per get. Aggressive invalidation gets cheap and stale entries GC via TTL.

[cupofjoakim]

I realise we're on wildly different time zones so I went ahead with a proposal from how I understood your suggestion. Scope is currently very slim, happy to change that if needed.

[jaredwray]

@cupofjoakim - great. Will review tomorrow