devlensio 0.6.2 → 1.0.1

package/extractors/rust/src/nodes.rs

@@ -0,0 +1,174 @@
+// nodes.rs — CodeNode building from parsed facts (mirrors go/nodes.go).
+//
+// Contract rules enforced here:
+//   - FILE id `file::rel/path.rs`; file nodes parent themselves
+//   - TEST files (any #[test] fn) = LEAF nodes: nodes=[] for them, test fns
+//     ride in metadata.testCases only (the bug that shipped in Python's
+//     parser — asserted in the bun suite)
+//   - rawCode + codeHash on every FUNCTION/METHOD/STRUCT/ENUM/TRAIT/IMPL_BLOCK
+//   - deterministic ids (file-scoped; trait-impl method suffix for the
+//     same-name-different-trait collision class)
+
+use crate::contract::{base_metadata, code_node, file_node, CodeNode, NODE_FILE, NODE_TEST};
+use crate::parser::{ParsedFile, ParsedItem};
+use serde_json::{Map, Value};
+
+/// FILE (or TEST leaf) nodes — always parents of their file's children.
+pub fn collect_file_nodes(files: &[ParsedFile]) -> Vec<CodeNode> {
+    let mut out = vec![];
+    for pf in files {
+        if pf.is_test_file {
+            let mut n = file_node(&pf.rel_path, pf.line_count, NODE_TEST);
+            let meta = n
+                .metadata
+                .entry("testCases".to_string())
+                .or_insert_with(|| Value::Array(vec![]));
+            if let Value::Array(arr) = meta {
+                for t in &pf.test_fns {
+                    arr.push(Value::from(t.clone()));
+                }
+            }
+            out.push(n);
+        } else {
+            out.push(file_node(&pf.rel_path, pf.line_count, NODE_FILE));
+        }
+    }
+    out
+}
+
+/// Code nodes (FUNCTION/METHOD/STRUCT/ENUM/TRAIT/IMPL_BLOCK) — test fns are
+/// NOT emitted (leaf rule); they feed metadata.testCases only.
+pub fn collect_code_nodes(files: &[ParsedFile]) -> Vec<CodeNode> {
+    let mut out = vec![];
+    for pf in files {
+        if pf.is_test_file {
+            continue;
+        }
+        for item in &pf.items {
+            if item.is_test {
+                continue;
+            }
+            out.push(item_node(pf, item));
+        }
+    }
+    out
+}
+
+fn item_node(pf: &ParsedFile, item: &ParsedItem) -> CodeNode {
+    let mut meta = base_metadata();
+    meta.insert("isPublic".to_string(), Value::from(item.is_pub));
+    if item.is_async {
+        meta.insert("isAsync".to_string(), Value::from(true));
+    }
+    if item.receiver.contains("self") {
+        meta.insert("receiver".to_string(), Value::from(item.receiver.clone()));
+    }
+
+    let (id, node_type, name) = match item.kind {
+        crate::parser::KIND_FUNCTION => (
+            crate::lookup::func_node_id(&pf.rel_path, &item.name),
+            "FUNCTION",
+            item.name.clone(),
+        ),
+        crate::parser::KIND_METHOD => {
+            let owner = item.impl_target.clone();
+            let trait_path = item.impl_trait_path.clone();
+            let id = crate::lookup::method_node_id(
+                &pf.rel_path,
+                &owner,
+                &item.name,
+                trait_path.as_deref(),
+            );
+            meta.insert("parentStruct".to_string(), Value::from(owner.clone()));
+            if let Some(t) = &trait_path {
+                meta.insert("traitPath".to_string(), Value::from(t.clone()));
+            }
+            (id, "METHOD", item.name.clone())
+        }
+        crate::parser::KIND_STRUCT => {
+            let id = crate::lookup::struct_node_id(&pf.rel_path, &item.name);
+            if !item.fields.is_empty() {
+                let fields: Vec<Value> = item
+                    .fields
+                    .iter()
+                    .map(|f| Value::from(f.name.clone()))
+                    .collect();
+                meta.insert("fields".to_string(), Value::Array(fields));
+            }
+            if !item.derives.is_empty() {
+                let d: Vec<Value> = item
+                    .derives
+                    .iter()
+                    .map(|d| Value::from(d.clone()))
+                    .collect();
+                meta.insert("derives".to_string(), Value::Array(d));
+            }
+            (id, "STRUCT", item.name.clone())
+        }
+        crate::parser::KIND_ENUM => {
+            let id = crate::lookup::enum_node_id(&pf.rel_path, &item.name);
+            if !item.variants.is_empty() {
+                let v: Vec<Value> = item
+                    .variants
+                    .iter()
+                    .map(|v| Value::from(v.clone()))
+                    .collect();
+                meta.insert("variants".to_string(), Value::Array(v));
+            }
+            (id, "ENUM", item.name.clone())
+        }
+        crate::parser::KIND_TRAIT => {
+            let id = crate::lookup::trait_node_id(&pf.rel_path, &item.name);
+            if !item.supertraits.is_empty() {
+                let s: Vec<Value> = item
+                    .supertraits
+                    .iter()
+                    .map(|s| Value::from(s.clone()))
+                    .collect();
+                meta.insert("supertraits".to_string(), Value::Array(s));
+            }
+            (id, "TRAIT", item.name.clone())
+        }
+        crate::parser::KIND_IMPL_BLOCK => {
+            let label = if item.impl_trait.is_some() {
+                format!(
+                    "impl {} for {}",
+                    item.impl_trait_path.as_deref().unwrap_or(""),
+                    item.impl_target
+                )
+            } else {
+                format!("impl {}", item.impl_target)
+            };
+            let id = crate::lookup::impl_block_node_id(&pf.rel_path, &label, item.start_line);
+            if let Some(t) = &item.impl_trait_path {
+                meta.insert("traitPath".to_string(), Value::from(t.clone()));
+            }
+            if !item.impl_target.is_empty() {
+                meta.insert(
+                    "implTarget".to_string(),
+                    Value::from(item.impl_target.clone()),
+                );
+            }
+            (id, "IMPL_BLOCK", label)
+        }
+        _ => return code_node("", "", "", "", 0, 0, "", Map::new()),
+    };
+
+    let mut n = code_node(
+        &id,
+        &pf.rel_path,
+        &name,
+        node_type,
+        item.start_line,
+        item.end_line,
+        &item.raw_code,
+        meta,
+    );
+    // metadata.calls — contract compliance + LLM context (the orchestrator
+    // never resolves them for subprocess languages, but they must be present)
+    if !item.calls.is_empty() {
+        let calls: Vec<Value> = item.calls.iter().map(|c| Value::from(c.clone())).collect();
+        n.metadata.insert("calls".to_string(), Value::Array(calls));
+    }
+    n
+}

package/extractors/rust/src/orm_edges.rs

@@ -0,0 +1,125 @@
+// orm_edges.rs — Diesel data layer: table! concepts + model structs →
+// READS_FROM / WRITES_TO edges (consumer → store, mirroring stateEdges.ts).
+//
+// Model detection (documented diesel API):
+//   - struct with #[derive(Queryable, Insertable, ...)] and/or
+//     #[diesel(table_name = users)] (legacy #[table_name = "users"]) → model
+// R/W grammar (diesel query DSL):
+//   READ  — users::table.filter/.first/.get_result/.get_results/.load/.find
+//   WRITE — diesel::insert_into(users::table) / users::table.insert(...) /
+//           diesel::update(users::table) / diesel::delete(...)
+// Target: the model STRUCT whose table_name matches; fallback = the FILE
+// containing the table! decl (no TABLE node type in types.ts — documented).
+// sqlx raw SQL → V2 (documented). isModel/tableName metadata enrichment
+// happens in enrich.rs (same facts, single source).
+
+use crate::contract::{edge, CodeEdge, EDGE_READS_FROM, EDGE_WRITES_TO};
+use crate::extractor::{Options, ParsedRepo};
+use std::collections::HashMap;
+
+/// table name → model struct node id
+pub fn table_to_model_map(repo: &ParsedRepo) -> HashMap<String, String> {
+    let mut map = HashMap::new();
+    for pf in &repo.files {
+        if pf.is_test_file {
+            continue;
+        }
+        for item in &pf.items {
+            if item.kind != crate::parser::KIND_STRUCT || item.is_test {
+                continue;
+            }
+            let is_diesel_model = item.derives.iter().any(|d| {
+                d == "Queryable"
+                    || d == "Insertable"
+                    || d == "QueryableByName"
+                    || d == "Associations"
+                    || d == "Identifiable"
+            }) || item.attrs.iter().any(|a| {
+                (a.path == "diesel" && a.args.contains("table_name")) || a.path == "table_name"
+            });
+            if !is_diesel_model {
+                continue;
+            }
+            let table_name = diesel_table_name(item);
+            if !table_name.is_empty() {
+                let id = crate::lookup::struct_node_id(&pf.rel_path, &item.name);
+                map.insert(table_name, id);
+            }
+        }
+    }
+    map
+}
+
+/// table name → file containing the table! decl (fallback store target).
+pub fn table_to_schema_file_map(repo: &ParsedRepo) -> HashMap<String, String> {
+    let mut map = HashMap::new();
+    for pf in &repo.files {
+        for t in &pf.tables {
+            map.insert(t.name.clone(), pf.rel_path.clone());
+        }
+    }
+    map
+}
+
+/// Parse the table name from #[diesel(table_name = users)] /
+/// #[table_name = "users"] (legacy diesel 1.x).
+pub fn diesel_table_name(item: &crate::parser::ParsedItem) -> String {
+    for a in &item.attrs {
+        if a.path == "diesel" && a.args.contains("table_name") {
+            if let Some((_, v)) = a.args.split_once('=') {
+                return v.trim().trim_matches('"').to_string();
+            }
+        } else if a.path == "table_name" {
+            return a.args.trim().trim_matches('"').to_string();
+        }
+    }
+    String::new()
+}
+
+pub fn detect_orm_edges(
+    repo: &ParsedRepo,
+    _lookup: &crate::lookup::LookupMaps,
+    _opts: &Options,
+) -> Vec<CodeEdge> {
+    let mut edges = vec![];
+    if repo.files.is_empty() {
+        return edges;
+    }
+    let table_to_model = table_to_model_map(repo);
+    let table_to_schema_file = table_to_schema_file_map(repo);
+
+    for pf in &repo.files {
+        if pf.is_test_file {
+            continue;
+        }
+        for item in &pf.items {
+            if item.is_test || item.orm_calls.is_empty() {
+                continue;
+            }
+            if item.kind != crate::parser::KIND_FUNCTION && item.kind != crate::parser::KIND_METHOD
+            {
+                continue;
+            }
+            let from = crate::lookup::node_id_for_item(&pf.rel_path, item);
+            for oc in &item.orm_calls {
+                // normalize the table ref ("users::table" → "users") — top-
+                // level fn args keep the raw path (insert_into(users::table))
+                let table = crate::parser::table_name_from_ref(&oc.table_ref);
+                let target = table_to_model.get(&table).cloned().or_else(|| {
+                    table_to_schema_file
+                        .get(&table)
+                        .map(|f| format!("file::{}", f))
+                });
+                if let Some(to) = target {
+                    let etype = if oc.kind == "read" {
+                        EDGE_READS_FROM
+                    } else {
+                        EDGE_WRITES_TO
+                    };
+                    edges.push(edge(&from, &to, etype));
+                }
+            }
+        }
+    }
+    edges
+}