@ankhorage/data-sources 0.6.0 → 1.0.1

package/src/test-runner/index.test.ts

@@ -3,10 +3,12 @@ import { describe, expect, it } from 'bun:test';
 
 import { buildEndpointTestRequest, type EndpointTestFetch, testEndpoint } from './index';
 
-function createRestDataSource(): DataSourceConfig {
+function restSource(): DataSourceConfig {
   return {
     id: 'cms',
-    kind: 'rest',
+    kind: 'api',
+    origin: 'external',
+    protocol: 'rest',
     baseUrl: 'https://cms.example.com',
     credential: { id: 'cms-token', kind: 'bearer' },
     endpoints: {
@@ -30,19 +32,9 @@ function createRestDataSource(): DataSourceConfig {
                   required: true,
                   schema: { type: 'string' },
                 },
-                {
-                  name: 'preview',
-                  location: 'query',
-                  schema: { type: 'boolean' },
-                },
+                { name: 'preview', location: 'query', schema: { type: 'boolean' } },
               ],
             },
-            response: {
-              status: 200,
-              schema: {
-                type: 'object',
-              },
-            },
           },
           'posts.create': {
             id: 'posts.create',
@@ -51,14 +43,6 @@ function createRestDataSource(): DataSourceConfig {
             intent: 'create',
             method: 'POST',
             path: '/posts',
-            request: {
-              contentType: 'application/json',
-              schema: { type: 'object' },
-            },
-            response: {
-              status: 201,
-              schema: { type: 'object' },
-            },
           },
         },
       },
@@ -66,10 +50,12 @@ function createRestDataSource(): DataSourceConfig {
   };
 }
 
-function createGraphQlDataSource(): DataSourceConfig {
+function graphQlSource(): DataSourceConfig {
   return {
     id: 'content',
-    kind: 'graphql',
+    kind: 'api',
+    origin: 'external',
+    protocol: 'graphql',
     endpointUrl: 'https://content.example.com/graphql',
     endpoints: {
       graphql: {
@@ -81,12 +67,7 @@ function createGraphQlDataSource(): DataSourceConfig {
             endpointId: 'graphql',
             protocol: 'graphql',
             intent: 'read',
-            request: { schema: { type: 'object' } },
-            response: { schema: { type: 'object' } },
-            metadata: {
-              document: 'query Viewer($id: ID!) { viewer(id: $id) { id } }',
-              selectionPath: '$.data.viewer',
-            },
+            metadata: { document: 'query Viewer($id: ID!) { viewer(id: $id) { id } }' },
           },
         },
       },
@@ -95,172 +76,123 @@ function createGraphQlDataSource(): DataSourceConfig {
 }
 
 describe('endpoint test runner', () => {
-  it('builds a dry-run REST request with path, query, and credential headers', async () => {
+  it('builds REST dry runs with params and credential headers', async () => {
     const result = await buildEndpointTestRequest({
-      dataSource: createRestDataSource(),
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.get',
       dryRun: true,
-      values: {
-        postId: 'post 1',
-        preview: true,
-      },
-      credentialResolver: () => ({
-        headers: { authorization: 'Bearer token' },
-      }),
+      values: { postId: 'post 1', preview: true },
+      credentialResolver: () => ({ headers: { authorization: 'Bearer token' } }),
     });
-
     expect(result.ok).toBe(true);
     if (result.ok) {
       expect(result.request.url).toBe('https://cms.example.com/posts/post%201?preview=true');
-      expect(result.request.method).toBe('GET');
       expect(result.request.headers.authorization).toBe('Bearer token');
-      expect(result.request.dryRun).toBe(true);
     }
   });
 
-  it('executes a successful REST request and parses JSON responses', async () => {
-    const fetch: EndpointTestFetch = (url, init) => {
-      expect(url).toBe('https://cms.example.com/posts/post-1');
-      expect(init.method).toBe('GET');
-      return Promise.resolve({
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-        text: () => Promise.resolve('{"id":"post-1"}'),
-      });
-    };
-
+  it('executes REST requests and parses responses', async () => {
+    const fetch: EndpointTestFetch = () =>
+      Promise.resolve({ status: 200, text: () => Promise.resolve('{"id":"post-1"}') });
     const result = await testEndpoint({
-      dataSource: createRestDataSource(),
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.get',
       values: { postId: 'post-1' },
       credentialResolver: () => ({ headers: { authorization: 'Bearer token' } }),
       fetch,
     });
-
     expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.response?.status).toBe(200);
-      expect(result.data).toEqual({ id: 'post-1' });
-    }
+    if (result.ok) expect(result.data).toEqual({ id: 'post-1' });
   });
 
-  it('returns structured diagnostics for HTTP errors', async () => {
-    const fetch: EndpointTestFetch = () =>
-      Promise.resolve({
-        status: 404,
-        text: () => Promise.resolve('{"error":"Not found"}'),
-      });
-
-    const result = await testEndpoint({
-      dataSource: createRestDataSource(),
+  it('returns HTTP, network, credential and input diagnostics', async () => {
+    const http = await testEndpoint({
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.get',
       values: { postId: 'missing' },
-      credentialResolver: () => ({ headers: { authorization: 'Bearer token' } }),
-      fetch,
+      credentialResolver: () => ({ headers: {} }),
+      fetch: () => Promise.resolve({ status: 404, text: () => Promise.resolve('{}') }),
     });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.response?.status).toBe(404);
-      expect(result.diagnostics.map((diagnostic) => diagnostic.code)).toContain('http-error');
-    }
-  });
-
-  it('returns structured diagnostics for network errors', async () => {
-    const fetch: EndpointTestFetch = () => Promise.reject(new Error('Connection failed'));
-
-    const result = await testEndpoint({
-      dataSource: createRestDataSource(),
+    const network = await testEndpoint({
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.get',
-      values: { postId: 'post-1' },
-      credentialResolver: () => ({ headers: { authorization: 'Bearer token' } }),
-      fetch,
+      values: { postId: 'x' },
+      credentialResolver: () => ({ headers: {} }),
+      fetch: () => Promise.reject(new Error('Connection failed')),
     });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.diagnostics.map((diagnostic) => diagnostic.code)).toContain('network-error');
-      expect(result.diagnostics.map((diagnostic) => diagnostic.message)).toContain(
-        'Connection failed',
-      );
-    }
-  });
-
-  it('returns structured diagnostics for missing credentials', async () => {
-    const result = await buildEndpointTestRequest({
-      dataSource: createRestDataSource(),
+    const credential = await buildEndpointTestRequest({
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.get',
-      values: { postId: 'post-1' },
+      values: { postId: 'x' },
     });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.diagnostics.map((diagnostic) => diagnostic.code)).toContain(
-        'missing-credential',
-      );
-    }
-  });
-
-  it('returns structured diagnostics for invalid input', async () => {
-    const result = await buildEndpointTestRequest({
-      dataSource: createRestDataSource(),
+    const input = await buildEndpointTestRequest({
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.get',
-      credentialResolver: () => ({ headers: { authorization: 'Bearer token' } }),
+      credentialResolver: () => ({ headers: {} }),
     });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.diagnostics.map((diagnostic) => diagnostic.message)).toContain(
-        "Missing required path parameter 'postId'.",
-      );
-    }
+    expect(http.ok).toBe(false);
+    expect(network.ok).toBe(false);
+    expect(credential.ok).toBe(false);
+    expect(input.ok).toBe(false);
   });
 
-  it('builds POST request bodies from input body values', async () => {
-    const result = await buildEndpointTestRequest({
-      dataSource: createRestDataSource(),
+  it('builds POST bodies and GraphQL requests', async () => {
+    const post = await buildEndpointTestRequest({
+      dataSource: restSource(),
       endpointId: 'posts',
       operationId: 'posts.create',
       dryRun: true,
-      values: {
-        body: { title: 'Hello' },
-      },
-      credentialResolver: () => ({ headers: { authorization: 'Bearer token' } }),
+      values: { body: { title: 'Hello' } },
+      credentialResolver: () => ({ headers: {} }),
     });
-
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.request.method).toBe('POST');
-      expect(result.request.body).toBe('{"title":"Hello"}');
-      expect(result.request.headers['content-type']).toBe('application/json');
-    }
-  });
-
-  it('builds dry-run GraphQL requests from operation metadata', async () => {
-    const result = await buildEndpointTestRequest({
-      dataSource: createGraphQlDataSource(),
+    const graphql = await buildEndpointTestRequest({
+      dataSource: graphQlSource(),
       endpointId: 'graphql',
       operationId: 'query.viewer',
       dryRun: true,
-      values: {
-        variables: { id: 'viewer-1' },
-      },
+      values: { variables: { id: 'viewer-1' } },
     });
+    expect(post.ok).toBe(true);
+    if (post.ok) expect(post.request.body).toBe('{"title":"Hello"}');
+    expect(graphql.ok).toBe(true);
+    if (graphql.ok) expect(graphql.request.url).toBe('https://content.example.com/graphql');
+  });
 
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.request.url).toBe('https://content.example.com/graphql');
-      expect(result.request.method).toBe('POST');
-      expect(result.request.headers['content-type']).toBe('application/json');
-      expect(result.request.body).toBe(
-        '{"query":"query Viewer($id: ID!) { viewer(id: $id) { id } }","variables":{"id":"viewer-1"}}',
-      );
-    }
+  it('does not pretend database-backed generated operations are HTTP endpoints', async () => {
+    const source: DataSourceConfig = {
+      id: 'catalog',
+      kind: 'api',
+      origin: 'generated',
+      protocol: 'rest',
+      generatedApiId: 'catalog',
+      adapter: { id: 'db', kind: 'database' },
+      endpoints: {
+        products: {
+          id: 'products',
+          kind: 'database',
+          operations: {
+            'products.list': {
+              id: 'products.list',
+              endpointId: 'products',
+              protocol: 'database',
+              intent: 'read',
+            },
+          },
+        },
+      },
+    };
+    const result = await buildEndpointTestRequest({
+      dataSource: source,
+      endpointId: 'products',
+      operationId: 'products.list',
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.diagnostics[0]?.message).toContain('adapter executor');
   });
 });