@geekmidas/client 0.4.0 → 0.5.0

package/src/__tests__/types.spec.ts

@@ -1,134 +1,134 @@
 import { describe, expectTypeOf, it } from 'vitest';
 import type { paths } from '../openapi-types';
 import type {
-  ExtractEndpointConfig,
-  ExtractEndpointResponse,
-  FilteredRequestConfig,
-  TypedEndpoint,
-  ValidEndpoint,
+	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>;
-    }>();
-  });
+	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

@@ -2,195 +2,195 @@ 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),
-    );
-  });
+	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),
+		);
+	});
 });