From 8b6138773324da2e8acc8071ae86d5744bd938e1 Mon Sep 17 00:00:00 2001
From: ledouxm <martin.ledoux.pro@gmail.com>
Date: Tue, 18 Feb 2025 15:25:55 +0100
Subject: [PATCH] fix: add client response type inference when options.throw is
 true

---
 src/client.test.ts | 54 +++++++++++++++++++++++++++++
 src/client.ts      | 85 +++++++++++++++++++++++++++++++---------------
 2 files changed, 111 insertions(+), 28 deletions(-)

diff --git a/src/client.test.ts b/src/client.test.ts
index bf8faec..589b6c7 100644
--- a/src/client.test.ts
+++ b/src/client.test.ts
@@ -214,4 +214,58 @@ describe("client", () => {
 		});
 		expectTypeOf<Parameters<typeof client>[0]>().toMatchTypeOf<"@post/test">();
 	});
+
+	it("should infer response depending on options.throw", async () => {
+		const endpoint = createEndpoint(
+			"/test",
+			{
+				method: "POST",
+				body: z.object({
+					hello: z.string(),
+				}),
+			},
+			async () => {
+				return {
+					status: 200,
+					body: {
+						hello: "world",
+					},
+				};
+			},
+		);
+
+		const router = createRouter({
+			endpoint,
+		});
+
+		const client = createClient<typeof router>({
+			baseURL: "http://localhost:3000",
+			customFetchImpl: async () => {
+				return new Response(null);
+			},
+		});
+
+		const throwingClient = createClient<typeof router>({
+			baseURL: "http://localhost:3000",
+			customFetchImpl: async () => {
+				return new Response(null);
+			},
+			throw: true,
+		});
+
+		const response = await client("@post/test", {
+			body: {
+				hello: "world",
+			},
+		});
+
+		const throwingResponse = await throwingClient("@post/test", {
+			body: {
+				hello: "world",
+			},
+		});
+
+		expectTypeOf(response.data).toMatchTypeOf<{ body: { hello: string } } | null>();
+		expectTypeOf(throwingResponse).toMatchTypeOf<{ body: { hello: string } }>();
+	});
 });
diff --git a/src/client.ts b/src/client.ts
index d88cc63..10b0aa6 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -55,37 +55,66 @@ export type RequiredOptionKeys<
 				params: true;
 			});
 
-export const createClient = <R extends Router | Router["endpoints"]>(options: ClientOptions) => {
+export function createClient<R extends Router | Router["endpoints"]>(
+	options: ClientOptions & { throw: true },
+): FetchClientReturn<R, true>;
+
+export function createClient<R extends Router | Router["endpoints"]>(
+	options: ClientOptions & { throw: false },
+): FetchClientReturn<R, false>;
+
+export function createClient<R extends Router | Router["endpoints"]>(
+	options: ClientOptions,
+): FetchClientReturn<R, false>;
+
+export function createClient<R extends Router | Router["endpoints"]>(
+	options: ClientOptions,
+): FetchClientReturn<R, any> {
 	const fetch = createFetch(options);
-	type API = R extends { endpoints: Record<string, Endpoint> } ? R["endpoints"] : R;
-	type Options = API extends {
-		[key: string]: infer T;
-	}
-		? T extends Endpoint
-			? {
-					[key in T["options"]["method"] extends "GET"
-						? T["path"]
-						: `@${T["options"]["method"] extends string ? Lowercase<T["options"]["method"]> : never}${T["path"]}`]: T;
-				}
-			: {}
-		: {};
 
-	type O = Prettify<UnionToIntersection<Options>>;
-	return async <OPT extends O, K extends keyof OPT, C extends InferContext<OPT[K]>>(
-		path: K,
-		...options: HasRequired<C> extends true
-			? [
-					WithRequired<
-						BetterFetchOption<C["body"], C["query"], C["params"]>,
-						keyof RequiredOptionKeys<C>
-					>,
-				]
-			: [BetterFetchOption<C["body"], C["query"], C["params"]>?]
-	): Promise<
-		BetterFetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>
-	> => {
+	return async (path, ...options) => {
 		return (await fetch(path as string, {
 			...options[0],
 		})) as any;
 	};
-};
+}
+
+type FetchClientAPI<R extends Router | Router["endpoints"]> = R extends {
+	endpoints: Record<string, Endpoint>;
+}
+	? R["endpoints"]
+	: R;
+
+type FetchClientOptions<R extends Router | Router["endpoints"]> = FetchClientAPI<R> extends {
+	[key: string]: infer T;
+}
+	? T extends Endpoint
+		? {
+				[key in T["options"]["method"] extends "GET"
+					? T["path"]
+					: `@${T["options"]["method"] extends string ? Lowercase<T["options"]["method"]> : never}${T["path"]}`]: T;
+			}
+		: {}
+	: {};
+
+type FetchClientReturn<R extends Router | Router["endpoints"], Throw extends boolean> = <
+	OPT extends Prettify<UnionToIntersection<FetchClientOptions<R>>>,
+	K extends keyof OPT,
+	C extends InferContext<OPT[K]>,
+>(
+	path: K,
+	...options: HasRequired<C> extends true
+		? [
+				WithRequired<
+					BetterFetchOption<C["body"], C["query"], C["params"]>,
+					keyof RequiredOptionKeys<C>
+				>,
+			]
+		: [BetterFetchOption<C["body"], C["query"], C["params"]>?]
+) => Promise<
+	BetterFetchResponse<
+		Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>,
+		unknown,
+		Throw
+	>
+>;