@signalium/query 0.0.0

package/src/__tests__/rest-query-api.test.ts

@@ -0,0 +1,564 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SyncQueryStore, MemoryPersistentStore } from '../QueryStore.js';
+import { QueryClient } from '../QueryClient.js';
+import { entity, t } from '../typeDefs.js';
+import { query } from '../query.js';
+import { createMockFetch, testWithClient, getEntityMapSize } from './utils.js';
+
+/**
+ * REST Query API Tests
+ *
+ * These tests focus on the PUBLIC query() API - what users will actually use.
+ * All external fetch calls are mocked.
+ */
+
+describe('REST Query API', () => {
+  let client: QueryClient;
+  let mockFetch: ReturnType<typeof createMockFetch>;
+
+  beforeEach(() => {
+    const store = new SyncQueryStore(new MemoryPersistentStore());
+    mockFetch = createMockFetch();
+    client = new QueryClient(store, { fetch: mockFetch as any });
+  });
+
+  describe('Basic Query Execution', () => {
+    it('should execute a GET query with path parameters', async () => {
+      mockFetch.get('/users/[id]', { id: 123, name: 'Test User' });
+
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getUser({ id: '123' });
+        const result = await relay;
+
+        expect(result.id).toBe(123);
+        expect(result.name).toBe('Test User');
+        expect(mockFetch.calls[0].url).toBe('/users/123');
+        expect(mockFetch.calls[0].options.method).toBe('GET');
+      });
+    });
+
+    it('should execute a GET query with search parameters', async () => {
+      mockFetch.get('/users', { users: [], page: 1, total: 0 });
+
+      const listUsers = query(t => ({
+        path: '/users',
+        searchParams: {
+          page: t.number,
+          limit: t.number,
+        },
+        response: {
+          users: t.array(
+            t.object({
+              id: t.number,
+              name: t.string,
+            }),
+          ),
+          page: t.number,
+          total: t.number,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = listUsers({ page: 1, limit: 10 });
+        const result = await relay;
+
+        expect(result.page).toBe(1);
+        expect(result.total).toBe(0);
+        // Verify URL was constructed with search params
+        const callUrl = mockFetch.calls[0].url;
+        expect(callUrl).toContain('page=1');
+        expect(callUrl).toContain('limit=10');
+      });
+    });
+
+    it('should execute a GET query with both path and search params', async () => {
+      mockFetch.get('/users/[userId]/posts', { posts: [], userId: 5 });
+
+      const getUserPosts = query(t => ({
+        path: '/users/[userId]/posts',
+        searchParams: {
+          status: t.string,
+        },
+        response: {
+          posts: t.array(
+            t.object({
+              id: t.number,
+              title: t.string,
+            }),
+          ),
+          userId: t.number,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getUserPosts({ userId: '5', status: 'published' });
+        const result = await relay;
+
+        expect(result.userId).toBe(5);
+        const callUrl = mockFetch.calls[0].url;
+        expect(callUrl).toContain('/users/5/posts');
+        expect(callUrl).toContain('status=published');
+      });
+    });
+
+    it('should execute POST requests', async () => {
+      mockFetch.post('/users', { id: 456, name: 'New User', created: true });
+
+      const createUser = query(t => ({
+        path: '/users',
+        method: 'POST',
+        response: {
+          id: t.number,
+          name: t.string,
+          created: t.boolean,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = createUser();
+        const result = await relay;
+
+        expect(result.id).toBe(456);
+        expect(result.created).toBe(true);
+        expect(mockFetch.calls[0].url).toBe('/users');
+        expect(mockFetch.calls[0].options.method).toBe('POST');
+      });
+    });
+
+    it('should execute PUT requests', async () => {
+      mockFetch.put('/users/[id]', { id: 123, name: 'Updated User', updated: true });
+
+      const updateUser = query(t => ({
+        path: '/users/[id]',
+        method: 'PUT',
+        response: {
+          id: t.number,
+          name: t.string,
+          updated: t.boolean,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = updateUser({ id: '123' });
+        const result = await relay;
+
+        expect(result.updated).toBe(true);
+        expect(mockFetch.calls[0].url).toBe('/users/123');
+        expect(mockFetch.calls[0].options.method).toBe('PUT');
+      });
+    });
+
+    it('should execute DELETE requests', async () => {
+      mockFetch.delete('/users/[id]', { success: true, id: 123 });
+
+      const deleteUser = query(t => ({
+        path: '/users/[id]',
+        method: 'DELETE',
+        response: {
+          success: t.boolean,
+          id: t.number,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = deleteUser({ id: '123' });
+        const result = await relay;
+
+        expect(result.success).toBe(true);
+        expect(mockFetch.calls[0].url).toBe('/users/123');
+        expect(mockFetch.calls[0].options.method).toBe('DELETE');
+      });
+    });
+
+    it('should execute PATCH requests', async () => {
+      mockFetch.patch('/users/[id]', {
+        id: 123,
+        email: 'new@example.com',
+        patched: true,
+      });
+
+      const patchUser = query(t => ({
+        path: '/users/[id]',
+        method: 'PATCH',
+        response: {
+          id: t.number,
+          email: t.string,
+          patched: t.boolean,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = patchUser({ id: '123' });
+        const result = await relay;
+
+        expect(result.patched).toBe(true);
+        expect(mockFetch.calls[0].url).toBe('/users/123');
+        expect(mockFetch.calls[0].options.method).toBe('PATCH');
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle network errors', async () => {
+      const error = new Error('Network connection failed');
+      mockFetch.get('/users/[id]', null, { error });
+
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getUser({ id: '123' });
+
+        await expect(relay).rejects.toThrow('Network connection failed');
+        expect(relay.isRejected).toBe(true);
+        expect(relay.error).toBe(error);
+      });
+    });
+
+    it('should handle malformed JSON responses', async () => {
+      mockFetch.get('/users/[id]', null, {
+        jsonError: new Error('Unexpected token in JSON'),
+      });
+
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getUser({ id: '123' });
+
+        await expect(relay).rejects.toThrow('Unexpected token in JSON');
+
+        expect(relay.isRejected).toBe(true);
+        expect(relay.error).toBeInstanceOf(Error);
+        expect((relay.error as Error).message).toBe('Unexpected token in JSON');
+      });
+    });
+
+    it('should require QueryClient context', async () => {
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      // Call without context
+      expect(() => getUser({ id: '123' })).toThrow('QueryClient not found');
+    });
+  });
+
+  describe('Query Deduplication', () => {
+    it('should deduplicate identical queries', async () => {
+      mockFetch.get('/users/[id]', { id: 123, name: 'Test User' });
+
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay1 = getUser({ id: '123' });
+        const relay2 = getUser({ id: '123' });
+        const relay3 = getUser({ id: '123' });
+
+        // Should return the same relay instance
+        expect(relay1).toBe(relay2);
+        expect(relay2).toBe(relay3);
+
+        await relay1;
+
+        // Should only fetch once
+        expect(mockFetch.calls).toHaveLength(1);
+      });
+    });
+
+    it('should create separate queries for different parameters', async () => {
+      // Mocks are matched in LIFO order (last added is matched first)
+      mockFetch.get('/users/1', { id: 1, name: 'User' });
+      mockFetch.get('/users/2', { id: 2, name: 'User' });
+
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay1 = getUser({ id: '1' });
+        const relay2 = getUser({ id: '2' });
+
+        // Should be different relay instances
+        expect(relay1).not.toBe(relay2);
+
+        const [result1, result2] = await Promise.all([relay1, relay2]);
+
+        expect(result1.id).toBe(1);
+        expect(result2.id).toBe(2);
+        expect(mockFetch.calls).toHaveLength(2);
+      });
+    });
+  });
+
+  describe('Response Type Handling', () => {
+    it('should handle primitive response types', async () => {
+      mockFetch.get('/message', 'Hello, World!');
+
+      const getMessage = query(t => ({
+        path: '/message',
+        response: t.string,
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getMessage();
+        const result = await relay;
+
+        expect(result).toBe('Hello, World!');
+      });
+    });
+
+    it('should handle array responses', async () => {
+      mockFetch.get('/numbers', [1, 2, 3, 4, 5]);
+
+      const getNumbers = query(t => ({
+        path: '/numbers',
+        response: t.array(t.number),
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getNumbers();
+        const result = await relay;
+
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+      });
+    });
+
+    it('should handle nested object responses', async () => {
+      mockFetch.get('/user', {
+        user: {
+          id: 1,
+          profile: {
+            name: 'Alice',
+            email: 'alice@example.com',
+          },
+        },
+      });
+
+      const getUser = query(t => ({
+        path: '/user',
+        response: {
+          user: t.object({
+            id: t.number,
+            profile: t.object({
+              name: t.string,
+              email: t.string,
+            }),
+          }),
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getUser();
+        const result = await relay;
+
+        expect(result.user.profile.name).toBe('Alice');
+        expect(result.user.profile.email).toBe('alice@example.com');
+      });
+    });
+  });
+
+  describe('Entity Handling', () => {
+    it('should handle entity responses', async () => {
+      const User = entity(() => ({
+        __typename: t.typename('User'),
+        id: t.id,
+        name: t.string,
+        email: t.string,
+      }));
+
+      mockFetch.get('/users/[id]', {
+        user: {
+          __typename: 'User',
+          id: 1,
+          name: 'Alice',
+          email: 'alice@example.com',
+        },
+      });
+
+      const getUser = query(t => ({
+        path: '/users/[id]',
+        response: {
+          user: User,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = getUser({ id: '1' });
+        const result = await relay;
+
+        expect(result.user.name).toBe('Alice');
+        expect(result.user.email).toBe('alice@example.com');
+
+        // Verify entity was cached
+        expect(getEntityMapSize(client)).toBe(1);
+      });
+    });
+
+    it('should handle array of entities', async () => {
+      const User = entity(() => ({
+        __typename: t.typename('User'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      mockFetch.get('/users', {
+        users: [
+          { __typename: 'User', id: 1, name: 'Alice' },
+          { __typename: 'User', id: 2, name: 'Bob' },
+          { __typename: 'User', id: 3, name: 'Charlie' },
+        ],
+      });
+
+      const listUsers = query(t => ({
+        path: '/users',
+        response: {
+          users: t.array(User),
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        const relay = listUsers();
+        const result = await relay;
+
+        expect(result.users).toHaveLength(3);
+        expect(result.users[0].name).toBe('Alice');
+        expect(result.users[1].name).toBe('Bob');
+        expect(result.users[2].name).toBe('Charlie');
+
+        // Verify all entities were cached
+        expect(getEntityMapSize(client)).toBe(3);
+      });
+    });
+
+    it('should deduplicate entities across queries', async () => {
+      const User = entity(() => ({
+        __typename: t.typename('User'),
+        id: t.id,
+        name: t.string,
+      }));
+
+      mockFetch.get('/users/[id]', {
+        user: { __typename: 'User', id: 1, name: 'Alice' },
+      });
+      mockFetch.get('/users', {
+        users: [{ __typename: 'User', id: 1, name: 'Alice' }],
+      });
+
+      await testWithClient(client, async () => {
+        const getUser = query(t => ({
+          path: '/users/[id]',
+          response: {
+            user: User,
+          },
+        }));
+
+        const listUsers = query(t => ({
+          path: '/users',
+          response: {
+            users: t.array(User),
+          },
+        }));
+
+        const relay1 = getUser({ id: '1' });
+        const result1 = await relay1;
+
+        const relay2 = listUsers();
+        const result2 = await relay2;
+
+        // Should be the same entity proxy
+        expect(result1.user).toBe(result2.users[0]);
+      });
+    });
+  });
+
+  describe('Optional Parameters', () => {
+    it('should handle optional search parameters', async () => {
+      mockFetch.get('/users', { users: [] });
+      mockFetch.get('/users', { users: [] });
+      mockFetch.get('/users', { users: [] });
+
+      await testWithClient(client, async () => {
+        const listUsers = query(t => ({
+          path: '/users',
+          searchParams: {
+            page: t.union(t.number, t.undefined),
+            limit: t.union(t.number, t.undefined),
+          },
+          response: {
+            users: t.array(t.object({ id: t.number, name: t.string })),
+          },
+        }));
+
+        // Call without optional params
+        const relay1 = listUsers({});
+        await relay1;
+
+        // Call with some params
+        const relay2 = listUsers({ page: 1 });
+        await relay2;
+
+        // Call with all params
+        const relay3 = listUsers({ page: 1, limit: 10 });
+        await relay3;
+
+        expect(mockFetch.calls).toHaveLength(3);
+      });
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should infer correct types for path parameters', async () => {
+      mockFetch.get('/items/[itemId]/details/[detailId]', { id: 1, name: 'Test' });
+
+      const getItem = query(t => ({
+        path: '/items/[itemId]/details/[detailId]',
+        response: {
+          id: t.number,
+          name: t.string,
+        },
+      }));
+
+      await testWithClient(client, async () => {
+        // TypeScript should require both path params
+        const relay = getItem({ itemId: '1', detailId: '2' });
+        await relay;
+
+        expect(mockFetch.calls[0].url).toContain('/items/1/details/2');
+        expect(mockFetch.calls[0].options.method).toBe('GET');
+      });
+    });
+  });
+});

package/src/__tests__/type-to-string.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import { typeToString } from '../errors.js';
+import { t } from '../typeDefs.js';
+
+/**
+ * Unit tests for typeToString function
+ * Tests the debug logging representation of TypeDef types
+ */
+
+describe('typeToString', () => {
+  describe('Primitive Types', () => {
+    it('should convert string type to "string"', () => {
+      expect(typeToString(t.string)).toBe('string');
+    });
+
+    it('should convert number type to "number"', () => {
+      expect(typeToString(t.number)).toBe('number');
+    });
+
+    it('should convert boolean type to "boolean"', () => {
+      expect(typeToString(t.boolean)).toBe('boolean');
+    });
+
+    it('should convert null type to "null"', () => {
+      expect(typeToString(t.null)).toBe('null');
+    });
+
+    it('should convert undefined type to "undefined"', () => {
+      expect(typeToString(t.undefined)).toBe('undefined');
+    });
+  });
+
+  describe('Constant Values', () => {
+    it('should convert string constant to quoted string', () => {
+      expect(typeToString(t.const('user'))).toBe('"user"');
+    });
+
+    it('should convert boolean constant to boolean string', () => {
+      expect(typeToString(t.const(true))).toBe('true');
+      expect(typeToString(t.const(false))).toBe('false');
+    });
+
+    it('should convert number constant to number string', () => {
+      const numConst = t.const(42);
+      expect(typeToString(numConst)).toBe('42');
+    });
+  });
+
+  describe('Union Types', () => {
+    it('should convert primitive union types', () => {
+      const unionType = t.union(t.string, t.number);
+      const result = typeToString(unionType);
+      // Union of primitives should show both types
+      expect(result).toMatch(/string.*number|number.*string/);
+    });
+
+    it('should convert union with null', () => {
+      const unionType = t.union(t.string, t.null);
+      const result = typeToString(unionType);
+      expect(result).toContain('null');
+      expect(result).toContain('string');
+    });
+
+    it('should convert union with undefined', () => {
+      const unionType = t.union(t.number, t.undefined);
+      const result = typeToString(unionType);
+      expect(result).toContain('undefined');
+      expect(result).toContain('number');
+    });
+
+    it('should convert value union with types', () => {
+      // Union with both types and values
+      const unionType = t.union(t.string, t.const('admin'));
+      const result = typeToString(unionType);
+    });
+  });
+
+  describe('Array Types', () => {
+    it('should convert array of primitives', () => {
+      expect(typeToString(t.array(t.string))).toBe('Array<string>');
+      expect(typeToString(t.array(t.number))).toBe('Array<number>');
+    });
+
+    it('should convert nested arrays', () => {
+      const nestedArray = t.array(t.array(t.string));
+      expect(typeToString(nestedArray)).toBe('Array<Array<string>>');
+    });
+  });
+
+  describe('Record Types', () => {
+    it('should convert record of primitives', () => {
+      expect(typeToString(t.record(t.string))).toBe('Record<string, string>');
+      expect(typeToString(t.record(t.number))).toBe('Record<string, number>');
+    });
+
+    it('should convert record of arrays', () => {
+      const recordOfArrays = t.record(t.array(t.string));
+      expect(typeToString(recordOfArrays)).toBe('Record<string, Array<string>>');
+    });
+  });
+
+  describe('Object Types', () => {
+    it('should convert object without typename', () => {
+      const obj = t.object({ name: t.string, age: t.number });
+      expect(typeToString(obj)).toBe('object');
+    });
+  });
+
+  describe('Complex Nested Types', () => {
+    it('should handle array of records', () => {
+      const type = t.array(t.record(t.string));
+      expect(typeToString(type)).toBe('Array<Record<string, string>>');
+    });
+
+    it('should handle record of arrays', () => {
+      const type = t.record(t.array(t.number));
+      expect(typeToString(type)).toBe('Record<string, Array<number>>');
+    });
+
+    it('should handle union of primitives with null and undefined', () => {
+      const type = t.union(t.string, t.number, t.null, t.undefined);
+      const result = typeToString(type);
+      expect(result).toContain('string');
+      expect(result).toContain('number');
+      expect(result).toContain('null');
+      expect(result).toContain('undefined');
+    });
+  });
+});