@trieb.work/nextjs-turbo-redis-cache 1.15.0 → 1.15.1

package/README.md

@@ -15,6 +15,8 @@ Key Features:
 
 This library offers you an easy and high performant caching solution for docker, Kubernetes or Google Cloud Run deployments of Next.js. Read more on how it originated at [TRWK> Case Study](https://trwk.de/case-studies/nextjs-turbo-redis-cache).
 
+For a deep dive into the internal architecture (shared hash maps, SyncedMap, request deduplication, and how `get`/`set`/`revalidateTag` work under the hood), see [ARCHITECTURE.md](./ARCHITECTURE.md).
+
 ## Compatibility
 
 This package is compatible with Next.js 15.0.3 and above while using App Router. It is not compatible with Next.js 14.x. or 15-canary or if you are using Pages Router.
@@ -25,10 +27,10 @@ Tested versions are:
 - Nextjs 15.0.3 + redis client 4.7.0
 - Nextjs 15.2.4 + redis client 4.7.0
 - Nextjs 15.3.2 + redis client 4.7.0
-- Nextjs 15.4.7 + redis client 4.7.0
-- Nextjs 16.0.3 + redis client 4.7.0 (cacheComponents: false)
-- Nextjs 16.2.3 + redis client 4.7.0 (cacheComponents: false)
-- Nextjs 16.2.3 + redis client 4.7.0 (cacheComponents: true)
+- Nextjs 15.4.11 + redis client 4.7.0
+- Nextjs 16.0.11 + redis client 4.7.0 (cacheComponents: false)
+- Nextjs 16.2.6 + redis client 4.7.0 (cacheComponents: false)
+- Nextjs 16.2.6 + redis client 4.7.0 (cacheComponents: true)
 
 _Cache Components_ (Next.js 16+) are fully supported. Automated test coverage includes `'use cache'`, `cacheTag`, and `cacheLife` flows in the Cache Components integration suite.
 
@@ -133,27 +135,27 @@ const nextConfig = {
 }
 ```
 
-A working example of above can be found in the `test/integration/next-app-customized` folder.
+A working example of above can be found in the `test/nextjs-test-projects/next-app-customized` folder.
 
 ## Available Options
 
-| Option                        | Description                                                                                                                                                | Default Value                                                                                                                                                                                                                |
-| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| redisUrl                      | Redis connection url                                                                                                                                       | `process.env.REDIS_URL? process.env.REDIS_URL : process.env.REDISHOST ? redis://${process.env.REDISHOST}:${process.env.REDISPORT} : 'redis://localhost:6379'`                                                                |
-| database                      | Redis database number to use. Uses DB 0 for production, DB 1 otherwise                                                                                     | `process.env.VERCEL_ENV === 'production' ? 0 : 1`                                                                                                                                                                            |
-| keyPrefix                     | Prefix added to all Redis keys                                                                                                                             | `RedisStringsHandler` default: `process.env.KEY_PREFIX \|\| process.env.VERCEL_URL \|\| 'UNDEFINED_URL_'`<br> Next handlers resolve: `options.keyPrefix \|\| KEY_PREFIX \|\| VERCEL_URL \|\| BUILD_ID \|\| 'UNDEFINED_URL_'` |
-| sharedTagsKey                 | Key used to store shared tags hash map in Redis                                                                                                            | `'__sharedTags__'`                                                                                                                                                                                                           |
-| getTimeoutMs                  | Timeout in milliseconds for time critical Redis operations. If Redis get is not fulfilled within this time, returns null to avoid blocking site rendering. | `process.env.REDIS_COMMAND_TIMEOUT_MS ? (Number.parseInt(process.env.REDIS_COMMAND_TIMEOUT_MS) ?? 500) : 500`                                                                                                                |
-| revalidateTagQuerySize        | Number of entries to query in one batch during full sync of shared tags hash map                                                                           | `250`                                                                                                                                                                                                                        |
-| avgResyncIntervalMs           | Average interval in milliseconds between tag map full re-syncs                                                                                             | `3600000` (1 hour)                                                                                                                                                                                                           |
-| redisGetDeduplication         | Enable deduplication of Redis get requests via internal in-memory cache.                                                                                   | `true`                                                                                                                                                                                                                       |
-| inMemoryCachingTime           | Time in milliseconds to cache Redis get results in memory. Set this to 0 to disable in-memory caching completely.                                          | `10000`                                                                                                                                                                                                                      |
-| defaultStaleAge               | Default stale age in seconds for cached items                                                                                                              | `1209600` (14 days)                                                                                                                                                                                                          |
-| estimateExpireAge             | Function to calculate expire age (redis TTL value) from stale age                                                                                          | Production: `staleAge * 2`<br> Other: `staleAge * 1.2`                                                                                                                                                                       |
-| socketOptions                 | Redis client socket options for TLS/SSL configuration (e.g., `{ tls: true, rejectUnauthorized: false }`)                                                   | `{ connectTimeout: timeoutMs }`                                                                                                                                                                                              |
-| clientOptions                 | Additional Redis client options (e.g., username, password)                                                                                                 | `undefined`                                                                                                                                                                                                                  |
-| killContainerOnErrorThreshold | Number of consecutive errors before the container is killed. Set to 0 to disable.                                                                          | `Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0`                                                                                                                                                    |
-| valueSerializer               | Pluggable wire-format codec for Redis string values (compression, encryption, custom encoding). See [Custom value serializer](#custom-value-serializer-compression-encryption). | `jsonCacheValueSerializer` (`JSON.stringify` with built-in `Buffer` and `Map` encoding)                                                                       |
+| Option                        | Description                                                                                                                                                                     | Default Value                                                                                                                                                                                                                |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| redisUrl                      | Redis connection url                                                                                                                                                            | `process.env.REDIS_URL? process.env.REDIS_URL : process.env.REDISHOST ? redis://${process.env.REDISHOST}:${process.env.REDISPORT} : 'redis://localhost:6379'`                                                                |
+| database                      | Redis database number to use. Uses DB 0 for production, DB 1 otherwise                                                                                                          | `process.env.VERCEL_ENV === 'production' ? 0 : 1`                                                                                                                                                                            |
+| keyPrefix                     | Prefix added to all Redis keys                                                                                                                                                  | `RedisStringsHandler` default: `process.env.KEY_PREFIX \|\| process.env.VERCEL_URL \|\| 'UNDEFINED_URL_'`<br> Next handlers resolve: `options.keyPrefix \|\| KEY_PREFIX \|\| VERCEL_URL \|\| BUILD_ID \|\| 'UNDEFINED_URL_'` |
+| sharedTagsKey                 | Key used to store shared tags hash map in Redis                                                                                                                                 | `'__sharedTags__'`                                                                                                                                                                                                           |
+| getTimeoutMs                  | Timeout in milliseconds for time critical Redis operations. If Redis get is not fulfilled within this time, returns null to avoid blocking site rendering.                      | `process.env.REDIS_COMMAND_TIMEOUT_MS ? (Number.parseInt(process.env.REDIS_COMMAND_TIMEOUT_MS) ?? 500) : 500`                                                                                                                |
+| revalidateTagQuerySize        | Number of entries to query in one batch during full sync of shared tags hash map                                                                                                | `250`                                                                                                                                                                                                                        |
+| avgResyncIntervalMs           | Average interval in milliseconds between tag map full re-syncs                                                                                                                  | `3600000` (1 hour)                                                                                                                                                                                                           |
+| redisGetDeduplication         | Enable deduplication of Redis get requests via internal in-memory cache.                                                                                                        | `true`                                                                                                                                                                                                                       |
+| inMemoryCachingTime           | Time in milliseconds to cache Redis get results in memory. Set this to 0 to disable in-memory caching completely.                                                               | `10000`                                                                                                                                                                                                                      |
+| defaultStaleAge               | Default stale age in seconds for cached items                                                                                                                                   | `1209600` (14 days)                                                                                                                                                                                                          |
+| estimateExpireAge             | Function to calculate expire age (redis TTL value) from stale age                                                                                                               | Production: `staleAge * 2`<br> Other: `staleAge * 1.2`                                                                                                                                                                       |
+| socketOptions                 | Redis client socket options for TLS/SSL configuration (e.g., `{ tls: true, rejectUnauthorized: false }`)                                                                        | `{ connectTimeout: timeoutMs }`                                                                                                                                                                                              |
+| clientOptions                 | Additional Redis client options (e.g., username, password)                                                                                                                      | `undefined`                                                                                                                                                                                                                  |
+| killContainerOnErrorThreshold | Number of consecutive errors before the container is killed. Set to 0 to disable.                                                                                               | `Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0`                                                                                                                                                    |
+| valueSerializer               | Pluggable wire-format codec for Redis string values (compression, encryption, custom encoding). See [Custom value serializer](#custom-value-serializer-compression-encryption). | `jsonCacheValueSerializer` (`JSON.stringify` with built-in `Buffer` and `Map` encoding)                                                                                                                                      |
 
 ## Custom value serializer (compression, encryption)
 
@@ -300,7 +302,6 @@ export default class CustomizedCacheHandler {
   affects `RedisStringsHandler`. The Next.js 16+ `CacheComponentsHandler` does
   not currently route through `valueSerializer`; that's a candidate follow-up.
 
-
 ## TLS Configuration
 
 To connect to Redis using TLS/SSL (e.g., when using Redis over `rediss://` URLs), you can configure the socket options. Here's an example:
@@ -328,6 +329,8 @@ module.exports = class CustomizedCacheHandler {
 
 ## Consistency of Redis and this caching implementation
 
+> For a detailed description of the shared hash maps (`sharedTagsMap`, `revalidatedTagsMap`), the `SyncedMap` Pub/Sub mechanism, and the `DeduplicatedRequestHandler`, see [ARCHITECTURE.md](./ARCHITECTURE.md).
+
 To understand consistency levels of this caching implementation we first have to understand the consistency of redis itself:
 Redis executes commands in a single-threaded manner. This ensures that all operations are processed sequentially, so clients always see a consistent view of the data.
 But depending on the setup of redis this can change:
@@ -336,23 +339,43 @@ But depending on the setup of redis this can change:
 - Eventual consistency: In a master-replica setup (strong consistency only while there is no failover)
 - Eventual consistency: In Redis Cluster mode
 
-Consistency levels of Caching Handler:
-If Redis is used in a single node setup and Request Deduplication is turned off, only then the caching handler will have strong consistency.
+### Consistency levels of the Caching Handler
+
+Strong consistency is only achievable when **all** of the following conditions are met:
+
+1. Redis is used in a single node setup
+2. Only a **single application instance** is running (no cross-instance Pub/Sub propagation delay)
+3. Request Deduplication is turned off (`redisGetDeduplication: false`)
+
+In practice, most deployments run multiple application instances, which introduces eventual consistency through two mechanisms:
+
+#### Source 1: SyncedMap Pub/Sub propagation (both handlers)
+
+Both `RedisStringsHandler` and `CacheComponentsHandler` maintain in-memory maps (`sharedTagsMap`, `revalidatedTagsMap`) that are synchronized across instances via Redis Pub/Sub (see [SyncedMap in ARCHITECTURE.md](./ARCHITECTURE.md#syncedmap--the-synchronization-primitive)). When a tag is revalidated on instance 1, the Pub/Sub message must propagate to instance 2 before its local maps reflect the change. Until the message arrives, `get()` on instance 2 may still consider a cache entry valid.
 
-If using Request Deduplication, the strong consistency is not guaranteed anymore. The following sequence can happen with request deduplication:
+This is especially relevant for **implicit tags** (`_N_T_` prefix): when `revalidatePath("/products")` is called, the handler records a timestamp in `revalidatedTagsMap` and lazily invalidates nested fetch entries on the next `get()`. If another instance hasn't received the Pub/Sub update yet, it can serve a stale fetch result.
+
+The propagation delay is typically in the order of a few milliseconds (Redis Pub/Sub round-trip).
+
+#### Source 2: Request Deduplication (both handlers)
+
+Both `RedisStringsHandler` and `CacheComponentsHandler` use `DeduplicatedRequestHandler` (enabled by default via `redisGetDeduplication: true`). It caches Redis GET results in memory for `inMemoryCachingTime` (default 10s). The following sequence can occur across instances:
+
+```
 Instance 1: call set A 1
 Instance 1: served set A 1
-Instance 2: call get A
-Instance 1: call delete A
-Instance 2: call get A
-Instance 2: served get A -> 1
-Instance 2: served get A -> 1 (served 1 but should already be deleted)
+Instance 2: call get A           → result cached in dedup cache
+Instance 1: call delete A        → revalidateTag deletes from Redis + publishes Pub/Sub delete
+Instance 2: call get A           → served from dedup cache (stale!) if Pub/Sub delete hasn't arrived
+Instance 2: served get A → 1     (should already be deleted)
 Instance 1: served delete A
+```
+
+When `revalidateTag` / `updateTags` runs, it also deletes the affected keys from the `inMemoryDeduplicationCache` and broadcasts this deletion via Pub/Sub. So the consistency window is bounded by the Pub/Sub propagation time (typically 5–100ms), not the full `inMemoryCachingTime`. Only if the Pub/Sub message is lost would the stale entry persist for the full caching duration.
 
-The time window for this eventual consistency to occur is typically around the length of a single redis command. Depending on your load ranging from 5ms to max 100ms.
-If using local in-memory caching (Enabled by RedisStringsHandler option inMemoryCachingTime), the window for this eventual consistency to occur can be even higher because additionally also synchronization messages have to get delivered. Depending on your load typically ranging around 50ms to max of 120ms.
+#### Practical impact
 
-Since all caching calls in one api/page/server action request is always served by the same instance this problem will not occur inside a single request but rather in a combination of multiple parallel requests. The probability that this will occur for a single user during a request sequence is very low, since typically a single user will not make the follow up request during this small time window of typically 50ms. To further mitigate the Problem and increase performance (increase local in-memory cache hit ratio) make sure that your load balancer will always serve one user to the same instance (sticky sessions).
+Since all caching calls within one API/page/server action request are always served by the same instance, this problem will not occur inside a single request but rather in a combination of multiple parallel requests across instances. The probability that this will affect a single user during a request sequence is very low, since typically a single user will not make a follow-up request during this small time window of typically <100ms. To further mitigate the problem and increase performance (increase local in-memory cache hit ratio) make sure that your load balancer will always serve one user to the same instance (sticky sessions).
 
 By accepting and tolerating this eventual consistency, the performance of the caching handler is significantly increased.
 
@@ -382,9 +405,9 @@ pnpm test:integration:build-id-prefix
 
 Folder layout / runners:
 
-- **Vitest** (unit + integration) lives in `src/**/*.test.ts(x)` and `test/**`.
-- **Playwright** (E2E) lives in `tests/**` (see `playwright.config.ts`).
-- `test/browser/**` contains Vitest tests that hit a running Next.js app over HTTP. Despite the folder name, this is not Playwright and does not use Vitest browser mode.
+- **Vitest** unit tests live in `test/vitest/unit/**`; integration tests in `test/vitest/integration/**`.
+- **Playwright** (E2E) lives in `test/playwright/**` (see `playwright.config.ts`).
+- **Test fixtures** (Next.js apps) live in `test/nextjs-test-projects/`.
 
 ### Unit tests
 
@@ -408,14 +431,6 @@ To run the BUILD_ID integration test independently:
 pnpm build && pnpm test:integration:build-id-prefix
 ```
 
-### E2E tests (Playwright)
-
-To run Playwright tests (`tests/**`) you can use:
-
-```bash
-pnpm test:e2e
-```
-
 The integration tests will start a Next.js server and test the caching handler. You can modify testing behavior by setting the following environment variables:
 
 - SKIP_BUILD: If set to true, the integration tests will not build the Next.js app. Therefore the nextjs app needs to be built before running the tests. Or you execute the test once without skip build and the re-execute `pnpm test:integration` with skip build set to true.
@@ -424,6 +439,14 @@ The integration tests will start a Next.js server and test the caching handler.
 
 Integration tests may have dependencies between test cases, so individual test failures should be evaluated in the context of the full test suite rather than in isolation.
 
+### E2E tests (Playwright)
+
+To run Playwright tests (`test/playwright/**`) you can use:
+
+```bash
+pnpm test:e2e
+```
+
 ## Cache Components handler (Next.js 16+)
 
 This package can be used as a Cache Components handler (Node.js runtime) for Next.js apps that enable Cache Components.
@@ -487,8 +510,8 @@ This repo includes a dedicated Next.js Cache Components integration app with rea
 1. Install + start the Cache Components test app:
 
 ```bash
-pnpm -C test/integration/next-app-16-2-3-cache-components install
-pnpm -C test/integration/next-app-16-2-3-cache-components dev
+pnpm -C test/nextjs-test-projects/next-app-16-2-6-cache-components install
+pnpm -C test/nextjs-test-projects/next-app-16-2-6-cache-components dev
 ```
 
 Then open the Cache Lab pages:
@@ -516,6 +539,8 @@ app/<segment>/page.tsx files will request using the APP_PAGE kind.
 
 Fetch requests (inside app route or page) will request using the FETCH kind.
 
+For details on how these kinds are handled internally (tag maps, deduplication, value transformation), see [ARCHITECTURE.md](./ARCHITECTURE.md).
+
 ## License
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

package/dist/index.js

@@ -68,6 +68,7 @@ function debugVerbose(color, ...args) {
 var SYNC_CHANNEL_SUFFIX = ":sync-channel:";
 var SyncedMap = class {
   constructor(options) {
+    this.isReconnecting = false;
     this.client = options.client;
     this.keyPrefix = options.keyPrefix;
     this.redisKey = options.redisKey;
@@ -208,6 +209,10 @@ var SyncedMap = class {
       }
     };
     try {
+      this.subscriberClient.on("error", async (err) => {
+        console.error("Subscriber client error:", err);
+        await this.reconnectSubscriber();
+      });
       const connectIfNeeded = async () => {
         if (!this.subscriberClient.isOpen && !this.subscriberClient.isReady) {
           await this.subscriberClient.connect();
@@ -227,12 +232,12 @@ var SyncedMap = class {
         const keyspaceEventConfig = (await this.subscriberClient.configGet("notify-keyspace-events"))?.["notify-keyspace-events"];
         if (!keyspaceEventConfig.includes("E")) {
           throw new Error(
-            'Keyspace event configuration is set to "' + keyspaceEventConfig + "\" but has to include 'E' for Keyevent events, published with __keyevent@<db>__ prefix. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
+            'Keyspace event configuration is set to "' + keyspaceEventConfig + " but has to include 'E' for Keyevent events, published with __keyevent@<db>__ prefix. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
           );
         }
         if (!keyspaceEventConfig.includes("A") && !(keyspaceEventConfig.includes("x") && keyspaceEventConfig.includes("e"))) {
           throw new Error(
-            'Keyspace event configuration is set to "' + keyspaceEventConfig + "\" but has to include 'A' or 'x' and 'e' for expired and evicted events. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
+            'Keyspace event configuration is set to "' + keyspaceEventConfig + " but has to include 'A' or 'x' and 'e' for expired and evicted events. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
           );
         }
       }
@@ -252,22 +257,48 @@ var SyncedMap = class {
           keyEventHandler
         )
       ]);
-      this.subscriberClient.on("error", async (err) => {
-        console.error("Subscriber client error:", err);
+    } catch (error) {
+      console.error("Error setting up pub/sub client:", error);
+      throw error;
+    }
+  }
+  /**
+   * Reconnect the subscriber client with exponential backoff.
+   * Guarded by `isReconnecting` to prevent concurrent reconnection
+   * attempts when multiple error events fire during an outage.
+   * Retries indefinitely (with capped delay) so the subscriber
+   * eventually recovers once Redis is available again.
+   */
+  async reconnectSubscriber() {
+    if (this.isReconnecting) return;
+    this.isReconnecting = true;
+    try {
+      let attempt = 0;
+      while (true) {
         try {
-          await this.subscriberClient.quit();
+          try {
+            this.subscriberClient.removeAllListeners("error");
+            await this.subscriberClient.disconnect();
+          } catch {
+          }
           this.subscriberClient = this.client.duplicate();
           await this.setupPubSub();
-        } catch (reconnectError) {
+          return;
+        } catch (error) {
+          const delay = Math.min(
+            500 * Math.pow(2, Math.min(attempt, 5)),
+            1e4
+          );
+          attempt++;
           console.error(
-            "Failed to reconnect subscriber client:",
-            reconnectError
+            `Subscriber reconnect attempt ${attempt} failed, retrying in ${delay}ms`,
+            error
           );
+          await new Promise((r) => setTimeout(r, delay));
         }
-      });
-    } catch (error) {
-      console.error("Error setting up pub/sub client:", error);
-      throw error;
+      }
+    } finally {
+      this.isReconnecting = false;
     }
   }
   async waitUntilReady() {
@@ -1110,6 +1141,8 @@ var RedisCacheComponentsHandler = class {
     getTimeoutMs = process.env.REDIS_COMMAND_TIMEOUT_MS ? Number.parseInt(process.env.REDIS_COMMAND_TIMEOUT_MS) ?? 500 : 500,
     revalidateTagQuerySize = 250,
     avgResyncIntervalMs = 60 * 60 * 1e3,
+    redisGetDeduplication = true,
+    inMemoryCachingTime = 1e4,
     socketOptions,
     clientOptions,
     killContainerOnErrorThreshold = process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD ? Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0,
@@ -1122,6 +1155,8 @@ var RedisCacheComponentsHandler = class {
         env: process.env
       });
       this.getTimeoutMs = getTimeoutMs;
+      this.redisGetDeduplication = redisGetDeduplication;
+      this.inMemoryCachingTime = inMemoryCachingTime;
       this.client = (0, import_redis2.createClient)({
         url: redisUrl,
         pingInterval: 1e4,
@@ -1188,6 +1223,26 @@ var RedisCacheComponentsHandler = class {
         filterKeys,
         resyncIntervalMs: avgResyncIntervalMs - avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
       });
+      this.inMemoryDeduplicationCache = new SyncedMap({
+        client: this.client,
+        keyPrefix: this.keyPrefix,
+        redisKey: "__cacheComponents_inMemoryDeduplicationCache__",
+        database,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        customizedSync: {
+          withoutRedisHashmap: true,
+          withoutSetSync: true
+        }
+      });
+      const redisGet = this.client.get.bind(this.client);
+      this.redisDeduplicationHandler = new DeduplicatedRequestHandler(
+        redisGet,
+        inMemoryCachingTime,
+        this.inMemoryDeduplicationCache
+      );
+      this.redisGet = redisGet;
+      this.deduplicatedRedisGet = this.redisDeduplicationHandler.deduplicatedFunction;
     } catch (error) {
       console.error("RedisCacheComponentsHandler constructor error", error);
       throw error;
@@ -1222,9 +1277,10 @@ var RedisCacheComponentsHandler = class {
     const redisKey = `${this.keyPrefix}${cacheKey}`;
     try {
       await this.assertClientIsReady();
+      const clientGet = this.redisGetDeduplication ? this.deduplicatedRedisGet(cacheKey) : this.redisGet;
       const serialized = await redisErrorHandler(
-        "RedisCacheComponentsHandler.get(), operation: get " + this.getTimeoutMs + "ms " + redisKey,
-        this.client.get(
+        "RedisCacheComponentsHandler.get(), operation: get" + (this.redisGetDeduplication ? " deduplicated" : "") + " " + this.getTimeoutMs + "ms " + redisKey,
+        clientGet(
           (0, import_redis2.commandOptions)({ signal: AbortSignal.timeout(this.getTimeoutMs) }),
           redisKey
         )
@@ -1297,6 +1353,9 @@ var RedisCacheComponentsHandler = class {
         console.error("Stored object:", stored);
         throw jsonError;
       }
+      if (this.redisGetDeduplication) {
+        this.redisDeduplicationHandler.seedRequestReturn(cacheKey, serialized);
+      }
       const ttlSeconds = Number.isFinite(stored.expire) && stored.expire > 0 ? Math.floor(stored.expire) : void 0;
       const redisKey = `${this.keyPrefix}${cacheKey}`;
       const setOperation = redisErrorHandler(
@@ -1363,6 +1422,11 @@ var RedisCacheComponentsHandler = class {
         "RedisCacheComponentsHandler.updateTags(), operation: unlink",
         this.client.unlink(fullRedisKeys)
       );
+      if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
+        for (const key of keysToDelete) {
+          this.inMemoryDeduplicationCache.delete(key);
+        }
+      }
       const deleteTagsOperation = this.sharedTagsMap.delete(cacheKeys);
       await deleteTagsOperation;
     } catch (error) {