Support JSON.MERGE Command

src/NRedisStack/Json/DataTypes/KeyValuePath.cs

@@ -2,22 +2,17 @@
 
 namespace NRedisStack.Json.DataTypes;
 
-public struct KeyValuePath
+public struct KeyPathValue
 {
     public string Key { get; set; }
-    public object Value { get; set; }
     public string Path { get; set; }
+    public object Value { get; set; }
 
-    public KeyValuePath(string key, object value, string path = "$")
+    public KeyPathValue(string key, string path, object value)
     {
-        if (key == null || value == null)
-        {
-            throw new ArgumentNullException("Key and value cannot be null.");
-        }
-
         Key = key;
-        Value = value;
         Path = path;
+        Value = value;
     }
     public string[] ToArray()
     {

src/NRedisStack/Json/IJsonCommands.cs

@@ -209,11 +209,31 @@ public interface IJsonCommands
     /// <summary>
     /// Sets or updates the JSON value of one or more keys.
     /// </summary>
-    /// <param name="keyValuePathList">The key, The value to set and
+    /// <param name="KeyPathValueList">The key, The value to set and
     /// The path to set within the key, must be > 1 </param>
     /// <returns>The disposition of the command</returns>
     /// <remarks><seealso href="https://redis.io/commands/json.mset"/></remarks>
-    bool MSet(KeyValuePath[] keyValuePathList);
+    bool MSet(KeyPathValue[] KeyPathValueList);
+
+    /// <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 at a path.
+    /// </summary>
+    /// <param name="key">The key.</param>
+    /// <param name="path">The path to set within the key.</param>
+    /// <param name="obj">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, object obj);
 
     /// <summary>
     /// Sets or updates the JSON value of one or more keys.
@@ -242,7 +262,8 @@ public interface IJsonCommands
     /// <param name="key">The key to append to.</param>
     /// <param name="path">The path of the string(s) to append to.</param>
     /// <param name="value">The value to append.</param>
-    /// <returns>The new length of the string(s) appended to, those lengths will be null if the path did not resolve ot a string.</returns>
+    /// <returns>The new length of the string(s) appended to, those lengths
+    /// will be null if the path did not resolve ot a string.</returns>
     /// <remarks><seealso href="https://redis.io/commands/json.strappend"/></remarks>
     long?[] StrAppend(RedisKey key, string value, string? path = null);
 
@@ -251,7 +272,8 @@ public interface IJsonCommands
     /// </summary>
     /// <param name="key">The key of the json object.</param>
     /// <param name="path">The path of the string(s) within the json object.</param>
-    /// <returns>The length of the string(s) appended to, those lengths will be null if the path did not resolve ot a string.</returns>
+    /// <returns>The length of the string(s) appended to, those lengths
+    /// will be null if the path did not resolve ot a string.</returns>
     /// <remarks><seealso href="https://redis.io/commands/json.strlen"/></remarks>
     public long?[] StrLen(RedisKey key, string? path = null);
 

src/NRedisStack/Json/IJsonCommandsAsync.cs

@@ -209,11 +209,31 @@ public interface IJsonCommandsAsync
     /// <summary>
     /// Sets or updates the JSON value of one or more keys.
     /// </summary>
-    /// <param name="keyValuePathList">The key, The value to set and
+    /// <param name="KeyPathValueList">The key, The value to set and
     /// The path to set within the key, must be > 1 </param>
     /// <returns>The disposition of the command</returns>
     /// <remarks><seealso href="https://redis.io/commands/json.mset"/></remarks>
-    Task<bool> MSetAsync(KeyValuePath[] keyValuePathList);
+    Task<bool> MSetAsync(KeyPathValue[] KeyPathValueList);
+
+    /// <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>
+    /// 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="obj">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, object obj);
 
     /// <summary>
     /// Set json file from the provided file Path.

src/NRedisStack/Json/JsonCommandBuilder.cs

@@ -29,15 +29,20 @@ public static SerializedCommand Set(RedisKey key, RedisValue path, RedisValue js
         };
     }
 
-    public static SerializedCommand MSet(KeyValuePath[] keyValuePathList)
+    public static SerializedCommand MSet(KeyPathValue[] KeyPathValueList)
     {
-        if (keyValuePathList.Length < 1)
-            throw new ArgumentOutOfRangeException(nameof(keyValuePathList));
+        if (KeyPathValueList.Length < 1)
+            throw new ArgumentOutOfRangeException(nameof(KeyPathValueList));
 
-            var args = keyValuePathList.SelectMany(x => x.ToArray()).ToArray();
+            var args = KeyPathValueList.SelectMany(x => x.ToArray()).ToArray();
             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

@@ -41,9 +41,22 @@ public bool Set(RedisKey key, RedisValue path, RedisValue json, When when = When
     }
 
     /// <inheritdoc/>
-    public bool MSet(KeyValuePath[] keyValuePathList)
+    public bool MSet(KeyPathValue[] KeyPathValueList)
     {
-        return _db.Execute(JsonCommandBuilder.MSet(keyValuePathList)).OKtoBoolean();
+        return _db.Execute(JsonCommandBuilder.MSet(KeyPathValueList)).OKtoBoolean();
+    }
+
+    /// <inheritdoc/>
+    public bool Merge(RedisKey key, RedisValue path, RedisValue json)
+    {
+        return _db.Execute(JsonCommandBuilder.Merge(key, path, json)).OKtoBoolean();
+    }
+
+    /// <inheritdoc/>
+    public bool Merge(RedisKey key, RedisValue path, object obj)
+    {
+        string json = JsonSerializer.Serialize(obj);
+        return _db.Execute(JsonCommandBuilder.Merge(key, path, json)).OKtoBoolean();
     }
 
     /// <inheritdoc/>

src/NRedisStack/Json/JsonCommandsAsync.cs

@@ -144,9 +144,22 @@ public async Task<bool> SetAsync(RedisKey key, RedisValue path, RedisValue json,
         return (await _db.ExecuteAsync(JsonCommandBuilder.Set(key, path, json, when))).OKtoBoolean();
     }
 
-    public async Task<bool> MSetAsync(KeyValuePath[] keyValuePathList)
+    public async Task<bool> MSetAsync(KeyPathValue[] KeyPathValueList)
     {
-        return (await _db.ExecuteAsync(JsonCommandBuilder.MSet(keyValuePathList))).OKtoBoolean();
+        return (await _db.ExecuteAsync(JsonCommandBuilder.MSet(KeyPathValueList))).OKtoBoolean();
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> MergeAsync(RedisKey key, RedisValue path, RedisValue json)
+    {
+        return (await _db.ExecuteAsync(JsonCommandBuilder.Merge(key, path, json))).OKtoBoolean();
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> MergeAsync(RedisKey key, RedisValue path, object obj)
+    {
+        string json = JsonSerializer.Serialize(obj);
+        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)

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,18 +726,18 @@ public async Task GetAsync()
     }
 
     [Fact]
-    [Trait("Category","edge")]
+    [Trait("Category", "edge")]
     public void MSet()
     {
         IJsonCommands commands = new JsonCommands(redisFixture.Redis.GetDatabase());
         var keys = CreateKeyNames(2);
         var key1 = keys[0];
         var key2 = keys[1];
 
-        KeyValuePath[] values = new[]
+        KeyPathValue[] values = new[]
         {
-            new KeyValuePath(key1, new { a = "hello" }),
-            new KeyValuePath(key2, new { a = "world" })
+            new KeyPathValue(key1, "$", new { a = "hello" }),
+            new KeyPathValue(key2, "$", new { a = "world" })
         };
         commands.MSet(values)
 ;
@@ -747,22 +747,21 @@ public void MSet()
         Assert.Equal("[\"world\"]", result[1].ToString());
 
         // test errors:
-        Assert.Throws<ArgumentOutOfRangeException>(() => commands.MSet(new KeyValuePath[0]));
-
+        Assert.Throws<ArgumentOutOfRangeException>(() => commands.MSet(new KeyPathValue[0]));
     }
 
     [Fact]
-    [Trait("Category","edge")]
+    [Trait("Category", "edge")]
     public async Task MSetAsync()
     {
         IJsonCommandsAsync commands = new JsonCommands(redisFixture.Redis.GetDatabase());
         var keys = CreateKeyNames(2);
         var key1 = keys[0];
         var key2 = keys[1];
-        KeyValuePath[] values = new[]
+        KeyPathValue[] values = new[]
         {
-            new KeyValuePath(key1, new { a = "hello" }),
-            new KeyValuePath(key2, new { a = "world" })
+            new KeyPathValue(key1, "$", new { a = "hello" }),
+            new KeyPathValue(key2, "$", new { a = "world" })
         };
         await commands.MSetAsync(values)
 ;
@@ -772,14 +771,47 @@ await commands.MSetAsync(values)
         Assert.Equal("[\"world\"]", result[1].ToString());
 
         // test errors:
-        await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await commands.MSetAsync(new KeyValuePath[0]));
+        await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await commands.MSetAsync(new KeyPathValue[0]));
     }
 
     [Fact]
-    public void TestKeyValuePathErrors()
+    [Trait("Category", "edge")]
+    public void Merge()
     {
-        Assert.Throws<ArgumentNullException>(() => new KeyValuePath(null!, new { a = "hello" }));
-        Assert.Throws<ArgumentNullException>(() => new KeyValuePath("key", null!) );
+        // Create a connection to Redis
+        IJsonCommands commands = new JsonCommands(redisFixture.Redis.GetDatabase());
+
+        Assert.True(commands.Set("test_merge", "$", new { person = new { name = "John Doe", age = 25, address = new {home = "123 Main Street"}, phone = "123-456-7890" } }));
+        Assert.True(commands.Merge("test_merge", "$", new { person = new { age = 30 } }));
+        Assert.Equal("{\"person\":{\"name\":\"John Doe\",\"age\":30,\"address\":{\"home\":\"123 Main Street\"},\"phone\":\"123-456-7890\"}}", commands.Get("test_merge").ToString());
+
+        // Test with root path path $.a.b
+        Assert.True(commands.Merge("test_merge", "$.person.address", new {work = "Redis office"}));
+        Assert.Equal("{\"person\":{\"name\":\"John Doe\",\"age\":30,\"address\":{\"home\":\"123 Main Street\",\"work\":\"Redis office\"},\"phone\":\"123-456-7890\"}}", commands.Get("test_merge").ToString());
+
+        // Test with null value to delete a value
+        Assert.True(commands.Merge("test_merge", "$.person", "{\"age\":null}"));
+        Assert.Equal("{\"person\":{\"name\":\"John Doe\",\"phone\":\"123-456-7890\",\"address\":{\"home\":\"123 Main Street\",\"work\":\"Redis office\"}}}", commands.Get("test_merge").ToString());
+    }
+
+    [Fact]
+    [Trait("Category", "edge")]
+    public async Task MergeAsync()
+    {
+        // Create a connection to Redis
+        IJsonCommandsAsync commands = new JsonCommands(redisFixture.Redis.GetDatabase());
+
+        Assert.True(await commands.SetAsync("test_merge", "$", new { person = new { name = "John Doe", age = 25, address = new {home = "123 Main Street"}, phone = "123-456-7890" } }));
+        Assert.True(await commands.MergeAsync("test_merge", "$", new { person = new { age = 30 } }));
+        Assert.Equal("{\"person\":{\"name\":\"John Doe\",\"age\":30,\"address\":{\"home\":\"123 Main Street\"},\"phone\":\"123-456-7890\"}}", (await commands.GetAsync("test_merge")).ToString());
+
+        // Test with root path path $.a.b
+        Assert.True(await commands.MergeAsync("test_merge", "$.person.address", new {work = "Redis office"}));
+        Assert.Equal("{\"person\":{\"name\":\"John Doe\",\"age\":30,\"address\":{\"home\":\"123 Main Street\",\"work\":\"Redis office\"},\"phone\":\"123-456-7890\"}}", (await commands.GetAsync("test_merge")).ToString());
+
+        // Test with null value to delete a value
+        Assert.True(await commands.MergeAsync("test_merge", "$.person", "{\"age\":null}"));
+        Assert.Equal("{\"person\":{\"name\":\"John Doe\",\"phone\":\"123-456-7890\",\"address\":{\"home\":\"123 Main Street\",\"work\":\"Redis office\"}}}", (await commands.GetAsync("test_merge")).ToString());
     }
 
     [Fact]
@@ -1067,18 +1099,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());
         }