devlensio 0.6.2 → 1.0.0

package/extractors/go/nodes.go

@@ -0,0 +1,177 @@
+// nodes.go — FILE/TEST nodes + code nodes (FUNCTION/METHOD/STRUCT/INTERFACE/
+// ENUM). Test files are LEAF nodes: their test funcs feed metadata.testCases
+// only — never emitted into the graph (JS parity, python bug #7).
+
+package main
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// ── file / test nodes ──
+
+func collectFileNodes(pr *parsedRepo, l *LookupMaps) []map[string]any {
+	nodes := []map[string]any{}
+	pkgByFile := map[string]string{}
+	for _, pkg := range pr.packages {
+		for _, pf := range pkg.Files {
+			pkgByFile[pf.RelPath] = pkg.ImportPath
+		}
+	}
+	for _, pf := range pr.files {
+		nodeType := NodeFile
+		if pf.IsTest {
+			nodeType = NodeTest
+		}
+		n := fileNode(pf.RelPath, pf.EndLine, nodeType)
+		meta := n["metadata"].(map[string]any)
+		if pf.IsTest {
+			meta["testCases"] = testCaseNames(pf)
+		} else {
+			ids := []string{}
+			for _, fn := range pf.Funcs {
+				ids = append(ids, nodeIDForFunc(pf.RelPath, fn))
+			}
+			for _, st := range pf.Structs {
+				if st.IsEnum {
+					continue // iota enums dropped — no node, no child
+				}
+				ids = append(ids, structNodeID(pf.RelPath, st.Name))
+			}
+			for _, it := range pf.Interfaces {
+				ids = append(ids, interfaceNodeID(pf.RelPath, it.Name))
+			}
+			meta["nodeCount"] = len(ids)
+			meta["childNodeIds"] = ids
+		}
+		meta["package"] = pkgByFile[pf.RelPath]
+		nodes = append(nodes, n)
+		l.FileNodesByPath[pf.RelPath] = n
+		l.NodeByID[n["id"].(string)] = n
+	}
+	return nodes
+}
+
+func testCaseNames(pf *ParsedFile) []string {
+	var names []string
+	for _, fn := range pf.Funcs {
+		if fn.IsTest {
+			names = append(names, fn.Name)
+		}
+	}
+	return names
+}
+
+// ── code nodes ──
+
+func collectCodeNodes(pr *parsedRepo, l *LookupMaps, ti *TypeInfo) []map[string]any {
+	nodes := []map[string]any{}
+	for _, pf := range pr.files {
+		if pf.IsTest {
+			continue // leaf rule
+		}
+		for _, fn := range pf.Funcs {
+			meta := map[string]any{
+				"package":    fn.PkgPath,
+				"isExported": isExported(fn.Name),
+			}
+			if fn.IsMethod {
+				meta["parentStruct"] = fn.RecvType
+			}
+			id := nodeIDForFunc(pf.RelPath, fn)
+			n := codeNode(id, pf.RelPath, fn.Name, nodeTypeForFunc(fn), fn.Start, fn.End, fn.RawCode, meta)
+			nodes = append(nodes, n)
+			l.NodeByID[id] = n
+		}
+		for _, st := range pf.Structs {
+			if st.IsEnum {
+				continue // iota enums dropped (2026-08-17) — no node, no edge
+			}
+			meta := map[string]any{
+				"package":    st.PkgPath,
+				"isExported": isExported(st.Name),
+			}
+			fields := make([]map[string]any, 0, len(st.Fields))
+			for _, f := range st.Fields {
+				fields = append(fields, map[string]any{"name": f.Name, "type": f.Type, "tag": f.Tag})
+			}
+			meta["fields"] = fields
+			meta["embedded"] = st.Embedded
+			id := structNodeID(pf.RelPath, st.Name)
+			n := codeNode(id, pf.RelPath, st.Name, NodeStruct, st.Start, st.End, st.RawCode, meta)
+			nodes = append(nodes, n)
+			l.NodeByID[id] = n
+		}
+		for _, it := range pf.Interfaces {
+			meta := map[string]any{
+				"package":    it.PkgPath,
+				"isExported": isExported(it.Name),
+				"methods":    it.Methods,
+				"embedded":   it.Embedded,
+			}
+			id := interfaceNodeID(pf.RelPath, it.Name)
+			n := codeNode(id, pf.RelPath, it.Name, NodeInterface, it.Start, it.End, it.RawCode, meta)
+			nodes = append(nodes, n)
+			l.NodeByID[id] = n
+		}
+	}
+	return nodes
+}
+
+func nodeTypeForFunc(fn *ParsedFunc) string {
+	if fn.IsMethod {
+		return NodeMethod
+	}
+	return NodeFunction
+}
+
+func isExported(name string) bool {
+	r, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(r)
+}
+
+// ── fingerprint helpers (net-http / database/sql / main) ──
+
+func importsNetHTTP(pr *parsedRepo) bool {
+	for _, pf := range pr.files {
+		for _, imp := range pf.Imports {
+			if imp.Path == "net/http" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func importsDatabaseSQL(pr *parsedRepo) bool {
+	for _, pf := range pr.files {
+		for _, imp := range pf.Imports {
+			if imp.Path == "database/sql" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func hasMainPackage(pr *parsedRepo) bool {
+	for _, pkg := range pr.packages {
+		if pkg.Name == "main" {
+			return true
+		}
+	}
+	return false
+}
+
+// pkgPathOf — package import path for a parsed file (tests.go uses it).
+func pkgPathOf(pr *parsedRepo, pf *ParsedFile) string {
+	for _, pkg := range pr.packages {
+		for _, f := range pkg.Files {
+			if f == pf {
+				return pkg.ImportPath
+			}
+		}
+	}
+	return ""
+}

package/extractors/go/orm_edges.go

@@ -0,0 +1,277 @@
+// orm_edges.go — GORM + database/sql → READS_FROM/WRITES_TO (consumer → store,
+// mirrors stateEdges.ts and python's orm_edges). Go's type info resolves the
+// model argument EXACTLY (Mode A); Mode B falls back to receiver-name
+// heuristics flagged `heuristic: true`.
+
+package main
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+	"strings"
+)
+
+// GORM method grammar (documented GORM API).
+var gormReadVerbs = map[string]bool{
+	"Find": true, "First": true, "Take": true, "Last": true, "Count": true,
+	"Pluck": true, "Scan": true, "Joins": true, "Preload": true, "Where": true,
+	"Model": true, "Limit": true, "Offset": true, "Order": true, "Select": true,
+	"Group": true, "Having": true, "Distinct": true, "Raw": true,
+	"FindInBatches": true,
+}
+
+var gormWriteVerbs = map[string]bool{
+	"Create": true, "Save": true, "Updates": true, "Update": true,
+	"Delete": true, "Exec": true, "CreateInBatches": true,
+}
+
+// database/sql: Scan targets the model; Exec takes an optional model.
+var sqlReadVerbs = map[string]bool{"Query": true, "QueryRow": true, "Scan": true}
+var sqlWriteVerbs = map[string]bool{"Exec": true}
+
+// common receiver names for the Mode-B heuristic (documented as heuristic).
+var dbReceiverNames = map[string]bool{
+	"db": true, "tx": true, "d": true, "conn": true, "pool": true,
+	"database": true, "sqlDB": true, "gormDB": true, "store": true, "repo": true,
+}
+
+func detectOrmEdges(pr *parsedRepo, l *LookupMaps, ti *TypeInfo, opts *Options) []map[string]any {
+	edges := []map[string]any{}
+	dbVars := dbVarKinds(pr) // pkgPath → varName → "gorm" | "sql" (from var decls)
+
+	// ── model detection (GORM): embeds gorm.Model OR has gorm:"..." tags ──
+	for _, pf := range pr.files {
+		for _, st := range pf.Structs {
+			isModel := false
+			for _, emb := range st.Embedded {
+				if strings.Contains(emb, "gorm.Model") {
+					isModel = true
+					break
+				}
+			}
+			if !isModel {
+				for _, f := range st.Fields {
+					if strings.Contains(f.Tag, "gorm:") {
+						isModel = true
+						break
+					}
+				}
+			}
+			if isModel {
+				if n, ok := l.NodeByID[structNodeID(pf.RelPath, st.Name)]; ok {
+					m := n["metadata"].(map[string]any)
+					m["isModel"] = true
+					m["modelType"] = "gorm"
+				}
+			}
+		}
+	}
+
+	// ── R/W edges: consumer (func) → model STRUCT ──
+	for _, pf := range pr.files {
+		info := ti.Infos[pf.RelPath]
+		for _, fn := range pf.Funcs {
+			if fn.IsTest {
+				continue
+			}
+			consumer := nodeIDForFunc(pf.RelPath, fn)
+			for _, c := range fn.Calls {
+				if !c.IsSel {
+					continue
+				}
+				receiverType, heuristic := dbReceiverType(c, info, dbVars, fn.PkgPath)
+				if receiverType == "" {
+					continue
+				}
+				var edgeType string
+				switch {
+				case gormReadVerbs[c.Sel] || sqlReadVerbs[c.Sel]:
+					edgeType = EdgeReadsFrom
+				case gormWriteVerbs[c.Sel] || sqlWriteVerbs[c.Sel]:
+					edgeType = EdgeWritesTo
+				default:
+					continue
+				}
+				modelID := modelArgID(c, info, l, fn)
+				if modelID == "" {
+					continue
+				}
+				edges = append(edges, edgeWithMeta(consumer, modelID, edgeType, map[string]any{
+					"method":       c.Sel,
+					"receiverVar":  firstSegment(c.Receiver),
+					"heuristic":    heuristic,
+					"modelType":    receiverType,
+				}))
+			}
+		}
+	}
+	return edges
+}
+
+// dbReceiverType — "gorm" | "sql" | "" — resolution ladder:
+// 1. types.Info (exact, local types)
+// 2. the receiver's `var` DECLARATION type (e.g. `var DB *gorm.DB` — exact,
+//    works for external types the checker can't resolve)
+// 3. receiver-name heuristic (common db var names — flagged heuristic).
+func dbReceiverType(c CallSite, info *types.Info, dbVars map[string]map[string]string, pkgPath string) (string, bool) {
+	recvName := firstSegment(c.Receiver)
+	if info != nil {
+		if selExpr, ok := c.Node.(*ast.SelectorExpr); ok {
+			if recvIdent, ok := selExpr.X.(*ast.Ident); ok {
+				if tv, ok := info.Types[recvIdent]; ok && tv.Type != nil {
+					switch t := deref(tv.Type).(type) {
+					case *types.Named:
+						if t.Obj() != nil && t.Obj().Pkg() != nil {
+							switch t.Obj().Pkg().Path() {
+							case "gorm.io/gorm":
+								return "gorm", false
+							case "database/sql":
+								return "sql", false
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	// var declaration scan (exact: the declared type names the package)
+	if m, ok := dbVars[pkgPath]; ok {
+		if kind, ok := m[recvName]; ok {
+			return kind, false
+		}
+	}
+	// name heuristic (Mode B)
+	if dbReceiverNames[strings.ToLower(recvName)] {
+		return "gorm", true
+	}
+	return "", false
+}
+
+// dbVarKinds — package-level vars whose declared type mentions gorm/sql.
+func dbVarKinds(pr *parsedRepo) map[string]map[string]string {
+	out := map[string]map[string]string{}
+	for _, pkg := range pr.packages {
+		m := map[string]string{}
+		for _, pf := range pkg.Files {
+			for _, decl := range pf.AST.Decls {
+				gd, ok := decl.(*ast.GenDecl)
+				if !ok || gd.Tok != token.VAR {
+					continue
+				}
+				for _, spec := range gd.Specs {
+					vs, ok := spec.(*ast.ValueSpec)
+					if !ok || vs.Type == nil {
+						continue
+					}
+					t := exprText(vs.Type)
+					kind := ""
+					switch {
+					case strings.Contains(t, "gorm"):
+						kind = "gorm"
+					case strings.Contains(t, "sql"):
+						kind = "sql"
+					}
+					if kind != "" {
+						for _, n := range vs.Names {
+							m[n.Name] = kind
+						}
+					}
+				}
+			}
+		}
+		if len(m) > 0 {
+			out[pkg.ImportPath] = m
+		}
+	}
+	return out
+}
+
+func deref(t types.Type) types.Type {
+	for {
+		switch tt := t.(type) {
+		case *types.Pointer:
+			t = tt.Elem()
+		case *types.Slice:
+			t = tt.Elem()
+		default:
+			return t
+		}
+	}
+}
+
+// modelArgID — the model struct node from the method's model argument.
+// Handles the documented GORM chain form `DB.Model(&user).Updates(map...)`
+// where the model lives in the inner Model() call.
+func modelArgID(c CallSite, info *types.Info, l *LookupMaps, fn *ParsedFunc) string {
+	sel, ok := c.Node.(*ast.SelectorExpr)
+	if !ok {
+		return ""
+	}
+	call := selParentCall(c, fn)
+	if call == nil || len(call.Args) == 0 {
+		return ""
+	}
+	// direct: arg0 is the model
+	if id := typeExprToStructID(call.Args[0], info, l); id != "" {
+		return id
+	}
+	// chain: receiver is a CallExpr — its args may carry the model
+	if chain, ok := sel.X.(*ast.CallExpr); ok && len(chain.Args) > 0 {
+		if id := typeExprToStructID(chain.Args[0], info, l); id != "" {
+			return id
+		}
+	}
+	return ""
+}
+
+// selParentCall — the CallExpr containing the selector (we have the callee
+// node; climb to the call itself via the fn's AST). Since CallSite only
+// carries the callee expr, locate the call by walking the function body.
+func selParentCall(c CallSite, fn *ParsedFunc) *ast.CallExpr {
+	if fn.Decl == nil || fn.Decl.Body == nil {
+		return nil
+	}
+	var found *ast.CallExpr
+	ast.Inspect(fn.Decl.Body, func(n ast.Node) bool {
+		if found != nil {
+			return false
+		}
+		call, ok := n.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if call.Fun == c.Node {
+			found = call
+			return false
+		}
+		return true
+	})
+	return found
+}
+
+// typeExprToStructID — resolve an argument expr to a local struct node id.
+func typeExprToStructID(arg ast.Expr, info *types.Info, l *LookupMaps) string {
+	// unwrap &x
+	if un, ok := arg.(*ast.UnaryExpr); ok && un.Op.String() == "&" {
+		arg = un.X
+	}
+	if lit, ok := arg.(*ast.CompositeLit); ok {
+		arg = lit.Type
+	}
+	if info != nil {
+		if tv, ok := info.Types[arg]; ok && tv.Type != nil {
+			if named, ok := deref(tv.Type).(*types.Named); ok && named.Obj() != nil {
+				if named.Obj().Pkg() != nil {
+					pkgPath := named.Obj().Pkg().Path()
+					if _, local := l.PkgNodesByPath[pkgPath]; local {
+						if id, ok := l.StructNodeByPkgName[pkgPath+"::"+named.Obj().Name()]; ok {
+							return id
+						}
+					}
+				}
+			}
+		}
+	}
+	return ""
+}