graphify-sf 0.3.2__tar.gz → 0.3.4__tar.gz

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.3.2
+Version: 0.3.4
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/graphify_sf/extract/apex.py

@@ -316,26 +316,42 @@ def extract_apex_class(path: Path) -> dict:
                     )
                 )
 
-        # DML → dml edges
-        seen_dml_targets: set[str] = set()
+        # DML → dml edges. The relation stays "dml" (unchanged) but each edge carries an
+        # "operation" field derived from the DML verb (insert→create / update→update /
+        # delete→delete / upsert / merge / undelete) so downstream can distinguish the
+        # kind of write. Native SF verbs (upsert/merge/undelete) are preserved rather than
+        # forced into CRUD. confidence stays INFERRED: the DML target is a variable name we
+        # cannot statically resolve to an object type — that honesty label must not change.
+        # Dedup is by (obj_var, operation) so a class that both inserts and updates the same
+        # object yields two edges, not one collapsed dml edge.
+        _DML_VERB_TO_OP = {
+            "insert": "create",
+            "update": "update",
+            "delete": "delete",
+            "upsert": "upsert",
+            "merge": "merge",
+            "undelete": "undelete",
+        }
+        seen_dml_ops: set[tuple[str, str]] = set()
         for dm in _DML_RE.finditer(text):
+            operation = _DML_VERB_TO_OP[dm.group(1).lower()]
             obj_var = dm.group(2)
             # obj_var is a variable name, not necessarily an object API name.
             # We record it as INFERRED since we can't always resolve the type statically.
-            if obj_var.lower() not in _APEX_KEYWORDS and obj_var not in seen_dml_targets:
-                seen_dml_targets.add(obj_var)
+            if obj_var.lower() not in _APEX_KEYWORDS and (obj_var, operation) not in seen_dml_ops:
+                seen_dml_ops.add((obj_var, operation))
                 # Only add the edge if it looks like a type name (capitalized) or known object
                 if obj_var[0].isupper():
-                    edges.append(
-                        _make_edge(
-                            class_nid,
-                            object_id(obj_var),
-                            "dml",
-                            "INFERRED",
-                            str_path,
-                            confidence_score=0.7,
-                        )
+                    edge = _make_edge(
+                        class_nid,
+                        object_id(obj_var),
+                        "dml",
+                        "INFERRED",
+                        str_path,
+                        confidence_score=0.7,
                     )
+                    edge["operation"] = operation
+                    edges.append(edge)
 
         # Apex → Flow invocations via Flow.Interview.FlowName
         seen_flow_invokes: set[str] = set()

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/graphify_sf/extract/flow.py

@@ -122,15 +122,26 @@ def extract_flow(path: Path) -> dict:
             if sub_name:
                 edges.append(_make_edge(flow_nid, flow_id(sub_name), "invokes", "EXTRACTED", str_path))
 
-    # Object record operations
-    _record_tags = ("recordLookups", "recordCreates", "recordUpdates", "recordDeletes")
-    seen_objects: set[str] = set()
-    for tag in _record_tags:
+    # Object record operations. The relation stays "references" (a generic relation
+    # reused by many extractors — never change its semantics), but each edge carries an
+    # "operation" field (read/create/update/delete) so downstream can distinguish
+    # read-only access from writes. Dedup is by (object, operation) so a flow that both
+    # reads and updates the same object yields two edges, not one collapsed reference.
+    _record_op_tags = {
+        "recordLookups": "read",
+        "recordCreates": "create",
+        "recordUpdates": "update",
+        "recordDeletes": "delete",
+    }
+    seen_record_ops: set[tuple[str, str]] = set()
+    for tag, operation in _record_op_tags.items():
         for el in _find_all(root_el, tag, ns):
             obj = _find_text(el, "object", ns)
-            if obj and obj not in seen_objects:
-                seen_objects.add(obj)
-                edges.append(_make_edge(flow_nid, object_id(obj), "references", "EXTRACTED", str_path))
+            if obj and (obj, operation) not in seen_record_ops:
+                seen_record_ops.add((obj, operation))
+                edge = _make_edge(flow_nid, object_id(obj), "references", "EXTRACTED", str_path)
+                edge["operation"] = operation
+                edges.append(edge)
 
     # Subflows
     for subflow in _find_all(root_el, "subflows", ns):

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/graphify_sf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.3.2
+Version: 0.3.4
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphify-sf"
-version = "0.3.2"
+version = "0.3.4"
 description = "Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required."
 readme = "README.md"
 requires-python = ">=3.10"

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/tests/test_extract_apex.py

@@ -385,6 +385,113 @@ public class LeadCreator {
         assert e["confidence"] == "INFERRED"
 
 
+def test_extract_apex_dml_insert_and_update_same_object_two_edges(tmp_path):
+    """A class that both inserts and updates the same object yields TWO dml edges
+    (operation=create and operation=update), not one collapsed edge."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "AccountWriter.cls"
+    cls.write_text(
+        """\
+public class AccountWriter {
+    public void work() {
+        Account Acct = new Account();
+        insert Acct;
+        update Acct;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    acct_dml = [e for e in result["edges"] if e.get("relation") == "dml" and "acct" in e["target"].lower()]
+    assert len(acct_dml) == 2, "insert+update on same object must not be deduped to one edge"
+    ops = {e.get("operation") for e in acct_dml}
+    assert ops == {"create", "update"}
+    for e in acct_dml:
+        assert e["confidence"] == "INFERRED"
+
+
+def test_extract_apex_dml_pure_update_carries_operation(tmp_path):
+    """A bare DML update produces a dml edge with operation='update' and INFERRED confidence."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "AccountUpdater.cls"
+    cls.write_text(
+        """\
+public class AccountUpdater {
+    public void touch() {
+        update Acct;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    dml_edges = [e for e in result["edges"] if e.get("relation") == "dml"]
+    assert len(dml_edges) == 1
+    assert dml_edges[0].get("operation") == "update"
+    assert dml_edges[0]["confidence"] == "INFERRED"
+
+
+def test_extract_apex_dml_native_verbs_preserved(tmp_path):
+    """SF-native DML verbs map to their own operation, not forced into CRUD:
+    upsert/undelete are preserved; insert->create, delete->delete, update->update.
+
+    Note: `merge` uses two-object syntax (`merge a b;`) which the single-object DML
+    regex deliberately does not capture — that's an existing extractor boundary, out
+    of scope for this change (no object-type resolution upgrade)."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "AllDml.cls"
+    cls.write_text(
+        """\
+public class AllDml {
+    public void run() {
+        insert Acct;
+        update Con;
+        delete Lead;
+        upsert Opp;
+        undelete Cse;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    ops_by_target = {e["target"].lower(): e.get("operation") for e in result["edges"] if e.get("relation") == "dml"}
+    assert ops_by_target.get("object_acct") == "create"
+    assert ops_by_target.get("object_con") == "update"
+    assert ops_by_target.get("object_lead") == "delete"
+    assert ops_by_target.get("object_opp") == "upsert"
+    assert ops_by_target.get("object_cse") == "undelete"
+
+
+def test_extract_apex_soql_queries_edge_unaffected(tmp_path):
+    """Regression: SOQL still produces a 'queries' edge (EXTRACTED) with no 'operation'
+    field — only DML edges gained operation."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "AccountReader.cls"
+    cls.write_text(
+        """\
+public class AccountReader {
+    public void read() {
+        List<Account> a = [SELECT Id FROM Account];
+        update Acct;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    query_edges = [e for e in result["edges"] if e.get("relation") == "queries"]
+    assert len(query_edges) >= 1
+    for e in query_edges:
+        assert e["confidence"] == "EXTRACTED"
+        assert e.get("operation") is None, "queries edges must not carry an operation field"
+
+
 # ---------------------------------------------------------------------------
 # Apex trigger fallback (no regex match → filename)
 # ---------------------------------------------------------------------------

{graphify_sf-0.3.2 → graphify_sf-0.3.4}/tests/test_extract_flow.py

@@ -324,6 +324,122 @@ def test_extract_flow_action_call_subflow_creates_invokes_edge(tmp_path):
     assert "subflow" in invokes_edges[0]["target"].lower()
 
 
+# ---------------------------------------------------------------------------
+# Flow → Object record operations (read/create/update/delete)
+# ---------------------------------------------------------------------------
+
+READ_AND_UPDATE_SAME_OBJECT_XML = f"""\
+<?xml version="1.0" encoding="UTF-8"?>
+<Flow {_NS}>
+    <processType>AutoLaunchedFlow</processType>
+    <recordLookups>
+        <name>GetOpp</name>
+        <object>Opportunity</object>
+    </recordLookups>
+    <recordUpdates>
+        <name>UpdateOpp</name>
+        <object>Opportunity</object>
+    </recordUpdates>
+</Flow>
+"""
+
+PURE_UPDATE_XML = f"""\
+<?xml version="1.0" encoding="UTF-8"?>
+<Flow {_NS}>
+    <processType>AutoLaunchedFlow</processType>
+    <recordUpdates>
+        <name>UpdateOpp</name>
+        <object>Opportunity</object>
+    </recordUpdates>
+</Flow>
+"""
+
+ALL_FOUR_OPS_XML = f"""\
+<?xml version="1.0" encoding="UTF-8"?>
+<Flow {_NS}>
+    <processType>AutoLaunchedFlow</processType>
+    <recordLookups>
+        <name>GetAcc</name>
+        <object>Account</object>
+    </recordLookups>
+    <recordCreates>
+        <name>MakeContact</name>
+        <object>Contact</object>
+    </recordCreates>
+    <recordUpdates>
+        <name>UpdateAcc</name>
+        <object>Account</object>
+    </recordUpdates>
+    <recordDeletes>
+        <name>DeleteLead</name>
+        <object>Lead</object>
+    </recordDeletes>
+</Flow>
+"""
+
+
+def test_extract_flow_read_and_update_yields_two_edges(tmp_path):
+    """A flow that both reads and updates the same object yields TWO edges
+    (operation=read and operation=update), not one collapsed reference."""
+    from graphify_sf.extract.flow import extract_flow
+
+    f = tmp_path / "OppReadWrite.flow-meta.xml"
+    f.write_text(READ_AND_UPDATE_SAME_OBJECT_XML)
+
+    result = extract_flow(f)
+    opp_edges = [
+        e for e in result["edges"] if e.get("relation") == "references" and "opportunity" in e["target"].lower()
+    ]
+    assert len(opp_edges) == 2, "read+update on same object must not be deduped to one edge"
+    ops = {e.get("operation") for e in opp_edges}
+    assert ops == {"read", "update"}
+
+
+def test_extract_flow_pure_update_carries_operation(tmp_path):
+    """A recordUpdates element produces a references edge with operation='update'."""
+    from graphify_sf.extract.flow import extract_flow
+
+    f = tmp_path / "OppUpdate.flow-meta.xml"
+    f.write_text(PURE_UPDATE_XML)
+
+    result = extract_flow(f)
+    ref_edges = [e for e in result["edges"] if e.get("relation") == "references"]
+    assert len(ref_edges) == 1
+    assert ref_edges[0].get("operation") == "update"
+    assert "opportunity" in ref_edges[0]["target"].lower()
+
+
+def test_extract_flow_record_ops_relation_unchanged(tmp_path):
+    """Regression: record-op edges keep relation='references' (semantics unchanged);
+    only the new 'operation' field distinguishes them."""
+    from graphify_sf.extract.flow import extract_flow
+
+    f = tmp_path / "OppReadWrite.flow-meta.xml"
+    f.write_text(READ_AND_UPDATE_SAME_OBJECT_XML)
+
+    result = extract_flow(f)
+    record_op_edges = [e for e in result["edges"] if e.get("operation") is not None]
+    assert record_op_edges, "expected at least one record-op edge"
+    for e in record_op_edges:
+        assert e["relation"] == "references"
+        assert e["confidence"] == "EXTRACTED"
+
+
+def test_extract_flow_all_four_operations(tmp_path):
+    """All four record-op tags map to their operation: read/create/update/delete."""
+    from graphify_sf.extract.flow import extract_flow
+
+    f = tmp_path / "AllOps.flow-meta.xml"
+    f.write_text(ALL_FOUR_OPS_XML)
+
+    result = extract_flow(f)
+    by_op = {e.get("operation"): e["target"].lower() for e in result["edges"] if e.get("operation") is not None}
+    assert by_op.get("read") and "account" in by_op["read"]
+    assert by_op.get("create") and "contact" in by_op["create"]
+    assert by_op.get("update") and "account" in by_op["update"]
+    assert by_op.get("delete") and "lead" in by_op["delete"]
+
+
 # ---------------------------------------------------------------------------
 # Flow child element nodes (Decision, Screen, Loop, Assignment)
 # ---------------------------------------------------------------------------