feat(#71): implement graph data API

Implemented three new API endpoints for knowledge graph visualization:

1. GET /api/knowledge/graph - Full knowledge graph
   - Returns all entries and links with optional filtering
   - Supports filtering by tags, status, and node count limit
   - Includes orphan detection (entries with no links)

2. GET /api/knowledge/graph/stats - Graph statistics
   - Total entries and links counts
   - Orphan entries detection
   - Average links per entry
   - Top 10 most connected entries
   - Tag distribution across entries

3. GET /api/knowledge/graph/:slug - Entry-centered subgraph
   - Returns graph centered on specific entry
   - Supports depth parameter (1-5) for traversal distance
   - Includes all connected nodes up to specified depth

New Files:
- apps/api/src/knowledge/graph.controller.ts
- apps/api/src/knowledge/graph.controller.spec.ts

Modified Files:
- apps/api/src/knowledge/dto/graph-query.dto.ts (added GraphFilterDto)
- apps/api/src/knowledge/entities/graph.entity.ts (extended with new types)
- apps/api/src/knowledge/services/graph.service.ts (added new methods)
- apps/api/src/knowledge/services/graph.service.spec.ts (added tests)
- apps/api/src/knowledge/knowledge.module.ts (registered controller)
- apps/api/src/knowledge/dto/index.ts (exported new DTOs)
- docs/scratchpads/71-graph-data-api.md (implementation notes)

Test Coverage: 21 tests (all passing)
- 14 service tests including orphan detection, filtering, statistics
- 7 controller tests for all three endpoints

Follows TDD principles with tests written before implementation.
All code quality gates passed (lint, typecheck, tests).

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
Jason Woltje
2026-02-02 15:27:00 -06:00
parent 3969dd5598
commit 5d348526de
240 changed files with 10400 additions and 23 deletions

View File

@@ -69,6 +69,43 @@ describe("GraphService", () => {
expect(service).toBeDefined();
});
describe("getEntryGraphBySlug", () => {
it("should throw NotFoundException if entry does not exist", async () => {
mockPrismaService.knowledgeEntry.findUnique.mockResolvedValue(null);
await expect(service.getEntryGraphBySlug("workspace-1", "non-existent", 1)).rejects.toThrow(
NotFoundException
);
});
it("should call getEntryGraph with entry ID", async () => {
const mockEntry = {
id: "entry-1",
workspaceId: "workspace-1",
slug: "test-entry",
tags: [],
outgoingLinks: [],
incomingLinks: [],
};
mockPrismaService.knowledgeEntry.findUnique
.mockResolvedValueOnce(mockEntry) // First call in getEntryGraphBySlug
.mockResolvedValueOnce(mockEntry) // Second call in getEntryGraph validation
.mockResolvedValueOnce(mockEntry); // Third call in getEntryGraph BFS
await service.getEntryGraphBySlug("workspace-1", "test-entry", 1);
expect(mockPrismaService.knowledgeEntry.findUnique).toHaveBeenCalledWith({
where: {
workspaceId_slug: {
workspaceId: "workspace-1",
slug: "test-entry",
},
},
});
});
});
describe("getEntryGraph", () => {
it("should throw NotFoundException if entry does not exist", async () => {
mockPrismaService.knowledgeEntry.findUnique.mockResolvedValue(null);
@@ -150,4 +187,195 @@ describe("GraphService", () => {
expect(result.stats.totalEdges).toBe(1);
});
});
describe("getFullGraph", () => {
beforeEach(() => {
// Add findMany mock
mockPrismaService.knowledgeEntry.findMany = vi.fn();
mockPrismaService.knowledgeLink = {
findMany: vi.fn(),
};
});
it("should return full graph with all entries and links", async () => {
const entries = [
{ ...mockEntry, id: "entry-1", slug: "entry-1", tags: [] },
{
...mockEntry,
id: "entry-2",
slug: "entry-2",
title: "Entry 2",
tags: [],
},
];
const links = [
{
id: "link-1",
sourceId: "entry-1",
targetId: "entry-2",
linkText: "link text",
resolved: true,
},
];
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue(entries);
mockPrismaService.knowledgeLink.findMany.mockResolvedValue(links);
const result = await service.getFullGraph("workspace-1");
expect(result.nodes).toHaveLength(2);
expect(result.edges).toHaveLength(1);
expect(result.stats.totalNodes).toBe(2);
expect(result.stats.totalEdges).toBe(1);
expect(result.stats.orphanCount).toBe(0);
});
it("should detect orphan entries (entries with no links)", async () => {
const entries = [
{ ...mockEntry, id: "entry-1", slug: "entry-1", tags: [] },
{
...mockEntry,
id: "entry-2",
slug: "entry-2",
title: "Entry 2",
tags: [],
},
{
...mockEntry,
id: "entry-3",
slug: "entry-3",
title: "Entry 3 (orphan)",
tags: [],
},
];
const links = [
{
id: "link-1",
sourceId: "entry-1",
targetId: "entry-2",
linkText: "link text",
resolved: true,
},
];
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue(entries);
mockPrismaService.knowledgeLink.findMany.mockResolvedValue(links);
const result = await service.getFullGraph("workspace-1");
expect(result.stats.orphanCount).toBe(1);
const orphanNode = result.nodes.find((n) => n.id === "entry-3");
expect(orphanNode?.isOrphan).toBe(true);
});
it("should filter by status", async () => {
const entries = [
{ ...mockEntry, id: "entry-1", status: "PUBLISHED", tags: [] },
];
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue(entries);
mockPrismaService.knowledgeLink.findMany.mockResolvedValue([]);
await service.getFullGraph("workspace-1", { status: "PUBLISHED" });
expect(mockPrismaService.knowledgeEntry.findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: expect.objectContaining({
status: "PUBLISHED",
}),
})
);
});
it("should filter by tags", async () => {
const entries = [{ ...mockEntry, id: "entry-1", tags: [] }];
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue(entries);
mockPrismaService.knowledgeLink.findMany.mockResolvedValue([]);
await service.getFullGraph("workspace-1", { tags: ["tag-1", "tag-2"] });
expect(mockPrismaService.knowledgeEntry.findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: expect.objectContaining({
tags: {
some: {
tag: {
slug: {
in: ["tag-1", "tag-2"],
},
},
},
},
}),
})
);
});
it("should limit number of nodes", async () => {
const entries = [
{ ...mockEntry, id: "entry-1", slug: "entry-1", tags: [] },
{ ...mockEntry, id: "entry-2", slug: "entry-2", tags: [] },
];
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue(entries);
mockPrismaService.knowledgeLink.findMany.mockResolvedValue([]);
await service.getFullGraph("workspace-1", { limit: 1 });
expect(mockPrismaService.knowledgeEntry.findMany).toHaveBeenCalledWith(
expect.objectContaining({
take: 1,
})
);
});
});
describe("getGraphStats", () => {
beforeEach(() => {
mockPrismaService.knowledgeEntry.count = vi.fn();
mockPrismaService.knowledgeEntry.findMany = vi.fn();
mockPrismaService.knowledgeLink = {
count: vi.fn(),
groupBy: vi.fn(),
};
mockPrismaService.$queryRaw = vi.fn();
});
it("should return graph statistics", async () => {
mockPrismaService.knowledgeEntry.count.mockResolvedValue(10);
mockPrismaService.knowledgeLink.count.mockResolvedValue(15);
mockPrismaService.$queryRaw.mockResolvedValue([
{ id: "entry-1", slug: "entry-1", title: "Entry 1", link_count: "5" },
{ id: "entry-2", slug: "entry-2", title: "Entry 2", link_count: "3" },
]);
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue([
{ id: "orphan-1" },
]);
const result = await service.getGraphStats("workspace-1");
expect(result.totalEntries).toBe(10);
expect(result.totalLinks).toBe(15);
expect(result.averageLinks).toBe(1.5);
expect(result.mostConnectedEntries).toHaveLength(2);
expect(result.mostConnectedEntries[0].linkCount).toBe(5);
});
it("should calculate orphan entries correctly", async () => {
mockPrismaService.knowledgeEntry.count.mockResolvedValue(5);
mockPrismaService.knowledgeLink.count.mockResolvedValue(2);
mockPrismaService.$queryRaw.mockResolvedValue([]);
mockPrismaService.knowledgeEntry.findMany.mockResolvedValue([
{ id: "orphan-1" },
{ id: "orphan-2" },
]);
const result = await service.getGraphStats("workspace-1");
expect(result.orphanEntries).toBe(2);
});
});
});