@monoes/monograph 1.5.6 → 1.5.8

package/__tests__/integration/call-attribution.test.ts

@@ -1,116 +0,0 @@
-/**
- * CALLS edges must be attributed to the function containing the call, not to
- * the containing file.
- *
- * Attributing them to the file gave every function an inbound CALLS edge from
- * its own file purely for being declared there, which silently disabled
- * dead-export detection: `detectDeadCodeNodes` rejects any candidate with an
- * inbound CALLS/IMPORTS/REFERENCES/RE_EXPORTS edge, and that self-edge always
- * matched. Measured on the monomind repo before the fix: 9,672 of 9,672 CALLS
- * edges originated from a File node, 1,942 of 1,951 exported functions carried
- * a self-file edge, and 1,107 had it as their only inbound edge — while the
- * tool reported a single dead-code candidate.
- *
- * Calls at module top level are genuinely file-scoped and must keep a File
- * source, so this pins both directions.
- */
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
-import { buildAsync } from '../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { detectDeadCodeNodes } from '../../src/graph/dead-code.js';
-import type { Database } from 'better-sqlite3';
-
-const tmpRepo = join(tmpdir(), `monograph-call-attribution-${Date.now()}`);
-let db: Database;
-
-beforeAll(async () => {
-  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
-
-  writeFileSync(join(tmpRepo, 'src', 'util.ts'), 'export function helper(n: string): string { return `hi ${n}`; }\n');
-
-  // greet() calls helper() from inside a method — must be attributed to greet.
-  // neverCalledAnywhere is exported and called by nobody.
-  writeFileSync(
-    join(tmpRepo, 'src', 'service.ts'),
-    [
-      "import { helper } from './util.js';",
-      'export class UserService {',
-      '  constructor(private readonly name: string) {}',
-      '  greet(): string { return helper(this.name); }',
-      '}',
-      'export function neverCalledAnywhere(): number { return 42; }',
-      '',
-    ].join('\n'),
-  );
-
-  // Calls at module top level — legitimately file-scoped.
-  writeFileSync(
-    join(tmpRepo, 'src', 'main.ts'),
-    [
-      "import { UserService } from './service.js';",
-      "const s = new UserService('a');",
-      'console.log(s.greet());',
-      '',
-    ].join('\n'),
-  );
-
-  await buildAsync(tmpRepo, { codeOnly: true, force: true });
-  db = openDb(join(tmpRepo, '.monomind', 'monograph.db'));
-}, 60000);
-
-afterAll(() => {
-  if (db) closeDb(db);
-  rmSync(tmpRepo, { recursive: true, force: true });
-});
-
-function callSources(targetName: string): Array<{ label: string; name: string }> {
-  return db
-    .prepare(
-      `SELECT s.label, s.name FROM edges e
-         JOIN nodes s ON e.source_id = s.id
-         JOIN nodes t ON e.target_id = t.id
-        WHERE e.relation = 'CALLS' AND t.name = ?`,
-    )
-    .all(targetName) as Array<{ label: string; name: string }>;
-}
-
-describe('CALLS edge attribution', () => {
-  it('attributes a call inside a method to that method', () => {
-    const sources = callSources('helper');
-    expect(sources.length).toBeGreaterThan(0);
-    expect(sources.some(s => s.label === 'Method' && s.name === 'greet')).toBe(true);
-  });
-
-  it('does not attribute a call to the file merely containing the callee', () => {
-    // `helper` is declared in util.ts. util.ts must not "call" it.
-    expect(callSources('helper').some(s => s.label === 'File' && s.name === 'util.ts')).toBe(false);
-  });
-
-  it('keeps module-top-level calls attributed to the file', () => {
-    // main.ts calls s.greet() and `new UserService()` at top level.
-    const row = db
-      .prepare(
-        `SELECT COUNT(*) c FROM edges e JOIN nodes s ON e.source_id = s.id
-          WHERE e.relation = 'CALLS' AND s.label = 'File' AND s.name = 'main.ts'`,
-      )
-      .get() as { c: number };
-    expect(row.c).toBeGreaterThan(0);
-  });
-
-  it('leaves an uncalled exported function with no inbound CALLS edge', () => {
-    expect(callSources('neverCalledAnywhere').length).toBe(0);
-  });
-
-  it('lets dead-code detection find a genuinely uncalled export', () => {
-    expect(detectDeadCodeNodes(db).map(n => n.name)).toContain('neverCalledAnywhere');
-  });
-
-  it('still records the calls that really happen', () => {
-    // The fix must move attribution, not drop edges: greet->helper and the two
-    // top-level calls in main.ts should all survive.
-    const total = db.prepare("SELECT COUNT(*) c FROM edges WHERE relation = 'CALLS'").get() as { c: number };
-    expect(total.c).toBeGreaterThanOrEqual(3);
-  });
-});

package/__tests__/integration/full-pipeline.test.ts

@@ -1,64 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { countNodes } from '../../src/storage/node-store.js';
-import { countEdges } from '../../src/storage/edge-store.js';
-import { ftsSearch } from '../../src/storage/fts-store.js';
-
-const tmpRepo = join(tmpdir(), `monograph-integration-${Date.now()}`);
-
-beforeAll(() => {
-  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
-  writeFileSync(join(tmpRepo, 'src', 'auth.ts'), `
-export interface AuthService {
-  login(username: string, password: string): Promise<boolean>;
-}
-export class AuthServiceImpl implements AuthService {
-  async login(username: string, password: string): Promise<boolean> {
-    return username.length > 0;
-  }
-}
-  `);
-  writeFileSync(join(tmpRepo, 'src', 'user.ts'), `
-import { AuthService } from './auth';
-export class UserController {
-  constructor(private auth: AuthService) {}
-  async authenticate(u: string, p: string) {
-    return this.auth.login(u, p);
-  }
-}
-  `);
-});
-
-afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
-
-describe('full pipeline integration', () => {
-  it('builds without errors', async () => {
-    await expect(buildAsync(tmpRepo)).resolves.not.toThrow();
-  }, 30000);
-
-  it('creates the SQLite database', () => {
-    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('indexes nodes and edges', () => {
-    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
-    const db = openDb(dbPath);
-    const nodes = countNodes(db);
-    const edges = countEdges(db);
-    closeDb(db);
-    expect(nodes).toBeGreaterThan(2);
-    expect(edges).toBeGreaterThan(0);
-  });
-
-  it('FTS search finds AuthService', () => {
-    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
-    const db = openDb(dbPath);
-    const results = ftsSearch(db, 'AuthService', 10);
-    closeDb(db);
-    expect(results.some(r => r.name === 'AuthService' || r.name === 'AuthServiceImpl')).toBe(true);
-  });
-}, 60000);

package/__tests__/integration/graph-report-freshness.test.ts

@@ -1,53 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from 'fs';
-
-// Regression (issue #91): the graph report used to be generated inside the
-// open build transaction via the string overload of generateGraphReport,
-// which opens a SECOND DB connection. In WAL mode that connection only sees
-// the last committed snapshot, so GRAPH_REPORT.md was always one build stale —
-// on the very first build it rendered a completely empty graph. The report is
-// now generated after COMMIT.
-const tmpRepo = join(tmpdir(), `monograph-report-freshness-${Date.now()}`);
-
-beforeAll(() => {
-  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
-  writeFileSync(join(tmpRepo, 'src', 'greeter.ts'), `
-export interface Greeter {
-  greet(name: string): string;
-}
-export class GreeterImpl implements Greeter {
-  greet(name: string): string {
-    return 'hello ' + name;
-  }
-}
-  `);
-});
-
-afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
-
-describe('graph report freshness — report reflects the build that produced it', () => {
-  it('first build writes a report with the actual node count, not an empty snapshot', async () => {
-    const { buildAsync } = await import('../../src/pipeline/orchestrator.js');
-    await buildAsync(tmpRepo);
-
-    const reportPath = join(tmpRepo, 'GRAPH_REPORT.md');
-    expect(existsSync(reportPath)).toBe(true);
-
-    const { openDb, closeDb } = await import('../../src/storage/db.js');
-    const { countNodes } = await import('../../src/storage/node-store.js');
-    const db = openDb(join(tmpRepo, '.monomind', 'monograph.db'));
-    let nodeCount: number;
-    try {
-      nodeCount = countNodes(db);
-    } finally {
-      closeDb(db);
-    }
-    expect(nodeCount).toBeGreaterThan(0);
-
-    const report = readFileSync(reportPath, 'utf8');
-    // The report's overview table must reflect the just-committed build,
-    // not the previous (here: nonexistent) snapshot.
-    expect(report).toContain(`| Total nodes | ${nodeCount} |`);
-  }, 60000);
-});

package/__tests__/integration/incremental-build.test.ts

@@ -1,103 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync, unlinkSync } from 'fs';
-import { buildAsync, buildIncrementalAsync } from '../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { countNodes } from '../../src/storage/node-store.js';
-import { countEdges } from '../../src/storage/edge-store.js';
-import { ftsSearch } from '../../src/storage/fts-store.js';
-import { getNodesForFile } from '../../src/storage/node-store.js';
-
-const tmpRepo = join(tmpdir(), `monograph-incremental-${Date.now()}`);
-const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
-const srcDir = join(tmpRepo, 'src');
-
-beforeAll(async () => {
-  mkdirSync(srcDir, { recursive: true });
-  writeFileSync(join(srcDir, 'auth.ts'), `
-export class AuthService {
-  login(u: string): boolean { return u.length > 0; }
-}
-  `);
-  writeFileSync(join(srcDir, 'user.ts'), `
-export class UserController {
-  greet(): string { return 'hello'; }
-}
-  `);
-  await buildAsync(tmpRepo);
-}, 30000);
-
-afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
-
-describe('incremental build', () => {
-  it('updates nodes when a file is modified', async () => {
-    const db1 = openDb(dbPath);
-    const authNodesBefore = getNodesForFile(db1, 'src/auth.ts');
-    closeDb(db1);
-    expect(authNodesBefore.some(n => n.name === 'logout')).toBe(false);
-
-    writeFileSync(join(srcDir, 'auth.ts'), `
-export class AuthService {
-  login(u: string): boolean { return u.length > 0; }
-  logout(): void {}
-}
-export function helperFn(): string { return 'x'; }
-    `);
-
-    await buildIncrementalAsync(tmpRepo, [join(srcDir, 'auth.ts')]);
-
-    const db2 = openDb(dbPath);
-    const authNodesAfter = getNodesForFile(db2, 'src/auth.ts');
-    closeDb(db2);
-
-    expect(authNodesAfter.some(n => n.name === 'logout')).toBe(true);
-    expect(authNodesAfter.some(n => n.name === 'helperFn')).toBe(true);
-  }, 15000);
-
-  it('removes nodes when a file is deleted', async () => {
-    const db1 = openDb(dbPath);
-    const nodesBefore = countNodes(db1);
-    const userNodesBefore = getNodesForFile(db1, 'src/user.ts');
-    closeDb(db1);
-    expect(userNodesBefore.length).toBeGreaterThan(0);
-
-    unlinkSync(join(srcDir, 'user.ts'));
-    await buildIncrementalAsync(tmpRepo, [join(srcDir, 'user.ts')]);
-
-    const db2 = openDb(dbPath);
-    const nodesAfter = countNodes(db2);
-    const userNodesAfter = getNodesForFile(db2, 'src/user.ts');
-    closeDb(db2);
-
-    expect(userNodesAfter.length).toBe(0);
-    expect(nodesAfter).toBeLessThan(nodesBefore);
-  }, 15000);
-
-  it('FTS stays in sync after incremental update', async () => {
-    const db = openDb(dbPath);
-    const results = ftsSearch(db, 'helperFn', 10);
-    closeDb(db);
-    expect(results.some(r => r.name === 'helperFn')).toBe(true);
-  });
-
-  it('FTS removes deleted file symbols', async () => {
-    const db = openDb(dbPath);
-    const results = ftsSearch(db, 'UserController', 10);
-    closeDb(db);
-    expect(results.some(r => r.name === 'UserController')).toBe(false);
-  });
-
-  it('falls back to full build when threshold exceeded', async () => {
-    const manyFiles = Array.from({ length: 25 }, (_, i) => join(srcDir, `gen${i}.ts`));
-    for (const f of manyFiles) {
-      writeFileSync(f, `export const x${Math.random().toString(36).slice(2)} = 1;`);
-    }
-
-    await buildIncrementalAsync(tmpRepo, manyFiles);
-
-    const db = openDb(dbPath);
-    const nodes = countNodes(db);
-    closeDb(db);
-    expect(nodes).toBeGreaterThan(0);
-  }, 30000);
-}, 60000);

package/__tests__/mcp-resources/resources.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unlinkSync, existsSync } from 'fs';
-import { openDb, closeDb } from '../../src/storage/db.js';
-import { insertNode } from '../../src/storage/node-store.js';
-import { insertEdge } from '../../src/storage/edge-store.js';
-import { getProcessesResource } from '../../src/mcp-resources/processes-resource.js';
-import { getCommunitiesResource } from '../../src/mcp-resources/communities-resource.js';
-import { getSchemaResource } from '../../src/mcp-resources/schema-resource.js';
-import { getGraphResource } from '../../src/mcp-resources/graph-resource.js';
-import type { MonographNode, MonographEdge } from '../../src/types.js';
-
-type Db = ReturnType<typeof openDb>;
-
-// Each test gets a fresh DB with a unique path to avoid cross-test contamination
-function freshDb(): { db: Db; cleanup: () => void } {
-  const dbPath = join(tmpdir(), `monograph-res-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
-  const db = openDb(dbPath);
-  return {
-    db,
-    cleanup: () => {
-      closeDb(db);
-      if (existsSync(dbPath)) unlinkSync(dbPath);
-    },
-  };
-}
-
-function makeNode(overrides: Partial<MonographNode> & Pick<MonographNode, 'id' | 'name' | 'label'>): MonographNode {
-  return {
-    normLabel: overrides.name.toLowerCase(),
-    filePath: 'src/test.ts',
-    startLine: 1,
-    isExported: true,
-    ...overrides,
-  };
-}
-
-function makeEdge(id: string, sourceId: string, targetId: string, relation: string): MonographEdge {
-  return {
-    id,
-    sourceId,
-    targetId,
-    relation,
-    confidence: 'EXTRACTED',
-    confidenceScore: 1.0,
-  };
-}
-
-// ── Processes resource ─────────────────────────────────────────────────────────
-
-describe('getProcessesResource', () => {
-  it('returns empty processes list when no Process nodes exist', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'fn1', name: 'doSomething', label: 'Function' }));
-      const result = getProcessesResource(db);
-      expect(result.processes).toEqual([]);
-    } finally { cleanup(); }
-  });
-
-  it('returns Process nodes with no steps when no STEP_IN_PROCESS edges exist', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'proc1', name: 'CheckoutProcess', label: 'Process' }));
-      const result = getProcessesResource(db);
-      expect(result.processes).toHaveLength(1);
-      expect(result.processes[0].id).toBe('proc1');
-      expect(result.processes[0].name).toBe('CheckoutProcess');
-      expect(result.processes[0].stepCount).toBe(0);
-      expect(result.processes[0].steps).toEqual([]);
-    } finally { cleanup(); }
-  });
-
-  it('returns Process nodes with their steps via STEP_IN_PROCESS edges', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'proc2', name: 'OrderProcess', label: 'Process' }));
-      insertNode(db, makeNode({ id: 'step1', name: 'validateOrder', label: 'Function' }));
-      insertNode(db, makeNode({ id: 'step2', name: 'chargePayment', label: 'Function' }));
-      insertEdge(db, makeEdge('e1', 'proc2', 'step1', 'STEP_IN_PROCESS'));
-      insertEdge(db, makeEdge('e2', 'proc2', 'step2', 'STEP_IN_PROCESS'));
-
-      const result = getProcessesResource(db);
-      const proc = result.processes.find((p) => p.id === 'proc2');
-      expect(proc).toBeDefined();
-      expect(proc!.stepCount).toBe(2);
-      expect(proc!.steps.map((s) => s.name).sort()).toEqual(['chargePayment', 'validateOrder']);
-    } finally { cleanup(); }
-  });
-
-  it('does not include non-STEP_IN_PROCESS edges in steps', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'proc3', name: 'ShipProcess', label: 'Process' }));
-      insertNode(db, makeNode({ id: 'fn2', name: 'sendEmail', label: 'Function' }));
-      insertEdge(db, makeEdge('e3', 'proc3', 'fn2', 'CALLS'));
-
-      const result = getProcessesResource(db);
-      const proc = result.processes.find((p) => p.id === 'proc3');
-      expect(proc!.stepCount).toBe(0);
-    } finally { cleanup(); }
-  });
-});
-
-// ── Communities resource ───────────────────────────────────────────────────────
-
-describe('getCommunitiesResource', () => {
-  it('returns empty communities when no nodes have community_id', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'iso1', name: 'Isolated', label: 'Function' }));
-      const result = getCommunitiesResource(db);
-      expect(result.communities).toEqual([]);
-    } finally { cleanup(); }
-  });
-
-  it('groups nodes by community_id', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      const nodeA: MonographNode = { ...makeNode({ id: 'ca1', name: 'Alpha', label: 'Class' }), communityId: 1 };
-      const nodeB: MonographNode = { ...makeNode({ id: 'ca2', name: 'Beta', label: 'Function' }), communityId: 1 };
-      const nodeC: MonographNode = { ...makeNode({ id: 'ca3', name: 'Gamma', label: 'Class' }), communityId: 2 };
-      insertNode(db, nodeA);
-      insertNode(db, nodeB);
-      insertNode(db, nodeC);
-
-      const result = getCommunitiesResource(db);
-      expect(result.communities.length).toBeGreaterThanOrEqual(2);
-
-      const comm1 = result.communities.find((c) => c.id === 1);
-      expect(comm1).toBeDefined();
-      expect(comm1!.memberCount).toBe(2);
-      expect(comm1!.topMembers).toHaveLength(2);
-
-      const comm2 = result.communities.find((c) => c.id === 2);
-      expect(comm2).toBeDefined();
-      expect(comm2!.memberCount).toBe(1);
-    } finally { cleanup(); }
-  });
-
-  it('returns at most 5 top members per community', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      for (let i = 0; i < 8; i++) {
-        const node: MonographNode = {
-          ...makeNode({ id: `bulk${i}`, name: `Node${i}`, label: 'Function' }),
-          communityId: 99,
-        };
-        insertNode(db, node);
-      }
-
-      const result = getCommunitiesResource(db);
-      const comm = result.communities.find((c) => c.id === 99);
-      expect(comm!.memberCount).toBe(8);
-      expect(comm!.topMembers.length).toBeLessThanOrEqual(5);
-    } finally { cleanup(); }
-  });
-});
-
-// ── Schema resource ────────────────────────────────────────────────────────────
-
-describe('getSchemaResource', () => {
-  it('returns zero totals for empty database', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      const result = getSchemaResource(db);
-      expect(result.totalNodes).toBe(0);
-      expect(result.totalEdges).toBe(0);
-      expect(result.nodeLabels).toEqual([]);
-      expect(result.edgeRelations).toEqual([]);
-    } finally { cleanup(); }
-  });
-
-  it('returns correct node label counts', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 's1', name: 'Cls1', label: 'Class' }));
-      insertNode(db, makeNode({ id: 's2', name: 'Fn1', label: 'Function' }));
-      insertNode(db, makeNode({ id: 's3', name: 'Fn2', label: 'Function' }));
-
-      const result = getSchemaResource(db);
-      expect(result.totalNodes).toBe(3);
-
-      const fnEntry = result.nodeLabels.find((l) => l.label === 'Function');
-      expect(fnEntry?.count).toBe(2);
-
-      const clsEntry = result.nodeLabels.find((l) => l.label === 'Class');
-      expect(clsEntry?.count).toBe(1);
-    } finally { cleanup(); }
-  });
-
-  it('returns correct edge relation counts', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'se1', name: 'A', label: 'Function' }));
-      insertNode(db, makeNode({ id: 'se2', name: 'B', label: 'Function' }));
-      insertNode(db, makeNode({ id: 'se3', name: 'C', label: 'Function' }));
-      insertEdge(db, makeEdge('ee1', 'se1', 'se2', 'CALLS'));
-      insertEdge(db, makeEdge('ee2', 'se1', 'se3', 'CALLS'));
-      insertEdge(db, makeEdge('ee3', 'se2', 'se3', 'IMPORTS'));
-
-      const result = getSchemaResource(db);
-      expect(result.totalEdges).toBe(3);
-
-      const callsEntry = result.edgeRelations.find((r) => r.relation === 'CALLS');
-      expect(callsEntry?.count).toBe(2);
-
-      const importsEntry = result.edgeRelations.find((r) => r.relation === 'IMPORTS');
-      expect(importsEntry?.count).toBe(1);
-    } finally { cleanup(); }
-  });
-});
-
-// ── Graph resource ─────────────────────────────────────────────────────────────
-
-describe('getGraphResource', () => {
-  it('returns empty graph for empty database', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      const result = getGraphResource(db);
-      expect(result.nodes).toEqual([]);
-      expect(result.edges).toEqual([]);
-      expect(result.communities).toEqual({});
-    } finally { cleanup(); }
-  });
-
-  it('returns nodes and edges', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      insertNode(db, makeNode({ id: 'gr1', name: 'Foo', label: 'Function' }));
-      insertNode(db, makeNode({ id: 'gr2', name: 'Bar', label: 'Function' }));
-      insertEdge(db, makeEdge('ge1', 'gr1', 'gr2', 'CALLS'));
-
-      const result = getGraphResource(db);
-      expect(result.nodes).toHaveLength(2);
-      expect(result.edges).toHaveLength(1);
-      expect(result.edges[0].relation).toBe('CALLS');
-    } finally { cleanup(); }
-  });
-
-  it('groups nodes into communities map', () => {
-    const { db, cleanup } = freshDb();
-    try {
-      const nodeA: MonographNode = { ...makeNode({ id: 'grc1', name: 'ModA', label: 'Class' }), communityId: 5 };
-      const nodeB: MonographNode = { ...makeNode({ id: 'grc2', name: 'ModB', label: 'Class' }), communityId: 5 };
-      insertNode(db, nodeA);
-      insertNode(db, nodeB);
-
-      const result = getGraphResource(db);
-      expect(result.communities['5']).toBeDefined();
-      expect(result.communities['5']).toContain('grc1');
-      expect(result.communities['5']).toContain('grc2');
-    } finally { cleanup(); }
-  });
-});