@optave/codegraph 3.1.2 → 3.1.4

package/src/db/repository/base.js

@@ -0,0 +1,201 @@
+/**
+ * Abstract Repository base class.
+ *
+ * Defines the contract for all graph data access. Every method throws
+ * "not implemented" by default — concrete subclasses override what they support.
+ */
+export class Repository {
+  // ── Node lookups ────────────────────────────────────────────────────
+  /** @param {number} id @returns {object|undefined} */
+  findNodeById(_id) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} file @returns {object[]} */
+  findNodesByFile(_file) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} fileLike @returns {object[]} */
+  findFileNodes(_fileLike) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} namePattern @param {object} [opts] @returns {object[]} */
+  findNodesWithFanIn(_namePattern, _opts) {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {number} */
+  countNodes() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {number} */
+  countEdges() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {number} */
+  countFiles() {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} name @param {string} kind @param {string} file @param {number} line @returns {number|undefined} */
+  getNodeId(_name, _kind, _file, _line) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} name @param {string} file @param {number} line @returns {number|undefined} */
+  getFunctionNodeId(_name, _file, _line) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} file @returns {{ id: number, name: string, kind: string, line: number }[]} */
+  bulkNodeIdsByFile(_file) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} parentId @returns {object[]} */
+  findNodeChildren(_parentId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} scopeName @param {object} [opts] @returns {object[]} */
+  findNodesByScope(_scopeName, _opts) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} qualifiedName @param {object} [opts] @returns {object[]} */
+  findNodeByQualifiedName(_qualifiedName, _opts) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {object} [opts] @returns {object[]} */
+  listFunctionNodes(_opts) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {object} [opts] @returns {IterableIterator} */
+  iterateFunctionNodes(_opts) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {object} [opts] @returns {object[]} */
+  findNodesForTriage(_opts) {
+    throw new Error('not implemented');
+  }
+
+  // ── Edge queries ────────────────────────────────────────────────────
+  /** @param {number} nodeId @returns {object[]} */
+  findCallees(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {object[]} */
+  findCallers(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {object[]} */
+  findDistinctCallers(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {object[]} */
+  findAllOutgoingEdges(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {object[]} */
+  findAllIncomingEdges(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {string[]} */
+  findCalleeNames(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {string[]} */
+  findCallerNames(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {{ file: string, edge_kind: string }[]} */
+  findImportTargets(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {{ file: string, edge_kind: string }[]} */
+  findImportSources(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {object[]} */
+  findImportDependents(_nodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} file @returns {Set<number>} */
+  findCrossFileCallTargets(_file) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @param {string} file @returns {number} */
+  countCrossFileCallers(_nodeId, _file) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} classNodeId @returns {Set<number>} */
+  getClassHierarchy(_classNodeId) {
+    throw new Error('not implemented');
+  }
+
+  /** @param {string} file @returns {{ caller_name: string, callee_name: string }[]} */
+  findIntraFileCallEdges(_file) {
+    throw new Error('not implemented');
+  }
+
+  // ── Graph-read queries ──────────────────────────────────────────────
+  /** @returns {{ id: number, name: string, kind: string, file: string }[]} */
+  getCallableNodes() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {{ source_id: number, target_id: number }[]} */
+  getCallEdges() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {{ id: number, name: string, file: string }[]} */
+  getFileNodesAll() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {{ source_id: number, target_id: number }[]} */
+  getImportEdges() {
+    throw new Error('not implemented');
+  }
+
+  // ── Optional table checks (default: false/undefined) ────────────────
+  /** @returns {boolean} */
+  hasCfgTables() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {boolean} */
+  hasEmbeddings() {
+    throw new Error('not implemented');
+  }
+
+  /** @returns {boolean} */
+  hasDataflowTable() {
+    throw new Error('not implemented');
+  }
+
+  /** @param {number} nodeId @returns {object|undefined} */
+  getComplexityForNode(_nodeId) {
+    throw new Error('not implemented');
+  }
+}

package/src/db/repository/cached-stmt.js

@@ -0,0 +1,19 @@
+/**
+ * Resolve a cached prepared statement, compiling on first use per db.
+ * Each `cache` WeakMap must always be called with the same `sql` —
+ * the sql argument is only used on the first compile; subsequent calls
+ * return the cached statement regardless of the sql passed.
+ *
+ * @param {WeakMap} cache  - WeakMap keyed by db instance
+ * @param {object}  db     - better-sqlite3 database instance
+ * @param {string}  sql    - SQL to compile on first use
+ * @returns {object} prepared statement
+ */
+export function cachedStmt(cache, db, sql) {
+  let stmt = cache.get(db);
+  if (!stmt) {
+    stmt = db.prepare(sql);
+    cache.set(db, stmt);
+  }
+  return stmt;
+}

package/src/db/repository/cfg.js

@@ -1,5 +1,6 @@
+import { cachedStmt } from './cached-stmt.js';
+
 // ─── Statement caches (one prepared statement per db instance) ────────────
-// WeakMap keys on the db object so statements are GC'd when the db closes.
 const _getCfgBlocksStmt = new WeakMap();
 const _getCfgEdgesStmt = new WeakMap();
 const _deleteCfgEdgesStmt = new WeakMap();
@@ -26,16 +27,13 @@ export function hasCfgTables(db) {
  * @returns {object[]}
  */
 export function getCfgBlocks(db, functionNodeId) {
-  let stmt = _getCfgBlocksStmt.get(db);
-  if (!stmt) {
-    stmt = db.prepare(
-      `SELECT id, block_index, block_type, start_line, end_line, label
-       FROM cfg_blocks WHERE function_node_id = ?
-       ORDER BY block_index`,
-    );
-    _getCfgBlocksStmt.set(db, stmt);
-  }
-  return stmt.all(functionNodeId);
+  return cachedStmt(
+    _getCfgBlocksStmt,
+    db,
+    `SELECT id, block_index, block_type, start_line, end_line, label
+     FROM cfg_blocks WHERE function_node_id = ?
+     ORDER BY block_index`,
+  ).all(functionNodeId);
 }
 
 /**
@@ -45,21 +43,18 @@ export function getCfgBlocks(db, functionNodeId) {
  * @returns {object[]}
  */
 export function getCfgEdges(db, functionNodeId) {
-  let stmt = _getCfgEdgesStmt.get(db);
-  if (!stmt) {
-    stmt = db.prepare(
-      `SELECT e.kind,
-              sb.block_index AS source_index, sb.block_type AS source_type,
-              tb.block_index AS target_index, tb.block_type AS target_type
-       FROM cfg_edges e
-       JOIN cfg_blocks sb ON e.source_block_id = sb.id
-       JOIN cfg_blocks tb ON e.target_block_id = tb.id
-       WHERE e.function_node_id = ?
-       ORDER BY sb.block_index, tb.block_index`,
-    );
-    _getCfgEdgesStmt.set(db, stmt);
-  }
-  return stmt.all(functionNodeId);
+  return cachedStmt(
+    _getCfgEdgesStmt,
+    db,
+    `SELECT e.kind,
+            sb.block_index AS source_index, sb.block_type AS source_type,
+            tb.block_index AS target_index, tb.block_type AS target_type
+     FROM cfg_edges e
+     JOIN cfg_blocks sb ON e.source_block_id = sb.id
+     JOIN cfg_blocks tb ON e.target_block_id = tb.id
+     WHERE e.function_node_id = ?
+     ORDER BY sb.block_index, tb.block_index`,
+  ).all(functionNodeId);
 }
 
 /**
@@ -68,16 +63,10 @@ export function getCfgEdges(db, functionNodeId) {
  * @param {number} functionNodeId
  */
 export function deleteCfgForNode(db, functionNodeId) {
-  let delEdges = _deleteCfgEdgesStmt.get(db);
-  if (!delEdges) {
-    delEdges = db.prepare('DELETE FROM cfg_edges WHERE function_node_id = ?');
-    _deleteCfgEdgesStmt.set(db, delEdges);
-  }
-  let delBlocks = _deleteCfgBlocksStmt.get(db);
-  if (!delBlocks) {
-    delBlocks = db.prepare('DELETE FROM cfg_blocks WHERE function_node_id = ?');
-    _deleteCfgBlocksStmt.set(db, delBlocks);
-  }
-  delEdges.run(functionNodeId);
-  delBlocks.run(functionNodeId);
+  cachedStmt(_deleteCfgEdgesStmt, db, 'DELETE FROM cfg_edges WHERE function_node_id = ?').run(
+    functionNodeId,
+  );
+  cachedStmt(_deleteCfgBlocksStmt, db, 'DELETE FROM cfg_blocks WHERE function_node_id = ?').run(
+    functionNodeId,
+  );
 }

package/src/db/repository/cochange.js

@@ -1,3 +1,10 @@
+import { cachedStmt } from './cached-stmt.js';
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+const _hasCoChangesStmt = new WeakMap();
+const _getCoChangeMetaStmt = new WeakMap();
+const _upsertCoChangeMetaStmt = new WeakMap();
+
 /**
  * Check whether the co_changes table has data.
  * @param {object} db
@@ -5,7 +12,7 @@
  */
 export function hasCoChanges(db) {
   try {
-    return !!db.prepare('SELECT 1 FROM co_changes LIMIT 1').get();
+    return !!cachedStmt(_hasCoChangesStmt, db, 'SELECT 1 FROM co_changes LIMIT 1').get();
   } catch {
     return false;
   }
@@ -19,7 +26,11 @@ export function hasCoChanges(db) {
 export function getCoChangeMeta(db) {
   const meta = {};
   try {
-    for (const row of db.prepare('SELECT key, value FROM co_change_meta').all()) {
+    for (const row of cachedStmt(
+      _getCoChangeMetaStmt,
+      db,
+      'SELECT key, value FROM co_change_meta',
+    ).all()) {
       meta[row.key] = row.value;
     }
   } catch {
@@ -35,7 +46,9 @@ export function getCoChangeMeta(db) {
  * @param {string} value
  */
 export function upsertCoChangeMeta(db, key, value) {
-  db.prepare(
+  cachedStmt(
+    _upsertCoChangeMetaStmt,
+    db,
     'INSERT INTO co_change_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value',
   ).run(key, value);
 }

package/src/db/repository/complexity.js

@@ -1,3 +1,8 @@
+import { cachedStmt } from './cached-stmt.js';
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+const _getComplexityForNodeStmt = new WeakMap();
+
 /**
  * Get complexity metrics for a node.
  * Used by contextData and explainFunctionImpl in queries.js.
@@ -6,10 +11,10 @@
  * @returns {{ cognitive: number, cyclomatic: number, max_nesting: number, maintainability_index: number, halstead_volume: number }|undefined}
  */
 export function getComplexityForNode(db, nodeId) {
-  return db
-    .prepare(
-      `SELECT cognitive, cyclomatic, max_nesting, maintainability_index, halstead_volume
-       FROM function_complexity WHERE node_id = ?`,
-    )
-    .get(nodeId);
+  return cachedStmt(
+    _getComplexityForNodeStmt,
+    db,
+    `SELECT cognitive, cyclomatic, max_nesting, maintainability_index, halstead_volume
+     FROM function_complexity WHERE node_id = ?`,
+  ).get(nodeId);
 }

package/src/db/repository/dataflow.js

@@ -1,3 +1,8 @@
+import { cachedStmt } from './cached-stmt.js';
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+const _hasDataflowTableStmt = new WeakMap();
+
 /**
  * Check whether the dataflow table exists and has data.
  * @param {object} db
@@ -5,7 +10,7 @@
  */
 export function hasDataflowTable(db) {
   try {
-    return db.prepare('SELECT COUNT(*) AS c FROM dataflow').get().c > 0;
+    return cachedStmt(_hasDataflowTableStmt, db, 'SELECT COUNT(*) AS c FROM dataflow').get().c > 0;
   } catch {
     return false;
   }