@geekmidas/client 0.2.0 → 0.4.0

package/src/__tests__/auth-fetcher.spec.ts

@@ -0,0 +1,505 @@
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest';
+import {
+  type ApiKeyProvider,
+  type AwsSigner,
+  type SecuritySchemeObject,
+  type TokenProvider,
+  createAuthAwareFetcher,
+} from '../auth-fetcher';
+
+// Test types - structured to match OpenAPI spec format
+interface TestPaths {
+  '/users': {
+    get: {
+      responses: {
+        200: {
+          content: {
+            'application/json': { users: Array<{ id: string; name: string }> };
+          };
+        };
+      };
+    };
+  };
+  '/protected': {
+    get: {
+      responses: {
+        200: {
+          content: {
+            'application/json': { data: string };
+          };
+        };
+      };
+    };
+  };
+  '/api-key-protected': {
+    get: {
+      responses: {
+        200: {
+          content: {
+            'application/json': { data: string };
+          };
+        };
+      };
+    };
+  };
+  '/iam-protected': {
+    get: {
+      responses: {
+        200: {
+          content: {
+            'application/json': { data: string };
+          };
+        };
+      };
+    };
+  };
+  '/data': {
+    post: {
+      requestBody: {
+        content: {
+          'application/json': { value: string };
+        };
+      };
+      responses: {
+        201: {
+          content: {
+            'application/json': { id: string };
+          };
+        };
+      };
+    };
+  };
+}
+
+// Track headers received by handlers
+let lastReceivedHeaders: Record<string, string> = {};
+
+const handlers = [
+  http.get('https://api.example.com/users', ({ request }) => {
+    lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+    return HttpResponse.json({
+      users: [{ id: '1', name: 'John' }],
+    });
+  }),
+
+  http.get('https://api.example.com/protected', ({ request }) => {
+    lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+    const auth = request.headers.get('Authorization');
+    if (!auth || auth !== 'Bearer valid-token') {
+      return HttpResponse.json({ message: 'Unauthorized' }, { status: 401 });
+    }
+    return HttpResponse.json({ data: 'secret' });
+  }),
+
+  http.get('https://api.example.com/api-key-protected', ({ request }) => {
+    lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+    const apiKey = request.headers.get('X-API-Key');
+    if (!apiKey || apiKey !== 'my-api-key') {
+      return HttpResponse.json({ message: 'Unauthorized' }, { status: 401 });
+    }
+    return HttpResponse.json({ data: 'api-key-data' });
+  }),
+
+  http.get('https://api.example.com/iam-protected', ({ request }) => {
+    lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+    return HttpResponse.json({ data: 'iam-data' });
+  }),
+
+  http.post('https://api.example.com/data', async ({ request }) => {
+    lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+    return HttpResponse.json({ id: '123' }, { status: 201 });
+  }),
+];
+
+const server = setupServer(...handlers);
+
+beforeAll(() => {
+  server.listen({ onUnhandledRequest: 'error' });
+});
+
+afterEach(() => {
+  server.resetHandlers();
+  lastReceivedHeaders = {};
+  vi.clearAllMocks();
+});
+
+afterAll(() => {
+  server.close();
+});
+
+describe('createAuthAwareFetcher', () => {
+  const securitySchemes: Record<string, SecuritySchemeObject> = {
+    bearer: {
+      type: 'http',
+      scheme: 'bearer',
+      bearerFormat: 'JWT',
+    },
+    apiKey: {
+      type: 'apiKey',
+      in: 'header',
+      name: 'X-API-Key',
+    },
+    iam: {
+      type: 'http',
+      scheme: 'aws4-hmac-sha256',
+    },
+  };
+
+  describe('bearer auth', () => {
+    it('should add Authorization header for bearer auth endpoints', async () => {
+      const tokenProvider: TokenProvider = {
+        getValidAccessToken: vi.fn().mockResolvedValue('valid-token'),
+        createValidAuthHeaders: vi.fn().mockResolvedValue({
+          Authorization: 'Bearer valid-token',
+        }),
+      };
+
+      const endpointAuth = {
+        'GET /users': null,
+        'GET /protected': 'bearer',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          bearer: { type: 'bearer', tokenProvider },
+        },
+      });
+
+      const result = await api('GET /protected');
+
+      expect(tokenProvider.createValidAuthHeaders).toHaveBeenCalled();
+      expect(result).toEqual({ data: 'secret' });
+      expect(lastReceivedHeaders.authorization).toBe('Bearer valid-token');
+    });
+
+    it('should not add auth headers for public endpoints', async () => {
+      const tokenProvider: TokenProvider = {
+        getValidAccessToken: vi.fn().mockResolvedValue('valid-token'),
+        createValidAuthHeaders: vi.fn().mockResolvedValue({
+          Authorization: 'Bearer valid-token',
+        }),
+      };
+
+      const endpointAuth = {
+        'GET /users': null,
+        'GET /protected': 'bearer',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          bearer: { type: 'bearer', tokenProvider },
+        },
+      });
+
+      const result = await api('GET /users');
+
+      expect(tokenProvider.createValidAuthHeaders).not.toHaveBeenCalled();
+      expect(result).toEqual({ users: [{ id: '1', name: 'John' }] });
+      expect(lastReceivedHeaders.authorization).toBeUndefined();
+    });
+  });
+
+  describe('apiKey auth', () => {
+    it('should add API key header for apiKey auth endpoints', async () => {
+      const apiKeyProvider: ApiKeyProvider = {
+        getApiKey: vi.fn().mockResolvedValue('my-api-key'),
+      };
+
+      const endpointAuth = {
+        'GET /api-key-protected': 'apiKey',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          apiKey: { type: 'apiKey', apiKeyProvider },
+        },
+      });
+
+      const result = await api('GET /api-key-protected');
+
+      expect(apiKeyProvider.getApiKey).toHaveBeenCalled();
+      expect(result).toEqual({ data: 'api-key-data' });
+      expect(lastReceivedHeaders['x-api-key']).toBe('my-api-key');
+    });
+
+    it('should use custom header name if provided', async () => {
+      const apiKeyProvider: ApiKeyProvider = {
+        getApiKey: vi.fn().mockResolvedValue('custom-key'),
+      };
+
+      const customSchemes: Record<string, SecuritySchemeObject> = {
+        customApiKey: {
+          type: 'apiKey',
+          in: 'header',
+          name: 'X-Custom-Key',
+        },
+      };
+
+      const endpointAuth = {
+        'GET /api-key-protected': 'customApiKey',
+      } as const;
+
+      server.use(
+        http.get('https://api.example.com/api-key-protected', ({ request }) => {
+          lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+          return HttpResponse.json({ data: 'custom-key-data' });
+        }),
+      );
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes: customSchemes,
+        authStrategies: {
+          customApiKey: {
+            type: 'apiKey',
+            apiKeyProvider,
+            headerName: 'X-Custom-Key',
+          },
+        },
+      });
+
+      await api('GET /api-key-protected');
+
+      expect(lastReceivedHeaders['x-custom-key']).toBe('custom-key');
+    });
+
+    it('should handle synchronous getApiKey', async () => {
+      const apiKeyProvider: ApiKeyProvider = {
+        getApiKey: vi.fn().mockReturnValue('sync-api-key'),
+      };
+
+      server.use(
+        http.get('https://api.example.com/api-key-protected', ({ request }) => {
+          lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+          return HttpResponse.json({ data: 'sync-data' });
+        }),
+      );
+
+      const endpointAuth = {
+        'GET /api-key-protected': 'apiKey',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          apiKey: { type: 'apiKey', apiKeyProvider },
+        },
+      });
+
+      await api('GET /api-key-protected');
+
+      expect(lastReceivedHeaders['x-api-key']).toBe('sync-api-key');
+    });
+  });
+
+  describe('IAM auth', () => {
+    it('should call signer for IAM auth endpoints', async () => {
+      const signer: AwsSigner = {
+        sign: vi.fn().mockResolvedValue({}),
+      };
+
+      const endpointAuth = {
+        'GET /iam-protected': 'iam',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          iam: { type: 'iam', signer },
+        },
+      });
+
+      const result = await api('GET /iam-protected');
+
+      // IAM returns empty headers in current implementation
+      expect(result).toEqual({ data: 'iam-data' });
+    });
+  });
+
+  describe('header merging', () => {
+    it('should merge auth headers with user-provided headers', async () => {
+      const tokenProvider: TokenProvider = {
+        getValidAccessToken: vi.fn().mockResolvedValue('valid-token'),
+        createValidAuthHeaders: vi.fn().mockResolvedValue({
+          Authorization: 'Bearer valid-token',
+        }),
+      };
+
+      const endpointAuth = {
+        'GET /protected': 'bearer',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          bearer: { type: 'bearer', tokenProvider },
+        },
+      });
+
+      await api('GET /protected', {
+        headers: { 'X-Custom-Header': 'custom-value' },
+      });
+
+      expect(lastReceivedHeaders.authorization).toBe('Bearer valid-token');
+      expect(lastReceivedHeaders['x-custom-header']).toBe('custom-value');
+    });
+
+    it('should allow user headers to override auth headers', async () => {
+      const tokenProvider: TokenProvider = {
+        getValidAccessToken: vi.fn().mockResolvedValue('valid-token'),
+        createValidAuthHeaders: vi.fn().mockResolvedValue({
+          Authorization: 'Bearer valid-token',
+        }),
+      };
+
+      // Override handler to accept any valid Bearer token
+      server.use(
+        http.get('https://api.example.com/protected', ({ request }) => {
+          lastReceivedHeaders = Object.fromEntries(request.headers.entries());
+          const auth = request.headers.get('Authorization');
+          if (!auth || !auth.startsWith('Bearer ')) {
+            return HttpResponse.json(
+              { message: 'Unauthorized' },
+              { status: 401 },
+            );
+          }
+          return HttpResponse.json({ data: 'secret' });
+        }),
+      );
+
+      const endpointAuth = {
+        'GET /protected': 'bearer',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          bearer: { type: 'bearer', tokenProvider },
+        },
+      });
+
+      await api('GET /protected', {
+        headers: { Authorization: 'Bearer override-token' },
+      });
+
+      expect(lastReceivedHeaders.authorization).toBe('Bearer override-token');
+    });
+  });
+
+  describe('onRequest interceptor', () => {
+    it('should call user onRequest interceptor after auth headers', async () => {
+      const onRequest = vi.fn((config: RequestInit) => ({
+        ...config,
+        headers: {
+          ...config.headers,
+          'X-Intercepted': 'true',
+        },
+      }));
+
+      const tokenProvider: TokenProvider = {
+        getValidAccessToken: vi.fn().mockResolvedValue('valid-token'),
+        createValidAuthHeaders: vi.fn().mockResolvedValue({
+          Authorization: 'Bearer valid-token',
+        }),
+      };
+
+      const endpointAuth = {
+        'GET /protected': 'bearer',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes,
+        authStrategies: {
+          bearer: { type: 'bearer', tokenProvider },
+        },
+        onRequest,
+      });
+
+      await api('GET /protected');
+
+      expect(onRequest).toHaveBeenCalled();
+      expect(lastReceivedHeaders['x-intercepted']).toBe('true');
+    });
+  });
+
+  describe('none auth strategy', () => {
+    it('should not add any headers for none strategy', async () => {
+      const endpointAuth = {
+        'GET /users': 'noAuth',
+      } as const;
+
+      const customSchemes: Record<string, SecuritySchemeObject> = {
+        noAuth: {
+          type: 'http',
+          scheme: 'none',
+        },
+      };
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes: customSchemes,
+        authStrategies: {
+          noAuth: { type: 'none' },
+        },
+      });
+
+      const result = await api('GET /users');
+
+      expect(result).toEqual({ users: [{ id: '1', name: 'John' }] });
+      expect(lastReceivedHeaders.authorization).toBeUndefined();
+    });
+  });
+
+  describe('missing strategy handling', () => {
+    it('should not add headers when scheme exists but strategy is missing', async () => {
+      const endpointAuth = {
+        'GET /users': 'unknownScheme',
+      } as const;
+
+      const api = createAuthAwareFetcher<TestPaths>({
+        baseURL: 'https://api.example.com',
+        endpointAuth,
+        securitySchemes: {
+          unknownScheme: { type: 'http', scheme: 'custom' },
+        },
+        // No strategy for unknownScheme
+        authStrategies: {} as any,
+      });
+
+      const result = await api('GET /users');
+
+      expect(result).toEqual({ users: [{ id: '1', name: 'John' }] });
+    });
+  });
+});

package/src/__tests__/openapi-hooks.spec.tsx

@@ -3,8 +3,6 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
  * @vitest-environment jsdom
  */
 import { renderHook, waitFor } from '@testing-library/react';
-// biome-ignore lint/style/useImportType: required for React provider
-import React from 'react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { createOpenAPIHooks } from '../openapi-hooks';
 import './setup';
@@ -152,7 +150,7 @@ function createWrapper() {
     },
   });
 
-  return ({ children }: { children: React.ReactNode }) => (
+  return ({ children }: { children: any }) => (
     <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
   );
 }
@@ -426,11 +424,12 @@ describe('createOpenAPIHooks', () => {
         expect(result.current.isSuccess).toBe(true);
       });
 
-      expect(onSuccess).toHaveBeenCalledWith(
-        { id: '123', name: 'Test', email: 'test@test.com' },
-        expect.any(Object),
-        undefined,
-      );
+      expect(onSuccess).toHaveBeenCalled();
+      expect(onSuccess.mock.calls[0]?.[0]).toEqual({
+        id: '123',
+        name: 'Test',
+        email: 'test@test.com',
+      });
       expect(onError).not.toHaveBeenCalled();
     });
   });

package/src/auth-fetcher.ts

@@ -199,7 +199,7 @@ export function createAuthAwareFetcher<
       const strategy =
         authStrategies[schemeName as UsedSecuritySchemes<EndpointAuth>];
 
-      if (strategy) {
+      if (strategy && scheme) {
         authHeaders = await resolveAuthHeaders(strategy, scheme);
       }
     }

package/src/endpoint-hooks.ts

@@ -149,10 +149,13 @@ export function createEndpointHooks<Paths>(
         () => ({
           queryKey,
           queryFn: () =>
-            fetcher(
-              endpoint as Parameters<typeof fetcher>[0],
-              config as Parameters<typeof fetcher>[1],
-            ),
+            // Type assertion needed due to complex conditional types
+            (
+              fetcher as (
+                endpoint: T,
+                config?: unknown,
+              ) => Promise<ExtractEndpointResponse<Paths, T>>
+            )(endpoint, config),
           ...queryOptions,
         }),
         [
@@ -182,10 +185,13 @@ export function createEndpointHooks<Paths>(
       const memoizedOptions = useMemo(
         () => ({
           mutationFn: (config: FilteredRequestConfig<Paths, T>) =>
-            fetcher(
-              endpoint as Parameters<typeof fetcher>[0],
-              config as Parameters<typeof fetcher>[1],
-            ),
+            // Type assertion needed due to complex conditional types
+            (
+              fetcher as (
+                endpoint: T,
+                config?: unknown,
+              ) => Promise<ExtractEndpointResponse<Paths, T>>
+            )(endpoint, config),
           ...mutationOptions,
         }),
         [endpoint, JSON.stringify(mutationOptions)],

package/src/fetcher.ts

@@ -160,7 +160,7 @@ export class TypedFetcher<Paths> {
   ): ParseEndpoint<T> {
     const [method, ...routeParts] = endpoint.split(' ');
     const route = routeParts.join(' ');
-    return { method: method.toLowerCase(), route } as ParseEndpoint<T>;
+    return { method: method?.toLowerCase() ?? '', route } as ParseEndpoint<T>;
   }
 }
 

package/src/openapi-hooks.ts

@@ -66,7 +66,7 @@ type OperationParams<
         : Spec extends { parameters: { path: infer P } }
           ? P
           : never;
-      query?: Spec extends { parameters: { query?: infer Q } } ? Q : never;
+      query?: Spec extends { parameters?: { query?: infer Q } } ? Q : never;
       body?: Spec extends {
         requestBody: { content: { 'application/json': infer Body } };
       }
@@ -129,8 +129,8 @@ export function createOpenAPIHooks<Paths>(
     operationId: OpId,
   ): string {
     // Runtime lookup from registry
-    if (operations && operations[operationId as string]) {
-      const op = operations[operationId as string];
+    const op = operations?.[operationId as string];
+    if (op) {
       return `${op.method.toUpperCase()} ${op.path}`;
     }
     // Fallback for compile-time only usage

package/src/types.ts

@@ -154,15 +154,17 @@ export type FilteredRequestConfig<
   : never;
 
 /**
- * Helper to build request config with correct required/optional fields
+ * Helper to build request config with correct required/optional fields.
+ * Uses [T] extends [never] pattern to prevent distribution over union types,
+ * which would cause the entire type to become `never`.
  */
 type BuildRequestConfig<TParams, TQuery, TBody> = SimplifyIntersection<
   // params: required if not never
-  (TParams extends never ? {} : { params: TParams }) &
+  ([TParams] extends [never] ? {} : { params: TParams }) &
     // body: required if not never
-    (TBody extends never ? {} : { body: TBody }) &
+    ([TBody] extends [never] ? {} : { body: TBody }) &
     // query: optional if not never
-    (TQuery extends never ? {} : { query?: TQuery }) & {
+    ([TQuery] extends [never] ? {} : { query?: TQuery }) & {
       // headers: always optional
       headers?: Record<string, string>;
     }

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true,
+    "lib": ["ES2023", "DOM"],
+    "jsx": "react-jsx"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/__tests__/**/*"]
+}