codegraph/__tests__/concurrent-locking.test.ts

/**
 * Issue #238 — "database is locked" on concurrent MCP tool calls.
 *
 * With node:sqlite (real WAL) as the backend, the fixes that remain relevant:
 *  1. busy_timeout is a bounded few-second wait (not a 2-minute hang) and WAL is
 *     active — so a reader never blocks on a concurrent writer.
 *  2. The MCP ToolHandler reuses the default instance when a tool passes a
 *     projectPath pointing at the default project, instead of opening a SECOND
 *     connection to the same DB.
 */

import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import CodeGraph from '../src';
import { ToolHandler } from '../src/mcp/tools';
import { DatabaseConnection } from '../src/db';

/** Normalize a PRAGMA read across return shapes (array | object | scalar). */
function pragmaValue(raw: unknown, key: string): unknown {
  const row = Array.isArray(raw) ? raw[0] : raw;
  if (row !== null && typeof row === 'object') return (row as Record<string, unknown>)[key];
  return row;
}

describe('issue #238 — connection PRAGMAs (#1)', () => {
  let dir: string;
  let conn: DatabaseConnection;

  beforeAll(() => {
    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg238-pragma-'));
    conn = DatabaseConnection.initialize(path.join(dir, 'codegraph.db'));
  });

  afterAll(() => {
    conn.close();
    fs.rmSync(dir, { recursive: true, force: true });
  });

  it('uses a bounded busy_timeout, not the old 2-minute hang', () => {
    const ms = Number(pragmaValue(conn.getDb().pragma('busy_timeout'), 'timeout'));
    expect(ms).toBeGreaterThan(0);
    expect(ms).toBeLessThanOrEqual(30000); // far below the old 120000
  });

  it('runs in WAL mode — the mode that lets readers proceed during a write', () => {
    const mode = String(pragmaValue(conn.getDb().pragma('journal_mode'), 'journal_mode')).toLowerCase();
    expect(mode).toBe('wal');
  });

  it('getJournalMode() surfaces the effective mode for status triage', () => {
    expect(conn.getJournalMode()).toBe('wal');
  });
});

describe('issue #238 — WAL lets a reader proceed during a writer', () => {
  let dir: string;

  beforeAll(() => {
    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg238-wal-'));
  });

  afterAll(() => {
    fs.rmSync(dir, { recursive: true, force: true });
  });

  it('a read on a 2nd connection succeeds while a writer holds the lock', () => {
    const dbPath = path.join(dir, 'codegraph.db');
    const writer = DatabaseConnection.initialize(dbPath);
    // The property only holds under WAL; skip if the filesystem couldn't enable it.
    if (writer.getJournalMode() !== 'wal') {
      writer.close();
      return;
    }
    const reader = DatabaseConnection.open(dbPath);
    try {
      writer.getDb().prepare('BEGIN EXCLUSIVE').run(); // hard write lock, held open
      const t0 = Date.now();
      const row = reader.getDb().prepare('SELECT COUNT(*) AS c FROM nodes').get() as { c: number };
      const waited = Date.now() - t0;
      expect(row.c).toBe(0);
      expect(waited).toBeLessThan(1000); // proceeds immediately, no busy wait
    } finally {
      try { writer.getDb().prepare('COMMIT').run(); } catch { /* ignore */ }
      reader.close();
      writer.close();
    }
  });
});

describe('issue #238 — ToolHandler reuses the default instance (#2)', () => {
  let dir: string;
  let cg: CodeGraph;
  let root: string;
  let handler: ToolHandler;

  beforeAll(async () => {
    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg238-tools-'));
    fs.writeFileSync(path.join(dir, 'a.ts'), 'export function helper(): number { return 1; }\n');
    fs.writeFileSync(
      path.join(dir, 'b.ts'),
      "import { helper } from './a';\nexport function main(): number { return helper(); }\n"
    );
    cg = await CodeGraph.init(dir, { index: true });
    root = cg.getProjectRoot();
    handler = new ToolHandler(cg);
  });

  afterAll(() => {
    cg.close();
    fs.rmSync(dir, { recursive: true, force: true });
  });

  it('getCodeGraph(defaultRoot) returns the default instance, not a new connection', () => {
    const openSpy = vi.spyOn(CodeGraph, 'openSync');
    try {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      const resolved = (handler as any).getCodeGraph(root);
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      const nested = (handler as any).getCodeGraph(path.join(root, 'does', 'not', 'exist'));
      expect(resolved).toBe(cg);
      expect(nested).toBe(cg); // a sub-path resolves up to the same default project
      expect(openSpy).not.toHaveBeenCalled(); // no second connection opened
    } finally {
      openSpy.mockRestore();
    }
  });

  it('concurrent read tool calls (mixed projectPath) all succeed without "database is locked"', async () => {
    const openSpy = vi.spyOn(CodeGraph, 'openSync');
    try {
      const calls: Promise<{ content: Array<{ text: string }>; isError?: boolean }>[] = [
        handler.execute('codegraph_search', { query: 'helper' }),
        handler.execute('codegraph_search', { query: 'helper', projectPath: root }),
        handler.execute('codegraph_callers', { symbol: 'helper', projectPath: root }),
        handler.execute('codegraph_callees', { symbol: 'main' }),
        handler.execute('codegraph_files', { projectPath: root }),
        handler.execute('codegraph_status', { projectPath: root }),
      ];
      const results = await Promise.all(calls);
      for (const r of results) {
        expect(r.isError).not.toBe(true);
        expect(r.content[0]?.text ?? '').not.toMatch(/database is locked/i);
      }
      // Passing the default project's own path must not open a second connection.
      expect(openSpy).not.toHaveBeenCalled();
    } finally {
      openSpy.mockRestore();
    }
  });
});