@signalium/query 0.0.2 → 1.0.0

package/src/__tests__/reactivity.test.ts

@@ -1,424 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { SyncQueryStore, MemoryPersistentStore } from '../QueryStore.js';
-import { QueryClient, QueryClientContext } from '../QueryClient.js';
-import { entity, t } from '../typeDefs.js';
-import { query } from '../query.js';
-import { watcher, withContexts, reactive } from 'signalium';
-import { createMockFetch, testWithClient } from './utils.js';
-
-/**
- * Signalium Reactivity Tests
- *
- * Tests relay lifecycle, reactive computations, watcher behavior,
- * and entity update propagation.
- */
-
-describe('Signalium Reactivity', () => {
-  let client: QueryClient;
-  let mockFetch: ReturnType<typeof createMockFetch>;
-  let kv: any;
-  let store: any;
-
-  beforeEach(() => {
-    kv = new MemoryPersistentStore();
-    store = new SyncQueryStore(kv);
-    mockFetch = createMockFetch();
-    client = new QueryClient(store, { fetch: mockFetch as any });
-  });
-
-  afterEach(() => {
-    client?.destroy();
-  });
-
-  describe('Relay Lifecycle', () => {
-    it('should start relay in pending state', async () => {
-      mockFetch.get('/item', { data: 'test' }, { delay: 100 });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-
-        // Relay should exist and be in pending state
-        expect(relay).toBeDefined();
-        expect(relay.isPending).toBe(true);
-      });
-    });
-
-    it('should transition to resolved state with data', async () => {
-      mockFetch.get('/item', { data: 'test' });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-        await relay;
-
-        expect(relay.isResolved).toBe(true);
-        expect(relay.isReady).toBe(true);
-        expect(relay.isPending).toBe(false);
-        expect(relay.value).toEqual({ data: 'test' });
-      });
-    });
-
-    it('should transition to error state on failure', async () => {
-      const error = new Error('Failed to fetch');
-      mockFetch.get('/item', null, { error });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-        await expect(relay).rejects.toThrow('Failed to fetch');
-
-        expect(relay.isRejected).toBe(true);
-        expect(relay.error).toBe(error);
-      });
-    });
-  });
-
-  describe('Reactive Computations', () => {
-    it('should support reactive functions depending on query relay', async () => {
-      mockFetch.get('/counter', { count: 5 });
-
-      await testWithClient(client, async () => {
-        const getCounter = query(t => ({
-          path: '/counter',
-          response: { count: t.number },
-        }));
-
-        const relay = getCounter();
-
-        // Create a reactive function that depends on the relay
-        const doubled = reactive(() => {
-          if (relay.isReady) {
-            return relay.value.count * 2;
-          }
-          return 0;
-        });
-
-        await relay;
-
-        // Wait for reactive computation
-        const result = doubled();
-
-        expect(result).toBe(10);
-      });
-    });
-
-    it('should support nested reactive functions', async () => {
-      mockFetch.get('/value', { value: 10 });
-
-      await testWithClient(client, async () => {
-        const getValue = query(t => ({
-          path: '/value',
-          response: { value: t.number },
-        }));
-
-        const relay = getValue();
-
-        const doubled = reactive(() => {
-          if (relay.isReady) {
-            return relay.value.value * 2;
-          }
-          return 0;
-        });
-
-        const tripled = reactive(() => {
-          return doubled() * 1.5;
-        });
-
-        await relay;
-
-        expect(doubled()).toBe(20);
-        expect(tripled()).toBe(30);
-      });
-    });
-
-    it('should support conditional reactivity', async () => {
-      mockFetch.get('/config', { value: 5, shouldDouble: true });
-
-      await testWithClient(client, async () => {
-        const getConfig = query(t => ({
-          path: '/config',
-          response: { value: t.number, shouldDouble: t.boolean },
-        }));
-
-        const relay = getConfig();
-
-        const computed = reactive(() => {
-          if (relay.isReady) {
-            const config = relay.value;
-            return config.shouldDouble ? config.value * 2 : config.value;
-          }
-          return 0;
-        });
-
-        await relay;
-
-        expect(computed()).toBe(10);
-      });
-    });
-  });
-
-  describe('Promise State Tracking', () => {
-    it('should track isPending state', async () => {
-      mockFetch.get('/item', { data: 'test' }, { delay: 50 });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-
-        // Initially should be pending
-        expect(relay.isPending).toBe(true);
-
-        await relay;
-
-        // After resolution should not be pending
-        expect(relay.isPending).toBe(false);
-        expect(relay.isSettled).toBe(true);
-      });
-    });
-
-    it('should track isReady state correctly', async () => {
-      mockFetch.get('/item', { data: 'test' });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-
-        await relay;
-
-        // After resolution should be ready
-        expect(relay.isReady).toBe(true);
-        expect(relay.value).toEqual({ data: 'test' });
-      });
-    });
-
-    it('should track isResolved state', async () => {
-      mockFetch.get('/item', { success: true });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { success: t.boolean },
-        }));
-
-        const relay = getItem();
-        await relay;
-
-        expect(relay.isResolved).toBe(true);
-        expect(relay.isRejected).toBe(false);
-      });
-    });
-
-    it('should track isRejected state', async () => {
-      mockFetch.get('/item', null, { error: new Error('Failed') });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { success: t.boolean },
-        }));
-
-        const relay = getItem();
-        await expect(relay).rejects.toThrow('Failed');
-
-        expect(relay.isRejected).toBe(true);
-        expect(relay.isResolved).toBe(false);
-      });
-    });
-  });
-
-  describe('Reactive Query Patterns', () => {
-    it('should support query results in reactive computations', async () => {
-      mockFetch.get('/users', {
-        users: [
-          { id: 1, name: 'Alice' },
-          { id: 2, name: 'Bob' },
-        ],
-      });
-
-      await testWithClient(client, async () => {
-        const getUsers = query(t => ({
-          path: '/users',
-          response: {
-            users: t.array(t.object({ id: t.number, name: t.string })),
-          },
-        }));
-
-        const relay = getUsers();
-
-        const userCount = reactive(() => {
-          if (relay.isReady) {
-            return relay.value.users.length;
-          }
-          return 0;
-        });
-
-        const firstUserName = reactive(() => {
-          if (relay.isReady && relay.value.users.length > 0) {
-            return relay.value.users[0].name;
-          }
-          return 'Unknown';
-        });
-
-        await relay;
-
-        expect(userCount()).toBe(2);
-        expect(firstUserName()).toBe('Alice');
-      });
-    });
-
-    it('should handle conditional query access', async () => {
-      mockFetch.get('/config', { enabled: true, data: 'test' });
-
-      await testWithClient(client, async () => {
-        const getConfig = query(t => ({
-          path: '/config',
-          response: { enabled: t.boolean, data: t.string },
-        }));
-
-        const relay = getConfig();
-
-        const result = reactive(() => {
-          if (relay.isReady) {
-            const config = relay.value;
-            // Conditional access - only read data if enabled
-            return config.enabled ? config.data : 'disabled';
-          }
-          return 'loading';
-        });
-
-        expect(result()).toBe('loading');
-
-        await relay;
-
-        expect(result()).toBe('test');
-      });
-    });
-  });
-
-  describe('Concurrent Query Handling', () => {
-    it('should handle concurrent queries without interference', async () => {
-      // Set up mocks for different IDs
-      mockFetch.get('/items/1', { url: '/items/1', timestamp: Date.now() });
-      mockFetch.get('/items/2', { url: '/items/2', timestamp: Date.now() });
-      mockFetch.get('/items/3', { url: '/items/3', timestamp: Date.now() });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/items/[id]',
-          response: { url: t.string, timestamp: t.number },
-        }));
-
-        // Start multiple concurrent queries
-        const relay1 = getItem({ id: '1' });
-        const relay2 = getItem({ id: '2' });
-        const relay3 = getItem({ id: '3' });
-
-        const [result1, result2, result3] = await Promise.all([relay1, relay2, relay3]);
-
-        expect(result1.url).toContain('/items/1');
-        expect(result2.url).toContain('/items/2');
-        expect(result3.url).toContain('/items/3');
-      });
-    });
-
-    it('should deduplicate concurrent identical requests', async () => {
-      // Set up single mock with delay - should only be called once
-      mockFetch.get('/item', { count: 1 }, { delay: 50 });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { count: t.number },
-        }));
-
-        // Start multiple concurrent identical requests
-        const relay1 = getItem();
-        const relay2 = getItem();
-        const relay3 = getItem();
-
-        // Should be same relay
-        expect(relay1).toBe(relay2);
-        expect(relay2).toBe(relay3);
-
-        const [result1, result2, result3] = await Promise.all([relay1, relay2, relay3]);
-
-        // Should only fetch once
-        expect(mockFetch.calls).toHaveLength(1);
-
-        // All should have same result
-        expect(result1).toEqual(result2);
-        expect(result2).toEqual(result3);
-      });
-    });
-  });
-
-  describe('Error State Reactivity', () => {
-    it('should notify watchers on error', async () => {
-      const error = new Error('Network error');
-      mockFetch.get('/item', null, { error });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-        let errorCaught = false;
-
-        const w = watcher(() => {
-          if (relay.isRejected) {
-            errorCaught = true;
-          }
-        });
-
-        const unsub = w.addListener(() => {});
-
-        await expect(relay).rejects.toThrow('Network error');
-        await new Promise(resolve => setTimeout(resolve, 10));
-
-        expect(errorCaught).toBe(true);
-
-        unsub();
-      });
-    });
-
-    it('should expose error object on relay', async () => {
-      const error = new Error('Custom error');
-      mockFetch.get('/item', null, { error });
-
-      await testWithClient(client, async () => {
-        const getItem = query(t => ({
-          path: '/item',
-          response: { data: t.string },
-        }));
-
-        const relay = getItem();
-        await expect(relay).rejects.toThrow('Custom error');
-
-        expect(relay.error).toBe(error);
-      });
-    });
-  });
-});

package/src/__tests__/refetch-interval.test.ts

@@ -1,262 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { SyncQueryStore, MemoryPersistentStore } from '../QueryStore.js';
-import { QueryClient } from '../QueryClient.js';
-import { query } from '../query.js';
-import { RefetchInterval } from '../types.js';
-import { createMockFetch, testWithClient, sleep } from './utils.js';
-
-/**
- * RefetchInterval Tests
- *
- * Tests refetchInterval with dynamic GCD-based timer management,
- * subscriber tracking, exponential backoff, and no overlapping fetches
- */
-
-describe('RefetchInterval', () => {
-  let client: QueryClient;
-  let mockFetch: ReturnType<typeof createMockFetch>;
-  let kv: any;
-  let store: any;
-
-  beforeEach(() => {
-    client?.destroy();
-    kv = new MemoryPersistentStore();
-    store = new SyncQueryStore(kv);
-    mockFetch = createMockFetch();
-    client = new QueryClient(store, { fetch: mockFetch as any, refetchMultiplier: 0.1 });
-  });
-
-  afterEach(() => {
-    client?.destroy();
-  });
-
-  describe('Basic Refetch Interval', () => {
-    it('should refetch at specified interval', async () => {
-      let callCount = 0;
-      mockFetch.get('/counter', () => ({ count: ++callCount }));
-
-      const getCounter = query(t => ({
-        path: '/counter',
-        response: { count: t.number },
-        cache: { refetchInterval: RefetchInterval.Every1Second },
-      }));
-
-      await testWithClient(client, async () => {
-        const relay = getCounter();
-        await relay;
-        expect(relay.value).toEqual({ count: 1 });
-
-        // Wait for interval to trigger (100ms with 0.1 multiplier + buffer)
-        await sleep(120);
-        expect(relay.value?.count).toBeGreaterThan(1);
-
-        // Wait for another interval
-        await sleep(110);
-        expect(relay.value?.count).toBeGreaterThan(2);
-      });
-    });
-
-    it('should stop refetching when query is no longer accessed', async () => {
-      let callCount = 0;
-      mockFetch.get('/item', () => ({ n: ++callCount }));
-
-      const getItem = query(t => ({
-        path: '/item',
-        response: { n: t.number },
-        cache: { refetchInterval: RefetchInterval.Every1Second },
-      }));
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-        const initialCount = relay.value!.n;
-
-        // Wait a bit (250ms with 0.1 multiplier = ~2.5 intervals)
-        await sleep(250);
-        const afterCount = relay.value!.n;
-
-        expect(afterCount).toBeGreaterThan(initialCount);
-
-        await sleep(250);
-      });
-
-      // After context ends, wait and check that no more calls happen
-      const countBeforeWait = callCount;
-      await sleep(200);
-
-      // Note: This test is simplified - in a real implementation,
-      // subscriber tracking would need proper cleanup
-      // For now we just verify the basic interval works
-    });
-  });
-
-  describe('Multiple Intervals with GCD', () => {
-    it('should handle multiple queries with different intervals efficiently', async () => {
-      let count1 = 0;
-      let count5 = 0;
-
-      mockFetch.get('/every1s', () => ({ count: ++count1 }));
-      mockFetch.get('/every5s', () => ({ count: ++count5 }));
-
-      const getEvery1s = query(t => ({
-        path: '/every1s',
-        response: { count: t.number },
-        cache: { refetchInterval: RefetchInterval.Every1Second },
-      }));
-
-      const getEvery5s = query(t => ({
-        path: '/every5s',
-        response: { count: t.number },
-        cache: { refetchInterval: RefetchInterval.Every5Seconds },
-      }));
-
-      await testWithClient(client, async () => {
-        const relay1s = getEvery1s();
-        const relay5s = getEvery5s();
-
-        await relay1s;
-        await relay5s;
-
-        // Wait and verify different refetch rates (350ms = 3.5 intervals of 1s)
-        await sleep(350);
-
-        // 1s query should have refetched ~3 times
-        expect(count1).toBeGreaterThanOrEqual(3);
-        expect(count1).toBeLessThanOrEqual(5);
-
-        // 5s query should have refetched 0-1 times
-        expect(count5).toBeGreaterThanOrEqual(1);
-        expect(count5).toBeLessThanOrEqual(2);
-
-        // Wait for 5s interval (200ms more)
-        await sleep(200);
-
-        // 5s query should now have refetched
-        expect(count5).toBeGreaterThanOrEqual(2);
-      });
-    });
-
-    it('should use GCD for multiple queries with compatible intervals', async () => {
-      // Every5Seconds and Every10Seconds should use GCD of 5s
-      let count5 = 0;
-      let count10 = 0;
-
-      mockFetch.get('/5s', () => ({ n: ++count5 }));
-      mockFetch.get('/10s', () => ({ n: ++count10 }));
-
-      const get5s = query(t => ({
-        path: '/5s',
-        response: { n: t.number },
-        cache: { refetchInterval: RefetchInterval.Every5Seconds },
-      }));
-
-      const get10s = query(t => ({
-        path: '/10s',
-        response: { n: t.number },
-        cache: { refetchInterval: RefetchInterval.Every10Seconds },
-      }));
-
-      await testWithClient(client, async () => {
-        const relay5 = get5s();
-        const relay10 = get10s();
-
-        await Promise.all([relay5, relay10]);
-
-        // Wait 1100ms (11 seconds at 0.1x = 1.1s)
-        await sleep(1100);
-
-        // 5s should refetch ~2 times
-        expect(count5).toBeGreaterThanOrEqual(2);
-
-        // 10s should refetch ~1 time
-        expect(count10).toBeGreaterThanOrEqual(1);
-        expect(count10).toBeLessThanOrEqual(2);
-      });
-    });
-  });
-
-  describe('No Overlapping Fetches', () => {
-    it('should wait for previous fetch to complete before next refetch', async () => {
-      let activeFetches = 0;
-      let maxConcurrent = 0;
-      let fetchCount = 0;
-
-      mockFetch.get('/slow', async () => {
-        activeFetches++;
-        maxConcurrent = Math.max(maxConcurrent, activeFetches);
-        fetchCount++;
-        await sleep(80); // Slow fetch (80ms = 800ms at 0.1x)
-        activeFetches--;
-        return { count: fetchCount };
-      });
-
-      const getSlow = query(t => ({
-        path: '/slow',
-        response: { count: t.number },
-        cache: { refetchInterval: RefetchInterval.Every1Second },
-      }));
-
-      await testWithClient(client, async () => {
-        const relay = getSlow();
-        await relay;
-
-        // Wait for several intervals (350ms = 3.5 intervals)
-        await sleep(350);
-
-        // Should never have overlapping fetches
-        expect(maxConcurrent).toBe(1);
-
-        // Should have attempted multiple fetches but not overlapping
-        expect(fetchCount).toBeGreaterThan(1);
-      });
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle query without refetchInterval', async () => {
-      let callCount = 0;
-      mockFetch.get('/no-interval', () => ({ n: ++callCount }));
-
-      const getItem = query(t => ({
-        path: '/no-interval',
-        response: { n: t.number },
-        // No refetchInterval
-      }));
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-        expect(relay.value).toEqual({ n: 1 });
-
-        // Wait a bit (200ms = 2s at 0.1x)
-        await sleep(200);
-
-        // Should not have refetched
-        expect(callCount).toBe(1);
-      });
-    });
-
-    it('should handle very fast intervals', async () => {
-      let callCount = 0;
-      mockFetch.get('/fast', () => ({ count: ++callCount }));
-
-      const getFast = query(t => ({
-        path: '/fast',
-        response: { count: t.number },
-        cache: { refetchInterval: RefetchInterval.Every1Second },
-      }));
-
-      await testWithClient(client, async () => {
-        const relay = getFast();
-        await relay;
-
-        // Wait 250ms (2.5 intervals at 0.1x)
-        await sleep(250);
-
-        // Should have refetched at least twice
-        expect(callCount).toBeGreaterThanOrEqual(2);
-      });
-    });
-  });
-});