@kya-os/mcp-i-core 1.2.3-canary.7 → 1.3.0

package/src/delegation/storage/__tests__/memory-graph-storage.test.ts

@@ -0,0 +1,366 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { MemoryDelegationGraphStorage } from "../memory-graph-storage.js";
+import type { DelegationNode } from "../../delegation-graph.js";
+
+describe("MemoryDelegationGraphStorage", () => {
+  let storage: MemoryDelegationGraphStorage;
+
+  const createMockNode = (
+    id: string,
+    parentId: string | null = null
+  ): DelegationNode => ({
+    id,
+    parentId,
+    issuerDid: `did:web:example.com:issuer${id}`,
+    subjectDid: `did:web:example.com:subject${id}`,
+    children: [],
+    credentialStatusId: `https://example.com/status#${id}`,
+  });
+
+  beforeEach(() => {
+    storage = new MemoryDelegationGraphStorage();
+  });
+
+  describe("getNode", () => {
+    it("should return null for non-existent node", async () => {
+      const result = await storage.getNode("non-existent");
+      expect(result).toBeNull();
+    });
+
+    it("should return stored node", async () => {
+      const node = createMockNode("del-001");
+      await storage.setNode(node);
+
+      const result = await storage.getNode("del-001");
+      expect(result).toEqual(node);
+    });
+  });
+
+  describe("setNode", () => {
+    it("should store node", async () => {
+      const node = createMockNode("del-001");
+      await storage.setNode(node);
+
+      const result = await storage.getNode("del-001");
+      expect(result).toEqual(node);
+    });
+
+    it("should overwrite existing node", async () => {
+      const node1 = createMockNode("del-001");
+      await storage.setNode(node1);
+
+      const node2 = {
+        ...node1,
+        issuerDid: "did:web:example.com:updated",
+      };
+      await storage.setNode(node2);
+
+      const result = await storage.getNode("del-001");
+      expect(result?.issuerDid).toBe("did:web:example.com:updated");
+    });
+  });
+
+  describe("getChildren", () => {
+    it("should return empty array for node with no children", async () => {
+      const node = createMockNode("del-001");
+      await storage.setNode(node);
+
+      const children = await storage.getChildren("del-001");
+      expect(children).toEqual([]);
+    });
+
+    it("should return direct children only", async () => {
+      const parent = createMockNode("del-parent");
+      const child1 = createMockNode("del-child1", "del-parent");
+      const child2 = createMockNode("del-child2", "del-parent");
+      const grandchild = createMockNode("del-grandchild", "del-child1");
+
+      parent.children = ["del-child1", "del-child2"];
+      child1.children = ["del-grandchild"];
+
+      await storage.setNode(parent);
+      await storage.setNode(child1);
+      await storage.setNode(child2);
+      await storage.setNode(grandchild);
+
+      const children = await storage.getChildren("del-parent");
+      expect(children.length).toBe(2);
+      expect(children.map((c) => c.id)).toContain("del-child1");
+      expect(children.map((c) => c.id)).toContain("del-child2");
+      expect(children.map((c) => c.id)).not.toContain("del-grandchild");
+    });
+
+    it("should return empty array for non-existent node", async () => {
+      const children = await storage.getChildren("non-existent");
+      expect(children).toEqual([]);
+    });
+
+    it("should filter out missing child nodes", async () => {
+      const parent = createMockNode("del-parent");
+      parent.children = ["del-child1", "del-missing", "del-child2"];
+
+      const child1 = createMockNode("del-child1", "del-parent");
+      const child2 = createMockNode("del-child2", "del-parent");
+
+      await storage.setNode(parent);
+      await storage.setNode(child1);
+      await storage.setNode(child2);
+      // del-missing is not stored
+
+      const children = await storage.getChildren("del-parent");
+      expect(children.length).toBe(2);
+      expect(children.map((c) => c.id)).toContain("del-child1");
+      expect(children.map((c) => c.id)).toContain("del-child2");
+    });
+  });
+
+  describe("getChain", () => {
+    it("should return single node for root", async () => {
+      const root = createMockNode("del-root");
+      await storage.setNode(root);
+
+      const chain = await storage.getChain("del-root");
+      expect(chain.length).toBe(1);
+      expect(chain[0].id).toBe("del-root");
+    });
+
+    it("should return chain from root to node", async () => {
+      const root = createMockNode("del-root");
+      const child = createMockNode("del-child", "del-root");
+      const grandchild = createMockNode("del-grandchild", "del-child");
+
+      root.children = ["del-child"];
+      child.children = ["del-grandchild"];
+
+      await storage.setNode(root);
+      await storage.setNode(child);
+      await storage.setNode(grandchild);
+
+      const chain = await storage.getChain("del-grandchild");
+      expect(chain.length).toBe(3);
+      expect(chain[0].id).toBe("del-root");
+      expect(chain[1].id).toBe("del-child");
+      expect(chain[2].id).toBe("del-grandchild");
+    });
+
+    it("should stop at missing parent", async () => {
+      const child = createMockNode("del-child", "del-missing-parent");
+      await storage.setNode(child);
+
+      const chain = await storage.getChain("del-child");
+      expect(chain.length).toBe(1);
+      expect(chain[0].id).toBe("del-child");
+    });
+
+    it("should return empty array for non-existent node", async () => {
+      const chain = await storage.getChain("non-existent");
+      expect(chain).toEqual([]);
+    });
+  });
+
+  describe("getDescendants", () => {
+    it("should return empty array for leaf node", async () => {
+      const leaf = createMockNode("del-leaf");
+      await storage.setNode(leaf);
+
+      const descendants = await storage.getDescendants("del-leaf");
+      expect(descendants).toEqual([]);
+    });
+
+    it("should return all descendants", async () => {
+      const root = createMockNode("del-root");
+      const child1 = createMockNode("del-child1", "del-root");
+      const child2 = createMockNode("del-child2", "del-root");
+      const grandchild = createMockNode("del-grandchild", "del-child1");
+
+      root.children = ["del-child1", "del-child2"];
+      child1.children = ["del-grandchild"];
+
+      await storage.setNode(root);
+      await storage.setNode(child1);
+      await storage.setNode(child2);
+      await storage.setNode(grandchild);
+
+      const descendants = await storage.getDescendants("del-root");
+      expect(descendants.length).toBe(3);
+      expect(descendants.map((d) => d.id)).toContain("del-child1");
+      expect(descendants.map((d) => d.id)).toContain("del-child2");
+      expect(descendants.map((d) => d.id)).toContain("del-grandchild");
+    });
+
+    it("should handle deep trees", async () => {
+      const nodes: DelegationNode[] = [];
+      for (let i = 0; i < 5; i++) {
+        const parentId = i === 0 ? null : `del-${i - 1}`;
+        const node = createMockNode(`del-${i}`, parentId);
+        if (i > 0) {
+          nodes[i - 1].children.push(`del-${i}`);
+        }
+        nodes.push(node);
+        await storage.setNode(node);
+      }
+
+      const descendants = await storage.getDescendants("del-0");
+      expect(descendants.length).toBe(4);
+    });
+
+    it("should prevent infinite loops", async () => {
+      // Create a cycle (shouldn't happen in real usage, but test defensive code)
+      const node1 = createMockNode("del-1");
+      const node2 = createMockNode("del-2", "del-1");
+      node1.children = ["del-2"];
+      node2.children = ["del-1"]; // Cycle!
+
+      await storage.setNode(node1);
+      await storage.setNode(node2);
+
+      const descendants = await storage.getDescendants("del-1");
+      // Should return node2 only once, not loop infinitely
+      expect(descendants.length).toBe(1);
+      expect(descendants[0].id).toBe("del-2");
+    });
+
+    it("should return empty array for non-existent node", async () => {
+      const descendants = await storage.getDescendants("non-existent");
+      expect(descendants).toEqual([]);
+    });
+  });
+
+  describe("deleteNode", () => {
+    it("should delete node", async () => {
+      const node = createMockNode("del-001");
+      await storage.setNode(node);
+
+      await storage.deleteNode("del-001");
+
+      const result = await storage.getNode("del-001");
+      expect(result).toBeNull();
+    });
+
+    it("should not throw when deleting non-existent node", async () => {
+      await expect(storage.deleteNode("non-existent")).resolves.not.toThrow();
+    });
+  });
+
+  describe("clear", () => {
+    it("should remove all nodes", async () => {
+      await storage.setNode(createMockNode("del-001"));
+      await storage.setNode(createMockNode("del-002"));
+
+      storage.clear();
+
+      expect(await storage.getNode("del-001")).toBeNull();
+      expect(await storage.getNode("del-002")).toBeNull();
+    });
+  });
+
+  describe("getAllNodeIds", () => {
+    it("should return empty array when no nodes", () => {
+      const ids = storage.getAllNodeIds();
+      expect(ids).toEqual([]);
+    });
+
+    it("should return all node IDs", async () => {
+      await storage.setNode(createMockNode("del-001"));
+      await storage.setNode(createMockNode("del-002"));
+      await storage.setNode(createMockNode("del-003"));
+
+      const ids = storage.getAllNodeIds();
+      expect(ids).toContain("del-001");
+      expect(ids).toContain("del-002");
+      expect(ids).toContain("del-003");
+      expect(ids.length).toBe(3);
+    });
+  });
+
+  describe("getStats", () => {
+    it("should return correct stats for empty storage", () => {
+      const stats = storage.getStats();
+      expect(stats.totalNodes).toBe(0);
+      expect(stats.rootNodes).toBe(0);
+      expect(stats.leafNodes).toBe(0);
+      expect(stats.maxDepth).toBe(0);
+    });
+
+    it("should count root nodes correctly", async () => {
+      await storage.setNode(createMockNode("del-root1"));
+      await storage.setNode(createMockNode("del-root2"));
+
+      const stats = storage.getStats();
+      expect(stats.rootNodes).toBe(2);
+    });
+
+    it("should count leaf nodes correctly", async () => {
+      const root = createMockNode("del-root");
+      const child1 = createMockNode("del-child1", "del-root");
+      const child2 = createMockNode("del-child2", "del-root");
+
+      root.children = ["del-child1", "del-child2"];
+
+      await storage.setNode(root);
+      await storage.setNode(child1);
+      await storage.setNode(child2);
+
+      const stats = storage.getStats();
+      expect(stats.leafNodes).toBe(2); // child1 and child2
+    });
+
+    it("should calculate max depth correctly", async () => {
+      const root = createMockNode("del-root");
+      const child = createMockNode("del-child", "del-root");
+      const grandchild = createMockNode("del-grandchild", "del-child");
+
+      root.children = ["del-child"];
+      child.children = ["del-grandchild"];
+
+      await storage.setNode(root);
+      await storage.setNode(child);
+      await storage.setNode(grandchild);
+
+      const stats = storage.getStats();
+      expect(stats.maxDepth).toBe(2); // root -> child -> grandchild (depth 2)
+    });
+
+    it("should handle multiple trees", async () => {
+      // Tree 1: depth 1
+      const root1 = createMockNode("del-root1");
+      const child1 = createMockNode("del-child1", "del-root1");
+      root1.children = ["del-child1"];
+
+      // Tree 2: depth 2
+      const root2 = createMockNode("del-root2");
+      const child2 = createMockNode("del-child2", "del-root2");
+      const grandchild2 = createMockNode("del-grandchild2", "del-child2");
+      root2.children = ["del-child2"];
+      child2.children = ["del-grandchild2"];
+
+      await storage.setNode(root1);
+      await storage.setNode(child1);
+      await storage.setNode(root2);
+      await storage.setNode(child2);
+      await storage.setNode(grandchild2);
+
+      const stats = storage.getStats();
+      expect(stats.totalNodes).toBe(5);
+      expect(stats.rootNodes).toBe(2);
+      expect(stats.maxDepth).toBe(2); // Max depth across all trees
+    });
+  });
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/src/delegation/storage/__tests__/memory-statuslist-storage.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { MemoryStatusListStorage } from "../memory-statuslist-storage.js";
+import type { StatusList2021Credential } from "@kya-os/contracts";
+
+describe("MemoryStatusListStorage", () => {
+  let storage: MemoryStatusListStorage;
+
+  const mockStatusListCredential: StatusList2021Credential = {
+    "@context": [
+      "https://www.w3.org/2018/credentials/v1",
+      "https://w3id.org/vc/status-list/2021/v1",
+    ],
+    id: "https://example.com/status/revocation/v1",
+    type: ["VerifiableCredential", "StatusList2021Credential"],
+    issuer: "did:web:example.com",
+    issuanceDate: "2024-01-01T00:00:00Z",
+    credentialSubject: {
+      id: "https://example.com/status/revocation/v1#list",
+      type: "StatusList2021",
+      statusPurpose: "revocation",
+      encodedList: "H4sIAAAAAAAAA2NgGAWjYBSMglEwCkYBqwAA0kEQVAEAAA==",
+    },
+    proof: {
+      type: "Ed25519Signature2020",
+      created: "2024-01-01T00:00:00Z",
+      verificationMethod: "did:web:example.com#key-1",
+      proofPurpose: "assertionMethod",
+      proofValue: "mock-proof",
+    },
+  };
+
+  beforeEach(() => {
+    storage = new MemoryStatusListStorage();
+  });
+
+  describe("getStatusList", () => {
+    it("should return null for non-existent status list", async () => {
+      const result = await storage.getStatusList("non-existent");
+      expect(result).toBeNull();
+    });
+
+    it("should return stored status list", async () => {
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        mockStatusListCredential
+      );
+
+      const result = await storage.getStatusList(
+        "https://example.com/status/revocation/v1"
+      );
+
+      expect(result).toEqual(mockStatusListCredential);
+    });
+  });
+
+  describe("setStatusList", () => {
+    it("should store status list", async () => {
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        mockStatusListCredential
+      );
+
+      const result = await storage.getStatusList(
+        "https://example.com/status/revocation/v1"
+      );
+      expect(result).toEqual(mockStatusListCredential);
+    });
+
+    it("should overwrite existing status list", async () => {
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        mockStatusListCredential
+      );
+
+      const updatedCredential = {
+        ...mockStatusListCredential,
+        issuanceDate: "2024-01-02T00:00:00Z",
+      };
+
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        updatedCredential
+      );
+
+      const result = await storage.getStatusList(
+        "https://example.com/status/revocation/v1"
+      );
+      expect(result?.issuanceDate).toBe("2024-01-02T00:00:00Z");
+    });
+
+    it("should store multiple status lists independently", async () => {
+      const revocationCredential = mockStatusListCredential;
+      const suspensionCredential = {
+        ...mockStatusListCredential,
+        id: "https://example.com/status/suspension/v1",
+        credentialSubject: {
+          ...mockStatusListCredential.credentialSubject,
+          id: "https://example.com/status/suspension/v1#list",
+          statusPurpose: "suspension" as const,
+        },
+      };
+
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        revocationCredential
+      );
+      await storage.setStatusList(
+        "https://example.com/status/suspension/v1",
+        suspensionCredential
+      );
+
+      const revocation = await storage.getStatusList(
+        "https://example.com/status/revocation/v1"
+      );
+      const suspension = await storage.getStatusList(
+        "https://example.com/status/suspension/v1"
+      );
+
+      expect(revocation?.credentialSubject.statusPurpose).toBe("revocation");
+      expect(suspension?.credentialSubject.statusPurpose).toBe("suspension");
+    });
+  });
+
+  describe("allocateIndex", () => {
+    it("should allocate sequential indices starting from 0", async () => {
+      const statusListId = "https://example.com/status/revocation/v1";
+
+      const index1 = await storage.allocateIndex(statusListId);
+      const index2 = await storage.allocateIndex(statusListId);
+      const index3 = await storage.allocateIndex(statusListId);
+
+      expect(index1).toBe(0);
+      expect(index2).toBe(1);
+      expect(index3).toBe(2);
+    });
+
+    it("should allocate indices independently per status list", async () => {
+      const list1 = "https://example.com/status/revocation/v1";
+      const list2 = "https://example.com/status/suspension/v1";
+
+      const index1 = await storage.allocateIndex(list1);
+      const index2 = await storage.allocateIndex(list2);
+      const index3 = await storage.allocateIndex(list1);
+
+      expect(index1).toBe(0);
+      expect(index2).toBe(0); // Independent counter
+      expect(index3).toBe(1);
+    });
+
+    it("should continue from previous allocation after clear", async () => {
+      const statusListId = "https://example.com/status/revocation/v1";
+
+      await storage.allocateIndex(statusListId);
+      await storage.allocateIndex(statusListId);
+      storage.clear();
+
+      const index = await storage.allocateIndex(statusListId);
+      expect(index).toBe(0); // Starts fresh after clear
+    });
+  });
+
+  describe("getIndexCount", () => {
+    it("should return 0 for new status list", () => {
+      const count = storage.getIndexCount("https://example.com/status/new");
+      expect(count).toBe(0);
+    });
+
+    it("should return current allocation count", async () => {
+      const statusListId = "https://example.com/status/revocation/v1";
+
+      await storage.allocateIndex(statusListId);
+      expect(storage.getIndexCount(statusListId)).toBe(1);
+
+      await storage.allocateIndex(statusListId);
+      expect(storage.getIndexCount(statusListId)).toBe(2);
+    });
+  });
+
+  describe("clear", () => {
+    it("should remove all status lists", async () => {
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        mockStatusListCredential
+      );
+
+      storage.clear();
+
+      const result = await storage.getStatusList(
+        "https://example.com/status/revocation/v1"
+      );
+      expect(result).toBeNull();
+    });
+
+    it("should reset index counters", async () => {
+      const statusListId = "https://example.com/status/revocation/v1";
+
+      await storage.allocateIndex(statusListId);
+      await storage.allocateIndex(statusListId);
+
+      storage.clear();
+
+      expect(storage.getIndexCount(statusListId)).toBe(0);
+    });
+  });
+
+  describe("getAllStatusListIds", () => {
+    it("should return empty array when no status lists", () => {
+      const ids = storage.getAllStatusListIds();
+      expect(ids).toEqual([]);
+    });
+
+    it("should return all stored status list IDs", async () => {
+      await storage.setStatusList(
+        "https://example.com/status/revocation/v1",
+        mockStatusListCredential
+      );
+      await storage.setStatusList("https://example.com/status/suspension/v1", {
+        ...mockStatusListCredential,
+        id: "https://example.com/status/suspension/v1",
+      });
+
+      const ids = storage.getAllStatusListIds();
+      expect(ids).toContain("https://example.com/status/revocation/v1");
+      expect(ids).toContain("https://example.com/status/suspension/v1");
+      expect(ids.length).toBe(2);
+    });
+  });
+});

package/src/delegation/storage/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Storage Implementations
+ *
+ * Example storage providers for testing and development.
+ * Production implementations would use persistent storage (KV, DB, etc.)
+ */
+
+export * from './memory-statuslist-storage';
+export * from './memory-graph-storage';