@tenxyte/core 0.1.5 → 0.9.0

package/tests/http.test.ts

@@ -1,144 +1,144 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { TenxyteHttpClient } from '../src/http/client';
-import { MemoryStorage } from '../src/storage';
-import { createAuthInterceptor, createRefreshInterceptor } from '../src/http/interceptors';
-
-// Mock global fetch
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-describe('TenxyteHttpClient', () => {
-    let client: TenxyteHttpClient;
-    let storage: MemoryStorage;
-
-    beforeEach(() => {
-        mockFetch.mockReset();
-        storage = new MemoryStorage();
-        client = new TenxyteHttpClient({ baseUrl: 'https://api.tenxyte.com/v1' });
-    });
-
-    describe('Core HTTP', () => {
-        it('should format URL correctly and apply default headers', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                headers: new Headers({ 'content-type': 'application/json' }),
-                json: () => Promise.resolve({ data: 'ok' })
-            } as any);
-
-            const res = await client.get<{ data: string }>('/users', { params: { limit: 10 } });
-
-            expect(res.data).toBe('ok');
-            expect(mockFetch).toHaveBeenCalledWith('https://api.tenxyte.com/v1/users?limit=10', expect.objectContaining({
-                method: 'GET',
-                headers: expect.objectContaining({
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json'
-                })
-            }));
-        });
-
-        it('should throw normalized TenxyteError on failure', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: false,
-                status: 400,
-                headers: new Headers({ 'content-type': 'application/json' }),
-                json: () => Promise.resolve({ error: 'Bad data', code: 'INVALID_CREDENTIALS', details: { email: ['invalid'] } })
-            } as any);
-
-            await expect(client.post('/auth/login', { bad: true })).rejects.toMatchObject({
-                error: 'Bad data',
-                code: 'INVALID_CREDENTIALS',
-                details: { email: ['invalid'] }
-            });
-        });
-
-        it('should handle 204 No Content correctly without parsing JSON', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 204,
-                headers: new Headers()
-            } as any);
-
-            const res = await client.delete('/users/1');
-            expect(res).toEqual({});
-        });
-    });
-
-    describe('Interceptors', () => {
-        it('should inject Authorization and Context headers', async () => {
-            storage.setItem('tx_access', 'jwt.token.123');
-            const authInterceptor = createAuthInterceptor(storage, { activeOrgSlug: 'tenxyte-labs', agentTraceId: 'trc_999' });
-            client.addRequestInterceptor(authInterceptor);
-
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                headers: new Headers({ 'content-type': 'application/json' }),
-                json: () => Promise.resolve({ ok: true })
-            } as any);
-
-            await client.get('/me');
-            expect(mockFetch).toHaveBeenCalledWith('https://api.tenxyte.com/v1/me', expect.objectContaining({
-                headers: expect.objectContaining({
-                    Authorization: 'Bearer jwt.token.123',
-                    'X-Org-Slug': 'tenxyte-labs',
-                    'X-Prompt-Trace-ID': 'trc_999'
-                })
-            }));
-        });
-
-        it('should seamlessly refresh token on 401', async () => {
-            storage.setItem('tx_access', 'expired.token');
-            storage.setItem('tx_refresh', 'valid.refresh.token');
-
-            const onSessionExpired = vi.fn();
-            const authInterceptor = createAuthInterceptor(storage, { activeOrgSlug: null, agentTraceId: null });
-            const refreshInterceptor = createRefreshInterceptor(client, storage, onSessionExpired);
-
-            client.addRequestInterceptor(authInterceptor);
-            client.addResponseInterceptor(refreshInterceptor);
-
-            // 1. Initial request gets 401
-            // 2. Interceptor triggers refresh (/auth/refresh/) returning 200 with new token
-            // 3. Interceptor retries initial request with new token, returning 200
-
-            mockFetch
-                // First fail call '/me' with 401
-                .mockResolvedValueOnce({
-                    ok: false,
-                    status: 401,
-                    headers: new Headers(),
-                    json: () => Promise.resolve({ error: 'Token expired', code: 'TOKEN_EXPIRED' })
-                } as any)
-                // Refresh call '/auth/refresh/' succeeds
-                .mockResolvedValueOnce({
-                    ok: true,
-                    status: 200,
-                    headers: new Headers({ 'content-type': 'application/json' }),
-                    json: () => Promise.resolve({ access: 'new.access', refresh: 'new.refresh' })
-                } as any)
-                // Retry call '/me' succeeds
-                .mockResolvedValueOnce({
-                    ok: true,
-                    status: 200,
-                    headers: new Headers({ 'content-type': 'application/json' }),
-                    json: () => Promise.resolve({ id: 1, name: 'Bob' })
-                } as any);
-
-            const res = await client.get('/me');
-
-            expect(res).toEqual({ id: 1, name: 'Bob' });
-            expect(storage.getItem('tx_access')).toBe('new.access');
-            expect(storage.getItem('tx_refresh')).toBe('new.refresh');
-            expect(mockFetch).toHaveBeenCalledTimes(3);
-
-            // Verify the retry request had the NEW token!
-            expect(mockFetch).toHaveBeenNthCalledWith(3, 'https://api.tenxyte.com/v1/me', expect.objectContaining({
-                headers: expect.objectContaining({
-                    Authorization: 'Bearer new.access'
-                })
-            }));
-        });
-    });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TenxyteHttpClient } from '../src/http/client';
+import { MemoryStorage } from '../src/storage';
+import { createAuthInterceptor, createRefreshInterceptor } from '../src/http/interceptors';
+
+// Mock global fetch
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('TenxyteHttpClient', () => {
+    let client: TenxyteHttpClient;
+    let storage: MemoryStorage;
+
+    beforeEach(() => {
+        mockFetch.mockReset();
+        storage = new MemoryStorage();
+        client = new TenxyteHttpClient({ baseUrl: 'https://api.tenxyte.com/v1' });
+    });
+
+    describe('Core HTTP', () => {
+        it('should format URL correctly and apply default headers', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: () => Promise.resolve({ data: 'ok' })
+            } as any);
+
+            const res = await client.get<{ data: string }>('/users', { params: { limit: 10 } });
+
+            expect(res.data).toBe('ok');
+            expect(mockFetch).toHaveBeenCalledWith('https://api.tenxyte.com/v1/users?limit=10', expect.objectContaining({
+                method: 'GET',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                })
+            }));
+        });
+
+        it('should throw normalized TenxyteError on failure', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: () => Promise.resolve({ error: 'Bad data', code: 'INVALID_CREDENTIALS', details: { email: ['invalid'] } })
+            } as any);
+
+            await expect(client.post('/auth/login', { bad: true })).rejects.toMatchObject({
+                error: 'Bad data',
+                code: 'INVALID_CREDENTIALS',
+                details: { email: ['invalid'] }
+            });
+        });
+
+        it('should handle 204 No Content correctly without parsing JSON', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 204,
+                headers: new Headers()
+            } as any);
+
+            const res = await client.delete('/users/1');
+            expect(res).toEqual({});
+        });
+    });
+
+    describe('Interceptors', () => {
+        it('should inject Authorization and Context headers', async () => {
+            storage.setItem('tx_access', 'jwt.token.123');
+            const authInterceptor = createAuthInterceptor(storage, { activeOrgSlug: 'tenxyte-labs', agentTraceId: 'trc_999' });
+            client.addRequestInterceptor(authInterceptor);
+
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: () => Promise.resolve({ ok: true })
+            } as any);
+
+            await client.get('/me');
+            expect(mockFetch).toHaveBeenCalledWith('https://api.tenxyte.com/v1/me', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer jwt.token.123',
+                    'X-Org-Slug': 'tenxyte-labs',
+                    'X-Prompt-Trace-ID': 'trc_999'
+                })
+            }));
+        });
+
+        it('should seamlessly refresh token on 401', async () => {
+            storage.setItem('tx_access', 'expired.token');
+            storage.setItem('tx_refresh', 'valid.refresh.token');
+
+            const onSessionExpired = vi.fn();
+            const authInterceptor = createAuthInterceptor(storage, { activeOrgSlug: null, agentTraceId: null });
+            const refreshInterceptor = createRefreshInterceptor(client, storage, onSessionExpired);
+
+            client.addRequestInterceptor(authInterceptor);
+            client.addResponseInterceptor(refreshInterceptor);
+
+            // 1. Initial request gets 401
+            // 2. Interceptor triggers refresh (/auth/refresh/) returning 200 with new token
+            // 3. Interceptor retries initial request with new token, returning 200
+
+            mockFetch
+                // First fail call '/me' with 401
+                .mockResolvedValueOnce({
+                    ok: false,
+                    status: 401,
+                    headers: new Headers(),
+                    json: () => Promise.resolve({ error: 'Token expired', code: 'TOKEN_EXPIRED' })
+                } as any)
+                // Refresh call '/auth/refresh/' succeeds
+                .mockResolvedValueOnce({
+                    ok: true,
+                    status: 200,
+                    headers: new Headers({ 'content-type': 'application/json' }),
+                    json: () => Promise.resolve({ access: 'new.access', refresh: 'new.refresh' })
+                } as any)
+                // Retry call '/me' succeeds
+                .mockResolvedValueOnce({
+                    ok: true,
+                    status: 200,
+                    headers: new Headers({ 'content-type': 'application/json' }),
+                    json: () => Promise.resolve({ id: 1, name: 'Bob' })
+                } as any);
+
+            const res = await client.get('/me');
+
+            expect(res).toEqual({ id: 1, name: 'Bob' });
+            expect(storage.getItem('tx_access')).toBe('new.access');
+            expect(storage.getItem('tx_refresh')).toBe('new.refresh');
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+
+            // Verify the retry request had the NEW token!
+            expect(mockFetch).toHaveBeenNthCalledWith(3, 'https://api.tenxyte.com/v1/me', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer new.access'
+                })
+            }));
+        });
+    });
+});

package/tests/modules/auth.test.ts

@@ -1,93 +1,93 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { AuthModule } from '../../src/modules/auth';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-describe('AuthModule', () => {
-    let client: TenxyteHttpClient;
-    let auth: AuthModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        auth = new AuthModule(client);
-
-        // Mock the underlying request method
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    it('loginWithEmail should POST to /api/v1/auth/login/email/', async () => {
-        const mockResponse = { access_token: 'acc', refresh_token: 'ref', token_type: 'Bearer', expires_in: 3600, device_summary: null };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-
-        const data = { email: 'test@example.com', password: 'password123' };
-        const result = await auth.loginWithEmail(data);
-
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/login/email/', {
-            method: 'POST',
-            body: data,
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('logout should POST to /api/v1/auth/logout/ with refresh_token', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-
-        await auth.logout('some_refresh_token');
-
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/logout/', {
-            method: 'POST',
-            body: { refresh_token: 'some_refresh_token' },
-        });
-    });
-
-    it('requestMagicLink should POST to /api/v1/auth/magic-link/request/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-
-        const data = { email: 'magic@example.com' };
-        await auth.requestMagicLink(data);
-
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/magic-link/request/', {
-            method: 'POST',
-            body: data,
-        });
-    });
-
-    it('verifyMagicLink should GET from /api/v1/auth/magic-link/verify/ with token in query', async () => {
-        const mockResponse = { access_token: 'acc' };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-
-        const result = await auth.verifyMagicLink('magic_token_123');
-
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/magic-link/verify/', {
-            method: 'GET',
-            params: { token: 'magic_token_123' },
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('loginWithSocial should POST to /api/v1/auth/social/:provider/', async () => {
-        const mockResponse = { access_token: 'acc' };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-
-        const data = { access_token: 'google_token' };
-        const result = await auth.loginWithSocial('google', data);
-
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/social/google/', {
-            method: 'POST',
-            body: data,
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('handleSocialCallback should GET from callback endpoint with correct params', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce({ access_token: 'acc' });
-
-        await auth.handleSocialCallback('github', 'auth_code', 'http://localhost/callback');
-
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/social/github/callback/', {
-            method: 'GET',
-            params: { code: 'auth_code', redirect_uri: 'http://localhost/callback' },
-        });
-    });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AuthModule } from '../../src/modules/auth';
+import { TenxyteHttpClient } from '../../src/http/client';
+
+describe('AuthModule', () => {
+    let client: TenxyteHttpClient;
+    let auth: AuthModule;
+
+    beforeEach(() => {
+        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
+        auth = new AuthModule(client);
+
+        // Mock the underlying request method
+        vi.spyOn(client, 'request').mockImplementation(async () => {
+            return {};
+        });
+    });
+
+    it('loginWithEmail should POST to /api/v1/auth/login/email/', async () => {
+        const mockResponse = { access_token: 'acc', refresh_token: 'ref', token_type: 'Bearer', expires_in: 3600, device_summary: null };
+        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
+
+        const data = { email: 'test@example.com', password: 'password123' };
+        const result = await auth.loginWithEmail(data);
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/login/email/', {
+            method: 'POST',
+            body: data,
+        });
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('logout should POST to /api/v1/auth/logout/ with refresh_token', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+
+        await auth.logout('some_refresh_token');
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/logout/', {
+            method: 'POST',
+            body: { refresh_token: 'some_refresh_token' },
+        });
+    });
+
+    it('requestMagicLink should POST to /api/v1/auth/magic-link/request/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+
+        const data = { email: 'magic@example.com' };
+        await auth.requestMagicLink(data);
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/magic-link/request/', {
+            method: 'POST',
+            body: data,
+        });
+    });
+
+    it('verifyMagicLink should GET from /api/v1/auth/magic-link/verify/ with token in query', async () => {
+        const mockResponse = { access_token: 'acc' };
+        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
+
+        const result = await auth.verifyMagicLink('magic_token_123');
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/magic-link/verify/', {
+            method: 'GET',
+            params: { token: 'magic_token_123' },
+        });
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('loginWithSocial should POST to /api/v1/auth/social/:provider/', async () => {
+        const mockResponse = { access_token: 'acc' };
+        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
+
+        const data = { access_token: 'google_token' };
+        const result = await auth.loginWithSocial('google', data);
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/social/google/', {
+            method: 'POST',
+            body: data,
+        });
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('handleSocialCallback should GET from callback endpoint with correct params', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce({ access_token: 'acc' });
+
+        await auth.handleSocialCallback('github', 'auth_code', 'http://localhost/callback');
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/social/github/callback/', {
+            method: 'GET',
+            params: { code: 'auth_code', redirect_uri: 'http://localhost/callback' },
+        });
+    });
+});