[NRL-1215] Switch root to DocumentReference in json dupe checker and add typing

Author: mattdean3-nhs

layer/nrlf/core/json_duplicate_checker.py

@@ -2,11 +2,11 @@
 from typing import Any
 
 
-def check_for_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict:
+def check_for_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
     """Custom JSON object_pairs_hook that checks for duplicate keys."""
-    keys = {}
-    dupes = {}
-    normalized_keys = []
+    keys: dict[str, Any] = {}
+    dupes: dict[str, Any] = {}
+    normalized_keys: list[str] = []
 
     for key, value in pairs:
         normalized_key = key.lower()
@@ -22,9 +22,9 @@ def check_for_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict:
     return keys
 
 
-def flatten_duplicates(data: dict | list) -> list[str]:
+def flatten_duplicates(data: dict[str, Any] | list[Any]) -> list[str]:
     """Flattens a JSON structure and returns a list of duplicate paths."""
-    duplicates = []
+    duplicates: list[str] = []
     items = data.items() if isinstance(data, dict) else enumerate(data)
 
     for key, value in items:
@@ -39,9 +39,9 @@ def flatten_duplicates(data: dict | list) -> list[str]:
 
 
 def format_path(path: str) -> str:
-    """Transforms a path like root.key1.[2].key2 into root.key1[2].key2"""
+    """Transforms a path like key1.[2].key2 into key1[2].key2"""
     parts = path.split(".")
-    formatted_parts = []
+    formatted_parts: list[str] = []
     for part in parts:
         if part.startswith("["):
             formatted_parts[-1] += part
@@ -55,15 +55,16 @@ def check_duplicate_keys(json_content: str) -> tuple[list[str], list[str]]:
 
     Traverses the entire JSON structure and reports:
     - List of keys that appear multiple times at the same level
-    - Full paths to each duplicate key occurrence
+    - Full paths to each duplicate key occurrkeysence
 
     A key is considered duplicate if it appears multiple times within
     the same object, regardless of nesting level or array position.
     """
     try:
         dupe_data = json.loads(json_content, object_pairs_hook=check_for_duplicate_keys)
         duplicate_paths = [
-            f"root.{format_path(path)}" for path in flatten_duplicates(dupe_data)
+            f"DocumentReference.{format_path(path)}"
+            for path in flatten_duplicates(dupe_data)
         ]
         duplicate_keys = list(
             dict.fromkeys([key.split(".")[-1] for key in duplicate_paths])

layer/nrlf/core/tests/test_json_duplicate_checker.py

@@ -14,7 +14,7 @@ def test_simple_duplicates(self):
         json_content = '{"a": 1, "b": 2, "a": 3}'
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(duplicates, ["a"])
-        self.assertEqual(paths, ["root.a"])
+        self.assertEqual(paths, ["DocumentReference.a"])
 
     def test_nested_duplicates(self):
         # This JSON has no duplicates because the 'b' keys are at different levels
@@ -28,7 +28,7 @@ def test_same_level_duplicates(self):
         json_content = '{"a": {"b": 1, "b": 2}, "c": {"d": 3}}'
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(duplicates, ["b"])
-        self.assertEqual(paths, ["root.a.b"])
+        self.assertEqual(paths, ["DocumentReference.a.b"])
 
     def test_same_level_duplicates_objects(self):
         # This JSON has duplicates because there are two 'b' keys at the same level
@@ -38,14 +38,16 @@ def test_same_level_duplicates_objects(self):
         )
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(duplicates, ["b"])
-        self.assertEqual(paths, ["root.a.b"])
+        self.assertEqual(paths, ["DocumentReference.a.b"])
 
     def test_multiple_level_duplicates(self):
         # This JSON has duplicates at multiple levels
         json_content = '{"a": 1, "b": {"c": 2, "c": 3}, "a": 4}'
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(sorted(duplicates), sorted(["a", "c"]))
-        self.assertEqual(sorted(paths), sorted(["root.a", "root.b.c"]))
+        self.assertEqual(
+            sorted(paths), sorted(["DocumentReference.a", "DocumentReference.b.c"])
+        )
 
     def test_invalid_json(self):
         json_content = "{invalid json}"
@@ -56,7 +58,7 @@ def test_complex_nested_duplicates(self):
         json_content = '{"a": {"b": 1, "c": {"d": 2, "c": 3}}, "a": {"e": 4}}'
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(sorted(duplicates), sorted(["a"]))
-        self.assertEqual(sorted(paths), sorted(["root.a"]))
+        self.assertEqual(sorted(paths), sorted(["DocumentReference.a"]))
 
     def test_multiple_duplicates_same_path(self):
         json_content = """
@@ -82,7 +84,15 @@ def test_multiple_duplicates_same_path(self):
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(sorted(duplicates), sorted(["b", "c", "e", "g"]))
         self.assertEqual(
-            sorted(paths), sorted(["root.b", "root.b.c", "root.b.d.e", "root.b.d.f.g"])
+            sorted(paths),
+            sorted(
+                [
+                    "DocumentReference.b",
+                    "DocumentReference.b.c",
+                    "DocumentReference.b.d.e",
+                    "DocumentReference.b.d.f.g",
+                ]
+            ),
         )
 
     def test_no_duplicates_deeply_nested(self):
@@ -119,7 +129,10 @@ def test_duplicates_with_arrays(self):
         """
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(sorted(duplicates), sorted(["b", "c"]))
-        self.assertEqual(sorted(paths), sorted(["root.a[0].b", "root.a[1].c"]))
+        self.assertEqual(
+            sorted(paths),
+            sorted(["DocumentReference.a[0].b", "DocumentReference.a[1].c"]),
+        )
 
     def test_large_json_with_mixed_duplicates(self):
         json_content = """
@@ -148,7 +161,14 @@ def test_large_json_with_mixed_duplicates(self):
         self.assertEqual(sorted(duplicates), sorted(["c", "f", "h", "j"]))
         self.assertEqual(
             sorted(paths),
-            sorted(["root.b.c", "root.b.e.f", "root.b.e.g.h", "root.i.j"]),
+            sorted(
+                [
+                    "DocumentReference.b.c",
+                    "DocumentReference.b.e.f",
+                    "DocumentReference.b.e.g.h",
+                    "DocumentReference.i.j",
+                ]
+            ),
         )
 
     def test_complex_nested_arrays_with_duplicates(self):
@@ -190,13 +210,13 @@ def test_complex_nested_arrays_with_duplicates(self):
             sorted(paths),
             sorted(
                 [
-                    "root.level1.arrays",
-                    "root.level1.arrays[0].a",
-                    "root.level1.arrays[0].nested.b",
-                    "root.level1.arrays[0].nested.b[0].c",
-                    "root.level1.arrays[1].mixed",
-                    "root.level1.arrays[1].mixed[1].f[0].g",
-                    "root.level1.arrays[1].mixed[1].f[1].h.i",
+                    "DocumentReference.level1.arrays",
+                    "DocumentReference.level1.arrays[0].a",
+                    "DocumentReference.level1.arrays[0].nested.b",
+                    "DocumentReference.level1.arrays[0].nested.b[0].c",
+                    "DocumentReference.level1.arrays[1].mixed",
+                    "DocumentReference.level1.arrays[1].mixed[1].f[0].g",
+                    "DocumentReference.level1.arrays[1].mixed[1].f[1].h.i",
                 ]
             ),
         )
@@ -233,8 +253,8 @@ def test_deep_nested_array_object_duplicates(self):
             sorted(paths),
             sorted(
                 [
-                    "root.root.level1[0].level2[0][0].data",
-                    "root.root.level1[0].level2[1][0].other",
+                    "DocumentReference.root.level1[0].level2[0][0].data",
+                    "DocumentReference.root.level1[0].level2[1][0].other",
                 ]
             ),
         )
@@ -263,7 +283,7 @@ def get_expected_duplicates(self, max_depth):
     def get_expected_paths(self, max_depth):
         """Helper function to get expected duplicate paths."""
         paths = []
-        current_path = "root"
+        current_path = "DocumentReference"
 
         # Start from level0 and increment
         for i in range(max_depth):
@@ -314,10 +334,10 @@ def test_array_edge_case_duplicate(self):
         """
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(duplicates, ["array"])
-        self.assertEqual(paths, ["root.array"])
+        self.assertEqual(paths, ["DocumentReference.array"])
 
     def test_case_sensitive_keys(self):
         json_content = '{"a": 1, "A": 2, "aA": 3, "Aa": 4}'
         duplicates, paths = check_duplicate_keys(json_content)
         self.assertEqual(duplicates, ["A", "Aa"])
-        self.assertEqual(paths, ["root.A", "root.Aa"])
+        self.assertEqual(paths, ["DocumentReference.A", "DocumentReference.Aa"])

layer/nrlf/core/tests/test_json_duplicate_checker_nrlf.py

@@ -59,4 +59,4 @@ def test_parse_body_valid_docref_with_duplicate_keys(field):
 
     node = field.split(".")[-1]
     assert result[0] == [node]
-    assert result[1] == [f"root.{field}"]
+    assert result[1] == [f"DocumentReference.{field}"]

layer/nrlf/core/tests/test_request.py

@@ -181,7 +181,7 @@ def test_parse_body_valid_docref_with_duplicate_key():
                     ]
                 },
                 "diagnostics": "Duplicate keys found in FHIR document: ['docStatus']",
-                "expression": ["root.docStatus"],
+                "expression": ["DocumentReference.docStatus"],
             }
         ],
     }