packages/core/src/v3/utils/flattenAttributes.ts (3)

6-8: Consider handling pre-existing backslashes in keys

The current implementation might not handle keys that already contain backslashes correctly. Consider escaping backslashes first to prevent ambiguous escaping.

Here's a more robust implementation:

 function escapeKey(key: string): string {
-  return key.replace(/\./g, '\\.');
+  return key.replace(/\\/g, '\\\\').replace(/\./g, '\\.');
 }

---

94-96: Ensure symmetric escaping/unescaping implementation

To maintain symmetry with the escapeKey function and handle all edge cases correctly, the unescaping should process the escapes in reverse order.

Here's a symmetric implementation:

 function unescapeKey(key: string): string {
-  return key.replace(/\\\./g, '.');
+  return key.replace(/\\\./g, '.').replace(/\\\\/g, '\\');
 }

---

Test coverage for key escaping is missing

The test suite lacks specific test cases for:

• Keys containing periods that should be escaped
• Keys with backslashes
• Keys with mixed escaped and unescaped periods
• Edge cases where periods in array indices need escaping

Please add test cases like:

it("handles keys with dots correctly", () => {
  const obj = {
    "key.with.dots": "value",
    "normal.key": "value2"
  };
  const result = flattenAttributes(obj);
  expect(result).toEqual({
    "key\\.with\\.dots": "value",
    "normal.key": "value2"
  });
  expect(unflattenAttributes(result)).toEqual(obj);
});

it("handles keys with backslashes correctly", () => {
  const obj = {
    "key\\with\\backslash": "value",
    "mixed.key\\.with\\.escaped.dots": "value2"
  };
  // ... similar assertions
});

🔗 Analysis chain

Line range hint 6-124: Verify test coverage for key escaping edge cases

Please ensure that the test suite includes coverage for various edge cases:

1. Keys with multiple periods
2. Keys with backslashes
3. Keys with escaped and unescaped periods
4. Array indices containing periods

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Search for related test files and their coverage of edge cases
fd -e test.ts -e spec.ts | xargs rg -l "flattenAttributes|unflattenAttributes"

# Look for existing test cases with dots in keys
rg -A 5 '\.".*\."' $(fd -e test.ts -e spec.ts)

Length of output: 824

---

Script:

#!/bin/bash
# Let's examine the test file content for flattenAttributes
cat packages/core/test/flattenAttributes.test.ts

Length of output: 7943

Configuration used: CodeRabbit UI
Review profile: CHILL

packages/core/src/v3/utils/flattenAttributes.ts (1)

121-134: Consider simplifying the key splitting logic

While the current implementation works, it could be simplified for better maintainability.

  const parts = key
-    .split('.') // Split by all dots
-    .reduce((acc, part, i, arr) => {
-      // If the previous part ends with an odd number of backslashes,
-      // the dot is escaped and should be part of the last segment.
-      if (i > 0 && arr[i - 1].match(/\\+$/)?.[0]?.length % 2 === 1) {
-        acc[acc.length - 1] += '.' + part;
-      } else {
-        acc.push(part);
-      }
-      return acc;
-    }, [] as (string | number)[])
-    .map(unescapeKey); // Unescape keys
+    // Split by unescaped dots (dots not preceded by backslash)
+    .split(/(?<=[^\\]|^)\./)
+    .map(unescapeKey);

Configuration used: CodeRabbit UI
Review profile: CHILL

function escapeKey(key: string): string {
-  return key.replace(/\./g, '\\.');
+  return key.replace(/(?<!\\)\./g, '\\.');
}

packages/core/src/v3/utils/flattenAttributes.ts (2)

6-8: Consider handling edge cases with pre-existing backslashes

The current implementation might not handle keys that already contain backslashes correctly. Consider adding handling for these edge cases.

 function escapeKey(key: string): string {
-  return key.replace(/\./g, '\\.');
+  // First, escape any existing backslashes
+  return key.replace(/\\/g, '\\\\').replace(/\./g, '\\.');
 }

---

94-96: Consider improving escape sequence handling

Similar to escapeKey, consider handling complex escape sequences more robustly.

 function unescapeKey(key: string): string {
-  return key.replace(/\\\./g, '.');
+  // First, unescape dots, then restore any legitimate backslashes
+  return key.replace(/\\\./g, '\u0000').replace(/\\\\/g, '\\').replace(/\u0000/g, '.');
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

    .map(unescapeKey); // Unescape keys
-   }
-   

#!/bin/bash
# Search for existing test cases to ensure coverage of edge cases
rg -l "test|spec" | xargs rg -A 5 "flattenAttributes|unflattenAttributes"

# Search for actual usage in the codebase to understand impact
rg -A 5 "flattenAttributes|unflattenAttributes"