@geekmidas/client 0.0.1

package/README.md

@@ -0,0 +1,518 @@
+# @geekmidas/client
+
+Type-safe client library for consuming HTTP APIs with full TypeScript support, React Query integration, and automatic code generation from OpenAPI specifications.
+
+## Features
+
+- **Type-Safe Fetcher**: Fully typed HTTP client with automatic type inference
+- **React Query Integration**: Pre-built hooks with TypeScript support
+- **OpenAPI Code Generation**: Generate React Query hooks from OpenAPI specs
+- **Infinite Queries**: Built-in support for pagination and infinite scroll
+- **Automatic Validation**: Request/response validation with StandardSchema
+- **Error Handling**: Type-safe error handling with HTTP status codes
+- **Query Invalidation**: Type-safe cache invalidation
+- **Method Restrictions**: Type-level enforcement of HTTP methods per endpoint
+
+## Installation
+
+```bash
+pnpm add @geekmidas/client
+```
+
+For React Query integration:
+
+```bash
+pnpm add @geekmidas/client @tanstack/react-query
+```
+
+## Package Exports
+
+```typescript
+// Type-safe fetcher
+import { createTypedFetcher } from '@geekmidas/client';
+
+// React Query client
+import { createTypedQueryClient } from '@geekmidas/client/react-query';
+
+// OpenAPI hooks generation
+import { generateReactQueryHooks } from '@geekmidas/client/openapi';
+
+// Type utilities
+import type { TypedFetcherOptions } from '@geekmidas/client/types';
+```
+
+## Quick Start
+
+### Type-Safe Fetcher
+
+Create a typed fetcher for your API:
+
+```typescript
+import { createTypedFetcher } from '@geekmidas/client';
+
+// Define your API types
+interface API {
+  'GET /users': {
+    response: {
+      id: string;
+      name: string;
+      email: string;
+    }[];
+  };
+  'POST /users': {
+    body: {
+      name: string;
+      email: string;
+    };
+    response: {
+      id: string;
+      name: string;
+      email: string;
+    };
+  };
+  'GET /users/:id': {
+    params: {
+      id: string;
+    };
+    response: {
+      id: string;
+      name: string;
+      email: string;
+    };
+  };
+}
+
+// Create typed fetcher
+const api = createTypedFetcher<API>({
+  baseUrl: 'https://api.example.com'
+});
+
+// Use with full type safety
+const users = await api('GET /users');
+// users is typed as Array<{ id: string; name: string; email: string }>
+
+const user = await api('POST /users', {
+  body: { name: 'John Doe', email: 'john@example.com' }
+});
+// user is typed as { id: string; name: string; email: string }
+
+const singleUser = await api('GET /users/:id', {
+  params: { id: '123' }
+});
+// singleUser is typed as { id: string; name: string; email: string }
+```
+
+### React Query Integration
+
+Use with React Query for automatic caching and state management:
+
+```typescript
+import { createTypedQueryClient } from '@geekmidas/client/react-query';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+
+// Create query client
+const queryClient = new QueryClient();
+const api = createTypedQueryClient<API>({
+  baseUrl: 'https://api.example.com'
+});
+
+// In your component
+function UsersList() {
+  const { data, isLoading, error } = api.useQuery('GET /users');
+
+  if (isLoading) return <div>Loading...</div>;
+  if (error) return <div>Error: {error.message}</div>;
+
+  return (
+    <ul>
+      {data.map(user => (
+        <li key={user.id}>{user.name}</li>
+      ))}
+    </ul>
+  );
+}
+
+// Mutations
+function CreateUser() {
+  const createUser = api.useMutation('POST /users');
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    await createUser.mutateAsync({
+      body: { name: 'Jane Doe', email: 'jane@example.com' }
+    });
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <button disabled={createUser.isPending}>
+        Create User
+      </button>
+    </form>
+  );
+}
+```
+
+### Query Parameters
+
+Handle query parameters with full type safety:
+
+```typescript
+interface API {
+  'GET /users/search': {
+    query: {
+      q: string;
+      limit?: number;
+      offset?: number;
+    };
+    response: {
+      users: Array<{ id: string; name: string }>;
+      total: number;
+    };
+  };
+}
+
+// Usage
+const result = await api('GET /users/search', {
+  query: { q: 'john', limit: 10 }
+});
+```
+
+### Infinite Queries
+
+Implement infinite scroll pagination:
+
+```typescript
+function InfiniteUsersList() {
+  const {
+    data,
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage
+  } = api.useInfiniteQuery(
+    'GET /users',
+    {
+      query: { limit: 20 }
+    },
+    {
+      getNextPageParam: (lastPage, pages) => {
+        if (pages.length * 20 < lastPage.total) {
+          return { offset: pages.length * 20 };
+        }
+        return undefined;
+      }
+    }
+  );
+
+  return (
+    <div>
+      {data?.pages.map((page, i) => (
+        <div key={i}>
+          {page.users.map(user => (
+            <div key={user.id}>{user.name}</div>
+          ))}
+        </div>
+      ))}
+      {hasNextPage && (
+        <button
+          onClick={() => fetchNextPage()}
+          disabled={isFetchingNextPage}
+        >
+          Load More
+        </button>
+      )}
+    </div>
+  );
+}
+```
+
+## OpenAPI Code Generation
+
+Generate React Query hooks from OpenAPI specifications:
+
+```bash
+# Using CLI
+pnpm gkm generate:react-query --input api-docs.json --output ./src/api
+
+# Programmatic usage
+import { generateReactQueryHooks } from '@geekmidas/client/openapi';
+import fs from 'fs/promises';
+
+const spec = JSON.parse(await fs.readFile('api-docs.json', 'utf-8'));
+const code = await generateReactQueryHooks(spec);
+await fs.writeFile('./src/api/generated.ts', code);
+```
+
+Generated hooks example:
+
+```typescript
+// Generated from OpenAPI spec
+export const api = createTypedQueryClient<{
+  'GET /users': {
+    response: User[];
+  };
+  'POST /users': {
+    body: CreateUserRequest;
+    response: User;
+  };
+  // ... all your endpoints
+}>({
+  baseUrl: process.env.REACT_APP_API_URL
+});
+
+// Use generated hooks
+function MyComponent() {
+  const { data: users } = api.useQuery('GET /users');
+  const createUser = api.useMutation('POST /users');
+
+  return (
+    // Your component
+  );
+}
+```
+
+## Advanced Features
+
+### Query Invalidation
+
+Type-safe cache invalidation:
+
+```typescript
+// Invalidate specific query
+await api.invalidateQueries('GET /users');
+
+// Invalidate with params
+await api.invalidateQueries('GET /users/:id', {
+  params: { id: '123' }
+});
+
+// Invalidate multiple queries
+await Promise.all([
+  api.invalidateQueries('GET /users'),
+  api.invalidateQueries('GET /users/:id')
+]);
+```
+
+### Optimistic Updates
+
+Implement optimistic UI updates:
+
+```typescript
+const updateUser = api.useMutation('PUT /users/:id', {
+  onMutate: async (variables) => {
+    // Cancel outgoing refetches
+    await api.cancelQueries('GET /users/:id', {
+      params: { id: variables.params.id }
+    });
+
+    // Snapshot previous value
+    const previousUser = api.getQueryData('GET /users/:id', {
+      params: { id: variables.params.id }
+    });
+
+    // Optimistically update
+    api.setQueryData('GET /users/:id', {
+      params: { id: variables.params.id }
+    }, variables.body);
+
+    return { previousUser };
+  },
+  onError: (err, variables, context) => {
+    // Rollback on error
+    if (context?.previousUser) {
+      api.setQueryData('GET /users/:id', {
+        params: { id: variables.params.id }
+      }, context.previousUser);
+    }
+  },
+  onSettled: (data, error, variables) => {
+    // Refetch after mutation
+    api.invalidateQueries('GET /users/:id', {
+      params: { id: variables.params.id }
+    });
+  }
+});
+```
+
+### Custom Headers
+
+Add custom headers to requests:
+
+```typescript
+const api = createTypedFetcher<API>({
+  baseUrl: 'https://api.example.com',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'X-Api-Key': apiKey
+  }
+});
+
+// Per-request headers
+const user = await api('GET /users/:id', {
+  params: { id: '123' },
+  headers: {
+    'X-Request-ID': requestId
+  }
+});
+```
+
+### Error Handling
+
+Handle errors with full type safety:
+
+```typescript
+import { HttpError } from '@geekmidas/errors';
+
+try {
+  const user = await api('GET /users/:id', {
+    params: { id: '123' }
+  });
+} catch (error) {
+  if (error instanceof HttpError) {
+    if (error.statusCode === 404) {
+      console.log('User not found');
+    } else if (error.statusCode === 403) {
+      console.log('Access denied');
+    } else {
+      console.error('API error:', error.message);
+    }
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+### Request/Response Interceptors
+
+Add interceptors for logging, auth, etc:
+
+```typescript
+const api = createTypedFetcher<API>({
+  baseUrl: 'https://api.example.com',
+  beforeRequest: async (url, options) => {
+    // Add auth token
+    const token = await getAuthToken();
+    options.headers = {
+      ...options.headers,
+      'Authorization': `Bearer ${token}`
+    };
+    return { url, options };
+  },
+  afterResponse: async (response) => {
+    // Log response
+    console.log(`${response.status} ${response.url}`);
+    return response;
+  },
+  onError: async (error) => {
+    // Handle auth errors
+    if (error instanceof HttpError && error.statusCode === 401) {
+      await refreshAuthToken();
+      // Retry request
+    }
+    throw error;
+  }
+});
+```
+
+### Prefetching
+
+Prefetch queries for better UX:
+
+```typescript
+function UsersList() {
+  const { data: users } = api.useQuery('GET /users');
+
+  const handleUserHover = (userId: string) => {
+    // Prefetch user details on hover
+    api.prefetchQuery('GET /users/:id', {
+      params: { id: userId }
+    });
+  };
+
+  return (
+    <ul>
+      {users?.map(user => (
+        <li
+          key={user.id}
+          onMouseEnter={() => handleUserHover(user.id)}
+        >
+          {user.name}
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+## Type Utilities
+
+### Infer API Types
+
+```typescript
+import type { InferAPIResponse, InferAPIRequest } from '@geekmidas/client/types';
+
+type UsersResponse = InferAPIResponse<API, 'GET /users'>;
+// type UsersResponse = Array<{ id: string; name: string; email: string }>
+
+type CreateUserRequest = InferAPIRequest<API, 'POST /users'>;
+// type CreateUserRequest = { body: { name: string; email: string } }
+```
+
+### Method Restrictions
+
+Enforce correct HTTP methods at type level:
+
+```typescript
+// ✅ Correct - POST endpoint with body
+await api('POST /users', {
+  body: { name: 'John' }
+});
+
+// ❌ Type error - GET endpoint can't have body
+await api('GET /users', {
+  body: { name: 'John' } // Type error!
+});
+
+// ❌ Type error - Wrong method
+await api('DELETE /users', {}); // Type error if endpoint not defined!
+```
+
+## Testing
+
+Mock API calls in tests:
+
+```typescript
+import { createTypedFetcher } from '@geekmidas/client';
+import { vi } from 'vitest';
+
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+const api = createTypedFetcher<API>({
+  baseUrl: 'https://api.example.com'
+});
+
+// Mock response
+mockFetch.mockResolvedValueOnce({
+  ok: true,
+  json: async () => [{ id: '1', name: 'John', email: 'john@example.com' }]
+});
+
+const users = await api('GET /users');
+expect(users).toHaveLength(1);
+expect(mockFetch).toHaveBeenCalledWith(
+  'https://api.example.com/users',
+  expect.objectContaining({ method: 'GET' })
+);
+```
+
+## Related Packages
+
+- [@geekmidas/constructs](../constructs) - Build type-safe endpoints that this client consumes
+- [@geekmidas/errors](../errors) - HTTP error classes for error handling
+- [@geekmidas/cli](../cli) - Generate OpenAPI specs and React Query hooks
+- [@tanstack/react-query](https://tanstack.com/query) - React Query library
+
+## License
+
+MIT

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/fetcher-DLDD_7Sa.mjs

@@ -0,0 +1,86 @@
+//#region src/fetcher.ts
+var TypedFetcher = class TypedFetcher {
+	baseURL;
+	defaultHeaders;
+	options;
+	fetchFn;
+	static getFetchFn(fn) {
+		if (fn) return fn;
+		if (typeof window !== "undefined" && typeof window.fetch === "function") return window.fetch.bind(window);
+		if (typeof globalThis !== "undefined" && typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+		throw new Error("No fetch implementation found");
+	}
+	constructor(options = {}) {
+		this.baseURL = options.baseURL || "";
+		this.defaultHeaders = options.headers || {};
+		this.options = options;
+		this.fetchFn = TypedFetcher.getFetchFn(options.fetch);
+	}
+	async request(endpoint, config) {
+		const { method, route } = this.parseEndpoint(endpoint);
+		let url = route;
+		if (config && "params" in config && config.params) Object.entries(config.params).forEach(([key, value]) => {
+			url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+		});
+		if (config && "query" in config && config.query) {
+			const queryParams = new URLSearchParams();
+			const appendQueryParam = (prefix, value) => {
+				if (value === void 0 || value === null) return;
+				if (Array.isArray(value)) value.forEach((item) => {
+					queryParams.append(prefix, String(item));
+				});
+				else if (typeof value === "object") Object.entries(value).forEach(([subKey, subValue]) => {
+					appendQueryParam(`${prefix}.${subKey}`, subValue);
+				});
+				else queryParams.append(prefix, String(value));
+			};
+			Object.entries(config.query).forEach(([key, value]) => {
+				appendQueryParam(key, value);
+			});
+			const queryString = queryParams.toString();
+			if (queryString) url += `?${queryString}`;
+		}
+		let requestConfig = {
+			method: method.toUpperCase(),
+			headers: {
+				...this.defaultHeaders,
+				...config && "headers" in config && config.headers || {}
+			}
+		};
+		if (config && "body" in config && config.body) {
+			requestConfig.body = JSON.stringify(config.body);
+			requestConfig.headers = {
+				...requestConfig.headers,
+				"Content-Type": "application/json"
+			};
+		}
+		if (this.options.onRequest) requestConfig = await this.options.onRequest(requestConfig);
+		try {
+			let response = await this.fetchFn(`${this.baseURL}${url}`, requestConfig);
+			if (this.options.onResponse) response = await this.options.onResponse(response);
+			if (!response.ok) throw response;
+			if (response.status === 204 || response.headers.get("content-length") === "0") return void 0;
+			const data = await response.json();
+			return data;
+		} catch (error) {
+			if (this.options.onError) await this.options.onError(error);
+			throw error;
+		}
+	}
+	parseEndpoint(endpoint) {
+		const [method, ...routeParts] = endpoint.split(" ");
+		const route = routeParts.join(" ");
+		return {
+			method: method.toLowerCase(),
+			route
+		};
+	}
+};
+function createTypedFetcher(options) {
+	const fetcher = new TypedFetcher(options);
+	return (endpoint, config) => fetcher.request(endpoint, config);
+}
+
+//#endregion
+export { TypedFetcher, createTypedFetcher };
+//# sourceMappingURL=fetcher-DLDD_7Sa.mjs.map

package/dist/fetcher-DLDD_7Sa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher-DLDD_7Sa.mjs","names":["fn?: FetchFn","options: FetcherOptions","endpoint: T","config?: FilteredRequestConfig<Paths, T>","prefix: string","value: unknown","requestConfig: RequestInit","options?: FetcherOptions"],"sources":["../src/fetcher.ts"],"sourcesContent":["import type {\n  EndpointString,\n  ExtractEndpointResponse,\n  FetcherOptions,\n  FilteredRequestConfig,\n  ParseEndpoint,\n  TypedEndpoint,\n} from './types';\n\nexport class TypedFetcher<Paths> {\n  private baseURL: string;\n  private defaultHeaders: Record<string, string>;\n  private options: FetcherOptions;\n  private fetchFn: FetchFn;\n\n  static getFetchFn(fn?: FetchFn): FetchFn {\n    if (fn) {\n      return fn;\n    }\n\n    if (typeof window !== 'undefined' && typeof window.fetch === 'function') {\n      return window.fetch.bind(window);\n    }\n\n    if (\n      typeof globalThis !== 'undefined' &&\n      typeof globalThis.fetch === 'function'\n    ) {\n      return globalThis.fetch.bind(globalThis);\n    }\n\n    throw new Error('No fetch implementation found');\n  }\n\n  constructor(options: FetcherOptions = {}) {\n    this.baseURL = options.baseURL || '';\n    this.defaultHeaders = options.headers || {};\n    this.options = options;\n    this.fetchFn = TypedFetcher.getFetchFn(options.fetch);\n  }\n\n  async request<T extends TypedEndpoint<Paths>>(\n    endpoint: T,\n    config?: FilteredRequestConfig<Paths, T>,\n  ): Promise<ExtractEndpointResponse<Paths, T>> {\n    const { method, route } = this.parseEndpoint(endpoint);\n\n    // Replace path parameters\n    let url = route;\n    if (config && 'params' in config && config.params) {\n      Object.entries(config.params as Record<string, unknown>).forEach(\n        ([key, value]) => {\n          url = url.replace(`{${key}}`, encodeURIComponent(String(value)));\n        },\n      );\n    }\n\n    // Add query parameters\n    if (config && 'query' in config && config.query) {\n      const queryParams = new URLSearchParams();\n\n      // Recursive function to handle nested objects and arrays\n      const appendQueryParam = (prefix: string, value: unknown) => {\n        if (value === undefined || value === null) {\n          return;\n        }\n\n        if (Array.isArray(value)) {\n          // Handle arrays by appending multiple values with the same key\n          value.forEach((item) => {\n            queryParams.append(prefix, String(item));\n          });\n        } else if (typeof value === 'object') {\n          // For objects, recursively flatten into dot notation\n          Object.entries(value as Record<string, unknown>).forEach(\n            ([subKey, subValue]) => {\n              appendQueryParam(`${prefix}.${subKey}`, subValue);\n            },\n          );\n        } else {\n          queryParams.append(prefix, String(value));\n        }\n      };\n\n      // Process all query parameters\n      Object.entries(config.query as Record<string, unknown>).forEach(\n        ([key, value]) => {\n          appendQueryParam(key, value);\n        },\n      );\n\n      const queryString = queryParams.toString();\n      if (queryString) {\n        url += `?${queryString}`;\n      }\n    }\n\n    // Build request configuration\n    let requestConfig: RequestInit = {\n      method: method.toUpperCase(),\n      headers: {\n        ...this.defaultHeaders,\n        ...((config && 'headers' in config && config.headers) || {}),\n      },\n    };\n\n    // Add body if present\n    if (config && 'body' in config && config.body) {\n      requestConfig.body = JSON.stringify(config.body);\n      requestConfig.headers = {\n        ...requestConfig.headers,\n        'Content-Type': 'application/json',\n      };\n    }\n\n    // Apply request interceptor\n    if (this.options.onRequest) {\n      requestConfig = await this.options.onRequest(requestConfig);\n    }\n\n    try {\n      // Make the request\n      let response = await this.fetchFn(`${this.baseURL}${url}`, requestConfig);\n\n      // Apply response interceptor\n      if (this.options.onResponse) {\n        response = await this.options.onResponse(response);\n      }\n\n      // Handle errors\n      if (!response.ok) {\n        throw response;\n      }\n\n      // Handle empty responses (204 No Content, etc.)\n      if (\n        response.status === 204 ||\n        response.headers.get('content-length') === '0'\n      ) {\n        return undefined as ExtractEndpointResponse<Paths, T>;\n      }\n\n      // Parse JSON response\n      const data = await response.json();\n      return data as ExtractEndpointResponse<Paths, T>;\n    } catch (error) {\n      // Apply error handler\n      if (this.options.onError) {\n        // @ts-ignore\n        await this.options.onError(error);\n      }\n      throw error;\n    }\n  }\n\n  private parseEndpoint<T extends EndpointString>(\n    endpoint: T,\n  ): ParseEndpoint<T> {\n    const [method, ...routeParts] = endpoint.split(' ');\n    const route = routeParts.join(' ');\n    return { method: method.toLowerCase(), route } as ParseEndpoint<T>;\n  }\n}\n\nexport function createTypedFetcher<Paths>(options?: FetcherOptions) {\n  const fetcher = new TypedFetcher<Paths>(options);\n  return <T extends TypedEndpoint<Paths>>(\n    endpoint: T,\n    config?: FilteredRequestConfig<Paths, T>,\n  ) => fetcher.request(endpoint, config);\n}\n\nexport type FetchFn = typeof fetch;\n"],"mappings":"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"}