@memorylayerai/sdk 0.1.0 → 0.2.0

package/tests/graph.unit.test.ts

@@ -0,0 +1,513 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GraphResource } from '../src/resources/graph.js';
+import { HTTPClient } from '../src/http-client.js';
+import { ValidationError } from '../src/errors.js';
+import type { GraphData, NodeDetails, GetNodeEdgesResponse, GraphNode } from '../src/types.js';
+
+/**
+ * Graph Resource Unit Tests
+ * 
+ * These are true unit tests that mock the HTTP client.
+ * They test the GraphResource class in isolation.
+ * 
+ * Requirements: 6.1, 6.2, 6.3, 6.4
+ */
+
+// Helper function to create empty graph data
+function createEmptyGraphData(): GraphData {
+  return {
+    nodes: [],
+    edges: [],
+    metadata: {
+      totalNodes: 0,
+      memoryCount: 0,
+      documentCount: 0,
+      entityCount: 0,
+      totalEdges: 0,
+      relationshipCount: 0,
+      similarityCount: 0,
+    },
+    pagination: {
+      hasMore: false,
+      nextCursor: undefined,
+    },
+  };
+}
+
+// Helper function to create a test node
+function createTestNode(id: string, label: string): GraphNode {
+  return {
+    id,
+    type: 'memory',
+    label,
+    data: {
+      status: 'latest',
+      createdAt: '2026-01-20T00:00:00Z',
+      content: `Content ${id}`,
+    },
+  };
+}
+
+describe('GraphResource Unit Tests', () => {
+  let graphResource: GraphResource;
+  let mockHttpClient: HTTPClient;
+
+  beforeEach(() => {
+    // Create mock HTTP client
+    mockHttpClient = {
+      request: vi.fn(),
+    } as unknown as HTTPClient;
+
+    graphResource = new GraphResource(mockHttpClient);
+  });
+
+  describe('getGraph', () => {
+    it('should make correct API request with minimal parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      const result = await graphResource.getGraph({
+        spaceId: 'test-space-123',
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {},
+      });
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should include cursor in query parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        cursor: 'cursor-abc',
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          cursor: 'cursor-abc',
+        },
+      });
+    });
+
+    it('should include limit in query parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        limit: 50,
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          limit: '50',
+        },
+      });
+    });
+
+    it('should include node types in query parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        nodeTypes: ['memory', 'document'],
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          nodeTypes: 'memory,document',
+        },
+      });
+    });
+
+    it('should include relationship types in query parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        relationshipTypes: ['extends', 'updates'],
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          relationshipTypes: 'extends,updates',
+        },
+      });
+    });
+
+    it('should include date range in query parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        startDate: '2026-01-01T00:00:00Z',
+        endDate: '2026-01-31T23:59:59Z',
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          startDate: '2026-01-01T00:00:00Z',
+          endDate: '2026-01-31T23:59:59Z',
+        },
+      });
+    });
+
+    it('should include all parameters when provided', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        cursor: 'cursor-abc',
+        limit: 50,
+        nodeTypes: ['memory'],
+        relationshipTypes: ['extends'],
+        startDate: '2026-01-01T00:00:00Z',
+        endDate: '2026-01-31T23:59:59Z',
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          cursor: 'cursor-abc',
+          limit: '50',
+          nodeTypes: 'memory',
+          relationshipTypes: 'extends',
+          startDate: '2026-01-01T00:00:00Z',
+          endDate: '2026-01-31T23:59:59Z',
+        },
+      });
+    });
+
+    it('should throw ValidationError for missing spaceId', async () => {
+      await expect(
+        graphResource.getGraph({ spaceId: '' })
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        graphResource.getGraph({ spaceId: '   ' })
+      ).rejects.toThrow('Space ID is required');
+    });
+
+    it('should not include empty arrays in query parameters', async () => {
+      const mockResponse = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getGraph({
+        spaceId: 'test-space-123',
+        nodeTypes: [],
+        relationshipTypes: [],
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {},
+      });
+    });
+  });
+
+  describe('getNodeDetails', () => {
+    it('should make correct API request', async () => {
+      const mockResponse: NodeDetails = {
+        node: {
+          id: 'node-123',
+          type: 'memory',
+          label: 'Test Memory',
+          data: {
+            status: 'latest',
+            createdAt: '2026-01-20T00:00:00Z',
+            content: 'Test content',
+          },
+        },
+        edges: [],
+        connectedNodes: [],
+      };
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      const result = await graphResource.getNodeDetails({
+        nodeId: 'node-123',
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/nodes/node-123',
+      });
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should throw ValidationError for missing nodeId', async () => {
+      await expect(
+        graphResource.getNodeDetails({ nodeId: '' })
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        graphResource.getNodeDetails({ nodeId: '   ' })
+      ).rejects.toThrow('Node ID is required');
+    });
+  });
+
+  describe('getNodeEdges', () => {
+    it('should make correct API request without filters', async () => {
+      const mockResponse: GetNodeEdgesResponse = {
+        edges: [],
+        connectedNodes: [],
+      };
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      const result = await graphResource.getNodeEdges({
+        nodeId: 'node-123',
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/nodes/node-123/edges',
+        query: {},
+      });
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should include edge types in query parameters', async () => {
+      const mockResponse: GetNodeEdgesResponse = {
+        edges: [],
+        connectedNodes: [],
+      };
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getNodeEdges({
+        nodeId: 'node-123',
+        edgeTypes: ['extends', 'updates'],
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/nodes/node-123/edges',
+        query: {
+          edgeTypes: 'extends,updates',
+        },
+      });
+    });
+
+    it('should throw ValidationError for missing nodeId', async () => {
+      await expect(
+        graphResource.getNodeEdges({ nodeId: '' })
+      ).rejects.toThrow(ValidationError);
+
+      await expect(
+        graphResource.getNodeEdges({ nodeId: '   ' })
+      ).rejects.toThrow('Node ID is required');
+    });
+
+    it('should not include empty arrays in query parameters', async () => {
+      const mockResponse: GetNodeEdgesResponse = {
+        edges: [],
+        connectedNodes: [],
+      };
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(mockResponse);
+
+      await graphResource.getNodeEdges({
+        nodeId: 'node-123',
+        edgeTypes: [],
+      });
+
+      expect(mockHttpClient.request).toHaveBeenCalledWith({
+        method: 'GET',
+        path: '/v1/graph/nodes/node-123/edges',
+        query: {},
+      });
+    });
+  });
+
+  describe('getAllGraphPages', () => {
+    it('should yield all pages until hasMore is false', async () => {
+      const page1: GraphData = {
+        nodes: [createTestNode('node-1', 'Node 1')],
+        edges: [],
+        metadata: {
+          totalNodes: 3,
+          memoryCount: 3,
+          documentCount: 0,
+          entityCount: 0,
+          totalEdges: 0,
+          relationshipCount: 0,
+          similarityCount: 0,
+        },
+        pagination: {
+          hasMore: true,
+          nextCursor: 'cursor-2',
+        },
+      };
+
+      const page2: GraphData = {
+        nodes: [createTestNode('node-2', 'Node 2')],
+        edges: [],
+        metadata: {
+          totalNodes: 3,
+          memoryCount: 3,
+          documentCount: 0,
+          entityCount: 0,
+          totalEdges: 0,
+          relationshipCount: 0,
+          similarityCount: 0,
+        },
+        pagination: {
+          hasMore: true,
+          nextCursor: 'cursor-3',
+        },
+      };
+
+      const page3: GraphData = {
+        nodes: [createTestNode('node-3', 'Node 3')],
+        edges: [],
+        metadata: {
+          totalNodes: 3,
+          memoryCount: 3,
+          documentCount: 0,
+          entityCount: 0,
+          totalEdges: 0,
+          relationshipCount: 0,
+          similarityCount: 0,
+        },
+        pagination: {
+          hasMore: false,
+          nextCursor: undefined,
+        },
+      };
+
+      vi.mocked(mockHttpClient.request)
+        .mockResolvedValueOnce(page1)
+        .mockResolvedValueOnce(page2)
+        .mockResolvedValueOnce(page3);
+
+      const pages: GraphData[] = [];
+      for await (const page of graphResource.getAllGraphPages({
+        spaceId: 'test-space-123',
+      })) {
+        pages.push(page);
+      }
+
+      expect(pages).toHaveLength(3);
+      expect(pages[0]).toEqual(page1);
+      expect(pages[1]).toEqual(page2);
+      expect(pages[2]).toEqual(page3);
+
+      // Verify correct API calls
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(3);
+      expect(mockHttpClient.request).toHaveBeenNthCalledWith(1, {
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {},
+      });
+      expect(mockHttpClient.request).toHaveBeenNthCalledWith(2, {
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: { cursor: 'cursor-2' },
+      });
+      expect(mockHttpClient.request).toHaveBeenNthCalledWith(3, {
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: { cursor: 'cursor-3' },
+      });
+    });
+
+    it('should handle single page result', async () => {
+      const page1 = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request).mockResolvedValue(page1);
+
+      const pages: GraphData[] = [];
+      for await (const page of graphResource.getAllGraphPages({
+        spaceId: 'test-space-123',
+      })) {
+        pages.push(page);
+      }
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0]).toEqual(page1);
+      expect(mockHttpClient.request).toHaveBeenCalledTimes(1);
+    });
+
+    it('should preserve filters across pages', async () => {
+      const page1: GraphData = {
+        ...createEmptyGraphData(),
+        pagination: {
+          hasMore: true,
+          nextCursor: 'cursor-2',
+        },
+      };
+
+      const page2 = createEmptyGraphData();
+
+      vi.mocked(mockHttpClient.request)
+        .mockResolvedValueOnce(page1)
+        .mockResolvedValueOnce(page2);
+
+      const pages: GraphData[] = [];
+      for await (const page of graphResource.getAllGraphPages({
+        spaceId: 'test-space-123',
+        limit: 10,
+        nodeTypes: ['memory'],
+        relationshipTypes: ['extends'],
+      })) {
+        pages.push(page);
+      }
+
+      expect(pages).toHaveLength(2);
+
+      // Verify filters are preserved
+      expect(mockHttpClient.request).toHaveBeenNthCalledWith(1, {
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          limit: '10',
+          nodeTypes: 'memory',
+          relationshipTypes: 'extends',
+        },
+      });
+      expect(mockHttpClient.request).toHaveBeenNthCalledWith(2, {
+        method: 'GET',
+        path: '/v1/graph/spaces/test-space-123',
+        query: {
+          cursor: 'cursor-2',
+          limit: '10',
+          nodeTypes: 'memory',
+          relationshipTypes: 'extends',
+        },
+      });
+    });
+  });
+});