not a perfect solution. right now only serves as a soft cap at 128 and hard cap at 256.

ephraimfeldblum · ephraimfeldblum · commit 5a07f4a70b39 · 2022-09-08T10:15:21.000+03:00
diff --git a/src/commands.rs b/src/commands.rs
@@ -625,24 +625,14 @@ pub fn json_set<M: Manager>(manager: M, ctx: &Context, args: Vec<RedisString>) -
                     let mut res = false;
                     if update_info.len() == 1 {
                         res = match update_info.pop().unwrap() {
-                            UpdateInfo::SUI(sui) => {
-                                if sui.path.len() < 128 {
-                                    redis_key.set_value(sui.path, val)?
-                                } else {
-                                    return Err(RedisError::Str("recursion limit exceeded"));
-                                }
-                            }
+                            UpdateInfo::SUI(sui) => redis_key.set_value(sui.path, val)?,
                             UpdateInfo::AUI(aui) => redis_key.dict_add(aui.path, &aui.key, val)?,
                         }
                     } else {
                         for ui in update_info {
                             res = match ui {
                                 UpdateInfo::SUI(sui) => {
-                                    if sui.path.len() < 128 {
-                                        redis_key.set_value(sui.path, val.clone())?
-                                    } else {
-                                        return Err(RedisError::Str("recursion limit exceeded"));
-                                    }
+                                    redis_key.set_value(sui.path, val.clone())?
                                 }
                                 UpdateInfo::AUI(aui) => {
                                     redis_key.dict_add(aui.path, &aui.key, val.clone())?
diff --git a/src/ivalue_manager.rs b/src/ivalue_manager.rs
@@ -322,7 +322,10 @@ impl<'a> WriteHolder<IValue, IValue> for IValueKeyHolderWrite<'a> {
 
     fn set_value(&mut self, path: Vec<String>, mut v: IValue) -> Result<bool, RedisError> {
         let mut updated = false;
-        if path.is_empty() {
+        
+        if path.len() > 127 {
+            return Err(RedisError::Str("recursion limit exceeded"));
+        } else if path.is_empty() {
             // update the root
             self.set_root(Some(v))?;
             updated = true;
@@ -342,7 +345,10 @@ impl<'a> WriteHolder<IValue, IValue> for IValueKeyHolderWrite<'a> {
         mut v: IValue,
     ) -> Result<bool, RedisError> {
         let mut updated = false;
-        if path.is_empty() {
+        
+        if path.len() > 127 {
+            return Err(RedisError::Str("recursion limit exceeded"));
+        } else if path.is_empty() {
             // update the root
             let root = self.get_value().unwrap().unwrap();
             if let Some(o) = root.as_object_mut() {
diff --git a/src/manager.rs b/src/manager.rs
@@ -304,7 +304,10 @@ impl<'a> WriteHolder<Value, Value> for KeyHolderWrite<'a> {
 
     fn set_value(&mut self, path: Vec<String>, mut v: Value) -> Result<bool, RedisError> {
         let mut updated = false;
-        if path.is_empty() {
+
+        if path.len() > 127 {
+            return Err(RedisError::Str("recursion limit exceeded"));
+        } else if path.is_empty() {
             // update the root
             self.set_root(Some(v))?;
             updated = true;
@@ -319,7 +322,9 @@ impl<'a> WriteHolder<Value, Value> for KeyHolderWrite<'a> {
 
     fn dict_add(&mut self, path: Vec<String>, key: &str, mut v: Value) -> Result<bool, RedisError> {
         let mut updated = false;
-        if path.is_empty() {
+        if path.len() > 127 {
+            return Err(RedisError::Str("recursion limit exceeded"));
+        } else if path.is_empty() {
             // update the root
             let root = self.get_value().unwrap().unwrap();
             let val = if let Value::Object(mut o) = root.take() {
diff --git a/tests/pytest/test.py b/tests/pytest/test.py
@@ -1131,19 +1131,20 @@ def testNesting(env):
     """ Test JSONPath Object nesting depth """
     r = env
 
-    # Max nesting level for a single JSON value
+    # Max nesting level for a single JSON value is 128
     depth = 128
     doc = nest_object(depth, 5, "__leaf", 42)
     r.assertOk(r.execute_command('JSON.SET', 'test', '$', doc))
     res = r.execute_command('JSON.GET', 'test', '$..__leaf')
     r.assertEqual(res, '[42]')
 
-    # Max nesting level of nested objects cannot exceed 128
+    # Max nesting level (can exceeded the single value max nesting level)
     doc = nest_object(depth, 5, "__deep_leaf", 420)
     r.execute_command('JSON.SET', 'test', '$..__leaf', doc)
     res = r.execute_command('JSON.GET', 'test', '$..__deep_leaf')
     r.assertEqual(res, '[420]')
 
+    # But the overall max nesting level, 256, cannot be exceeded
     doc = nest_object(depth, 5, "__helms_deep_leaf", 42000)
     r.expect('JSON.SET', 'test', '$..__deep_leaf', doc).raiseError().contains("recursion limit exceeded")
 
