@geekmidas/client 9.0.2 → 10.0.0-alpha.0

package/src/__tests__/setup.ts

@@ -1,281 +0,0 @@
-import { HttpResponse, http } from 'msw';
-import { setupServer } from 'msw/node';
-import { afterAll, afterEach, beforeAll } from 'vitest';
-
-// Define request handlers
-export const handlers = [
-	// GET /users
-	http.get('https://api.example.com/users', () => {
-		return HttpResponse.json({
-			users: [
-				{ id: '1', name: 'John Doe', email: 'john@example.com' },
-				{ id: '2', name: 'Jane Smith', email: 'jane@example.com' },
-			],
-		});
-	}),
-
-	// POST /users
-	http.post('https://api.example.com/users', async ({ request }) => {
-		const body = await request.json();
-		return HttpResponse.json(
-			{
-				id: '123',
-				name: (body as any).name,
-				email: (body as any).email,
-			},
-			{ status: 201 },
-		);
-	}),
-
-	// GET /users/{id}
-	http.get('https://api.example.com/users/:id', ({ params }) => {
-		const { id } = params;
-		if (id === '404') {
-			return HttpResponse.json({ message: 'User not found' }, { status: 404 });
-		}
-		return HttpResponse.json({
-			id,
-			name: 'John Doe',
-			email: 'john@example.com',
-		});
-	}),
-
-	// PUT /users/{id}
-	http.put('https://api.example.com/users/:id', async ({ params, request }) => {
-		const { id } = params;
-		const body = await request.json();
-		return HttpResponse.json({
-			id,
-			name: (body as any).name || 'John Doe',
-			email: (body as any).email || 'john@example.com',
-		});
-	}),
-
-	// PATCH /users/{id}
-	http.patch(
-		'https://api.example.com/users/:id',
-		async ({ params, request }) => {
-			const { id } = params;
-			const body = await request.json();
-			return HttpResponse.json({
-				id,
-				name: (body as any).name || 'John Doe',
-				email: (body as any).email || 'john@example.com',
-			});
-		},
-	),
-
-	// DELETE /users/{id}
-	http.delete('https://api.example.com/users/:id', () => {
-		return new HttpResponse(null, { status: 204 });
-	}),
-
-	// GET /posts with query parameters
-	http.get('https://api.example.com/posts', ({ request }) => {
-		const url = new URL(request.url);
-		const page = parseInt(url.searchParams.get('page') || '1', 10);
-		const limit = parseInt(url.searchParams.get('limit') || '10', 10);
-		const sort = url.searchParams.get('sort') || 'asc';
-
-		// Generate posts based on page to simulate pagination
-		const totalPosts = 50;
-		const startIndex = (page - 1) * limit;
-		const endIndex = Math.min(startIndex + limit, totalPosts);
-
-		const posts = Array.from({ length: endIndex - startIndex }, (_, i) => ({
-			id: `post-${startIndex + i + 1}`,
-			title: `Test Post ${startIndex + i + 1}`,
-			content: `Test content for post ${startIndex + i + 1}`,
-			authorId: `author-${((startIndex + i) % 5) + 1}`,
-			createdAt: new Date(
-				Date.now() - (startIndex + i) * 3600000,
-			).toISOString(),
-		}));
-
-		return HttpResponse.json({
-			posts,
-			pagination: {
-				page,
-				limit,
-				total: totalPosts,
-			},
-			sort,
-		});
-	}),
-
-	// GET /posts/{postId}
-	http.get('https://api.example.com/posts/:postId', ({ params, request }) => {
-		const { postId } = params;
-		const url = new URL(request.url);
-		const includeAuthor = url.searchParams.get('includeAuthor') === 'true';
-
-		const response = {
-			id: postId,
-			title: 'Test Post',
-			content: 'Test content',
-			authorId: '123',
-		};
-
-		if (includeAuthor) {
-			return HttpResponse.json({
-				...response,
-				author: { id: '123', name: 'John' },
-			});
-		}
-
-		return HttpResponse.json(response);
-	}),
-
-	// Error endpoint for testing
-	http.get('https://api.example.com/error', () => {
-		return HttpResponse.json(
-			{ message: 'Internal server error' },
-			{ status: 500 },
-		);
-	}),
-
-	// Unauthorized endpoint
-	http.get('https://api.example.com/protected', ({ request }) => {
-		const auth = request.headers.get('Authorization');
-		if (!auth || !auth.includes('valid-token')) {
-			return HttpResponse.json({ message: 'Unauthorized' }, { status: 401 });
-		}
-		return HttpResponse.json({ message: 'Protected data' });
-	}),
-
-	// Search endpoint
-	http.get('https://api.example.com/search', ({ request }) => {
-		const url = new URL(request.url);
-		const tags = url.searchParams.getAll('tags');
-		return HttpResponse.json({
-			items: tags,
-			results: tags.map((tag, i) => ({ id: i, tag })),
-		});
-	}),
-
-	// Products endpoint with filters
-	http.get('https://api.example.com/products', ({ request }) => {
-		const url = new URL(request.url);
-		const params: Record<string, string> = {};
-		url.searchParams.forEach((value, key) => {
-			params[key] = value;
-		});
-		return HttpResponse.json({
-			results: [],
-			filters: params,
-		});
-	}),
-
-	// Advanced search endpoint
-	http.get('https://api.example.com/advanced-search', ({ request }) => {
-		const url = new URL(request.url);
-		const params: Record<string, string> = {};
-		url.searchParams.forEach((value, key) => {
-			params[key] = value;
-		});
-		return HttpResponse.json({
-			results: [],
-			query: params,
-		});
-	}),
-
-	// Paginated users endpoint for infinite queries
-	http.get('https://api.example.com/users/paginated', ({ request }) => {
-		const url = new URL(request.url);
-		const page = parseInt(url.searchParams.get('page') || '1', 10);
-		const limit = parseInt(url.searchParams.get('limit') || '10', 10);
-
-		const allUsers = Array.from({ length: 50 }, (_, i) => ({
-			id: `user-${i + 1}`,
-			name: `User ${i + 1}`,
-			email: `user${i + 1}@example.com`,
-		}));
-
-		const startIndex = (page - 1) * limit;
-		const endIndex = startIndex + limit;
-		const users = allUsers.slice(startIndex, endIndex);
-		const hasMore = endIndex < allUsers.length;
-
-		return HttpResponse.json({
-			users,
-			pagination: {
-				page,
-				limit,
-				total: allUsers.length,
-				hasMore,
-			},
-		});
-	}),
-
-	// Cursor-based pagination endpoint for infinite queries
-	http.get('https://api.example.com/messages', ({ request }) => {
-		const url = new URL(request.url);
-		const cursor = url.searchParams.get('cursor');
-		const limit = parseInt(url.searchParams.get('limit') || '10', 10);
-
-		const allMessages = Array.from({ length: 100 }, (_, i) => ({
-			id: `msg-${i + 1}`,
-			text: `Message ${i + 1}`,
-			timestamp: new Date(Date.now() - i * 60000).toISOString(),
-		}));
-
-		let startIndex = 0;
-		if (cursor) {
-			const cursorIndex = allMessages.findIndex((m) => m.id === cursor);
-			startIndex = cursorIndex !== -1 ? cursorIndex + 1 : 0;
-		}
-
-		const messages = allMessages.slice(startIndex, startIndex + limit);
-		const nextCursor =
-			messages.length === limit ? messages[messages.length - 1].id : null;
-
-		return HttpResponse.json({
-			messages,
-			nextCursor,
-		});
-	}),
-
-	// Echo endpoint that returns all query parameters
-	http.get('https://api.example.com/echo', ({ request }) => {
-		const url = new URL(request.url);
-		const queryParams: Record<string, string> = {};
-
-		// Collect all query parameters
-		url.searchParams.forEach((value, key) => {
-			queryParams[key] = value;
-		});
-
-		return HttpResponse.json({
-			queryParams,
-			// Also include some pagination data for infinite query testing
-			data: Array.from({ length: 5 }, (_, i) => ({
-				id: `item-${i + 1}`,
-				value: `Value ${i + 1}`,
-			})),
-			pagination: {
-				page: parseInt(queryParams.page || '1', 10),
-				limit: parseInt(queryParams.limit || '10', 10),
-				total: 50,
-				hasMore: parseInt(queryParams.page || '1', 10) < 5,
-			},
-		});
-	}),
-];
-
-export const server = setupServer(...handlers);
-
-// Establish API mocking before all tests
-beforeAll(() => {
-	server.listen({ onUnhandledRequest: 'error' });
-});
-
-// Reset any request handlers that we may add during the tests,
-// so they don't affect other tests
-afterEach(() => {
-	server.resetHandlers();
-});
-
-// Clean up after the tests are finished
-afterAll(() => {
-	server.close();
-});

package/src/__tests__/types.spec.ts

@@ -1,134 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import type { paths } from '../openapi-types';
-import type {
-	ExtractEndpointConfig,
-	ExtractEndpointResponse,
-	FilteredRequestConfig,
-	TypedEndpoint,
-	ValidEndpoint,
-} from '../types';
-
-describe('Type utilities', () => {
-	it('should extract valid endpoints from paths', () => {
-		type ValidEndpoints = TypedEndpoint<paths>;
-
-		// Test that valid endpoints are correctly generated
-		expectTypeOf<ValidEndpoints>().toExtend<
-			| 'GET /users'
-			| 'POST /users'
-			| 'GET /users/{id}'
-			| 'PUT /users/{id}'
-			| 'DELETE /users/{id}'
-			| 'GET /posts'
-			| 'GET /protected'
-			| 'GET /error'
-		>();
-	});
-
-	it('should create typed endpoint strings', () => {
-		type Endpoints = TypedEndpoint<paths>;
-
-		// Test that TypedEndpoint resolves to the same as ValidEndpoint
-		expectTypeOf<Endpoints>().toEqualTypeOf<ValidEndpoint<paths>>();
-	});
-
-	it('should extract response types correctly', () => {
-		type UserResponse = ExtractEndpointResponse<paths, 'GET /users/{id}'>;
-		type UsersResponse = ExtractEndpointResponse<paths, 'GET /users'>;
-		type PostsResponse = ExtractEndpointResponse<paths, 'GET /posts'>;
-
-		expectTypeOf<UserResponse>().toEqualTypeOf<{
-			id: string;
-			name: string;
-			email: string;
-		}>();
-
-		expectTypeOf<UsersResponse>().toEqualTypeOf<{
-			users: Array<{
-				id: string;
-				name: string;
-				email: string;
-			}>;
-		}>();
-
-		expectTypeOf<PostsResponse>().toEqualTypeOf<{
-			posts: Array<{
-				id: string;
-				title: string;
-				content: string;
-				authorId: string;
-				createdAt: string;
-			}>;
-			pagination: {
-				page: number;
-				limit: number;
-				total: number;
-			};
-			sort: 'asc' | 'desc';
-		}>();
-	});
-
-	it('should extract config types correctly', () => {
-		type GetUserConfig = ExtractEndpointConfig<paths, 'GET /users/{id}'>;
-		type PostUserConfig = ExtractEndpointConfig<paths, 'POST /users'>;
-		type GetPostsConfig = ExtractEndpointConfig<paths, 'GET /posts'>;
-
-		expectTypeOf<GetUserConfig>().toEqualTypeOf<{
-			params?: { id: string };
-			query?: never;
-			body?: never;
-			headers?: Record<string, string>;
-		}>();
-
-		expectTypeOf<PostUserConfig>().toEqualTypeOf<{
-			params?: never;
-			query?: never;
-			body?: { name: string; email: string };
-			headers?: Record<string, string>;
-		}>();
-
-		expectTypeOf<GetPostsConfig>().toEqualTypeOf<{
-			params?: never;
-			query?: {
-				page?: number;
-				limit?: number;
-				sort?: 'asc' | 'desc';
-			};
-			body?: never;
-			headers?: Record<string, string>;
-		}>();
-	});
-
-	it('should filter config to only required properties', () => {
-		type GetUserFiltered = FilteredRequestConfig<paths, 'GET /users/{id}'>;
-		type PostUserFiltered = FilteredRequestConfig<paths, 'POST /users'>;
-		type GetUsersFiltered = FilteredRequestConfig<paths, 'GET /users'>;
-
-		// GET /users/{id} should require params
-		expectTypeOf<GetUserFiltered>().toEqualTypeOf<{
-			params?: { id: string };
-			headers?: Record<string, string>;
-		}>();
-
-		// POST /users should allow body
-		expectTypeOf<PostUserFiltered>().toEqualTypeOf<{
-			body?: { name: string; email: string };
-			headers?: Record<string, string>;
-		}>();
-
-		// GET /users should only allow headers (no params, query, or body)
-		expectTypeOf<GetUsersFiltered>().toEqualTypeOf<{
-			headers?: Record<string, string>;
-		}>();
-	});
-
-	it('should handle endpoints with multiple parameter types', () => {
-		type PutUserConfig = FilteredRequestConfig<paths, 'PUT /users/{id}'>;
-
-		expectTypeOf<PutUserConfig>().toEqualTypeOf<{
-			params?: { id: string };
-			body?: { name?: string; email?: string };
-			headers?: Record<string, string>;
-		}>();
-	});
-});

package/src/__tests__/url-parsing.spec.ts

@@ -1,196 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTypedFetcher } from '../fetcher';
-
-describe('URL Path Parameter Parsing', () => {
-	it('should correctly parse single path parameter', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-
-		const client = createTypedFetcher<any>({
-			baseURL: 'https://api.example.com',
-			fetch: mockFetch,
-		});
-
-		await client('GET /users/{userId}' as any, {
-			params: { userId: '12345' },
-		});
-
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/users/12345',
-			expect.any(Object),
-		);
-	});
-
-	it('should correctly parse multiple path parameters', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-
-		const client = createTypedFetcher<any>({
-			fetch: mockFetch,
-			baseURL: 'https://api.example.com',
-		});
-
-		await client(
-			'GET /organizations/{orgId}/projects/{projectId}/tasks/{taskId}' as any,
-			{
-				params: {
-					orgId: 'org-123',
-					projectId: 'proj-456',
-					taskId: 'task-789',
-				},
-			},
-		);
-
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/organizations/org-123/projects/proj-456/tasks/task-789',
-			expect.any(Object),
-		);
-	});
-
-	it('should URL encode special characters in path parameters', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-
-		const client = createTypedFetcher<any>({
-			baseURL: 'https://api.example.com',
-			fetch: mockFetch,
-		});
-
-		await client('GET /files/{filename}' as any, {
-			params: {
-				filename: 'my file with spaces & special#characters.txt',
-			},
-		});
-
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/files/my%20file%20with%20spaces%20%26%20special%23characters.txt',
-			expect.any(Object),
-		);
-	});
-
-	it('should handle path parameters with forward slashes', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-
-		const client = createTypedFetcher<any>({
-			baseURL: 'https://api.example.com',
-			fetch: mockFetch,
-		});
-
-		await client('GET /repositories/{repoPath}' as any, {
-			params: {
-				repoPath: 'owner/repo/branch',
-			},
-		});
-
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/repositories/owner%2Frepo%2Fbranch',
-			expect.any(Object),
-		);
-	});
-
-	it('should handle path parameters and query parameters together', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-		const client = createTypedFetcher<any>({
-			baseURL: 'https://api.example.com',
-			fetch: mockFetch,
-		});
-
-		await client('GET /users/{userId}/posts' as any, {
-			params: { userId: 'user-123' },
-			query: { page: 2, limit: 10, sort: 'desc' },
-		});
-
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/users/user-123/posts?page=2&limit=10&sort=desc',
-			expect.any(Object),
-		);
-	});
-
-	it('should handle numeric path parameters', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-		const client = createTypedFetcher<any>({
-			baseURL: 'https://api.example.com',
-			fetch: mockFetch,
-		});
-
-		await client('GET /api/v{version}/users/{id}' as any, {
-			params: { version: 2, id: 12345 },
-		});
-
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/api/v2/users/12345',
-			expect.any(Object),
-		);
-	});
-
-	it('should handle empty baseURL', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-		const client = createTypedFetcher<any>({
-			baseURL: '',
-			fetch: mockFetch,
-		});
-
-		await client('GET /users/{id}' as any, {
-			params: { id: '123' },
-		});
-
-		expect(mockFetch).toHaveBeenCalledWith('/users/123', expect.any(Object));
-	});
-
-	it('should not replace parameters that are not provided', async () => {
-		const mockFetch = vi.fn().mockResolvedValue(
-			new Response(JSON.stringify({ success: true }), {
-				status: 200,
-				headers: { 'Content-Type': 'application/json' },
-			}),
-		);
-
-		const client = createTypedFetcher<any>({
-			baseURL: 'https://api.example.com',
-			fetch: mockFetch,
-		});
-
-		// Missing the userId parameter
-		await client('GET /users/{userId}/posts/{postId}' as any, {
-			params: { postId: '456' },
-		});
-
-		// The {userId} should remain in the URL unchanged
-		expect(mockFetch).toHaveBeenCalledWith(
-			'https://api.example.com/users/{userId}/posts/456',
-			expect.any(Object),
-		);
-	});
-});