Fix types

Author: htunnicliff

.gitignore

@@ -132,3 +132,4 @@ dist
 # ----
 
 yarn.lock
+/generated/

package.json

@@ -26,22 +26,26 @@
   "scripts": {
     "prepublish": "npm run build && npm run types:check && npm run format:check",
     "build": "tsup",
+    "test": "./setup-test-data.sh && tsc --project test/tsconfig.json",
     "types:check": "tsc --noEmit",
     "format": "prettier --write .",
     "format:check": "prettier --check ."
   },
+  "dependencies": {
+    "openapi-typescript-helpers": "0.0.7"
+  },
   "devDependencies": {
     "@types/node": "20.11.19",
+    "expect-type": "0.17.3",
     "openapi-fetch": "0.9.2",
     "openapi-typescript": "6.7.4",
-    "openapi-typescript-helpers": "0.0.7",
     "prettier": "3.2.5",
     "swr": "2.2.5",
     "tsup": "7.2.0",
     "typescript": "5.2.2"
   },
   "peerDependencies": {
-    "openapi-fetch": ">=0.9",
+    "openapi-fetch": "0.9",
     "openapi-typescript": "6",
     "swr": "2",
     "typescript": "5"

pnpm-lock.yaml

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+./node_modules/.bin/openapi-typescript \
+  https://petstore3.swagger.io/api/v3/openapi.json \
+  --output ./generated/petstore.ts

setup-test-data.sh

@@ -1,6 +1,13 @@
-import type { FetchOptions } from "openapi-fetch";
 import type createClient from "openapi-fetch";
-import type { FilterKeys, PathsWithMethod } from "openapi-typescript-helpers";
+import type { FetchOptions, ParseAsResponse } from "openapi-fetch";
+import type {
+  ErrorResponse,
+  FilterKeys,
+  MediaType,
+  PathsWithMethod,
+  ResponseObjectMap,
+  SuccessResponse,
+} from "openapi-typescript-helpers";
 import useSWR, { type SWRConfiguration } from "swr";
 
 export function makeHookFactory<Paths extends {}>(
@@ -15,25 +22,32 @@ export function makeHookFactory<Paths extends {}>(
     // Define hook that is returned for consumers with typed options
     // based on the given path
     function useHook<
-      Options extends FetchOptions<FilterKeys<Paths[Path], "get">>,
-      Response extends Awaited<ReturnType<typeof api.GET<Path>>>
-    >(
-      fetchOptions: Options | null | undefined,
-      swrConfig?: SWRConfiguration<Response["data"], Response["error"]>
-    ) {
+      Req extends FilterKeys<Paths[Path], "get">,
+      Options extends FetchOptions<Req>,
+      Data extends ParseAsResponse<
+        FilterKeys<SuccessResponse<ResponseObjectMap<Req>>, MediaType>,
+        Options
+      >,
+      Error extends FilterKeys<
+        ErrorResponse<ResponseObjectMap<Req>>,
+        MediaType
+      >,
+    >(fetchOptions: Options | null, swrConfig?: SWRConfiguration<Data, Error>) {
       type Key = [typeof keyPrefix, Path, Options] | null;
 
-      return useSWR<Response["data"], Response["error"], Key>(
+      return useSWR<Data, Error, Key>(
         // SWR key is based on the path and fetch options
         // keyPrefix keeps each API's cache separate in case there are path collisions
         fetchOptions ? [keyPrefix, path, fetchOptions] : null,
         // Fetcher function
+        // @ts-expect-error - This functions correctly, but we don't need to fix its types
+        // types since we rely on the generics passed to useSWR instead
         async ([_, url, options]) => {
-          const { data, error } = await api.GET(url, options);
-          if (error) {
-            throw error;
+          const res = await api.GET(url, options);
+          if (res.error) {
+            throw res.error;
           }
-          return data;
+          return res.data;
         },
         // SWR config
         {

src/index.ts

@@ -0,0 +1,25 @@
+import createClient from "openapi-fetch";
+import type { paths } from "../petstore";
+import { makeHookFactory } from "../src/index";
+
+import { expectTypeOf } from "expect-type";
+
+const petStoreApi = createClient<paths>({
+  baseUrl: "https://petstore3.swagger.io/api/v3",
+});
+
+const petStoreHook = makeHookFactory<paths>(petStoreApi, "pet-store");
+
+const useOrder = petStoreHook("/store/order/{orderId}");
+
+const { data } = useOrder({
+  params: {
+    path: { orderId: 1 },
+  },
+});
+
+if (data) {
+  expectTypeOf(data).toEqualTypeOf<
+    paths["/store/order/{orderId}"]["get"]["responses"]["200"]["content"]["application/json"]
+  >();
+}

test/index.spec.ts

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "include": ["./src/**/*", "**/*"],
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "exclude": ["node_modules"]
+}