@signalium/query 0.1.0 → 1.0.0

package/src/__tests__/gc-time.test.ts

@@ -1,327 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { SyncQueryStore, MemoryPersistentStore, valueKeyFor } from '../QueryStore.js';
-import { QueryClient } from '../QueryClient.js';
-import { query } from '../query.js';
-import { t, entity } from '../typeDefs.js';
-import { createMockFetch, testWithClient, sleep } from './utils.js';
-import { hashValue } from 'signalium/utils';
-
-/**
- * GC Time Tests
- *
- * Tests gcTime-based garbage collection with sorted queue management,
- * LRU interaction, and subscriber-aware eviction
- */
-
-describe('GC Time', () => {
-  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, evictionMultiplier: 0.001 });
-  });
-
-  afterEach(() => {
-    client?.destroy();
-  });
-
-  describe('Basic GC', () => {
-    it('should evict queries from disk after gcTime expires', async () => {
-      const getItem = query(t => ({
-        path: '/item/[id]',
-        response: { id: t.number, name: t.string },
-        cache: { gcTime: 100, staleTime: 50 }, // 1 second
-      }));
-
-      mockFetch.get('/item/1', { id: 1, name: 'Item 1' });
-
-      await testWithClient(client, async () => {
-        const relay = getItem({ id: '1' });
-        expect(relay.value).toEqual(undefined);
-        await relay;
-        expect(relay.value).toEqual({ id: 1, name: 'Item 1' });
-      });
-
-      await sleep(75);
-
-      mockFetch.get('/item/1', { id: 1, name: 'Item 1 updated' }, { delay: 50 });
-      await testWithClient(client, async () => {
-        const relay = getItem({ id: '1' });
-        expect(relay.value).toEqual({ id: 1, name: 'Item 1' });
-        await relay;
-        expect(relay.value).toEqual({ id: 1, name: 'Item 1' });
-
-        await sleep(60);
-        expect(relay.value).toEqual({ id: 1, name: 'Item 1 updated' });
-      });
-
-      await sleep(200);
-
-      await testWithClient(client, async () => {
-        const relay = getItem({ id: '1' });
-        expect(relay.value).toEqual(undefined);
-        await relay;
-        expect(relay.value).toEqual({ id: 1, name: 'Item 1 updated' });
-      });
-    });
-
-    it('should NOT evict queries with active subscribers', async () => {
-      const getItem = query(t => ({
-        path: '/active',
-        response: { data: t.string },
-        cache: { gcTime: 50 },
-      }));
-
-      mockFetch.get('/active', { data: 'test' });
-
-      // Keep query active
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-
-        const queryKey = hashValue(['GET:/active', undefined]);
-
-        // Wait past GC time
-        await sleep(60);
-
-        // Should still be in memory because it's active (has subscriber)
-        expect(client.queryInstances.has(queryKey)).toBe(true);
-      });
-    }, 3000);
-  });
-
-  describe('GC with LRU', () => {
-    it('should work alongside LRU cache eviction', async () => {
-      const User = entity(() => ({
-        __typename: t.typename('User'),
-        id: t.id,
-        name: t.string,
-      }));
-
-      const getUser = query(t => ({
-        path: '/users/[id]',
-        response: { user: User },
-        cache: {
-          maxCount: 2, // LRU size
-          gcTime: 5000, // 5 seconds
-        },
-      }));
-
-      mockFetch.get('/users/1', { user: { __typename: 'User', id: 1, name: 'User 1' } });
-      mockFetch.get('/users/2', { user: { __typename: 'User', id: 2, name: 'User 2' } });
-      mockFetch.get('/users/3', { user: { __typename: 'User', id: 3, name: 'User 3' } });
-
-      await testWithClient(client, async () => {
-        // Fetch 3 users - third should evict first from disk via LRU
-        const relay1 = getUser({ id: '1' });
-        await relay1;
-
-        const relay2 = getUser({ id: '2' });
-        await relay2;
-
-        const relay3 = getUser({ id: '3' });
-        await relay3;
-
-        const query1Key = hashValue(['GET:/users/[id]', { id: '1' }]);
-        const query2Key = hashValue(['GET:/users/[id]', { id: '2' }]);
-        const query3Key = hashValue(['GET:/users/[id]', { id: '3' }]);
-
-        // All should be in memory initially
-        expect(client.queryInstances.has(query1Key)).toBe(true);
-        expect(client.queryInstances.has(query2Key)).toBe(true);
-        expect(client.queryInstances.has(query3Key)).toBe(true);
-
-        // First query should be evicted from DISK by LRU (but still in memory)
-        expect(kv.getString(valueKeyFor(query1Key))).toBeUndefined();
-        expect(kv.getString(valueKeyFor(query2Key))).toBeDefined();
-        expect(kv.getString(valueKeyFor(query3Key))).toBeDefined();
-      });
-    });
-  });
-
-  describe('GC Queue Management', () => {
-    it('should add queries to GC queue when deactivated', async () => {
-      const getItem = query(t => ({
-        path: '/item',
-        response: { value: t.string },
-        cache: { gcTime: 2000 },
-      }));
-
-      mockFetch.get('/item', { value: 'test' });
-
-      const queryKey = hashValue(['GET:/item', undefined]);
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-
-        expect(client.queryInstances.has(queryKey)).toBe(true);
-      });
-
-      // After context ends, query should be scheduled for GC
-      // In a real implementation, we'd check the GC queue
-      // For now, we verify the query is still in memory
-      expect(client.queryInstances.has(queryKey)).toBe(true);
-    });
-
-    it('should remove queries from GC queue when reactivated', async () => {
-      const getItem = query(t => ({
-        path: '/reactivate',
-        response: { n: t.number },
-        cache: { gcTime: 1000 },
-      }));
-
-      mockFetch.get('/reactivate', { n: 1 });
-
-      const queryKey = hashValue(['GET:/reactivate', undefined]);
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-      });
-
-      // Query deactivated, scheduled for GC
-      await sleep(40);
-
-      // Reactivate before GC
-      mockFetch.get('/reactivate', { n: 2 });
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        relay.value; // Access it
-        await sleep(60);
-
-        // Should still be in memory
-        expect(client.queryInstances.has(queryKey)).toBe(true);
-      });
-
-      // Even after original GC time, should not be evicted due to reactivation
-      await sleep(40);
-      expect(client.queryInstances.has(queryKey)).toBe(true);
-    });
-  });
-
-  describe('GC with Entities', () => {
-    it("should handle entity cleanup when query is GC'd", async () => {
-      const Post = entity(() => ({
-        __typename: t.typename('Post'),
-        id: t.id,
-        title: t.string,
-      }));
-
-      const User = entity(() => ({
-        __typename: t.typename('User'),
-        id: t.id,
-        name: t.string,
-        post: Post,
-      }));
-
-      const getUser = query(t => ({
-        path: '/user',
-        response: { user: User },
-        cache: { gcTime: 1000 },
-      }));
-
-      mockFetch.get('/user', {
-        user: {
-          __typename: 'User',
-          id: 1,
-          name: 'Alice',
-          post: {
-            __typename: 'Post',
-            id: 10,
-            title: 'Test Post',
-          },
-        },
-      });
-
-      await testWithClient(client, async () => {
-        const relay = getUser();
-        await relay;
-      });
-
-      const userKey = hashValue('User:1');
-      const postKey = hashValue('Post:10');
-
-      // Entities should exist in store
-      expect(kv.getString(valueKeyFor(userKey))).toBeDefined();
-      expect(kv.getString(valueKeyFor(postKey))).toBeDefined();
-
-      // Note: The actual GC of entities is handled by the LRU system
-      // when queries are evicted. The gcTime affects when queries
-      // are removed from memory, but disk cleanup is done by LRU.
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle queries without gcTime', async () => {
-      const getItem = query(t => ({
-        path: '/no-gc',
-        response: { data: t.string },
-        // No gcTime configured
-      }));
-
-      mockFetch.get('/no-gc', { data: 'test' });
-
-      const queryKey = hashValue(['GET:/no-gc', undefined]);
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-      });
-
-      // Should remain in memory indefinitely
-      await sleep(100);
-      expect(client.queryInstances.has(queryKey)).toBe(true);
-    });
-
-    it('should handle very short gcTime', async () => {
-      const getItem = query(t => ({
-        path: '/short-gc',
-        response: { value: t.number },
-        cache: { gcTime: 100 }, // Very short
-      }));
-
-      mockFetch.get('/short-gc', { value: 42 });
-
-      const queryKey = hashValue(['GET:/short-gc', undefined]);
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-      });
-
-      // Should be scheduled for GC quickly
-      // Note: Actual eviction timing depends on GC interval
-    });
-
-    it('should handle very long gcTime', async () => {
-      const getItem = query(t => ({
-        path: '/long-gc',
-        response: { data: t.string },
-        cache: { gcTime: 1000 * 60 * 60 }, // 1 hour
-      }));
-
-      mockFetch.get('/long-gc', { data: 'persisted' });
-
-      const queryKey = hashValue(['GET:/long-gc', undefined]);
-
-      await testWithClient(client, async () => {
-        const relay = getItem();
-        await relay;
-      });
-
-      // Should remain in memory for a while, then be evicted
-      await sleep(40);
-      expect(client.queryInstances.has(queryKey)).toBe(true);
-
-      await sleep(100);
-      expect(client.queryInstances.has(queryKey)).toBe(false);
-    });
-  });
-});

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

@@ -1,186 +0,0 @@
-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 reuse the last match when no unused mocks remain', async () => {
-    const mockFetch = createMockFetch();
-    mockFetch.get('/users/123', { id: 123, name: 'Alice' });
-
-    // First call should succeed
-    const response1 = await mockFetch('/users/123', { method: 'GET' });
-    const data1 = await response1.json();
-    expect(data1).toEqual({ id: 123, name: 'Alice' });
-
-    // Second call should reuse the same mock since there are no unused ones
-    const response2 = await mockFetch('/users/123', { method: 'GET' });
-    const data2 = await response2.json();
-    expect(data2).toEqual({ id: 123, name: 'Alice' });
-  });
-
-  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' });
-  });
-});