revalidateTag causing 'use cache' not to work with redis

[ChristianThingKnudsen]

Package

@mrjasonroy/cache-components-cache-handler

Package Version

16.1.6

Next.js Version

16.1.6

Bug Description

I have been using your plugin with redis in sentinel mode.

The function was cached the first many times and also fetched new data when data had to be revalidated. However, after the branches tag has been revalidated using: revalidateTag("branches", "max") it would never cache the function again.

In the logs i could see it ended up in the case:
log?.("get", cacheKey, "had expired tag", tag);

I managed to fix it by overwrite the get function and replacing this bit from redis.ts:

  // Check tag expiration
  let revalidate = entry.revalidate;
  for (const tag of entry.tags) {
    const tagData = await redis.hGetAll(getTagKey(tag));
  
    if (tagData.expired) {
      const expired = Number.parseInt(tagData.expired, 10);
      if (expired > entry.timestamp) {
        log?.("get", cacheKey, "had expired tag", tag);
        await redis.del(key);
        return undefined;
      }
    }
  
    if (tagData.stale) {
      const stale = Number.parseInt(tagData.stale, 10);
      if (stale > entry.timestamp) {
        log?.("get", cacheKey, "had stale tag", tag);
        revalidate = -1;
      }
    }
  }

With:

   // Check tag expiration
  let revalidate = entry.revalidate;
  for (const tag of entry.tags) {
      const tagData = await redisAdapter.hGetAll(getTagKey(tag));

      // Determine the revalidation timestamp.
      // revalidateTag('tag', 'max') sets both stale=now and expired=now+huge
      // revalidateTag('tag') sets only expired=now
      // Use stale when present (it's always the actual revalidation time when using 'max').
      // Fall back to expired only when stale is absent (immediate expiration).
      const revalidatedAt = tagData.stale
          ? Number.parseInt(tagData.stale, 10)
          : tagData.expired
            ? Number.parseInt(tagData.expired, 10)
            : 0;

      if (revalidatedAt && revalidatedAt > entry.timestamp) {
          log?.('get', cacheKey, 'tag revalidated after entry was cached', tag, {
              revalidatedAt,
              entryTimestamp: entry.timestamp
          });
          await redisAdapter.del(key);
          return undefined;
      }
  }

Steps to Reproduce

Create a function similar to:

const tagsBranches: string = ["branches", "data", "all"]
export const getBranches = async (searchTerm: string | undefined = undefined): Promise<BranchListResponse> => {
    'use cache';
    cacheLife("branches");
    cacheTag(...tagsBranches);

    const rand = Math.random().toString(36).substring(2, 8);
    console.log("rand:", rand);

};

Call revalidateTag("branches", "max")

See if the function with 'use cache' is cached when called multiple times.

Expected Behavior

After revalidate revalidateTag("branches", "max");

I do not expect my function with 'use cache' to be cached the first time, but on the second and third time, I do.

Actual Behavior

'use cache' functions does not work after revalidate tag

Error Logs

Configuration

Environment

Development (next dev)

Additional Context

No response

[bholly24]

I'm working on this @ChristianThingKnudsen when you implemented your fix locally, did you see any issues with other tests? I tried to create a unit test that recreates the behavior. Does this seem about right?

  test("re-caches correctly after revalidateTag with durations and multiple tags (fixes #32)", async () => {
    const redis = new FakeRedis();
    const handler = createRedisDataCacheHandler({ redis });

    // Entry has multiple tags, mirroring: cacheTag("branches", "data", "all")
    const original = createEntry("original", {
      tags: ["branches", "data", "all"],
      timestamp: BASE_TIME.getTime(),
      expire: 3600,
      revalidate: 1800,
    });
    await handler.set("branches-key", Promise.resolve(original));

    // revalidateTag("branches", "max") — only one of the three tags is invalidated
    vi.setSystemTime(new Date(BASE_TIME.getTime() + 5_000));
    await handler.updateTags(["branches"], { expire: 31_536_000 }); // 1 year

    // First get: old entry predates the revalidation → cache miss
    const miss = await handler.get("branches-key", []);
    expect(miss).toBeUndefined();

    // Next.js re-renders and writes a fresh entry after the revalidation
    vi.setSystemTime(new Date(BASE_TIME.getTime() + 6_000));
    const fresh = createEntry("fresh", {
      tags: ["branches", "data", "all"],
      timestamp: BASE_TIME.getTime() + 6_000,
      expire: 3600,
      revalidate: 1800,
    });
    await handler.set("branches-key", Promise.resolve(fresh));

    // Second call: fresh entry was cached after revalidation → must be a hit
    const hit1 = await handler.get("branches-key", []);
    expect(hit1).toBeDefined();
    expect(await readStream(hit1!.value)).toBe("fresh");

    // Third call: cache must continue to hit, not regress to a miss
    const hit2 = await handler.get("branches-key", []);
    expect(hit2).toBeDefined();
    expect(await readStream(hit2!.value)).toBe("fresh");
  });

[ChristianThingKnudsen]

Hey @bholly24. Yeah it seems about right. However The test donesn't reflect the SWR but might be okay as it can be hard to control when it calls after marked as stalled.

I didn't check the tests, as what I did was to override the get function with a modified version of yours. I did some slight changes to the above after posting it. Here is the full get function I have now:

async get(cacheKey, _softTags) {
                const key = getCacheKey(cacheKey);
                try {
                    const data = await redisAdapter.get(key);
                    if (!data) {
                        log?.('get', cacheKey, 'not found');
                        return undefined;
                    }

                    const entry = deserializeEntry(JSON.parse(data));
                    const now = Date.now();

                    // Tag-based: hard delete (explicit invalidation → fresh data immediately)
                    for (const tag of entry.tags) {
                        const tagData = await redisAdapter.hGetAll(getTagKey(tag));

                        // Determine the revalidation timestamp.
                        // revalidateTag('tag', 'max') sets both stale=now and expired=now+huge
                        // revalidateTag('tag') sets only expired=now
                        // Use stale when present (it's always the actual revalidation time when using 'max').
                        // Fall back to expired only when stale is absent (immediate expiration).
                        const revalidatedAt = tagData.stale
                            ? Number.parseInt(tagData.stale, 10)
                            : tagData.expired
                              ? Number.parseInt(tagData.expired, 10)
                              : 0;

                        if (revalidatedAt && revalidatedAt > entry.timestamp) {
                            log?.('get', cacheKey, 'tag revalidated after entry was cached', tag, {
                                revalidatedAt,
                                entryTimestamp: entry.timestamp
                            });
                            await redisAdapter.del(key);
                            return undefined;
                        }
                    }

                    // Time-based: serve stale, trigger background regeneration (SWR)
                    const revalidate = now > entry.timestamp + entry.revalidate * 1000 ? -1 : entry.revalidate;

                    const [returnStream, newSaved] = entry.value.tee();
                    entry.value = newSaved;

                    if (revalidate === -1) {
                        log?.('get', cacheKey, 'past revalidate window — serving stale');
                    } else {
                        log?.('get', cacheKey, 'found', {
                            tags: entry.tags,
                            timestamp: entry.timestamp,
                            revalidate
                        });
                    }

                    return { ...entry, revalidate, value: returnStream };
                } catch (error) {
                    log?.('get', cacheKey, 'error', error);
                    return undefined;
                }
            }

It seems to be working for me with this function. But maybe your tests says otherwise 😅