@signalium/query 0.1.0 → 1.0.1

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

@@ -1,425 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } 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;
-  });
-
-  afterEach(() => {
-    client?.destroy();
-  });
-
-  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
-    });
-  });
-});

package/src/__tests__/path-interpolation.test.ts

@@ -1,225 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createPathInterpolator } from '../pathInterpolator.js';
-
-describe('createPathInterpolator', () => {
-  describe('basic path interpolation', () => {
-    it('should interpolate a single parameter', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: '123' });
-      expect(result).toBe('/users/123');
-    });
-
-    it('should interpolate multiple parameters', () => {
-      const interpolate = createPathInterpolator('/users/[userId]/posts/[postId]');
-      const result = interpolate({ userId: '123', postId: '456' });
-      expect(result).toBe('/users/123/posts/456');
-    });
-
-    it('should handle consecutive parameters', () => {
-      const interpolate = createPathInterpolator('/items/[category][subcategory]');
-      const result = interpolate({ category: 'books', subcategory: 'fiction' });
-      expect(result).toBe('/items/booksfiction');
-    });
-
-    it('should handle path with no parameters', () => {
-      const interpolate = createPathInterpolator('/static/path');
-      const result = interpolate({});
-      expect(result).toBe('/static/path');
-    });
-
-    it('should handle path starting with parameter', () => {
-      const interpolate = createPathInterpolator('[tenant]/users/[userId]');
-      const result = interpolate({ tenant: 'acme', userId: '123' });
-      expect(result).toBe('acme/users/123');
-    });
-
-    it('should handle path ending with parameter', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: '123' });
-      expect(result).toBe('/users/123');
-    });
-  });
-
-  describe('URL encoding', () => {
-    it('should URL-encode special characters in path parameters', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: 'user@example.com' });
-      expect(result).toBe('/users/user%40example.com');
-    });
-
-    it('should URL-encode spaces', () => {
-      const interpolate = createPathInterpolator('/search/[query]');
-      const result = interpolate({ query: 'hello world' });
-      expect(result).toBe('/search/hello%20world');
-    });
-
-    it('should URL-encode forward slashes', () => {
-      const interpolate = createPathInterpolator('/files/[path]');
-      const result = interpolate({ path: 'folder/subfolder/file.txt' });
-      expect(result).toBe('/files/folder%2Fsubfolder%2Ffile.txt');
-    });
-
-    it('should handle unicode characters', () => {
-      const interpolate = createPathInterpolator('/items/[name]');
-      const result = interpolate({ name: '日本語' });
-      expect(result).toBe('/items/%E6%97%A5%E6%9C%AC%E8%AA%9E');
-    });
-  });
-
-  describe('query string parameters', () => {
-    it('should append extra parameters as query string', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: '123', page: 2, limit: 10 });
-      expect(result).toBe('/users/123?page=2&limit=10');
-    });
-
-    it('should append all non-path parameters as query string', () => {
-      const interpolate = createPathInterpolator('/users/[userId]/posts/[postId]');
-      const result = interpolate({
-        userId: '123',
-        postId: '456',
-        page: 2,
-        limit: 10,
-        sort: 'desc',
-      });
-      expect(result).toBe('/users/123/posts/456?page=2&limit=10&sort=desc');
-    });
-
-    it('should handle only query parameters when path has no params', () => {
-      const interpolate = createPathInterpolator('/search');
-      const result = interpolate({ q: 'test', page: 1 });
-      expect(result).toBe('/search?q=test&page=1');
-    });
-
-    it('should skip undefined query parameters', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: '123', page: 2, limit: undefined });
-      expect(result).toBe('/users/123?page=2');
-    });
-
-    it('should include null and empty string values in query params', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: '123', filter: null, name: '' });
-      expect(result).toBe('/users/123?filter=null&name=');
-    });
-
-    it('should handle boolean query parameters', () => {
-      const interpolate = createPathInterpolator('/items');
-      const result = interpolate({ active: true, deleted: false });
-      expect(result).toBe('/items?active=true&deleted=false');
-    });
-
-    it('should handle numeric query parameters', () => {
-      const interpolate = createPathInterpolator('/items');
-      const result = interpolate({ id: 0, count: 100 });
-      expect(result).toBe('/items?id=0&count=100');
-    });
-  });
-
-  describe('type coercion', () => {
-    it('should convert numeric path parameters to string', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-      const result = interpolate({ userId: 123 });
-      expect(result).toBe('/users/123');
-    });
-
-    it('should convert boolean path parameters to string', () => {
-      const interpolate = createPathInterpolator('/settings/[enabled]');
-      const result = interpolate({ enabled: true });
-      expect(result).toBe('/settings/true');
-    });
-
-    it('should convert null path parameters to string', () => {
-      const interpolate = createPathInterpolator('/items/[id]');
-      const result = interpolate({ id: null });
-      expect(result).toBe('/items/null');
-    });
-
-    it('should handle object conversion to string', () => {
-      const interpolate = createPathInterpolator('/items/[id]');
-      const result = interpolate({ id: { value: 123 } });
-      expect(result).toBe('/items/%5Bobject%20Object%5D');
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle empty path template', () => {
-      const interpolate = createPathInterpolator('');
-      const result = interpolate({});
-      expect(result).toBe('');
-    });
-
-    it('should handle empty params object', () => {
-      const interpolate = createPathInterpolator('/users/[userId]/posts/[postId]');
-      const result = interpolate({});
-      expect(result).toBe('/users/undefined/posts/undefined');
-    });
-
-    it('should handle missing path parameter values', () => {
-      const interpolate = createPathInterpolator('/users/[userId]/posts/[postId]');
-      const result = interpolate({ userId: '123' });
-      expect(result).toBe('/users/123/posts/undefined');
-    });
-
-    it('should handle parameter names with underscores', () => {
-      const interpolate = createPathInterpolator('/users/[user_id]');
-      const result = interpolate({ user_id: '123' });
-      expect(result).toBe('/users/123');
-    });
-
-    it('should handle parameter names with hyphens', () => {
-      const interpolate = createPathInterpolator('/users/[user-id]');
-      const result = interpolate({ 'user-id': '123' });
-      expect(result).toBe('/users/123');
-    });
-
-    it('should handle parameter names with numbers', () => {
-      const interpolate = createPathInterpolator('/items/[item1]/[item2]');
-      const result = interpolate({ item1: 'first', item2: 'second' });
-      expect(result).toBe('/items/first/second');
-    });
-
-    it('should be reusable for multiple interpolations', () => {
-      const interpolate = createPathInterpolator('/users/[userId]');
-
-      const result1 = interpolate({ userId: '123' });
-      const result2 = interpolate({ userId: '456' });
-      const result3 = interpolate({ userId: '789', page: 1 });
-
-      expect(result1).toBe('/users/123');
-      expect(result2).toBe('/users/456');
-      expect(result3).toBe('/users/789?page=1');
-    });
-
-    it('should handle complex real-world example', () => {
-      const interpolate = createPathInterpolator('/api/v1/tenants/[tenantId]/users/[userId]/documents/[documentId]');
-      const result = interpolate({
-        tenantId: 'acme-corp',
-        userId: 'user@example.com',
-        documentId: '12345',
-        version: 2,
-        format: 'pdf',
-        download: true,
-      });
-      expect(result).toBe(
-        '/api/v1/tenants/acme-corp/users/user%40example.com/documents/12345?version=2&format=pdf&download=true',
-      );
-    });
-  });
-
-  describe('performance characteristics', () => {
-    it('should create the interpolator once and reuse it efficiently', () => {
-      const interpolate = createPathInterpolator('/users/[userId]/posts/[postId]');
-
-      // Simulate multiple calls (as would happen in production)
-      const results = [];
-      for (let i = 0; i < 1000; i++) {
-        results.push(interpolate({ userId: `user${i}`, postId: `post${i}` }));
-      }
-
-      expect(results[0]).toBe('/users/user0/posts/post0');
-      expect(results[999]).toBe('/users/user999/posts/post999');
-      expect(results.length).toBe(1000);
-    });
-  });
-});