Add an optional prefix for redis cache keys

Author: kchenery

src/HotChocolate/PersistedOperations/src/PersistedOperations.Redis/Extensions/HotChocolateRedisPersistedOperationsRequestExecutorBuilderExtensions.cs

@@ -22,18 +22,23 @@ public static class HotChocolateRedisPersistedOperationsRequestExecutorBuilderEx
     /// <param name="queryExpiration">
     /// A timeout after which an operation document is removed from the Redis cache.
     /// </param>
+    /// <param name="cacheKeyPrefix">
+    /// An optional prefix for the cache keys used to store operation documents.
+    /// </param>
     public static IRequestExecutorBuilder AddRedisOperationDocumentStorage(
         this IRequestExecutorBuilder builder,
         Func<IServiceProvider, IDatabase> databaseFactory,
-        TimeSpan? queryExpiration = null)
+        TimeSpan? queryExpiration = null,
+        string? cacheKeyPrefix = null)
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentNullException.ThrowIfNull(databaseFactory);
 
         return builder.ConfigureSchemaServices(
             s => s.AddRedisOperationDocumentStorage(
                 sp => databaseFactory(sp.GetCombinedServices()),
-                queryExpiration));
+                queryExpiration,
+                cacheKeyPrefix));
     }
 
     /// <summary>
@@ -48,18 +53,23 @@ public static IRequestExecutorBuilder AddRedisOperationDocumentStorage(
     /// <param name="queryExpiration">
     /// A timeout after which an operation document is removed from the Redis cache.
     /// </param>
+    /// <param name="cacheKeyPrefix">
+    /// An optional prefix for the cache keys used to store operation documents.
+    /// </param>
     public static IRequestExecutorBuilder AddRedisOperationDocumentStorage(
         this IRequestExecutorBuilder builder,
         Func<IServiceProvider, IConnectionMultiplexer> multiplexerFactory,
-        TimeSpan? queryExpiration = null)
+        TimeSpan? queryExpiration = null,
+        string? cacheKeyPrefix = null)
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentNullException.ThrowIfNull(multiplexerFactory);
 
         return builder.ConfigureSchemaServices(
             s => s.AddRedisOperationDocumentStorage(
                 sp => multiplexerFactory(sp.GetCombinedServices()).GetDatabase(),
-                queryExpiration));
+                queryExpiration,
+                cacheKeyPrefix));
     }
 
     /// <summary>
@@ -73,14 +83,19 @@ public static IRequestExecutorBuilder AddRedisOperationDocumentStorage(
     /// <param name="queryExpiration">
     /// A timeout after which an operation document is removed from the Redis cache.
     /// </param>
+    /// <param name="cacheKeyPrefix">
+    /// An optional prefix for the cache keys used to store operation documents.
+    /// </param>
     public static IRequestExecutorBuilder AddRedisOperationDocumentStorage(
         this IRequestExecutorBuilder builder,
-        TimeSpan? queryExpiration = null)
+        TimeSpan? queryExpiration = null,
+        string? cacheKeyPrefix = null)
     {
         ArgumentNullException.ThrowIfNull(builder);
 
         return builder.AddRedisOperationDocumentStorage(
             sp => sp.GetRequiredService<IConnectionMultiplexer>(),
-            queryExpiration);
+            queryExpiration,
+            cacheKeyPrefix);
     }
 }

src/HotChocolate/PersistedOperations/src/PersistedOperations.Redis/Extensions/HotChocolateRedisPersistedOperationsServiceCollectionExtensions.cs

@@ -23,18 +23,23 @@ public static class HotChocolateRedisPersistedOperationsServiceCollectionExtensi
     /// <param name="queryExpiration">
     /// A timeout after which an operation document is removed from the Redis cache.
     /// </param>
+    /// <param name="cacheKeyPrefix">
+    /// An optional prefix for the cache keys used to store operation documents.
+    /// This can be useful to avoid key collisions when multiple applications share the same Redis instance.
+    /// </param>
     public static IServiceCollection AddRedisOperationDocumentStorage(
         this IServiceCollection services,
         Func<IServiceProvider, IDatabase> databaseFactory,
-        TimeSpan? queryExpiration = null)
+        TimeSpan? queryExpiration = null,
+        string? cacheKeyPrefix = null)
     {
         ArgumentNullException.ThrowIfNull(services);
         ArgumentNullException.ThrowIfNull(databaseFactory);
 
         return services
             .RemoveService<IOperationDocumentStorage>()
             .AddSingleton<IOperationDocumentStorage>(
-                sp => new RedisOperationDocumentStorage(databaseFactory(sp), queryExpiration));
+                sp => new RedisOperationDocumentStorage(databaseFactory(sp), queryExpiration, cacheKeyPrefix));
     }
 
     private static IServiceCollection RemoveService<TService>(

src/HotChocolate/PersistedOperations/src/PersistedOperations.Redis/RedisOperationDocumentStorage.cs

@@ -11,6 +11,7 @@ public class RedisOperationDocumentStorage : IOperationDocumentStorage
 {
     private readonly IDatabase _database;
     private readonly TimeSpan? _expiration;
+    private readonly string? _cacheKeyPrefix;
 
     /// <summary>
     /// Initializes a new instance of the class.
@@ -19,10 +20,14 @@ public class RedisOperationDocumentStorage : IOperationDocumentStorage
     /// <param name="expiration">
     /// A time span after which an operation document will be removed from the cache.
     /// </param>
-    public RedisOperationDocumentStorage(IDatabase database, TimeSpan? expiration = null)
+    /// <param name="cacheKeyPrefix">
+    /// An optional prefix for the cache keys used to store operation documents.
+    /// </param>
+    public RedisOperationDocumentStorage(IDatabase database, TimeSpan? expiration = null, string? cacheKeyPrefix = null)
     {
         _database = database ?? throw new ArgumentNullException(nameof(database));
         _expiration = expiration;
+        _cacheKeyPrefix = cacheKeyPrefix;
     }
 
     /// <inheritdoc />
@@ -40,7 +45,7 @@ public RedisOperationDocumentStorage(IDatabase database, TimeSpan? expiration =
 
     private async ValueTask<IOperationDocument?> TryReadInternalAsync(OperationDocumentId documentId)
     {
-        var buffer = (byte[]?)await _database.StringGetAsync(documentId.Value).ConfigureAwait(false);
+        var buffer = (byte[]?)await _database.StringGetAsync(GetCacheKey(documentId.Value)).ConfigureAwait(false);
         return buffer is null ? null : new OperationDocument(Utf8GraphQLParser.Parse(buffer));
     }
 
@@ -65,8 +70,23 @@ private async ValueTask SaveInternalAsync(
         IOperationDocument document)
     {
         var promise = _expiration.HasValue
-            ? _database.StringSetAsync(documentId.Value, document.ToArray(), _expiration.Value)
-            : _database.StringSetAsync(documentId.Value, document.ToArray());
+            ? _database.StringSetAsync(GetCacheKey(documentId.Value), document.ToArray(), _expiration.Value)
+            : _database.StringSetAsync(GetCacheKey(documentId.Value), document.ToArray());
         await promise.ConfigureAwait(false);
     }
+
+    private string GetCacheKey(string documentId)
+    {
+        if (string.IsNullOrEmpty(documentId))
+        {
+            throw new ArgumentNullException(nameof(documentId));
+        }
+
+        if (string.IsNullOrEmpty(_cacheKeyPrefix))
+        {
+            return documentId;
+        }
+
+        return $"{_cacheKeyPrefix}:{{{documentId}}}";
+    }
 }