So far so good

Author: lukasedw

packages/openapi-react-query/src/index.ts

@@ -3,6 +3,8 @@ import {
   type UseMutationResult,
   type UseQueryOptions,
   type UseQueryResult,
+  type InfiniteData,
+  type InfiniteQueryObserverResult,
   type UseInfiniteQueryOptions,
   type UseInfiniteQueryResult,
   type UseSuspenseQueryOptions,
@@ -103,34 +105,34 @@ export type UseInfiniteQueryMethod<Paths extends Record<string, Record<HttpMetho
     url: Path,
     ...[init, options, queryClient]: RequiredKeysOf<Init> extends never
         ? [
-          InitWithUnknowns<Init>?,
-          Omit<
-              UseInfiniteQueryOptions<
-                  Response["data"],
-                  Response["error"],
-                  Response["data"],
-                  number,
-                  QueryKey<Paths, Method, Path>
-              >,
-              "queryKey" | "queryFn"
-          >?,
-          QueryClient?,
+            InitWithUnknowns<Init>?,
+            Omit<
+                UseInfiniteQueryOptions<
+                    Response["data"],
+                    Response["error"],
+                    Response["data"],
+                    number,
+                    QueryKey<Paths, Method, Path>
+                >,
+                "queryKey" | "queryFn"
+            >?,
+            QueryClient?,
         ]
         : [
-          InitWithUnknowns<Init>,
-          Omit<
-              UseInfiniteQueryOptions<
-                  Response["data"],
-                  Response["error"],
-                  Response["data"],
-                  number,
-                  QueryKey<Paths, Method, Path>
-              >,
-              "queryKey" | "queryFn"
-          >?,
-          QueryClient?,
+            InitWithUnknowns<Init>,
+            Omit<
+                UseInfiniteQueryOptions<
+                    Response["data"],
+                    Response["error"],
+                    Response["data"],
+                    number,
+                    QueryKey<Paths, Method, Path>
+                >,
+                "queryKey" | "queryFn"
+            >?,
+            QueryClient?,
         ]
-) => UseInfiniteQueryResult<Response["data"], Response["error"]>;
+) => UseInfiniteQueryResult<InfiniteData<Response["data"]>, Response["error"]>;
 
 export type UseSuspenseQueryMethod<Paths extends Record<string, Record<HttpMethod, {}>>, Media extends MediaType> = <
   Method extends HttpMethod,

packages/openapi-react-query/test/fixtures/api.d.ts

@@ -4,6 +4,59 @@
  */
 
 export interface paths {
+    "/paginated-data": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query: {
+                    limit: number;
+                    cursor?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successful response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            items?: number[];
+                            nextPage?: number;
+                        };
+                    };
+                };
+                /** @description Error response */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code?: number;
+                            message?: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/comment": {
         parameters: {
             query?: never;

packages/openapi-react-query/test/fixtures/api.yaml

@@ -3,6 +3,44 @@ info:
   title: Test Specification
   version: "1.0"
 paths:
+  /paginated-data:
+    get:
+      parameters:
+        - in: query
+          name: limit
+          required: true
+          schema:
+            type: integer
+        - in: query
+          name: cursor
+          required: false
+          schema:
+            type: integer
+      responses:
+        '200':
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  items:
+                    type: array
+                    items:
+                      type: integer
+                  nextPage:
+                    type: integer
+        '500':
+          description: Error response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: integer
+                  message:
+                    type: string
   /comment:
     put:
       requestBody:

packages/openapi-react-query/test/index.test.tsx

@@ -822,4 +822,92 @@ describe("client", () => {
       });
     });
   });
+  describe("useInfiniteQuery", () => {
+    it("should fetch data correctly with pagination and include cursor", async () => {
+      const fetchClient = createFetchClient<paths>({ baseUrl });
+      const client = createClient(fetchClient);
+
+      // Track request URLs using the mock handler
+      let firstRequestUrl: URL | undefined;
+      let secondRequestUrl: URL | undefined;
+
+      // First page request handler
+      const firstRequestHandler = useMockRequestHandler({
+        baseUrl,
+        method: "get",
+        path: "/paginated-data",
+        status: 200,
+        body: { items: [1, 2, 3], nextPage: 1 },
+      });
+
+      const { result, rerender } = renderHook(
+        () => client.useInfiniteQuery("get", "/paginated-data",
+        {
+          params: {
+            query: {
+              limit: 3
+            }
+          }
+        },
+        {
+          getNextPageParam: (lastPage) => lastPage.nextPage,
+          initialPageParam: 0,
+        }),
+        { wrapper },
+      );
+
+      // Wait for initial query to complete
+      await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+      // Verify first request
+      firstRequestUrl = firstRequestHandler.getRequestUrl();
+      expect(firstRequestUrl?.searchParams.get('limit')).toBe('3');
+      expect(firstRequestUrl?.searchParams.get('cursor')).toBe('0');
+
+      // Set up mock for second page before triggering next page fetch
+      const secondRequestHandler = useMockRequestHandler({
+        baseUrl,
+        method: "get",
+        path: "/paginated-data",
+        status: 200,
+        body: { items: [4, 5, 6], nextPage: 2 },
+      });
+
+      // Fetch next page
+      await act(async () => {
+        await result.current.fetchNextPage();
+        // Force a rerender to ensure state is updated
+        rerender();
+      });
+
+      // Wait for second page to be fetched and verify loading states
+      await waitFor(() => {
+        expect(result.current.isFetching).toBe(false);
+        expect(result.current.hasNextPage).toBe(true);
+        expect(result.current.data?.pages).toHaveLength(2);
+      });
+
+      // Verify second request
+      secondRequestUrl = secondRequestHandler.getRequestUrl();
+      expect(secondRequestUrl?.searchParams.get('limit')).toBe('3');
+      expect(secondRequestUrl?.searchParams.get('cursor')).toBe('1');
+
+      expect(result.current.data).toBeDefined();
+      expect(result.current.data!.pages[0].nextPage).toBe(1);
+
+
+      expect(result.current.data).toBeDefined();
+      expect(result.current.data!.pages[1].nextPage).toBe(2);
+
+      // Verify the complete data structure
+      expect(result.current.data?.pages).toEqual([
+        { items: [1, 2, 3], nextPage: 1 },
+        { items: [4, 5, 6], nextPage: 2 }
+      ]);
+
+      // Verify we can access all items through pages
+      const allItems = result.current.data?.pages.flatMap(page => page.items);
+      expect(allItems).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+  })
 });