Support JSON.MERGE Command

src/NRedisStack/Json/IJsonCommands.cs

@@ -215,6 +215,16 @@ public interface IJsonCommands
     /// <remarks><seealso href="https://redis.io/commands/json.mset"/></remarks>
     bool MSet(KeyValuePath[] keyValuePathList);
 
+    /// <summary>
+    /// Sets or updates the JSON value at a path.
+    /// </summary>
+    /// <param name="key">The key.</param>
+    /// <param name="path">The path to set within the key.</param>
+    /// <param name="json">The value to set.</param>
+    /// <returns>The disposition of the command</returns>
+    /// <remarks><seealso href="https://redis.io/commands/json.merge"/></remarks>
+    bool Merge(RedisKey key, RedisValue path, RedisValue json);
+
     /// <summary>
     /// Sets or updates the JSON value of one or more keys.
     /// </summary>

src/NRedisStack/Json/IJsonCommandsAsync.cs

@@ -216,6 +216,17 @@ public interface IJsonCommandsAsync
     Task<bool> MSetAsync(KeyValuePath[] keyValuePathList);
 
     /// <summary>
+    /// Sets or updates the JSON value at a path.
+    /// </summary>
+    /// <param name="key">The key.</param>
+    /// <param name="path">The path to set within the key.</param>
+    /// <param name="json">The value to set.</param>
+    /// <returns>The disposition of the command</returns>
+    /// <remarks><seealso href="https://redis.io/commands/json.merge"/></remarks>
+    Task<bool> MergeAsync(RedisKey key, RedisValue path, RedisValue json);
+
+    /// <summary>
+
     /// Set json file from the provided file Path.
     /// </summary>
     /// <param name="key">The key.</param>

src/NRedisStack/Json/JsonCommandBuilder.cs

@@ -38,6 +38,11 @@ public static SerializedCommand MSet(KeyValuePath[] keyValuePathList)
             return new SerializedCommand(JSON.MSET, args);
     }
 
+    public static SerializedCommand Merge(RedisKey key, RedisValue path, RedisValue json)
+    {
+        return new SerializedCommand(JSON.MERGE, key, path, json);
+    }
+
     public static SerializedCommand StrAppend(RedisKey key, string value, string? path = null)
     {
         if (path == null)

src/NRedisStack/Json/JsonCommands.cs

@@ -46,6 +46,12 @@ public bool MSet(KeyValuePath[] keyValuePathList)
         return _db.Execute(JsonCommandBuilder.MSet(keyValuePathList)).OKtoBoolean();
     }
 
+    /// <inheritdoc/>
+    public bool Merge(RedisKey key, RedisValue path, RedisValue json)
+    {
+        return _db.Execute(JsonCommandBuilder.Merge(key, path, json)).OKtoBoolean();
+    }
+
     /// <inheritdoc/>
     public bool SetFromFile(RedisKey key, RedisValue path, string filePath, When when = When.Always)
     {

src/NRedisStack/Json/JsonCommandsAsync.cs

@@ -149,6 +149,12 @@ public async Task<bool> MSetAsync(KeyValuePath[] keyValuePathList)
         return (await _db.ExecuteAsync(JsonCommandBuilder.MSet(keyValuePathList))).OKtoBoolean();
     }
 
+    /// <inheritdoc/>
+    public async Task<bool> MergeAsync(RedisKey key, RedisValue path, RedisValue json)
+    {
+        return (await _db.ExecuteAsync(JsonCommandBuilder.Merge(key, path, json))).OKtoBoolean();
+    }
+
     public async Task<bool> SetFromFileAsync(RedisKey key, RedisValue path, string filePath, When when = When.Always)
     {
         if (!File.Exists(filePath))

src/NRedisStack/Json/Literals/Commands.cs

@@ -15,6 +15,7 @@ internal class JSON
         public const string FORGET = "JSON.FORGET";
         public const string GET = "JSON.GET";
         public const string MEMORY = "MEMORY";
+        public const string MERGE = "JSON.MERGE";
         public const string MSET = "JSON.MSET";
         public const string MGET = "JSON.MGET";
         public const string NUMINCRBY = "JSON.NUMINCRBY";

tests/NRedisStack.Tests/Json/JsonTests.cs

@@ -726,7 +726,7 @@ public async Task GetAsync()
     }
 
     [Fact]
-    [Trait("Category","edge")]
+    [Trait("Category", "edge")]
     public void MSet()
     {
         IJsonCommands commands = new JsonCommands(redisFixture.Redis.GetDatabase());
@@ -748,11 +748,10 @@ public void MSet()
 
         // test errors:
         Assert.Throws<ArgumentOutOfRangeException>(() => commands.MSet(new KeyValuePath[0]));
-
     }
 
     [Fact]
-    [Trait("Category","edge")]
+    [Trait("Category", "edge")]
     public async Task MSetAsync()
     {
         IJsonCommandsAsync commands = new JsonCommands(redisFixture.Redis.GetDatabase());
@@ -775,11 +774,49 @@ await commands.MSetAsync(values)
         await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await commands.MSetAsync(new KeyValuePath[0]));
     }
 
+    [Fact]
+    [Trait("Category", "edge")]
+    public void Merge()
+    {
+        IJsonCommands commands = new JsonCommands(redisFixture.Redis.GetDatabase());
+
+        // Create a key
+        Assert.True(commands.Set("test_merge", "$", "{\"a\":{\"b\":{\"c\":\"d\"}}}"));
+        Assert.True(commands.Merge("test_merge", "$", "{\"a\":{\"b\":{\"e\":\"f\"}}}"));
+        Assert.Equal("{\"a\":{\"b\":{\"c\":\"d\",\"e\":\"f\"}}}", commands.Get("test_merge").ToString());
+        // Test with root path path $.a.b
+
+        Assert.True(commands.Merge("test_merge", "$.a.b", "{\"h\":\"i\"}"));
+        Assert.Equal("{\"a\":{\"b\":{\"c\":\"d\",\"e\":\"f\",\"h\":\"i\"}}}", commands.Get("test_merge").ToString());
+        // Test with null value to delete a value
+        Assert.True(commands.Merge("test_merge", "$.a.b", "{\"c\":null}"));
+        Assert.Equal("{\"a\":{\"b\":{\"h\":\"i\",\"e\":\"f\"}}}", commands.Get("test_merge").ToString());
+    }
+
+    [Fact]
+    [Trait("Category", "edge")]
+    public async Task MergeAsync()
+    {
+        IJsonCommandsAsync commands = new JsonCommands(redisFixture.Redis.GetDatabase());
+
+        // Create a key
+        Assert.True(await commands.SetAsync("test_merge", "$", "{\"a\":{\"b\":{\"c\":\"d\"}}}"));
+        Assert.True(await commands.MergeAsync("test_merge", "$", "{\"a\":{\"b\":{\"e\":\"f\"}}}"));
+        Assert.Equal("{\"a\":{\"b\":{\"c\":\"d\",\"e\":\"f\"}}}", (await commands.GetAsync("test_merge")).ToString());
+        // Test with root path path $.a.b
+
+        Assert.True(await commands.MergeAsync("test_merge", "$.a.b", "{\"h\":\"i\"}"));
+        Assert.Equal("{\"a\":{\"b\":{\"c\":\"d\",\"e\":\"f\",\"h\":\"i\"}}}", (await commands.GetAsync("test_merge")).ToString());
+        // Test with null value to delete a value
+        Assert.True(await commands.MergeAsync("test_merge", "$.a.b", "{\"c\":null}"));
+        Assert.Equal("{\"a\":{\"b\":{\"h\":\"i\",\"e\":\"f\"}}}", (await commands.GetAsync("test_merge")).ToString());
+    }
+
     [Fact]
     public void TestKeyValuePathErrors()
     {
         Assert.Throws<ArgumentNullException>(() => new KeyValuePath(null!, new { a = "hello" }));
-        Assert.Throws<ArgumentNullException>(() => new KeyValuePath("key", null!) );
+        Assert.Throws<ArgumentNullException>(() => new KeyValuePath("key", null!));
     }
 
     [Fact]
@@ -1067,18 +1104,18 @@ public async Task TestSetFromDirectoryAsync()
     public void TestJsonCommandBuilder()
     {
         var getBuild1 = JsonCommandBuilder.Get("key", "indent", "newline", "space", "path");
-        var getBuild2 = JsonCommandBuilder.Get("key",new string[]{"path1", "path2", "path3"}, "indent", "newline", "space");
-        var expectedArgs1 = new object[] { "key", "INDENT", "indent", "NEWLINE","newline", "SPACE", "space", "path" };
+        var getBuild2 = JsonCommandBuilder.Get("key", new string[] { "path1", "path2", "path3" }, "indent", "newline", "space");
+        var expectedArgs1 = new object[] { "key", "INDENT", "indent", "NEWLINE", "newline", "SPACE", "space", "path" };
         var expectedArgs2 = new object[] { "key", "INDENT", "indent", "NEWLINE", "newline", "SPACE", "space", "path1", "path2", "path3" };
 
 
-        for(int i = 0; i < expectedArgs1.Length; i++)
+        for (int i = 0; i < expectedArgs1.Length; i++)
         {
             Assert.Equal(expectedArgs1[i].ToString(), getBuild1.Args[i].ToString());
         }
         Assert.Equal("JSON.GET", getBuild1.Command);
 
-        for(int i = 0; i < expectedArgs2.Length; i++)
+        for (int i = 0; i < expectedArgs2.Length; i++)
         {
             Assert.Equal(expectedArgs2[i].ToString(), getBuild2.Args[i].ToString());
         }