graphrag-codeproperty-graph 0.5.2__tar.gz → 0.5.3__tar.gz

{graphrag_codeproperty_graph-0.5.2 → graphrag_codeproperty_graph-0.5.3}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.5.3] - 2026-09-16
+
+### Fixed
+- **`GraphLoader` now coerces all node/edge properties to Neptune-safe scalar
+  literals before writing.** Neptune Database openCypher rejects list/dict/tuple/set
+  property values ("Property value must be a simple literal"). Joern's raw node/edge
+  `properties` (merged verbatim in `_node_to_write_dict` / `_edge_to_write_dict`) can
+  contain collection values — e.g. Java `modifiers`, `annotations`, `parameterTypes`,
+  edge `argIndexList` — which would fail the primary node/edge write the same way the
+  0.5.2 embedding write did. A new `_neptune_safe_properties` helper JSON-serializes
+  collection values to compact strings (preserving the data as a queryable scalar,
+  since these Joern properties have no other store) and drops `None`. Applied at the
+  single write boundary so every node and edge is Neptune-safe regardless of what the
+  Joern export contains. Covered by `tests/test_graph_loader_neptune_safe_props.py`.
+  (PSAPI-66782.)
+
 ## [0.5.2] - 2026-09-16
 
 ### Fixed

{graphrag_codeproperty_graph-0.5.2 → graphrag_codeproperty_graph-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphrag-codeproperty-graph
-Version: 0.5.2
+Version: 0.5.3
 Summary: Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring
 Project-URL: Repository, https://github.com/kanjani-ai-research/codeproperty-graph
 Author-email: Evan Erwee <evan@erwee.com>

{graphrag_codeproperty_graph-0.5.2 → graphrag_codeproperty_graph-0.5.3}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/codeproperty_graph"]
 
 [project]
 name = "graphrag-codeproperty-graph"
-version = "0.5.2"
+version = "0.5.3"
 description = "Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring"
 readme = "README.md"
 requires-python = ">=3.11"

{graphrag_codeproperty_graph-0.5.2 → graphrag_codeproperty_graph-0.5.3}/src/codeproperty_graph/graph_loader.py

@@ -7,6 +7,7 @@ Converts raw artifact dicts (from nodes.jsonl / edges.jsonl) into typed CPG
 models and writes them in batches to a graph store, applying tenant isolation.
 """
 
+import json
 import logging
 from typing import Any, Protocol, runtime_checkable
 
@@ -15,6 +16,35 @@ from .models import CPGNode, CPGEdge
 logger = logging.getLogger(__name__)
 
 
+def _neptune_safe_properties(properties: dict) -> dict:
+    """Coerce a property dict to Neptune-Database-safe SCALAR values.
+
+    Neptune Database openCypher only accepts simple-literal property values —
+    it rejects list/dict/tuple/set with "Property value must be a simple
+    literal". Joern's raw node/edge properties can contain collection values
+    (e.g. Java `modifiers`, `annotations`, `parameterTypes`), which would fail
+    the write. Unlike the embedding vector (which lives in the vector store),
+    these Joern properties have no other home, so we PRESERVE them as a compact
+    JSON string rather than dropping them — keeping the data queryable as a
+    scalar. `None` values are dropped (Neptune stores nothing for them).
+    """
+    safe = {}
+    for key, value in (properties or {}).items():
+        if value is None:
+            continue
+        if isinstance(value, (list, tuple, set, dict)):
+            try:
+                safe[key] = json.dumps(
+                    list(value) if isinstance(value, (tuple, set)) else value,
+                    ensure_ascii=False, default=str,
+                )
+            except (TypeError, ValueError):
+                safe[key] = str(value)
+        else:
+            safe[key] = value
+    return safe
+
+
 @runtime_checkable
 class GraphStoreProtocol(Protocol):
     """Protocol for graph store backends (e.g., Neptune)."""
@@ -220,7 +250,9 @@ class GraphLoader:
         return {
             "id": node.id,
             "label": f"{self._tenant_id}__{node.node_type}",
-            "properties": properties,
+            # Neptune Database rejects non-scalar property values; coerce
+            # collection-valued Joern properties to JSON strings.
+            "properties": _neptune_safe_properties(properties),
         }
 
     def _edge_to_write_dict(self, edge: CPGEdge) -> dict:
@@ -244,5 +276,7 @@ class GraphLoader:
             "source_id": edge.source_id,
             "target_id": edge.target_id,
             "edge_type": edge.edge_type,
-            "properties": properties,
+            # Neptune Database rejects non-scalar property values; coerce
+            # collection-valued Joern edge properties to JSON strings.
+            "properties": _neptune_safe_properties(properties),
         }

graphrag_codeproperty_graph-0.5.3/tests/test_graph_loader_neptune_safe_props.py

@@ -0,0 +1,75 @@
+"""GraphLoader must coerce node/edge properties to Neptune-safe scalars.
+
+Neptune Database openCypher rejects list/dict/tuple/set property values
+("Property value must be a simple literal"). Joern's raw node/edge properties
+can contain collection values (Java modifiers, annotations, parameterTypes, ...),
+so GraphLoader serializes them to JSON strings at the write boundary — preserving
+the data as a queryable scalar rather than failing the write.
+"""
+
+import json
+import pytest
+
+from codeproperty_graph.graph_loader import _neptune_safe_properties, GraphLoader
+from codeproperty_graph.models import CPGNode, CPGEdge
+
+
+def test_sanitizer_json_encodes_collections_and_keeps_scalars():
+    props = {
+        "name": "ProductController",          # str scalar → kept
+        "line_number": 42,                     # int scalar → kept
+        "is_external": False,                  # bool scalar → kept
+        "modifiers": ["public", "final"],      # list → JSON string
+        "annotations": {"RestController": {}}, # dict → JSON string
+        "parameterTypes": ("int", "String"),   # tuple → JSON string
+        "tags": {"a", "b"},                    # set → JSON string
+        "nothing": None,                        # None → dropped
+    }
+    out = _neptune_safe_properties(props)
+
+    # scalars unchanged
+    assert out["name"] == "ProductController"
+    assert out["line_number"] == 42
+    assert out["is_external"] is False
+    # None dropped
+    assert "nothing" not in out
+    # collections became strings, round-trippable
+    assert isinstance(out["modifiers"], str)
+    assert json.loads(out["modifiers"]) == ["public", "final"]
+    assert isinstance(out["annotations"], str)
+    assert json.loads(out["annotations"]) == {"RestController": {}}
+    assert isinstance(out["parameterTypes"], str)
+    assert json.loads(out["parameterTypes"]) == ["int", "String"]
+    assert isinstance(out["tags"], str)  # set serialized (order not asserted)
+    # EVERY value is now a Neptune-safe scalar literal
+    for k, v in out.items():
+        assert not isinstance(v, (list, dict, tuple, set)), k
+
+
+def test_node_write_dict_has_only_scalar_properties():
+    loader = GraphLoader.__new__(GraphLoader)
+    loader._tenant_id = "apm1"
+    node = CPGNode.from_artifact({
+        "cpg_node_id": "n1",
+        "node_type": "METHOD",
+        "full_name": "com.app.A.m",
+        "properties": {"modifiers": ["public"], "annotations": ["@Override"]},
+    })
+    wd = loader._node_to_write_dict(node)
+    for k, v in wd["properties"].items():
+        assert not isinstance(v, (list, dict, tuple, set)), (k, type(v))
+
+
+def test_edge_write_dict_has_only_scalar_properties():
+    loader = GraphLoader.__new__(GraphLoader)
+    loader._tenant_id = "apm1"
+    edge = CPGEdge.from_artifact({
+        "edge_id": "e1",
+        "source_cpg_node_id": "n1",
+        "target_cpg_node_id": "n2",
+        "edge_type": "CALL",
+        "properties": {"argIndexList": [0, 1, 2]},
+    })
+    wd = loader._edge_to_write_dict(edge)
+    for k, v in wd["properties"].items():
+        assert not isinstance(v, (list, dict, tuple, set)), (k, type(v))