@optave/codegraph 3.8.0 → 3.8.1

package/src/domain/analysis/dependencies.ts

@@ -1,11 +1,4 @@
-import {
-  findCallees,
-  findCallers,
-  findFileNodes,
-  findImportSources,
-  findImportTargets,
-  findNodesByFile,
-} from '../../db/index.js';
+import { findFileNodes, type Repository } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
@@ -18,13 +11,11 @@ import type {
   RelatedNodeRow,
   StmtCache,
 } from '../../types.js';
-import { withReadonlyDb } from './query-helpers.js';
+import { withReadonlyDb, withRepo } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
-type UpstreamRow = { id: number; name: string; kind: string; file: string; line: number };
 type NodeByIdRow = { name: string; kind: string; file: string; line: number };
 
-const _upstreamStmtCache: StmtCache<UpstreamRow> = new WeakMap();
 const _nodeByIdStmtCache: StmtCache<NodeByIdRow> = new WeakMap();
 
 export function fileDepsData(
@@ -32,21 +23,21 @@ export function fileDepsData(
   customDbPath: string,
   opts: { noTests?: boolean; limit?: number; offset?: number } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
-    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    const fileNodes = repo.findFileNodes(`%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, results: [] };
     }
 
     const results = fileNodes.map((fn) => {
-      let importsTo = findImportTargets(db, fn.id) as ImportEdgeRow[];
+      let importsTo = repo.findImportTargets(fn.id) as ImportEdgeRow[];
       if (noTests) importsTo = importsTo.filter((i) => !isTestFile(i.file));
 
-      let importedBy = findImportSources(db, fn.id) as ImportEdgeRow[];
+      let importedBy = repo.findImportSources(fn.id) as ImportEdgeRow[];
       if (noTests) importedBy = importedBy.filter((i) => !isTestFile(i.file));
 
-      const defs = findNodesByFile(db, fn.file) as NodeRow[];
+      const defs = repo.findNodesByFile(fn.file) as NodeRow[];
 
       return {
         file: fn.file,
@@ -64,9 +55,11 @@ export function fileDepsData(
 /**
  * BFS transitive caller traversal starting from `callers` of `nodeId`.
  * Returns an object keyed by depth (2..depth) -> array of caller descriptors.
+ *
+ * Uses Repository.findCallers() so it works with both native and WASM engines.
  */
 function buildTransitiveCallers(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   callers: Array<{ id: number; name: string; kind: string; file: string; line: number }>,
   nodeId: number,
   depth: number,
@@ -81,28 +74,12 @@ function buildTransitiveCallers(
   const visited = new Set([nodeId]);
   let frontier = callers;
 
-  const upstreamStmt = cachedStmt(
-    _upstreamStmtCache,
-    db,
-    `
-    SELECT n.id, n.name, n.kind, n.file, n.line
-    FROM edges e JOIN nodes n ON e.source_id = n.id
-    WHERE e.target_id = ? AND e.kind = 'calls'
-  `,
-  );
-
   for (let d = 2; d <= depth; d++) {
     const nextFrontier: typeof frontier = [];
     for (const f of frontier) {
       if (visited.has(f.id)) continue;
       visited.add(f.id);
-      const upstream = upstreamStmt.all(f.id) as Array<{
-        id: number;
-        name: string;
-        kind: string;
-        file: string;
-        line: number;
-      }>;
+      const upstream = repo.findCallers(f.id) as RelatedNodeRow[];
       for (const u of upstream) {
         if (noTests && isTestFile(u.file)) continue;
         if (!visited.has(u.id)) {
@@ -125,6 +102,59 @@ function buildTransitiveCallers(
   return transitiveCallers;
 }
 
+function collectCallersWithHierarchy(
+  repo: InstanceType<typeof Repository>,
+  node: NodeRow,
+  noTests: boolean,
+): Array<RelatedNodeRow & { viaHierarchy?: string }> {
+  let callers: Array<RelatedNodeRow & { viaHierarchy?: string }> = repo.findCallers(
+    node.id,
+  ) as RelatedNodeRow[];
+
+  if (node.kind === 'method' && node.name.includes('.')) {
+    const methodName = node.name.split('.').pop()!;
+    const relatedMethods = resolveMethodViaHierarchy(repo, methodName);
+    for (const rm of relatedMethods) {
+      if (rm.id === node.id) continue;
+      const extraCallers = repo.findCallers(rm.id) as RelatedNodeRow[];
+      callers.push(...extraCallers.map((c) => ({ ...c, viaHierarchy: rm.name })));
+    }
+  }
+  if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
+  return callers;
+}
+
+function buildNodeDepsResult(
+  repo: InstanceType<typeof Repository>,
+  node: NodeRow,
+  hc: Map<string, string | null>,
+  depth: number,
+  noTests: boolean,
+) {
+  const callees = repo.findCallees(node.id) as RelatedNodeRow[];
+  const filteredCallees = noTests ? callees.filter((c) => !isTestFile(c.file)) : callees;
+  const callers = collectCallersWithHierarchy(repo, node, noTests);
+  const transitiveCallers = buildTransitiveCallers(repo, callers, node.id, depth, noTests);
+
+  return {
+    ...normalizeSymbol(node, repo, hc),
+    callees: filteredCallees.map((c) => ({
+      name: c.name,
+      kind: c.kind,
+      file: c.file,
+      line: c.line,
+    })),
+    callers: callers.map((c) => ({
+      name: c.name,
+      kind: c.kind,
+      file: c.file,
+      line: c.line,
+      viaHierarchy: c.viaHierarchy || undefined,
+    })),
+    transitiveCallers,
+  };
+}
+
 export function fnDepsData(
   name: string,
   customDbPath: string,
@@ -137,56 +167,17 @@ export function fnDepsData(
     offset?: number;
   } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const depth = opts.depth || 3;
     const noTests = opts.noTests || false;
     const hc = new Map();
 
-    const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findMatchingNodes(repo, name, { noTests, file: opts.file, kind: opts.kind });
     if (nodes.length === 0) {
       return { name, results: [] };
     }
 
-    const results = nodes.map((node) => {
-      const callees = findCallees(db, node.id) as RelatedNodeRow[];
-      const filteredCallees = noTests ? callees.filter((c) => !isTestFile(c.file)) : callees;
-
-      let callers: Array<RelatedNodeRow & { viaHierarchy?: string }> = findCallers(
-        db,
-        node.id,
-      ) as RelatedNodeRow[];
-
-      if (node.kind === 'method' && node.name.includes('.')) {
-        const methodName = node.name.split('.').pop()!;
-        const relatedMethods = resolveMethodViaHierarchy(db, methodName);
-        for (const rm of relatedMethods) {
-          if (rm.id === node.id) continue;
-          const extraCallers = findCallers(db, rm.id) as RelatedNodeRow[];
-          callers.push(...extraCallers.map((c) => ({ ...c, viaHierarchy: rm.name })));
-        }
-      }
-      if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
-
-      const transitiveCallers = buildTransitiveCallers(db, callers, node.id, depth, noTests);
-
-      return {
-        ...normalizeSymbol(node, db, hc),
-        callees: filteredCallees.map((c) => ({
-          name: c.name,
-          kind: c.kind,
-          file: c.file,
-          line: c.line,
-        })),
-        callers: callers.map((c) => ({
-          name: c.name,
-          kind: c.kind,
-          file: c.file,
-          line: c.line,
-          viaHierarchy: c.viaHierarchy || undefined,
-        })),
-        transitiveCallers,
-      };
-    });
+    const results = nodes.map((node) => buildNodeDepsResult(repo, node, hc, depth, noTests));
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });

package/src/domain/analysis/fn-impact.ts

@@ -1,40 +1,32 @@
-import {
-  findDistinctCallers,
-  findFileNodes,
-  findImplementors,
-  findImportDependents,
-  findNodeById,
-} from '../../db/index.js';
+import { Repository, SqliteRepository } from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { BetterSqlite3Database, NodeRow, RelatedNodeRow } from '../../types.js';
-import { resolveAnalysisOpts, withReadonlyDb } from './query-helpers.js';
+import { resolveAnalysisOpts, withRepo } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
+/** Cache so repeated raw-db calls reuse the same SqliteRepository (preserves per-instance memoization). */
+const repoCache = new WeakMap<BetterSqlite3Database, InstanceType<typeof SqliteRepository>>();
+
+/** Coerce a raw db handle or Repository into a Repository instance. */
+function toRepo(
+  dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
+): InstanceType<typeof Repository> {
+  if (dbOrRepo instanceof Repository) return dbOrRepo;
+  const db = dbOrRepo as BetterSqlite3Database;
+  let repo = repoCache.get(db);
+  if (!repo) {
+    repo = new SqliteRepository(db);
+    repoCache.set(db, repo);
+  }
+  return repo;
+}
+
 // --- Shared BFS: transitive callers ---
 
 const INTERFACE_LIKE_KINDS = new Set(['interface', 'trait']);
 
-/**
- * Check whether the graph contains any 'implements' edges.
- * Cached per db handle so the query runs at most once per connection.
- */
-const _hasImplementsCache: WeakMap<BetterSqlite3Database, boolean> = new WeakMap();
-function hasImplementsEdges(db: BetterSqlite3Database): boolean {
-  if (_hasImplementsCache.has(db)) return _hasImplementsCache.get(db)!;
-  const row = db.prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1").get();
-  const result = !!row;
-  _hasImplementsCache.set(db, result);
-  return result;
-}
-
-/**
- * BFS traversal to find transitive callers of a node.
- * When an interface/trait node is encountered (either as the start node or
- * during traversal), its concrete implementors are also added to the frontier
- * so that changes to an interface signature propagate to all implementors.
- */
 type BfsLevel = Array<{
   name: string;
   kind: string;
@@ -76,7 +68,7 @@ function recordImplementor(
 
 /** Expand implementors for an interface/trait node into the BFS frontier. */
 function expandImplementors(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   nodeId: number,
   depth: number,
   visited: Set<number>,
@@ -85,14 +77,14 @@ function expandImplementors(
   noTests: boolean,
   onVisit?: BfsOnVisit,
 ): void {
-  const impls = findImplementors(db, nodeId) as RelatedNodeRow[];
+  const impls = repo.findImplementors(nodeId) as RelatedNodeRow[];
   for (const impl of impls) {
     recordImplementor(impl, nodeId, depth, visited, frontier, levels, noTests, onVisit);
   }
 }
 
 export function bfsTransitiveCallers(
-  db: BetterSqlite3Database,
+  dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
   startId: number,
   {
     noTests = false,
@@ -106,7 +98,8 @@ export function bfsTransitiveCallers(
     onVisit?: BfsOnVisit;
   } = {},
 ) {
-  const resolveImplementors = includeImplementors && hasImplementsEdges(db);
+  const repo = toRepo(dbOrRepo);
+  const resolveImplementors = includeImplementors && repo.hasImplementsEdges();
   const visited = new Set([startId]);
   const levels: BfsLevels = {};
   let frontier = [startId];
@@ -114,9 +107,9 @@ export function bfsTransitiveCallers(
   // Seed: if start node is an interface/trait, include its implementors at depth 1
   const implNextFrontier: number[] = [];
   if (resolveImplementors) {
-    const startNode = findNodeById(db, startId) as NodeRow | undefined;
+    const startNode = repo.findNodeById(startId) as NodeRow | undefined;
     if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
-      expandImplementors(db, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
+      expandImplementors(repo, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
     }
   }
 
@@ -126,7 +119,7 @@ export function bfsTransitiveCallers(
     }
     const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      const callers = findDistinctCallers(db, fid) as RelatedNodeRow[];
+      const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
       for (const c of callers) {
         if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
           visited.add(c.id);
@@ -136,7 +129,7 @@ export function bfsTransitiveCallers(
           if (onVisit) onVisit(c, fid, d);
         }
         if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
-          expandImplementors(db, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
+          expandImplementors(repo, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
         }
       }
     }
@@ -152,9 +145,9 @@ export function impactAnalysisData(
   customDbPath: string,
   opts: { noTests?: boolean } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
-    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    const fileNodes = repo.findFileNodes(`%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, sources: [], levels: {}, totalDependents: 0 };
     }
@@ -172,7 +165,7 @@ export function impactAnalysisData(
     while (queue.length > 0) {
       const current = queue.shift()!;
       const level = levels.get(current)!;
-      const dependents = findImportDependents(db, current) as RelatedNodeRow[];
+      const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
       for (const dep of dependents) {
         if (!visited.has(dep.id) && (!noTests || !isTestFile(dep.file))) {
           visited.add(dep.id);
@@ -186,7 +179,7 @@ export function impactAnalysisData(
     for (const [id, level] of levels) {
       if (level === 0) continue;
       if (!byLevel[level]) byLevel[level] = [];
-      const node = findNodeById(db, id) as NodeRow | undefined;
+      const node = repo.findNodeById(id) as NodeRow | undefined;
       if (node) byLevel[level].push({ file: node.file });
     }
 
@@ -213,12 +206,12 @@ export function fnImpactData(
     config?: any;
   } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const { noTests, config } = resolveAnalysisOpts(opts);
     const maxDepth = opts.depth || config.analysis?.fnImpactDepth || 5;
     const hc = new Map();
 
-    const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findMatchingNodes(repo, name, { noTests, file: opts.file, kind: opts.kind });
     if (nodes.length === 0) {
       return { name, results: [] };
     }
@@ -226,13 +219,13 @@ export function fnImpactData(
     const includeImplementors = opts.includeImplementors !== false;
 
     const results = nodes.map((node) => {
-      const { levels, totalDependents } = bfsTransitiveCallers(db, node.id, {
+      const { levels, totalDependents } = bfsTransitiveCallers(repo, node.id, {
         noTests,
         maxDepth,
         includeImplementors,
       });
       return {
-        ...normalizeSymbol(node, db, hc),
+        ...normalizeSymbol(node, repo, hc),
         levels,
         totalDependents,
       };

package/src/domain/analysis/implementations.ts

@@ -1,9 +1,9 @@
-import { findImplementors, findInterfaces, openReadonlyOrFail } from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { CORE_SYMBOL_KINDS } from '../../shared/kinds.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { RelatedNodeRow } from '../../types.js';
+import { withRepo } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 /**
@@ -14,12 +14,11 @@ export function implementationsData(
   customDbPath: string,
   opts: { noTests?: boolean; file?: string; kind?: string; limit?: number; offset?: number } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
     const hc = new Map();
 
-    const nodes = findMatchingNodes(db, name, {
+    const nodes = findMatchingNodes(repo, name, {
       noTests,
       file: opts.file,
       kind: opts.kind,
@@ -30,11 +29,11 @@ export function implementationsData(
     }
 
     const results = nodes.map((node) => {
-      let implementors = findImplementors(db, node.id) as RelatedNodeRow[];
+      let implementors = repo.findImplementors(node.id) as RelatedNodeRow[];
       if (noTests) implementors = implementors.filter((n) => !isTestFile(n.file));
 
       return {
-        ...normalizeSymbol(node, db, hc),
+        ...normalizeSymbol(node, repo, hc),
         implementors: implementors.map((impl) => ({
           name: impl.name,
           kind: impl.kind,
@@ -46,9 +45,7 @@ export function implementationsData(
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }
 
 /**
@@ -59,12 +56,11 @@ export function interfacesData(
   customDbPath: string,
   opts: { noTests?: boolean; file?: string; kind?: string; limit?: number; offset?: number } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
     const hc = new Map();
 
-    const nodes = findMatchingNodes(db, name, {
+    const nodes = findMatchingNodes(repo, name, {
       noTests,
       file: opts.file,
       kind: opts.kind,
@@ -75,11 +71,11 @@ export function interfacesData(
     }
 
     const results = nodes.map((node) => {
-      let interfaces = findInterfaces(db, node.id) as RelatedNodeRow[];
+      let interfaces = repo.findInterfaces(node.id) as RelatedNodeRow[];
       if (noTests) interfaces = interfaces.filter((n) => !isTestFile(n.file));
 
       return {
-        ...normalizeSymbol(node, db, hc),
+        ...normalizeSymbol(node, repo, hc),
         interfaces: interfaces.map((iface) => ({
           name: iface.name,
           kind: iface.kind,
@@ -91,7 +87,5 @@ export function interfacesData(
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }