@signalium/query 0.0.0

package/src/__tests__/mock-fetch.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { createMockFetch } from './utils.js';
+
+describe('createMockFetch', () => {
+  it('should handle GET requests', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123, name: 'Alice' });
+
+    const response = await mockFetch('/users/123', { method: 'GET' });
+    const data = await response.json();
+
+    expect(data).toEqual({ id: 123, name: 'Alice' });
+    expect(response.status).toBe(200);
+    expect(response.ok).toBe(true);
+  });
+
+  it('should handle POST requests with custom status', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.post('/users', { id: 456, name: 'Bob' }, { status: 201 });
+
+    const response = await mockFetch('/users', { method: 'POST' });
+    const data = await response.json();
+
+    expect(data).toEqual({ id: 456, name: 'Bob' });
+    expect(response.status).toBe(201);
+  });
+
+  it('should handle PUT requests', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.put('/users/123', { id: 123, name: 'Updated Alice' });
+
+    const response = await mockFetch('/users/123', { method: 'PUT' });
+    const data = await response.json();
+
+    expect(data).toEqual({ id: 123, name: 'Updated Alice' });
+  });
+
+  it('should handle DELETE requests', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.delete('/users/123', { success: true });
+
+    const response = await mockFetch('/users/123', { method: 'DELETE' });
+    const data = await response.json();
+
+    expect(data).toEqual({ success: true });
+  });
+
+  it('should handle PATCH requests', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.patch('/users/123', { id: 123, email: 'new@example.com' });
+
+    const response = await mockFetch('/users/123', { method: 'PATCH' });
+    const data = await response.json();
+
+    expect(data).toEqual({ id: 123, email: 'new@example.com' });
+  });
+
+  it('should support custom headers', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get(
+      '/users/123',
+      { id: 123 },
+      {
+        headers: { 'X-Custom-Header': 'test-value' },
+      },
+    );
+
+    const response = await mockFetch('/users/123', { method: 'GET' });
+
+    expect(response.headers.get('X-Custom-Header')).toBe('test-value');
+  });
+
+  it('should support delays', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123 }, { delay: 100 });
+
+    const start = Date.now();
+    await mockFetch('/users/123', { method: 'GET' });
+    const duration = Date.now() - start;
+
+    expect(duration).toBeGreaterThanOrEqual(90); // Allow some margin
+  });
+
+  it('should match path parameters', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/[id]', { id: 123, name: 'Alice' });
+
+    const response = await mockFetch('/users/123', { method: 'GET' });
+    const data = await response.json();
+
+    expect(data).toEqual({ id: 123, name: 'Alice' });
+  });
+
+  it('should match multiple path parameters', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/[userId]/posts/[postId]', { userId: 5, postId: 10 });
+
+    const response = await mockFetch('/users/5/posts/10', { method: 'GET' });
+    const data = await response.json();
+
+    expect(data).toEqual({ userId: 5, postId: 10 });
+  });
+
+  it('should throw error for unmocked routes', async () => {
+    const mockFetch = createMockFetch();
+
+    await expect(mockFetch('/users/123', { method: 'GET' })).rejects.toThrow(
+      'No mock response configured for GET /users/123',
+    );
+  });
+
+  it('should track all calls', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123 });
+    mockFetch.post('/users', { id: 456 });
+
+    await mockFetch('/users/123', { method: 'GET' });
+    await mockFetch('/users', { method: 'POST', body: '{}' });
+
+    expect(mockFetch.calls).toHaveLength(2);
+    expect(mockFetch.calls[0].url).toBe('/users/123');
+    expect(mockFetch.calls[1].url).toBe('/users');
+  });
+
+  it('should reset routes and calls', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123 });
+
+    await mockFetch('/users/123', { method: 'GET' });
+    expect(mockFetch.calls).toHaveLength(1);
+
+    mockFetch.reset();
+
+    expect(mockFetch.calls).toHaveLength(0);
+    await expect(mockFetch('/users/123', { method: 'GET' })).rejects.toThrow('No mock response configured');
+  });
+
+  it('should default to GET method', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123 });
+
+    const response = await mockFetch('/users/123');
+    const data = await response.json();
+
+    expect(data).toEqual({ id: 123 });
+  });
+
+  it('should handle query parameters in URLs', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users', { users: [] });
+
+    const response = await mockFetch('/users?page=1&limit=10', { method: 'GET' });
+    const data = await response.json();
+
+    expect(data).toEqual({ users: [] });
+  });
+
+  it('should only use each route once by default', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123, name: 'Alice' });
+
+    // First call should succeed
+    await mockFetch('/users/123', { method: 'GET' });
+
+    // Second call should fail because route was already used
+    await expect(mockFetch('/users/123', { method: 'GET' })).rejects.toThrow('No mock response configured');
+  });
+
+  it('should allow multiple setups for repeated calls', async () => {
+    const mockFetch = createMockFetch();
+    mockFetch.get('/users/123', { id: 123, name: 'Alice' });
+    mockFetch.get('/users/123', { id: 123, name: 'Updated Alice' });
+
+    const response1 = await mockFetch('/users/123', { method: 'GET' });
+    const data1 = await response1.json();
+    expect(data1).toEqual({ id: 123, name: 'Alice' });
+
+    const response2 = await mockFetch('/users/123', { method: 'GET' });
+    const data2 = await response2.json();
+    expect(data2).toEqual({ id: 123, name: 'Updated Alice' });
+  });
+});

package/src/__tests__/parse-entities.test.ts

@@ -0,0 +1,421 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SyncQueryStore, MemoryPersistentStore, valueKeyFor, refIdsKeyFor, refCountKeyFor } from '../QueryStore.js';
+import { QueryClient } from '../QueryClient.js';
+import { entity, t } from '../typeDefs.js';
+import { parseEntities } from '../parseEntities.js';
+import { hashValue } from 'signalium/utils';
+
+// Helper to get documents from kv store for testing
+async function getDocument(kv: any, key: number): Promise<unknown | undefined> {
+  const value = kv.getString(valueKeyFor(key));
+  return value ? JSON.parse(value) : undefined;
+}
+
+describe('Parse Entities', () => {
+  let client: QueryClient;
+  let kv: any;
+  let store: any;
+
+  beforeEach(() => {
+    kv = new MemoryPersistentStore();
+    const queryStore = new SyncQueryStore(kv);
+    client = new QueryClient(queryStore, { fetch: fetch });
+    store = queryStore;
+  });
+
+  describe('nested entities', () => {
+    it('should track refs for deeply nested entities (A->B->C)', async () => {
+      const EntityC = entity(() => ({
+        __typename: t.typename('EntityC'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      const EntityB = entity(() => ({
+        __typename: t.typename('EntityB'),
+        id: t.id,
+        name: t.string,
+        c: EntityC,
+      }));
+
+      const EntityA = entity(() => ({
+        __typename: t.typename('EntityA'),
+        id: t.id,
+        name: t.string,
+        b: EntityB,
+      }));
+
+      const QueryResult = t.object({
+        data: EntityA,
+      });
+
+      const result = {
+        data: {
+          __typename: 'EntityA',
+          id: 1,
+          name: 'A',
+          b: {
+            __typename: 'EntityB',
+            id: 2,
+            name: 'B',
+            c: {
+              __typename: 'EntityC',
+              id: 3,
+              name: 'C',
+            },
+          },
+        },
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      // Top-level object is not an entity, so it pushes EntityA's key up
+      expect(entityRefs.size).toBe(1);
+
+      // Get the keys for each entity
+      const keyA = hashValue('EntityA:1');
+      const keyB = hashValue('EntityB:2');
+      const keyC = hashValue('EntityC:3');
+
+      expect(entityRefs.has(keyA)).toBe(true);
+
+      // EntityA should reference only EntityB (immediate child)
+      const refsA = await kv.getBuffer(refIdsKeyFor(keyA));
+      expect(refsA).toBeDefined();
+      const refsAArray = Array.from(refsA!);
+      expect(refsAArray).toContain(keyB);
+      expect(refsAArray).not.toContain(keyC); // Not transitive
+      expect(refsAArray.length).toBe(1);
+
+      // EntityB should reference only EntityC (immediate child)
+      const refsB = await kv.getBuffer(refIdsKeyFor(keyB));
+      expect(refsB).toBeDefined();
+      const refsBArray = Array.from(refsB!);
+      expect(refsBArray).toContain(keyC);
+      expect(refsBArray.length).toBe(1);
+
+      // EntityC should have no refs (leaf node)
+      const refsC = await kv.getBuffer(refIdsKeyFor(keyC));
+      expect(refsC).toBeUndefined();
+    });
+
+    it('should track refs for sibling entities (A->[B,C])', async () => {
+      const EntityB = entity(() => ({
+        __typename: t.typename('EntityB'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      const EntityC = entity(() => ({
+        __typename: t.typename('EntityC'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      const EntityA = entity(() => ({
+        __typename: t.typename('EntityA'),
+        id: t.id,
+        name: t.string,
+        b: EntityB,
+        c: EntityC,
+      }));
+
+      const QueryResult = t.object({
+        data: EntityA,
+      });
+
+      const result = {
+        data: {
+          __typename: 'EntityA',
+          id: 1,
+          name: 'A',
+          b: {
+            __typename: 'EntityB',
+            id: 2,
+            name: 'B',
+          },
+          c: {
+            __typename: 'EntityC',
+            id: 3,
+            name: 'C',
+          },
+        },
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      // Top-level object is not an entity, so it pushes EntityA's key up
+      expect(entityRefs.size).toBe(1);
+
+      const keyA = hashValue('EntityA:1');
+      const keyB = hashValue('EntityB:2');
+      const keyC = hashValue('EntityC:3');
+
+      expect(entityRefs.has(keyA)).toBe(true);
+
+      // EntityA should reference both B and C (immediate children)
+      const refsA = await kv.getBuffer(refIdsKeyFor(keyA));
+      expect(refsA).toBeDefined();
+      const refsAArray = Array.from(refsA!);
+      expect(refsAArray).toContain(keyB);
+      expect(refsAArray).toContain(keyC);
+      expect(refsAArray.length).toBe(2);
+    });
+  });
+
+  describe('entities in collections', () => {
+    it('should track refs for entities in arrays', async () => {
+      const EntityItem = entity(() => ({
+        __typename: t.typename('EntityItem'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      const QueryResult = t.object({
+        items: t.array(EntityItem),
+      });
+
+      const result = {
+        items: [
+          { __typename: 'EntityItem', id: 1, name: 'Item1' },
+          { __typename: 'EntityItem', id: 2, name: 'Item2' },
+          { __typename: 'EntityItem', id: 3, name: 'Item3' },
+        ],
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      // Top-level object is not an entity, and arrays push their entity children up
+      // So entityRefs should have the three entity keys
+      expect(entityRefs.size).toBe(3);
+
+      const key1 = hashValue('EntityItem:1');
+      const key2 = hashValue('EntityItem:2');
+      const key3 = hashValue('EntityItem:3');
+
+      expect(entityRefs.has(key1)).toBe(true);
+      expect(entityRefs.has(key2)).toBe(true);
+      expect(entityRefs.has(key3)).toBe(true);
+
+      // Each entity should be stored
+      expect(await getDocument(kv, key1)).toBeDefined();
+      expect(await getDocument(kv, key2)).toBeDefined();
+      expect(await getDocument(kv, key3)).toBeDefined();
+
+      // None of the leaf entities should have refs
+      expect(await kv.getBuffer(refIdsKeyFor(key1))).toBeUndefined();
+      expect(await kv.getBuffer(refIdsKeyFor(key2))).toBeUndefined();
+      expect(await kv.getBuffer(refIdsKeyFor(key3))).toBeUndefined();
+    });
+
+    it('should track refs for entities in records', async () => {
+      const EntityValue = entity(() => ({
+        __typename: t.typename('EntityValue'),
+        id: t.id,
+        value: t.string,
+      }));
+
+      const QueryResult = t.object({
+        map: t.record(EntityValue),
+      });
+
+      const result = {
+        map: {
+          a: { __typename: 'EntityValue', id: 1, value: 'A' },
+          b: { __typename: 'EntityValue', id: 2, value: 'B' },
+          c: { __typename: 'EntityValue', id: 3, value: 'C' },
+        },
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      // Top-level object is not an entity, records push their entity children up
+      expect(entityRefs.size).toBe(3);
+
+      const key1 = hashValue('EntityValue:1');
+      const key2 = hashValue('EntityValue:2');
+      const key3 = hashValue('EntityValue:3');
+
+      expect(entityRefs.has(key1)).toBe(true);
+      expect(entityRefs.has(key2)).toBe(true);
+      expect(entityRefs.has(key3)).toBe(true);
+
+      // None of the leaf entities should have refs
+      expect(await kv.getBuffer(refIdsKeyFor(key1))).toBeUndefined();
+      expect(await kv.getBuffer(refIdsKeyFor(key2))).toBeUndefined();
+      expect(await kv.getBuffer(refIdsKeyFor(key3))).toBeUndefined();
+    });
+
+    it('should handle nested entities in arrays', async () => {
+      const EntityChild = entity(() => ({
+        __typename: t.typename('EntityChild'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      const EntityParent = entity(() => ({
+        __typename: t.typename('EntityParent'),
+        id: t.id,
+        name: t.string,
+        child: EntityChild,
+      }));
+
+      const QueryResult = t.object({
+        items: t.array(EntityParent),
+      });
+
+      const result = {
+        items: [
+          {
+            __typename: 'EntityParent',
+            id: 1,
+            name: 'Parent1',
+            child: { __typename: 'EntityChild', id: 10, name: 'Child10' },
+          },
+          {
+            __typename: 'EntityParent',
+            id: 2,
+            name: 'Parent2',
+            child: { __typename: 'EntityChild', id: 20, name: 'Child20' },
+          },
+        ],
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      // Should have parent keys
+      expect(entityRefs.size).toBe(2);
+
+      const keyP1 = hashValue('EntityParent:1');
+      const keyP2 = hashValue('EntityParent:2');
+      const keyC10 = hashValue('EntityChild:10');
+      const keyC20 = hashValue('EntityChild:20');
+
+      expect(entityRefs.has(keyP1)).toBe(true);
+      expect(entityRefs.has(keyP2)).toBe(true);
+
+      // Parent1 should reference Child10
+      const refsP1 = await kv.getBuffer(refIdsKeyFor(keyP1));
+      expect(refsP1).toBeDefined();
+      expect(Array.from(refsP1!)).toContain(keyC10);
+
+      // Parent2 should reference Child20
+      const refsP2 = await kv.getBuffer(refIdsKeyFor(keyP2));
+      expect(refsP2).toBeDefined();
+      expect(Array.from(refsP2!)).toContain(keyC20);
+    });
+  });
+
+  describe('shared entities', () => {
+    it('should handle same entity referenced multiple times', async () => {
+      const EntityShared = entity(() => ({
+        __typename: t.typename('EntityShared'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      const EntityContainer = entity(() => ({
+        __typename: t.typename('EntityContainer'),
+        id: t.id,
+        first: EntityShared,
+        second: EntityShared,
+      }));
+
+      const QueryResult = t.object({
+        data: EntityContainer,
+      });
+
+      const sharedEntity = {
+        __typename: 'EntityShared',
+        id: 99,
+        name: 'Shared',
+      };
+
+      const result = {
+        data: {
+          __typename: 'EntityContainer',
+          id: 1,
+          first: sharedEntity,
+          second: sharedEntity,
+        },
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      // Top-level object pushes Container's key
+      expect(entityRefs.size).toBe(1);
+
+      const keyContainer = hashValue('EntityContainer:1');
+      const keyShared = hashValue('EntityShared:99');
+
+      expect(entityRefs.has(keyContainer)).toBe(true);
+
+      // Container should reference the shared entity
+      const refsContainer = await kv.getBuffer(refIdsKeyFor(keyContainer));
+      expect(refsContainer).toBeDefined();
+      const refsArray = Array.from(refsContainer!).filter(k => k !== 0);
+
+      // The refs array may contain duplicates (first, second both point to same entity)
+      // But that's ok - the important part is the ref count is correct
+      expect(refsArray).toContain(keyShared);
+
+      // Ref count should be 1 (documentStore deduplicates when processing refs)
+      const refCount = await kv.getNumber(refCountKeyFor(keyShared));
+      expect(refCount).toBe(1);
+    });
+  });
+
+  describe('complex structures', () => {
+    it('should handle entity with array of nested entities', async () => {
+      const EntityTag = entity(() => ({
+        __typename: t.typename('EntityTag'),
+        id: t.id,
+        label: t.string,
+      }));
+
+      const EntityPost = entity(() => ({
+        __typename: t.typename('EntityPost'),
+        id: t.id,
+        title: t.string,
+        tags: t.array(EntityTag),
+      }));
+
+      const QueryResult = t.object({
+        post: EntityPost,
+      });
+
+      const result = {
+        post: {
+          __typename: 'EntityPost',
+          id: 1,
+          title: 'My Post',
+          tags: [
+            { __typename: 'EntityTag', id: 10, label: 'tech' },
+            { __typename: 'EntityTag', id: 20, label: 'coding' },
+          ],
+        },
+      };
+
+      const entityRefs = new Set<number>();
+      await parseEntities(result, QueryResult, client, entityRefs);
+
+      const keyPost = hashValue('EntityPost:1');
+      const keyTag10 = hashValue('EntityTag:10');
+      const keyTag20 = hashValue('EntityTag:20');
+
+      // Post should reference both tags
+      const refsPost = await kv.getBuffer(refIdsKeyFor(keyPost));
+      expect(refsPost).toBeDefined();
+      const refsArray = Array.from(refsPost!);
+      expect(refsArray).toContain(keyTag10);
+      expect(refsArray).toContain(keyTag20);
+      expect(refsArray.length).toBe(2); // We should have 2 unique refs
+    });
+  });
+});