@geekmidas/client 9.0.1 → 10.0.0-alpha.0

package/src/__tests__/infer.integration.spec.ts

@@ -1,188 +0,0 @@
-import { e } from '@geekmidas/constructs/endpoints';
-import { describe, expectTypeOf, it } from 'vitest';
-import { z } from 'zod';
-import type { InferOpenApi } from '../infer';
-
-describe('InferOpenApi - TypedFetcher Integration', () => {
-	it('should generate paths structure compatible with TypedFetcher', () => {
-		// Define some endpoints
-		const getUserEndpoint = e
-			.get('/users/{id}')
-			.params(z.object({ id: z.string() }))
-			.output(z.object({ id: z.string(), name: z.string(), email: z.string() }))
-			.handle(async ({ params }) => ({
-				id: params.id,
-				name: 'John Doe',
-				email: 'john@example.com',
-			}));
-
-		const createUserEndpoint = e
-			.post('/users')
-			.body(z.object({ name: z.string(), email: z.string() }))
-			.output(z.object({ id: z.string(), name: z.string(), email: z.string() }))
-			.handle(async ({ body }) => ({
-				id: '123',
-				name: body.name,
-				email: body.email,
-			}));
-
-		const listUsersEndpoint = e
-			.get('/users')
-			.query(z.object({ page: z.coerce.number().optional() }))
-			.output(
-				z.object({
-					users: z.array(
-						z.object({ id: z.string(), name: z.string(), email: z.string() }),
-					),
-				}),
-			)
-			.handle(async ({ query }) => ({
-				users: [],
-			}));
-
-		// Infer paths from endpoints
-		const endpoints = [
-			getUserEndpoint,
-			createUserEndpoint,
-			listUsersEndpoint,
-		] as const;
-		type Paths = InferOpenApi<typeof endpoints>['paths'];
-
-		// Verify the structure matches TypedFetcher expectations
-		expectTypeOf<Paths>().toMatchTypeOf<{
-			'/users/{id}': {
-				get: {
-					parameters: {
-						path: { id: string };
-					};
-					responses: {
-						200: {
-							content: {
-								'application/json': {
-									id: string;
-									name: string;
-									email: string;
-								};
-							};
-						};
-					};
-				};
-			};
-			'/users': {
-				get: {
-					parameters: {
-						query: { page?: number };
-					};
-					responses: {
-						200: {
-							content: {
-								'application/json': {
-									users: Array<{ id: string; name: string; email: string }>;
-								};
-							};
-						};
-					};
-				};
-				post: {
-					requestBody: {
-						content: {
-							'application/json': {
-								name: string;
-								email: string;
-							};
-						};
-					};
-					responses: {
-						200: {
-							content: {
-								'application/json': {
-									id: string;
-									name: string;
-									email: string;
-								};
-							};
-						};
-					};
-				};
-			};
-		}>();
-	});
-
-	it('should handle endpoints with multiple parameter types', () => {
-		const updateUserEndpoint = e
-			.put('/users/{id}')
-			.params(z.object({ id: z.string() }))
-			.query(z.object({ notify: z.coerce.boolean().optional() }))
-			.body(z.object({ name: z.string() }))
-			.output(z.object({ id: z.string(), name: z.string() }))
-			.handle(async ({ params, query, body }) => ({
-				id: params.id,
-				name: body.name,
-			}));
-
-		type Paths = InferOpenApi<[typeof updateUserEndpoint]>['paths'];
-
-		// Verify all parameter types are present
-		expectTypeOf<Paths>().toMatchTypeOf<{
-			'/users/{id}': {
-				parameters: {
-					path: { id: string };
-					query: { notify?: boolean };
-				};
-				put: {
-					parameters: {
-						path: { id: string };
-						query: { notify?: boolean };
-					};
-					requestBody: {
-						content: {
-							'application/json': {
-								name: string;
-							};
-						};
-					};
-					responses: {
-						200: {
-							content: {
-								'application/json': {
-									id: string;
-									name: string;
-								};
-							};
-						};
-					};
-				};
-			};
-		}>();
-	});
-
-	it('should handle endpoints without output schema', () => {
-		const deleteUserEndpoint = e
-			.delete('/users/{id}')
-			.params(z.object({ id: z.string() }))
-			.handle(async ({ params }) => {
-				// No return value
-			});
-
-		type Paths = InferOpenApi<[typeof deleteUserEndpoint]>['paths'];
-
-		// Verify response content is never when no output schema
-		expectTypeOf<Paths>().toMatchTypeOf<{
-			'/users/{id}': {
-				parameters: {
-					path: { id: string };
-				};
-				delete: {
-					parameters: {
-						path: { id: string };
-					};
-					responses: {
-						200: {
-							content: never;
-						};
-					};
-				};
-			};
-		}>();
-	});
-});

package/src/__tests__/infer.spec.ts

@@ -1,189 +0,0 @@
-import { e } from '@geekmidas/constructs/endpoints';
-import { describe, expectTypeOf, it } from 'vitest';
-import { z } from 'zod';
-import type { InferOpenApi, InferOpenApiFromEndpoint } from '../infer';
-
-describe('InferOpenApi', () => {
-	describe('single endpoint', () => {
-		it('should infer OpenAPI structure for GET endpoint', () => {
-			const endpoint = e
-				.get('/users/{id}')
-				.params(z.object({ id: z.string() }))
-				.output(z.object({ id: z.string(), name: z.string() }))
-				.handle(async ({ params }) => ({
-					id: params.id,
-					name: 'John',
-				}));
-
-			type API = InferOpenApiFromEndpoint<typeof endpoint>;
-
-			expectTypeOf<API>().toMatchTypeOf<{
-				paths: {
-					'/users/{id}': {
-						get: {
-							responses: {
-								'200': {
-									description: string;
-								};
-							};
-						};
-					};
-				};
-			}>();
-		});
-
-		it('should infer OpenAPI structure for POST endpoint with body', () => {
-			const endpoint = e
-				.post('/users')
-				.body(z.object({ name: z.string(), email: z.string() }))
-				.output(z.object({ id: z.string(), name: z.string() }))
-				.handle(async ({ body }) => ({
-					id: '123',
-					name: body.name,
-				}));
-
-			type API = InferOpenApiFromEndpoint<typeof endpoint>;
-
-			expectTypeOf<API>().toMatchTypeOf<{
-				paths: {
-					'/users': {
-						post: {
-							responses: {
-								'200': {
-									description: string;
-								};
-							};
-						};
-					};
-				};
-			}>();
-		});
-	});
-
-	describe('multiple endpoints', () => {
-		it('should merge OpenAPI specs from multiple endpoints', () => {
-			const getUserEndpoint = e
-				.get('/users/{id}')
-				.params(z.object({ id: z.string() }))
-				.output(z.object({ id: z.string(), name: z.string() }))
-				.handle(async ({ params }) => ({
-					id: params.id,
-					name: 'John',
-				}));
-
-			const createUserEndpoint = e
-				.post('/users')
-				.body(z.object({ name: z.string() }))
-				.output(z.object({ id: z.string(), name: z.string() }))
-				.handle(async ({ body }) => ({
-					id: '123',
-					name: body.name,
-				}));
-
-			const endpoints = [getUserEndpoint, createUserEndpoint] as const;
-
-			type API = InferOpenApi<typeof endpoints>;
-
-			// Should have both paths
-			expectTypeOf<API>().toMatchTypeOf<{
-				paths: {
-					'/users/{id}': {
-						get: unknown;
-					};
-					'/users': {
-						post: unknown;
-					};
-				};
-			}>();
-		});
-
-		it('should handle endpoints with different HTTP methods on same path', () => {
-			const getUserEndpoint = e
-				.get('/users')
-				.output(z.object({ users: z.array(z.object({ id: z.string() })) }))
-				.handle(async () => ({
-					users: [],
-				}));
-
-			const createUserEndpoint = e
-				.post('/users')
-				.body(z.object({ name: z.string() }))
-				.output(z.object({ id: z.string() }))
-				.handle(async ({ body }) => ({
-					id: '123',
-				}));
-
-			const endpoints = [getUserEndpoint, createUserEndpoint] as const;
-
-			type API = InferOpenApi<typeof endpoints>;
-
-			// Should have both methods on same path
-			expectTypeOf<API>().toMatchTypeOf<{
-				paths: {
-					'/users': {
-						get: unknown;
-						post: unknown;
-					};
-				};
-			}>();
-		});
-	});
-
-	describe('complex schemas', () => {
-		it('should handle endpoints with query parameters', () => {
-			const endpoint = e
-				.get('/users')
-				.query(
-					z.object({
-						page: z.coerce.number().optional(),
-						limit: z.coerce.number().optional(),
-					}),
-				)
-				.output(z.object({ users: z.array(z.object({ id: z.string() })) }))
-				.handle(async ({ query }) => ({
-					users: [],
-				}));
-
-			type API = InferOpenApiFromEndpoint<typeof endpoint>;
-
-			expectTypeOf<API>().toMatchTypeOf<{
-				paths: {
-					'/users': {
-						get: {
-							responses: {
-								'200': unknown;
-							};
-						};
-					};
-				};
-			}>();
-		});
-
-		it('should handle endpoints with body, params, and query', () => {
-			const endpoint = e
-				.put('/users/{id}')
-				.params(z.object({ id: z.string() }))
-				.query(z.object({ notify: z.coerce.boolean().optional() }))
-				.body(z.object({ name: z.string() }))
-				.output(z.object({ id: z.string(), name: z.string() }))
-				.handle(async ({ params, body }) => ({
-					id: params.id,
-					name: body.name,
-				}));
-
-			type API = InferOpenApiFromEndpoint<typeof endpoint>;
-
-			expectTypeOf<API>().toMatchTypeOf<{
-				paths: {
-					'/users/{id}': {
-						put: {
-							responses: {
-								'200': unknown;
-							};
-						};
-					};
-				};
-			}>();
-		});
-	});
-});

package/src/__tests__/method-restrictions.spec.tsx

@@ -1,227 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { renderHook } from '@testing-library/react';
-// biome-ignore lint/style/useImportType: <explanation>
-import React from 'react';
-import { describe, expect, it } from 'vitest';
-import type { paths } from '../openapi-types';
-import { createTypedQueryClient } from '../react-query';
-import './setup';
-
-describe('Method Restrictions', () => {
-	const queryClient = new QueryClient({
-		defaultOptions: {
-			queries: {
-				retry: false,
-			},
-		},
-	});
-
-	const wrapper = ({ children }: { children: React.ReactNode }) => (
-		<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-	);
-
-	describe('useQuery', () => {
-		it('should accept GET endpoints', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// This should compile - GET endpoints are allowed
-			const { result } = renderHook(() => typedClient.useQuery('GET /users'), {
-				wrapper,
-			});
-
-			expect(result.current).toBeDefined();
-		});
-
-		it('should accept GET endpoints with parameters', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// This should compile - GET endpoints with params are allowed
-			const { result } = renderHook(
-				() =>
-					typedClient.useQuery('GET /users/{id}', {
-						params: { id: '123' },
-					}),
-				{ wrapper },
-			);
-
-			expect(result.current).toBeDefined();
-		});
-
-		it('should accept GET endpoints with query parameters', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// This should compile - GET endpoints with query params are allowed
-			const { result } = renderHook(
-				() =>
-					typedClient.useQuery('GET /posts', {
-						query: { page: 1, limit: 10 },
-					}),
-				{ wrapper },
-			);
-
-			expect(result.current).toBeDefined();
-		});
-
-		// The following tests would fail TypeScript compilation if uncommented
-		// They are left here as documentation of what should NOT work
-
-		/*
-    it('should NOT accept POST endpoints', () => {
-      const typedClient = createTypedQueryClient<paths>({
-        baseURL: 'https://api.example.com',
-      });
-
-      // @ts-expect-error - POST endpoints should not be allowed in useQuery
-      const { result } = renderHook(
-        () => typedClient.useQuery('POST /users'),
-        { wrapper },
-      );
-    });
-
-    it('should NOT accept PUT endpoints', () => {
-      const typedClient = createTypedQueryClient<paths>({
-        baseURL: 'https://api.example.com',
-      });
-
-      // @ts-expect-error - PUT endpoints should not be allowed in useQuery
-      const { result } = renderHook(
-        () => typedClient.useQuery('PUT /users/{id}', { params: { id: '123' } }),
-        { wrapper },
-      );
-    });
-
-    it('should NOT accept DELETE endpoints', () => {
-      const typedClient = createTypedQueryClient<paths>({
-        baseURL: 'https://api.example.com',
-      });
-
-      // @ts-expect-error - DELETE endpoints should not be allowed in useQuery
-      const { result } = renderHook(
-        () => typedClient.useQuery('DELETE /users/{id}', { params: { id: '123' } }),
-        { wrapper },
-      );
-    });
-    */
-	});
-
-	describe('useMutation', () => {
-		it('should accept POST endpoints', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// This should compile - POST endpoints are allowed
-			const { result } = renderHook(
-				() => typedClient.useMutation('POST /users'),
-				{ wrapper },
-			);
-
-			expect(result.current).toBeDefined();
-		});
-
-		it('should accept PUT endpoints', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// This should compile - PUT endpoints are allowed
-			const { result } = renderHook(
-				() => typedClient.useMutation('PUT /users/{id}'),
-				{ wrapper },
-			);
-
-			expect(result.current).toBeDefined();
-		});
-
-		it('should accept DELETE endpoints', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// This should compile - DELETE endpoints are allowed
-			const { result } = renderHook(
-				() => typedClient.useMutation('DELETE /users/{id}'),
-				{ wrapper },
-			);
-
-			expect(result.current).toBeDefined();
-		});
-
-		// The following test would fail TypeScript compilation if uncommented
-		// It is left here as documentation of what should NOT work
-
-		/*
-    it('should NOT accept GET endpoints', () => {
-      const typedClient = createTypedQueryClient<paths>({
-        baseURL: 'https://api.example.com',
-      });
-
-      // @ts-expect-error - GET endpoints should not be allowed in useMutation
-      const { result } = renderHook(
-        () => typedClient.useMutation('GET /users'),
-        { wrapper },
-      );
-    });
-    */
-	});
-
-	describe('Type inference', () => {
-		it('should correctly infer response types for GET requests', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			const { result } = renderHook(() => typedClient.useQuery('GET /users'), {
-				wrapper,
-			});
-
-			// TypeScript should infer this type correctly
-			type ResponseType = typeof result.current.data;
-			type ExpectedType =
-				| { users: Array<{ id: string; name: string; email: string }> }
-				| undefined;
-
-			// This assertion validates that the types match at compile time
-			const _typeCheck: ResponseType extends ExpectedType ? true : false = true;
-			const _typeCheck2: ExpectedType extends ResponseType ? true : false =
-				true;
-
-			expect(_typeCheck).toBe(true);
-			expect(_typeCheck2).toBe(true);
-		});
-
-		it('should correctly infer response types for POST requests', () => {
-			const typedClient = createTypedQueryClient<paths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			const { result } = renderHook(
-				() => typedClient.useMutation('POST /users'),
-				{ wrapper },
-			);
-
-			// TypeScript should infer this type correctly
-			type ResponseType = typeof result.current.data;
-			type ExpectedType =
-				| { id: string; name: string; email: string }
-				| undefined;
-
-			// This assertion validates that the types match at compile time
-			const _typeCheck: ResponseType extends ExpectedType ? true : false = true;
-			const _typeCheck2: ExpectedType extends ResponseType ? true : false =
-				true;
-
-			expect(_typeCheck).toBe(true);
-			expect(_typeCheck2).toBe(true);
-		});
-	});
-});