@geekmidas/client 0.0.1 → 0.1.0

package/dist/react-query.d.cts

@@ -1,5 +1,5 @@
-import { ExtractEndpointResponse, FetcherOptions, FilteredRequestConfig, MutationEndpoint, QueryEndpoint, TypedEndpoint } from "./types-csACmD6U.cjs";
-import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { ExtractEndpointResponse, FetcherOptions, FilteredRequestConfig, MutationEndpoint, QueryEndpoint, TypedEndpoint } from "./types-DVVUpwI4.cjs";
+import * as _tanstack_react_query3 from "@tanstack/react-query";
 import { QueryClient, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
 
 //#region src/react-query.d.ts
@@ -10,15 +10,15 @@ declare class TypedQueryClient<Paths> {
   private fetcher;
   private queryClient?;
   constructor(options?: TypedQueryClientOptions);
-  useQuery<T extends QueryEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T>, options?: Omit<UseQueryOptions<ExtractEndpointResponse<Paths, T>, Response>, 'queryKey' | 'queryFn'>): _tanstack_react_query0.UseQueryResult<_tanstack_react_query0.NoInfer<ExtractEndpointResponse<Paths, T>>, Response>;
-  useMutation<T extends MutationEndpoint<Paths>>(endpoint: T, options?: Omit<UseMutationOptions<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>>, 'mutationFn'>): _tanstack_react_query0.UseMutationResult<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>, unknown>;
+  useQuery<T extends QueryEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T>, options?: Omit<UseQueryOptions<ExtractEndpointResponse<Paths, T>, Response>, 'queryKey' | 'queryFn'>): _tanstack_react_query3.UseQueryResult<_tanstack_react_query3.NoInfer<ExtractEndpointResponse<Paths, T>>, Response>;
+  useMutation<T extends MutationEndpoint<Paths>>(endpoint: T, options?: Omit<UseMutationOptions<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>>, 'mutationFn'>): _tanstack_react_query3.UseMutationResult<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>, unknown>;
   useInfiniteQuery<T extends QueryEndpoint<Paths>, TPageData = ExtractEndpointResponse<Paths, T>, TPageParam = unknown>(endpoint: T, options: Omit<UseInfiniteQueryOptions<TPageData, Response, {
     pages: TPageData[];
     pageParams: TPageParam[];
   }, unknown[], TPageParam>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam'> & {
     getNextPageParam: (lastPage: TPageData, allPages: TPageData[], lastPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined;
     initialPageParam: TPageParam;
-  }, config?: FilteredRequestConfig<Paths, T>): _tanstack_react_query0.UseInfiniteQueryResult<{
+  }, config?: FilteredRequestConfig<Paths, T>): _tanstack_react_query3.UseInfiniteQueryResult<{
     pages: TPageData[];
     pageParams: TPageParam[];
   }, Response>;
@@ -47,15 +47,15 @@ declare class TypedQueryClient<Paths> {
   setQueryClient(queryClient: QueryClient): void;
 }
 declare function createTypedQueryClient<Paths>(options?: TypedQueryClientOptions): TypedQueryClient<Paths>;
-declare function useTypedQuery<Paths, T extends QueryEndpoint<Paths>>(client: TypedQueryClient<Paths>, endpoint: T, config?: FilteredRequestConfig<Paths, T>, options?: Omit<UseQueryOptions<ExtractEndpointResponse<Paths, T>, Response>, 'queryKey' | 'queryFn'>): _tanstack_react_query0.UseQueryResult<_tanstack_react_query0.NoInfer<ExtractEndpointResponse<Paths, T>>, Response>;
-declare function useTypedMutation<Paths, T extends MutationEndpoint<Paths>>(client: TypedQueryClient<Paths>, endpoint: T, options?: Omit<UseMutationOptions<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>>, 'mutationFn'>): _tanstack_react_query0.UseMutationResult<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>, unknown>;
+declare function useTypedQuery<Paths, T extends QueryEndpoint<Paths>>(client: TypedQueryClient<Paths>, endpoint: T, config?: FilteredRequestConfig<Paths, T>, options?: Omit<UseQueryOptions<ExtractEndpointResponse<Paths, T>, Response>, 'queryKey' | 'queryFn'>): _tanstack_react_query3.UseQueryResult<_tanstack_react_query3.NoInfer<ExtractEndpointResponse<Paths, T>>, Response>;
+declare function useTypedMutation<Paths, T extends MutationEndpoint<Paths>>(client: TypedQueryClient<Paths>, endpoint: T, options?: Omit<UseMutationOptions<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>>, 'mutationFn'>): _tanstack_react_query3.UseMutationResult<ExtractEndpointResponse<Paths, T>, Response, FilteredRequestConfig<Paths, T>, unknown>;
 declare function useTypedInfiniteQuery<Paths, T extends QueryEndpoint<Paths>, TPageData = ExtractEndpointResponse<Paths, T>, TPageParam = unknown>(client: TypedQueryClient<Paths>, endpoint: T, options: Omit<UseInfiniteQueryOptions<TPageData, Response, {
   pages: TPageData[];
   pageParams: TPageParam[];
 }, unknown[], TPageParam>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam'> & {
   getNextPageParam: (lastPage: TPageData, allPages: TPageData[], lastPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined;
   initialPageParam: TPageParam;
-}, config?: FilteredRequestConfig<Paths, T>): _tanstack_react_query0.UseInfiniteQueryResult<{
+}, config?: FilteredRequestConfig<Paths, T>): _tanstack_react_query3.UseInfiniteQueryResult<{
   pages: TPageData[];
   pageParams: TPageParam[];
 }, Response>;

package/dist/react-query.d.mts

@@ -1,4 +1,4 @@
-import { ExtractEndpointResponse, FetcherOptions, FilteredRequestConfig, MutationEndpoint, QueryEndpoint, TypedEndpoint } from "./types-tMp85Lt_.mjs";
+import { ExtractEndpointResponse, FetcherOptions, FilteredRequestConfig, MutationEndpoint, QueryEndpoint, TypedEndpoint } from "./types-CyMkwV3g.mjs";
 import * as _tanstack_react_query3 from "@tanstack/react-query";
 import { QueryClient, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
 

package/dist/{types-csACmD6U.d.cts → types-CyMkwV3g.d.mts}

@@ -54,7 +54,38 @@ type ParseEndpoint<T extends EndpointString> = T extends `${infer Method} ${infe
 } : never;
 type ExtractEndpointResponse<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? ExtractResponse<Paths, Route, Lowercase<Method>> : never : never : never;
 type ExtractEndpointConfig<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? RequestConfig<Paths, Route, Lowercase<Method>> : never : never : never;
-type FilteredRequestConfig<Paths, T extends EndpointString> = { [K in keyof ExtractEndpointConfig<Paths, T> as ExtractEndpointConfig<Paths, T>[K] extends never | undefined ? never : K]: ExtractEndpointConfig<Paths, T>[K] };
+/**
+ * Build a request config type where:
+ * - `params` is required if the endpoint has path parameters
+ * - `body` is required if the endpoint has a request body
+ * - `query` and `headers` are always optional
+ */
+type FilteredRequestConfig<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? BuildRequestConfig<ExtractPathParams<Paths, Route>, ExtractQueryParams<Paths, Route, Lowercase<Method>>, ExtractRequestBody<Paths, Route, Lowercase<Method>>> : never : never : never;
+/**
+ * Helper to build request config with correct required/optional fields
+ */
+type BuildRequestConfig<TParams, TQuery, TBody> = SimplifyIntersection<(TParams extends never ? {} : {
+  params: TParams;
+}) & (TBody extends never ? {} : {
+  body: TBody;
+}) & (TQuery extends never ? {} : {
+  query?: TQuery;
+}) & {
+  headers?: Record<string, string>;
+}>;
+/**
+ * Simplify intersection types for better IDE display
+ */
+type SimplifyIntersection<T> = { [K in keyof T]: T[K] };
+/**
+ * Check if the config object is required (has any required fields)
+ */
+type IsConfigRequired<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? ExtractPathParams<Paths, Route> extends never ? ExtractRequestBody<Paths, Route, Lowercase<Method>> extends never ? false : true : true : false : false : false;
+/**
+ * Typed function signature for the API client.
+ * Config is required when endpoint has path params or body.
+ */
+type TypedApiFunction<Paths> = <T extends TypedEndpoint<Paths>>(endpoint: T, ...args: IsConfigRequired<Paths, T> extends true ? [config: FilteredRequestConfig<Paths, T>] : [config?: FilteredRequestConfig<Paths, T>]) => Promise<ExtractEndpointResponse<Paths, T>>;
 interface FetcherOptions {
   baseURL?: string;
   headers?: Record<string, string>;
@@ -64,5 +95,5 @@ interface FetcherOptions {
   fetch?: typeof fetch;
 }
 //#endregion
-export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedEndpoint, ValidEndpoint };
-//# sourceMappingURL=types-csACmD6U.d.cts.map
+export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint };
+//# sourceMappingURL=types-CyMkwV3g.d.mts.map

package/dist/{types-tMp85Lt_.d.mts → types-DVVUpwI4.d.cts}

@@ -54,7 +54,38 @@ type ParseEndpoint<T extends EndpointString> = T extends `${infer Method} ${infe
 } : never;
 type ExtractEndpointResponse<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? ExtractResponse<Paths, Route, Lowercase<Method>> : never : never : never;
 type ExtractEndpointConfig<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? RequestConfig<Paths, Route, Lowercase<Method>> : never : never : never;
-type FilteredRequestConfig<Paths, T extends EndpointString> = { [K in keyof ExtractEndpointConfig<Paths, T> as ExtractEndpointConfig<Paths, T>[K] extends never | undefined ? never : K]: ExtractEndpointConfig<Paths, T>[K] };
+/**
+ * Build a request config type where:
+ * - `params` is required if the endpoint has path parameters
+ * - `body` is required if the endpoint has a request body
+ * - `query` and `headers` are always optional
+ */
+type FilteredRequestConfig<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? BuildRequestConfig<ExtractPathParams<Paths, Route>, ExtractQueryParams<Paths, Route, Lowercase<Method>>, ExtractRequestBody<Paths, Route, Lowercase<Method>>> : never : never : never;
+/**
+ * Helper to build request config with correct required/optional fields
+ */
+type BuildRequestConfig<TParams, TQuery, TBody> = SimplifyIntersection<(TParams extends never ? {} : {
+  params: TParams;
+}) & (TBody extends never ? {} : {
+  body: TBody;
+}) & (TQuery extends never ? {} : {
+  query?: TQuery;
+}) & {
+  headers?: Record<string, string>;
+}>;
+/**
+ * Simplify intersection types for better IDE display
+ */
+type SimplifyIntersection<T> = { [K in keyof T]: T[K] };
+/**
+ * Check if the config object is required (has any required fields)
+ */
+type IsConfigRequired<Paths, T extends EndpointString> = T extends `${infer Method} ${infer Route}` ? Route extends OpenAPIRoutes<Paths> ? Lowercase<Method> extends ExtractMethod<Paths, Route> ? ExtractPathParams<Paths, Route> extends never ? ExtractRequestBody<Paths, Route, Lowercase<Method>> extends never ? false : true : true : false : false : false;
+/**
+ * Typed function signature for the API client.
+ * Config is required when endpoint has path params or body.
+ */
+type TypedApiFunction<Paths> = <T extends TypedEndpoint<Paths>>(endpoint: T, ...args: IsConfigRequired<Paths, T> extends true ? [config: FilteredRequestConfig<Paths, T>] : [config?: FilteredRequestConfig<Paths, T>]) => Promise<ExtractEndpointResponse<Paths, T>>;
 interface FetcherOptions {
   baseURL?: string;
   headers?: Record<string, string>;
@@ -64,5 +95,5 @@ interface FetcherOptions {
   fetch?: typeof fetch;
 }
 //#endregion
-export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedEndpoint, ValidEndpoint };
-//# sourceMappingURL=types-tMp85Lt_.d.mts.map
+export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint };
+//# sourceMappingURL=types-DVVUpwI4.d.cts.map

package/dist/types.d.cts

@@ -1,2 +1,2 @@
-import { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedEndpoint, ValidEndpoint } from "./types-csACmD6U.cjs";
-export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedEndpoint, ValidEndpoint };
+import { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint } from "./types-DVVUpwI4.cjs";
+export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint };

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedEndpoint, ValidEndpoint } from "./types-tMp85Lt_.mjs";
-export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedEndpoint, ValidEndpoint };
+import { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint } from "./types-CyMkwV3g.mjs";
+export { EndpointString, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/client",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -14,6 +14,11 @@
       "import": "./dist/fetcher.mjs",
       "require": "./dist/fetcher.cjs"
     },
+    "./infer": {
+      "types": "./dist/infer.d.ts",
+      "import": "./dist/infer.mjs",
+      "require": "./dist/infer.cjs"
+    },
     "./react-query": {
       "types": "./dist/react-query.d.ts",
       "import": "./dist/react-query.mjs",
@@ -28,16 +33,30 @@
       "types": "./dist/types.d.ts",
       "import": "./dist/types.mjs",
       "require": "./dist/types.cjs"
+    },
+    "./auth-fetcher": {
+      "types": "./dist/auth-fetcher.d.ts",
+      "import": "./dist/auth-fetcher.mjs",
+      "require": "./dist/auth-fetcher.cjs"
+    },
+    "./endpoint-hooks": {
+      "types": "./dist/endpoint-hooks.d.ts",
+      "import": "./dist/endpoint-hooks.mjs",
+      "require": "./dist/endpoint-hooks.cjs"
     }
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/geekmidas/toolbox.git"
+    "url": "https://github.com/geekmidas/toolbox"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "@geekmidas/schema": "0.0.2"
+  },
   "devDependencies": {
     "@testing-library/jest-dom": "~6.6.3",
     "@testing-library/dom": "~10.4.0",
@@ -51,7 +70,23 @@
   "peerDependencies": {
     "@tanstack/react-query": ">=5.0.0",
     "react": ">=18.0.0",
-    "react-dom": ">=18.0.0"
+    "react-dom": ">=18.0.0",
+    "zod": "~4.1.13",
+    "@geekmidas/constructs": "0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@geekmidas/constructs": {
+      "optional": false
+    },
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
   },
   "scripts": {
     "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"

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

@@ -0,0 +1,374 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import { http, HttpResponse } from 'msw';
+// biome-ignore lint/style/useImportType: needed for JSX
+import React, { createElement } from 'react';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createEndpointHooks } from '../endpoint-hooks';
+import type { TypedApiFunction } from '../types';
+import { server } from './setup';
+
+// Test API paths type
+interface TestPaths {
+  '/health': {
+    get: {
+      responses: {
+        200: {
+          content: {
+            'application/json': { status: string };
+          };
+        };
+      };
+    };
+  };
+  '/users/{id}': {
+    parameters: {
+      path: { id: string };
+    };
+    get: {
+      responses: {
+        200: {
+          content: {
+            'application/json': { id: string; name: string };
+          };
+        };
+      };
+    };
+  };
+  '/users': {
+    get: {
+      parameters: {
+        query: { limit?: number; offset?: number };
+      };
+      responses: {
+        200: {
+          content: {
+            'application/json': Array<{ id: string; name: string }>;
+          };
+        };
+      };
+    };
+    post: {
+      requestBody: {
+        content: {
+          'application/json': { name: string; email: string };
+        };
+      };
+      responses: {
+        201: {
+          content: {
+            'application/json': { id: string; name: string; email: string };
+          };
+        };
+      };
+    };
+  };
+  '/posts/{postId}/comments': {
+    parameters: {
+      path: { postId: string };
+    };
+    post: {
+      requestBody: {
+        content: {
+          'application/json': { content: string };
+        };
+      };
+      responses: {
+        201: {
+          content: {
+            'application/json': { id: string; postId: string; content: string };
+          };
+        };
+      };
+    };
+  };
+}
+
+// Create a mock fetcher
+function createMockFetcher(): TypedApiFunction<TestPaths> {
+  return async (endpoint: string, config?: any) => {
+    const [method, path] = endpoint.split(' ');
+    let url = `https://api.example.com${path}`;
+
+    // Replace path params
+    if (config?.params) {
+      for (const [key, value] of Object.entries(config.params)) {
+        url = url.replace(`{${key}}`, value as string);
+      }
+    }
+
+    // Add query params
+    if (config?.query) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(config.query)) {
+        if (value !== undefined) {
+          searchParams.set(key, String(value));
+        }
+      }
+      if (searchParams.toString()) {
+        url += `?${searchParams.toString()}`;
+      }
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...config?.headers,
+      },
+      body: config?.body ? JSON.stringify(config.body) : undefined,
+    });
+
+    return response.json();
+  };
+}
+
+// Test wrapper with QueryClient
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+
+  return ({ children }: { children: React.ReactNode }) =>
+    createElement(QueryClientProvider, { client: queryClient }, children);
+}
+
+describe('createEndpointHooks', () => {
+  beforeEach(() => {
+    // Add test-specific handlers
+    server.use(
+      http.get('https://api.example.com/health', () => {
+        return HttpResponse.json({ status: 'ok' });
+      }),
+      http.get('https://api.example.com/posts/:postId/comments', () => {
+        return HttpResponse.json([{ id: 'c1', content: 'Test comment' }]);
+      }),
+      http.post(
+        'https://api.example.com/posts/:postId/comments',
+        async ({ params, request }) => {
+          const body = (await request.json()) as { content: string };
+          return HttpResponse.json(
+            {
+              id: 'comment-1',
+              postId: params.postId as string,
+              content: body.content,
+            },
+            { status: 201 },
+          );
+        },
+      ),
+    );
+  });
+
+  describe('useQuery', () => {
+    it('should fetch data for endpoint without params', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const { result } = renderHook(() => hooks.useQuery('GET /health'), {
+        wrapper: createWrapper(),
+      });
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      expect(result.current.data).toEqual({ status: 'ok' });
+    });
+
+    it('should fetch data for endpoint with path params', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const { result } = renderHook(
+        () => hooks.useQuery('GET /users/{id}', { params: { id: '123' } }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      // Uses mock from setup.ts which returns { id, name: 'John Doe', email: ... }
+      expect(result.current.data).toMatchObject({
+        id: '123',
+        name: 'John Doe',
+      });
+    });
+
+    it('should pass query options to useQuery', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const { result } = renderHook(
+        () => hooks.useQuery('GET /health', undefined, { enabled: false }),
+        { wrapper: createWrapper() },
+      );
+
+      // Should not fetch because enabled: false
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.isFetching).toBe(false);
+      expect(result.current.data).toBeUndefined();
+    });
+  });
+
+  describe('useMutation', () => {
+    it('should mutate data for POST endpoint', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const { result } = renderHook(() => hooks.useMutation('POST /users'), {
+        wrapper: createWrapper(),
+      });
+
+      result.current.mutate({ body: { name: 'John', email: 'john@test.com' } });
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      // Uses mock from setup.ts
+      expect(result.current.data).toMatchObject({
+        id: '123',
+        name: 'John',
+        email: 'john@test.com',
+      });
+    });
+
+    it('should mutate data for endpoint with params and body', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const { result } = renderHook(
+        () => hooks.useMutation('POST /posts/{postId}/comments'),
+        { wrapper: createWrapper() },
+      );
+
+      result.current.mutate({
+        params: { postId: 'post-123' },
+        body: { content: 'Great post!' },
+      });
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      expect(result.current.data).toEqual({
+        id: 'comment-1',
+        postId: 'post-123',
+        content: 'Great post!',
+      });
+    });
+
+    it('should pass mutation options', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      let onSuccessCalled = false;
+
+      const { result } = renderHook(
+        () =>
+          hooks.useMutation('POST /users', {
+            onSuccess: () => {
+              onSuccessCalled = true;
+            },
+          }),
+        { wrapper: createWrapper() },
+      );
+
+      result.current.mutate({ body: { name: 'Jane', email: 'jane@test.com' } });
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      expect(onSuccessCalled).toBe(true);
+    });
+  });
+
+  describe('buildQueryKey', () => {
+    it('should build key with just endpoint', () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const key = hooks.buildQueryKey('GET /health');
+
+      expect(key).toEqual(['GET /health']);
+    });
+
+    it('should build key with params', () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const key = hooks.buildQueryKey('GET /users/{id}', {
+        params: { id: '123' },
+      });
+
+      expect(key).toEqual(['GET /users/{id}', { params: { id: '123' } }]);
+    });
+
+    it('should build key with both params and query', () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      // Using a hypothetical endpoint that has both
+      const key = hooks.buildQueryKey(
+        'GET /users/{id}' as any,
+        {
+          params: { id: '123' },
+          query: { include: 'posts' },
+        } as any,
+      );
+
+      expect(key).toEqual([
+        'GET /users/{id}',
+        { params: { id: '123' } },
+        { query: { include: 'posts' } },
+      ]);
+    });
+  });
+
+  describe('type enforcement', () => {
+    it('should allow optional config for endpoints without required fields', () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      // This should compile - config is optional for GET /health
+      renderHook(() => hooks.useQuery('GET /health'), {
+        wrapper: createWrapper(),
+      });
+
+      // This should also compile - providing optional config
+      renderHook(() => hooks.useQuery('GET /health', {}), {
+        wrapper: createWrapper(),
+      });
+    });
+
+    it('should require config for endpoints with path params', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      // Config with params is required for GET /users/{id}
+      const { result } = renderHook(
+        () => hooks.useQuery('GET /users/{id}', { params: { id: '456' } }),
+        { wrapper: createWrapper() },
+      );
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+      expect(result.current.data?.id).toBe('456');
+    });
+
+    it('should require body in mutation config for POST endpoints', async () => {
+      const fetcher = createMockFetcher();
+      const hooks = createEndpointHooks<TestPaths>(fetcher);
+
+      const { result } = renderHook(() => hooks.useMutation('POST /users'), {
+        wrapper: createWrapper(),
+      });
+
+      // Body is required in mutate() for POST /users
+      result.current.mutate({
+        body: { name: 'Test', email: 'test@test.com' },
+      });
+
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    });
+  });
+});