@powerhousedao/knowledge-note 1.0.0

package/dist/tests/processor/graph-indexer.test.js

@@ -0,0 +1,362 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { Kysely } from "kysely";
+import { PGlite } from "@electric-sql/pglite";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { up, down } from "../../processors/graph-indexer/migrations.js";
+let db;
+beforeAll(async () => {
+    const pglite = new PGlite();
+    db = new Kysely({ dialect: new PGliteDialect(pglite) });
+    await up(db);
+});
+afterAll(async () => {
+    await down(db);
+    await db.destroy();
+});
+describe("graph_nodes table", () => {
+    it("inserts a node and retrieves it with correct fields", async () => {
+        await db
+            .insertInto("graph_nodes")
+            .values({
+            id: "node-1",
+            document_id: "doc-1",
+            title: "Test Node",
+            description: "A test node",
+            note_type: "regular",
+            status: "CANONICAL",
+            updated_at: "2024-01-01T00:00:00Z",
+        })
+            .execute();
+        const row = await db
+            .selectFrom("graph_nodes")
+            .where("document_id", "=", "doc-1")
+            .selectAll()
+            .executeTakeFirst();
+        expect(row).toBeDefined();
+        expect(row.id).toBe("node-1");
+        expect(row.document_id).toBe("doc-1");
+        expect(row.title).toBe("Test Node");
+        expect(row.description).toBe("A test node");
+        expect(row.note_type).toBe("regular");
+        expect(row.status).toBe("CANONICAL");
+        expect(row.updated_at).toBe("2024-01-01T00:00:00Z");
+        // cleanup
+        await db.deleteFrom("graph_nodes").where("document_id", "=", "doc-1").execute();
+    });
+});
+describe("graph_edges table", () => {
+    it("inserts an edge and retrieves it with correct fields", async () => {
+        // Insert prerequisite nodes
+        await db
+            .insertInto("graph_nodes")
+            .values([
+            {
+                id: "n-edge-src",
+                document_id: "doc-edge-src",
+                title: "Source",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "n-edge-tgt",
+                document_id: "doc-edge-tgt",
+                title: "Target",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+        ])
+            .execute();
+        await db
+            .insertInto("graph_edges")
+            .values({
+            id: "edge-1",
+            source_document_id: "doc-edge-src",
+            target_document_id: "doc-edge-tgt",
+            link_type: "references",
+            target_title: "Target",
+            updated_at: "2024-01-01T00:00:00Z",
+        })
+            .execute();
+        const row = await db
+            .selectFrom("graph_edges")
+            .where("id", "=", "edge-1")
+            .selectAll()
+            .executeTakeFirst();
+        expect(row).toBeDefined();
+        expect(row.id).toBe("edge-1");
+        expect(row.source_document_id).toBe("doc-edge-src");
+        expect(row.target_document_id).toBe("doc-edge-tgt");
+        expect(row.link_type).toBe("references");
+        expect(row.target_title).toBe("Target");
+        // cleanup
+        await db.deleteFrom("graph_edges").where("id", "=", "edge-1").execute();
+        await db
+            .deleteFrom("graph_nodes")
+            .where("document_id", "in", ["doc-edge-src", "doc-edge-tgt"])
+            .execute();
+    });
+});
+describe("cascade delete", () => {
+    it("deletes edges referencing a node then deletes the node, leaving both tables clean", async () => {
+        await db
+            .insertInto("graph_nodes")
+            .values([
+            {
+                id: "n-cascade-a",
+                document_id: "doc-cascade-a",
+                title: "A",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "n-cascade-b",
+                document_id: "doc-cascade-b",
+                title: "B",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+        ])
+            .execute();
+        await db
+            .insertInto("graph_edges")
+            .values([
+            {
+                id: "e-cascade-1",
+                source_document_id: "doc-cascade-a",
+                target_document_id: "doc-cascade-b",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "e-cascade-2",
+                source_document_id: "doc-cascade-b",
+                target_document_id: "doc-cascade-a",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+        ])
+            .execute();
+        // Delete all edges referencing doc-cascade-a (as source or target)
+        await db
+            .deleteFrom("graph_edges")
+            .where((eb) => eb.or([
+            eb("source_document_id", "=", "doc-cascade-a"),
+            eb("target_document_id", "=", "doc-cascade-a"),
+        ]))
+            .execute();
+        // Delete the node itself
+        await db
+            .deleteFrom("graph_nodes")
+            .where("document_id", "=", "doc-cascade-a")
+            .execute();
+        // Verify no edges referencing doc-cascade-a remain
+        const remainingEdges = await db
+            .selectFrom("graph_edges")
+            .where((eb) => eb.or([
+            eb("source_document_id", "=", "doc-cascade-a"),
+            eb("target_document_id", "=", "doc-cascade-a"),
+        ]))
+            .selectAll()
+            .execute();
+        expect(remainingEdges).toHaveLength(0);
+        // Verify the node is gone
+        const remainingNode = await db
+            .selectFrom("graph_nodes")
+            .where("document_id", "=", "doc-cascade-a")
+            .selectAll()
+            .executeTakeFirst();
+        expect(remainingNode).toBeUndefined();
+        // cleanup remaining b node and its (now orphaned) edges
+        await db
+            .deleteFrom("graph_edges")
+            .where("source_document_id", "=", "doc-cascade-b")
+            .execute();
+        await db
+            .deleteFrom("graph_nodes")
+            .where("document_id", "=", "doc-cascade-b")
+            .execute();
+    });
+});
+describe("upsert on conflict", () => {
+    it("inserts the same document_id twice and only keeps 1 row with updated values", async () => {
+        const docId = "doc-upsert-1";
+        await db
+            .insertInto("graph_nodes")
+            .values({
+            id: "n-upsert-1",
+            document_id: docId,
+            title: "Original Title",
+            description: null,
+            note_type: null,
+            status: "DRAFT",
+            updated_at: "2024-01-01T00:00:00Z",
+        })
+            .execute();
+        // Second insert with same document_id — upsert by updating fields
+        await db
+            .insertInto("graph_nodes")
+            .values({
+            id: "n-upsert-1",
+            document_id: docId,
+            title: "Updated Title",
+            description: "Now has a description",
+            note_type: null,
+            status: "CANONICAL",
+            updated_at: "2024-06-01T00:00:00Z",
+        })
+            .onConflict((oc) => oc.column("document_id").doUpdateSet({
+            title: "Updated Title",
+            description: "Now has a description",
+            status: "CANONICAL",
+            updated_at: "2024-06-01T00:00:00Z",
+        }))
+            .execute();
+        const rows = await db
+            .selectFrom("graph_nodes")
+            .where("document_id", "=", docId)
+            .selectAll()
+            .execute();
+        expect(rows).toHaveLength(1);
+        expect(rows[0].title).toBe("Updated Title");
+        expect(rows[0].description).toBe("Now has a description");
+        expect(rows[0].status).toBe("CANONICAL");
+        expect(rows[0].updated_at).toBe("2024-06-01T00:00:00Z");
+        // cleanup
+        await db.deleteFrom("graph_nodes").where("document_id", "=", docId).execute();
+    });
+});
+describe("edge reconciliation", () => {
+    it("inserts 3 edges for source doc-1, deletes all, re-inserts 2 — exactly 2 edges remain", async () => {
+        const sourceDocId = "doc-recon-src";
+        await db
+            .insertInto("graph_nodes")
+            .values([
+            {
+                id: "n-recon-src",
+                document_id: sourceDocId,
+                title: "Source",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "n-recon-t1",
+                document_id: "doc-recon-t1",
+                title: "Target 1",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "n-recon-t2",
+                document_id: "doc-recon-t2",
+                title: "Target 2",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "n-recon-t3",
+                document_id: "doc-recon-t3",
+                title: "Target 3",
+                description: null,
+                note_type: null,
+                status: "CANONICAL",
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+        ])
+            .execute();
+        // Insert 3 edges
+        await db
+            .insertInto("graph_edges")
+            .values([
+            {
+                id: "e-recon-1",
+                source_document_id: sourceDocId,
+                target_document_id: "doc-recon-t1",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "e-recon-2",
+                source_document_id: sourceDocId,
+                target_document_id: "doc-recon-t2",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "e-recon-3",
+                source_document_id: sourceDocId,
+                target_document_id: "doc-recon-t3",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+        ])
+            .execute();
+        // Delete all edges for the source
+        await db
+            .deleteFrom("graph_edges")
+            .where("source_document_id", "=", sourceDocId)
+            .execute();
+        // Re-insert only 2 edges
+        await db
+            .insertInto("graph_edges")
+            .values([
+            {
+                id: "e-recon-1",
+                source_document_id: sourceDocId,
+                target_document_id: "doc-recon-t1",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+            {
+                id: "e-recon-2",
+                source_document_id: sourceDocId,
+                target_document_id: "doc-recon-t2",
+                link_type: null,
+                target_title: null,
+                updated_at: "2024-01-01T00:00:00Z",
+            },
+        ])
+            .execute();
+        const remainingEdges = await db
+            .selectFrom("graph_edges")
+            .where("source_document_id", "=", sourceDocId)
+            .selectAll()
+            .execute();
+        expect(remainingEdges).toHaveLength(2);
+        const targetIds = remainingEdges.map((e) => e.target_document_id).sort();
+        expect(targetIds).toEqual(["doc-recon-t1", "doc-recon-t2"]);
+        // cleanup
+        await db
+            .deleteFrom("graph_edges")
+            .where("source_document_id", "=", sourceDocId)
+            .execute();
+        await db
+            .deleteFrom("graph_nodes")
+            .where("document_id", "in", [
+            sourceDocId,
+            "doc-recon-t1",
+            "doc-recon-t2",
+            "doc-recon-t3",
+        ])
+            .execute();
+    });
+});

package/dist/tests/processor/graph-query.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graph-query.test.d.ts.map

package/dist/tests/processor/graph-query.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-query.test.d.ts","sourceRoot":"","sources":["../../../tests/processor/graph-query.test.ts"],"names":[],"mappings":""}

package/dist/tests/processor/graph-query.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
+import { Kysely } from "kysely";
+import { PGlite } from "@electric-sql/pglite";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { up, down } from "../../processors/graph-indexer/migrations.js";
+import { createGraphQuery } from "../../processors/graph-indexer/query.js";
+let db;
+let query;
+beforeAll(async () => {
+    const pglite = new PGlite();
+    db = new Kysely({ dialect: new PGliteDialect(pglite) });
+    await up(db);
+    query = createGraphQuery(db);
+});
+afterAll(async () => {
+    await down(db);
+    await db.destroy();
+});
+beforeEach(async () => {
+    await db.deleteFrom("graph_edges").execute();
+    await db.deleteFrom("graph_nodes").execute();
+});
+async function seedNodes(...nodes) {
+    await db
+        .insertInto("graph_nodes")
+        .values(nodes.map((n) => ({
+        id: n.id,
+        document_id: n.document_id,
+        title: n.title,
+        description: null,
+        note_type: null,
+        status: n.status ?? "CANONICAL",
+        updated_at: "2024-01-01T00:00:00Z",
+    })))
+        .execute();
+}
+async function seedEdge(source, target, linkType = null) {
+    await db
+        .insertInto("graph_edges")
+        .values({
+        id: `${source}-${target}`,
+        source_document_id: source,
+        target_document_id: target,
+        link_type: linkType,
+        target_title: null,
+        updated_at: "2024-01-01T00:00:00Z",
+    })
+        .execute();
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("allNodes()", () => {
+    it("returns all seeded nodes", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" }, { id: "n3", document_id: "c", title: "Node C" });
+        const nodes = await query.allNodes();
+        expect(nodes).toHaveLength(3);
+        const docIds = nodes.map((n) => n.documentId).sort();
+        expect(docIds).toEqual(["a", "b", "c"]);
+    });
+});
+describe("nodeByDocumentId()", () => {
+    it("returns the correct node for a given document id", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" });
+        const node = await query.nodeByDocumentId("b");
+        expect(node).toBeDefined();
+        expect(node.documentId).toBe("b");
+        expect(node.title).toBe("Node B");
+    });
+    it("returns undefined for a non-existent document id", async () => {
+        const node = await query.nodeByDocumentId("does-not-exist");
+        expect(node).toBeUndefined();
+    });
+});
+describe("nodesByStatus()", () => {
+    it("filters nodes by status correctly", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A", status: "CANONICAL" }, { id: "n2", document_id: "b", title: "Node B", status: "DRAFT" }, { id: "n3", document_id: "c", title: "Node C", status: "CANONICAL" });
+        const canonical = await query.nodesByStatus("CANONICAL");
+        expect(canonical).toHaveLength(2);
+        const docIds = canonical.map((n) => n.documentId).sort();
+        expect(docIds).toEqual(["a", "c"]);
+        const drafts = await query.nodesByStatus("DRAFT");
+        expect(drafts).toHaveLength(1);
+        expect(drafts[0].documentId).toBe("b");
+    });
+});
+describe("orphanNodes()", () => {
+    it("returns nodes with no incoming edges (A and C when only A→B exists)", async () => {
+        // A→B means B has an incoming edge, so B is NOT an orphan
+        // A and C have no incoming edges, so they ARE orphans
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" }, { id: "n3", document_id: "c", title: "Node C" });
+        await seedEdge("a", "b");
+        const orphans = await query.orphanNodes();
+        expect(orphans).toHaveLength(2);
+        const docIds = orphans.map((n) => n.documentId).sort();
+        expect(docIds).toEqual(["a", "c"]);
+    });
+});
+describe("stats()", () => {
+    it("returns correct nodeCount, edgeCount, and orphanCount", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" }, { id: "n3", document_id: "c", title: "Node C" });
+        // A→B and B→C: B and C are targets, so A is the only orphan
+        await seedEdge("a", "b");
+        await seedEdge("b", "c");
+        const stats = await query.stats();
+        expect(stats.nodeCount).toBe(3);
+        expect(stats.edgeCount).toBe(2);
+        expect(stats.orphanCount).toBe(1); // only A has no incoming edge
+    });
+});
+describe("connections()", () => {
+    it("BFS: returns B at depth 1 and C at depth 2 for A→B→C", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" }, { id: "n3", document_id: "c", title: "Node C" });
+        await seedEdge("a", "b");
+        await seedEdge("b", "c");
+        const conns = await query.connections("a", 2);
+        expect(conns).toHaveLength(2);
+        const b = conns.find((c) => c.node.documentId === "b");
+        const c = conns.find((c) => c.node.documentId === "c");
+        expect(b).toBeDefined();
+        expect(b.depth).toBe(1);
+        expect(c).toBeDefined();
+        expect(c.depth).toBe(2);
+    });
+    it("respects maxDepth: connections('a', 1) returns only B", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" }, { id: "n3", document_id: "c", title: "Node C" });
+        await seedEdge("a", "b");
+        await seedEdge("b", "c");
+        const conns = await query.connections("a", 1);
+        expect(conns).toHaveLength(1);
+        expect(conns[0].node.documentId).toBe("b");
+        expect(conns[0].depth).toBe(1);
+    });
+});
+describe("backlinks()", () => {
+    it("returns edges pointing to the given document id", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" });
+        await seedEdge("a", "b", "references");
+        const links = await query.backlinks("b");
+        expect(links).toHaveLength(1);
+        expect(links[0].sourceDocumentId).toBe("a");
+        expect(links[0].targetDocumentId).toBe("b");
+        expect(links[0].linkType).toBe("references");
+    });
+    it("returns empty array when no edges point to the document", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" });
+        const links = await query.backlinks("a");
+        expect(links).toHaveLength(0);
+    });
+});
+describe("density()", () => {
+    it("returns correct density with 3 nodes and 3 edges", async () => {
+        // density = edges / (n * (n-1)) = 3 / (3 * 2) = 3/6 = 0.5
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" }, { id: "n2", document_id: "b", title: "Node B" }, { id: "n3", document_id: "c", title: "Node C" });
+        await seedEdge("a", "b");
+        await seedEdge("b", "c");
+        await seedEdge("a", "c");
+        const d = await query.density();
+        expect(d).toBeCloseTo(0.5);
+    });
+    it("returns 0 with only 1 node", async () => {
+        await seedNodes({ id: "n1", document_id: "a", title: "Node A" });
+        const d = await query.density();
+        expect(d).toBe(0);
+    });
+    it("returns 0 with no nodes", async () => {
+        const d = await query.density();
+        expect(d).toBe(0);
+    });
+});

package/dist/tests/unit/knowledge-note-reducers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=knowledge-note-reducers.test.d.ts.map

package/dist/tests/unit/knowledge-note-reducers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-note-reducers.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/knowledge-note-reducers.test.ts"],"names":[],"mappings":""}