@topolo/sdk 0.3.0 → 0.4.1

package/src/client.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { TopoloClient } from './client.js';
 import { TopoloAuthError, TopoloHttpError, TopoloPermissionError } from './errors.js';
 
@@ -16,6 +16,15 @@ function stubFetch(responses: Array<{ status?: number; body?: unknown; contentTy
 }
 
 const AGENT = { clientName: 'topolo-test', clientVersion: '0.0.0' };
+const SERVICE_LOOKUP = { body: { success: true, data: { service_id: 'service_test' } } };
+
+function requestCalls(calls: Array<{ url: string; init: RequestInit }>) {
+  return calls.filter((call) => !call.url.includes('/api/services/by-slug/'));
+}
+
+beforeEach(() => {
+  TopoloClient.clearServiceIdCache();
+});
 
 describe('TopoloClient.request', () => {
   it('injects Bearer auth + audit headers for access_token credentials', async () => {
@@ -24,10 +33,12 @@ describe('TopoloClient.request', () => {
       credential: { kind: 'access_token', accessToken: 'tok_abc' },
       agent: AGENT,
       fetch: impl,
+      serviceIds: { auth: 'service_auth' },
     });
     await client.request({ service: 'auth', path: '/api/me' });
-    const headers = new Headers(calls[0]!.init.headers);
+    const headers = new Headers(requestCalls(calls)[0]!.init.headers);
     expect(headers.get('Authorization')).toBe('Bearer tok_abc');
+    expect(headers.get('X-Service-ID')).toBe('service_auth');
     expect(headers.get('X-Topolo-Client')).toBe('topolo-test/0.0.0');
     expect(headers.get('X-Topolo-Request-Id')).toMatch(/.+/);
   });
@@ -40,7 +51,7 @@ describe('TopoloClient.request', () => {
       fetch: impl,
     });
     await client.request({ service: 'crm', path: '/api/contacts' });
-    const headers = new Headers(calls[0]!.init.headers);
+    const headers = new Headers(requestCalls(calls)[0]!.init.headers);
     expect(headers.get('X-Api-Key')).toBe('dak_xyz');
     expect(headers.get('Authorization')).toBeNull();
   });
@@ -71,7 +82,7 @@ describe('TopoloClient.request', () => {
       body: { email: 'a@b.co' },
       confirm: true,
     });
-    expect(calls[0]!.init.method).toBe('POST');
+    expect(requestCalls(calls)[0]!.init.method).toBe('POST');
   });
 
   it('maps 401 → TopoloAuthError with unwrapped message', async () => {
@@ -144,7 +155,7 @@ describe('TopoloClient.request', () => {
       fetch: impl,
     });
     await client.request({ service: 'crm', path: '/api/contacts', query: { q: 'acme', page: 2 } });
-    const u = new URL(calls[0]!.url);
+    const u = new URL(requestCalls(calls)[0]!.url);
     expect(u.searchParams.get('q')).toBe('acme');
     expect(u.searchParams.get('page')).toBe('2');
   });
@@ -169,7 +180,7 @@ describe('TopoloClient.request', () => {
 
 describe('TopoloClient.debug hook', () => {
   it('fires request → response on a successful call with stable requestId + duration', async () => {
-    const { impl } = stubFetch([{ body: { ok: true } }]);
+    const { impl } = stubFetch([SERVICE_LOOKUP, { body: { ok: true } }]);
     const events: unknown[] = [];
     const client = new TopoloClient({
       credential: { kind: 'api_key', apiKey: 'x' },
@@ -262,14 +273,28 @@ describe('TopoloClient.getServiceIdBySlug', () => {
     });
   }
 
-  it('resolves a known slug via /api/services/by-slug/:slug', async () => {
+  it('uses configured service ids without calling Auth', async () => {
+    const { impl, calls } = stubFetch([]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'x' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' } as never,
+      serviceIds: { notify: 'service_notify' },
+    });
+    const id = await client.getServiceIdBySlug('topolo-notify');
+    expect(id).toBe('service_notify');
+    expect(calls).toEqual([]);
+  });
+
+  it('falls back to /api/services/by-slug/:slug for unknown slugs', async () => {
     const { impl, calls } = stubFetch([
-      { body: { success: true, data: { service_id: 'srv_abc123', base_url: 'https://x' } } },
+      { body: { success: true, data: { service_id: 'service_abc123', base_url: 'https://x' } } },
     ]);
     const client = freshClient(impl, { auth: 'https://auth.example.com' });
-    const id = await client.getServiceIdBySlug('topolo-notify');
-    expect(id).toBe('srv_abc123');
-    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/topolo-notify');
+    const id = await client.getServiceIdBySlug('external-service');
+    expect(id).toBe('service_abc123');
+    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/external-service');
     // No auth header — endpoint is public.
     const headers = new Headers(calls[0]!.init.headers);
     expect(headers.get('Authorization')).toBeNull();
@@ -286,21 +311,21 @@ describe('TopoloClient.getServiceIdBySlug', () => {
 
   it('caches positive results across calls', async () => {
     const { impl, calls } = stubFetch([
-      { body: { success: true, data: { service_id: 'srv_iCwM4jGXcwlj' } } },
+      { body: { success: true, data: { service_id: 'service_external' } } },
     ]);
     const client = freshClient(impl, { auth: 'https://auth.example.com' });
-    expect(await client.getServiceIdBySlug('topolo-crm')).toBe('srv_iCwM4jGXcwlj');
-    expect(await client.getServiceIdBySlug('topolo-crm')).toBe('srv_iCwM4jGXcwlj');
+    expect(await client.getServiceIdBySlug('external-service')).toBe('service_external');
+    expect(await client.getServiceIdBySlug('external-service')).toBe('service_external');
     expect(calls.length).toBe(1);
   });
 
   it('normalizes slug case + whitespace before hitting the network', async () => {
     const { impl, calls } = stubFetch([
-      { body: { success: true, data: { service_id: 'srv_x' } } },
+      { body: { success: true, data: { service_id: 'service_x' } } },
     ]);
     const client = freshClient(impl, { auth: 'https://auth.example.com' });
-    await client.getServiceIdBySlug('  TOPOLO-NOTIFY  ');
-    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/topolo-notify');
+    await client.getServiceIdBySlug('  EXTERNAL-SERVICE  ');
+    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/by-slug/external-service');
   });
 
   it('returns null on network failure without poisoning cache', async () => {
@@ -310,7 +335,7 @@ describe('TopoloClient.getServiceIdBySlug', () => {
         throws = false;
         throw new Error('ECONNREFUSED');
       }
-      return new Response(JSON.stringify({ success: true, data: { service_id: 'srv_y' } }), {
+      return new Response(JSON.stringify({ success: true, data: { service_id: 'service_y' } }), {
         status: 200,
         headers: { 'Content-Type': 'application/json' },
       });
@@ -324,7 +349,174 @@ describe('TopoloClient.getServiceIdBySlug', () => {
     });
     expect(await client.getServiceIdBySlug('flaky')).toBeNull();
     // Second call retries — earlier null was not cached.
-    expect(await client.getServiceIdBySlug('flaky')).toBe('srv_y');
+    expect(await client.getServiceIdBySlug('flaky')).toBe('service_y');
+  });
+});
+
+describe('TopoloClient.listServices', () => {
+  it('normalizes the live catalog and attaches the credential', async () => {
+    const { impl, calls } = stubFetch([
+      {
+        body: {
+          data: {
+            services: [
+              {
+                service_id: 'srv_wRCnLLbtvmVT',
+                app_slug: 'topolo-director',
+                name: 'Topolo Director',
+                description: 'Demo control plane',
+                base_url: 'https://director.topolo.app',
+                status: 'active',
+                surface_kind: 'application',
+                launchable: true,
+              },
+            ],
+          },
+        },
+      },
+    ]);
+    const client = new TopoloClient({
+      credential: { kind: 'access_token', accessToken: 'tok_abc' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+    const out = await client.listServices();
+    expect(out).toEqual([
+      {
+        serviceId: 'srv_wRCnLLbtvmVT',
+        slug: 'topolo-director',
+        name: 'Topolo Director',
+        description: 'Demo control plane',
+        baseUrl: 'https://director.topolo.app',
+        status: 'active',
+        surfaceKind: 'application',
+        launchable: true,
+      },
+    ]);
+    expect(calls[0]!.url).toBe(
+      'https://auth.example.com/api/services/catalog',
+    );
+    expect(new Headers(calls[0]!.init.headers).get('Authorization')).toBe(
+      'Bearer tok_abc',
+    );
+  });
+
+  it('falls back to the generated snapshot on HTTP failure', async () => {
+    const { impl } = stubFetch([{ status: 503, body: { error: 'down' } }]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'dak_xyz' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+    const out = await client.listServices();
+    expect(out.length).toBeGreaterThan(10);
+    expect(out.some((e) => e.serviceId === 'admin')).toBe(true);
+    expect(out.every((e) => typeof e.serviceId === 'string')).toBe(true);
+  });
+
+  it('resolves future API services from the live catalog during request routing', async () => {
+    const { impl, calls } = stubFetch([
+      {
+        body: {
+          data: {
+            services: [
+              {
+                service_id: 'srv_future',
+                app_slug: 'topolo-warehouse',
+                name: 'Warehouse',
+                base_url: 'https://warehouse.topolo.app',
+                surface_kind: 'api',
+                status: 'active',
+              },
+            ],
+          },
+        },
+      },
+      { body: { ok: true } },
+    ]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'dak_xyz' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+
+    await client.request({ service: 'warehouse', path: '/api/health' });
+
+    expect(calls[0]!.url).toBe('https://auth.example.com/api/services/catalog');
+    expect(calls[1]!.url).toBe('https://warehouse.topolo.app/api/health');
+  });
+
+  it('does not treat live browser applications as generic API services', async () => {
+    const { impl } = stubFetch([
+      {
+        body: {
+          data: {
+            services: [
+              {
+                service_id: 'srv_future_app',
+                app_slug: 'topolo-future-app',
+                name: 'Future App',
+                base_url: 'https://future-app.topolo.app',
+                surface_kind: 'application',
+                status: 'active',
+                launchable: true,
+              },
+            ],
+          },
+        },
+      },
+    ]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'dak_xyz' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+
+    await expect(client.request({ service: 'future-app', path: '/api/health' })).rejects.toMatchObject({
+      code: 'unknown_service',
+    });
+  });
+
+  it('caches the live catalog per client for repeated dynamic service calls', async () => {
+    const { impl, calls } = stubFetch([
+      {
+        body: {
+          data: {
+            services: [
+              {
+                service_id: 'srv_future',
+                app_slug: 'topolo-warehouse',
+                name: 'Warehouse',
+                base_url: 'https://warehouse.topolo.app',
+                surface_kind: 'api',
+                status: 'active',
+              },
+            ],
+          },
+        },
+      },
+      { body: { ok: true } },
+      { body: { ok: true } },
+    ]);
+    const client = new TopoloClient({
+      credential: { kind: 'api_key', apiKey: 'dak_xyz' },
+      agent: AGENT,
+      fetch: impl,
+      serviceUrls: { auth: 'https://auth.example.com' },
+    });
+
+    await client.request({ service: 'warehouse', path: '/api/one' });
+    await client.request({ service: 'warehouse', path: '/api/two' });
+
+    expect(calls.map((call) => call.url)).toEqual([
+      'https://auth.example.com/api/services/catalog',
+      'https://warehouse.topolo.app/api/one',
+      'https://warehouse.topolo.app/api/two',
+    ]);
   });
 });