@openapi-qraft/react 2.6.3 → 2.7.0

package/src/Unstable_QraftSecureRequestFn.ts

@@ -12,31 +12,29 @@ import { QueryClient, useQueries } from '@tanstack/react-query';
 import { createElement, Fragment, useEffect, useMemo } from 'react';
 import { jwtDecode } from './lib/jwt-decode/index.js';
 
-interface QraftSecureRequestFnBaseProps {
-  requestFn<TData, TError>(
-    schema: OperationSchema,
-    requestInfo: RequestFnInfo,
-    options?: RequestFnOptions
-  ): Promise<RequestFnResponse<TData, TError>>;
+type RequestFn = <TData, TError>(
+  schema: OperationSchema,
+  requestInfo: RequestFnInfo,
+  options?: RequestFnOptions
+) => Promise<RequestFnResponse<TData, TError>>;
+
+interface QraftSecureRequestFnBaseProps<TRequestFn extends RequestFn> {
+  requestFn: TRequestFn;
   securitySchemes: SecuritySchemeHandlers<string>;
 }
 
-type RequestFn = QraftSecureRequestFnBaseProps['requestFn'];
-
-export interface QraftSecureRequestFnProps
-  extends QraftSecureRequestFnBaseProps {
-  children(
-    secureRequestFn: QraftSecureRequestFnBaseProps['requestFn']
-  ): ReactNode;
+export interface QraftSecureRequestFnProps<TRequestFn extends RequestFn>
+  extends QraftSecureRequestFnBaseProps<TRequestFn> {
+  children(secureRequestFn: TRequestFn): ReactNode;
   queryClient?: QueryClient;
 }
 
-export function QraftSecureRequestFn({
+export function QraftSecureRequestFn<TRequestFn extends RequestFn>({
   children,
   requestFn,
   securitySchemes,
   queryClient: inQueryClient,
-}: QraftSecureRequestFnProps) {
+}: QraftSecureRequestFnProps<TRequestFn>) {
   const queryClient = useMemo(
     () =>
       inQueryClient ??
@@ -72,13 +70,13 @@ export function QraftSecureRequestFn({
   });
 }
 
-export const useSecuritySchemeAuth = ({
+export const useSecuritySchemeAuth = <TRequestFn extends RequestFn>({
   securitySchemes,
   requestFn,
   queryClient,
-}: QraftSecureRequestFnBaseProps & {
+}: QraftSecureRequestFnBaseProps<TRequestFn> & {
   queryClient: QueryClient;
-}): RequestFn => {
+}): TRequestFn => {
   useQueries(
     {
       queries: Object.entries(securitySchemes).map(([securitySchemeName]) => {
@@ -101,7 +99,7 @@ export const useSecuritySchemeAuth = ({
   return useMemo(
     () => createSecureRequestFn(securitySchemes, requestFn, queryClient),
     [securitySchemes, requestFn, queryClient]
-  );
+  ) as TRequestFn;
 };
 
 /**
@@ -113,11 +111,11 @@ export const useSecuritySchemeAuth = ({
  * @param requestFn Qraft `requestFn`
  * @param queryClient QueryClient instance.
  */
-export function createSecureRequestFn(
+export function createSecureRequestFn<TRequestFn extends RequestFn>(
   securitySchemes: SecuritySchemeHandlers<string>,
-  requestFn: RequestFn,
+  requestFn: TRequestFn,
   queryClient: QueryClient
-): RequestFn {
+): TRequestFn {
   return async function secureRequestFn(
     schema: OperationSchema,
     requestInfo: RequestFnInfo,
@@ -147,7 +145,7 @@ export function createSecureRequestFn(
       ),
       options
     );
-  };
+  } as TRequestFn;
 }
 
 /**
@@ -174,14 +172,25 @@ async function createSecureRequestInfo(
 ): Promise<RequestFnInfo> {
   const prevSecurityResult = queryClient.getQueryData<SecurityScheme>(queryKey);
 
-  const securityResult = await queryClient.fetchQuery({
-    queryKey,
-    queryFn: ({ signal }) =>
-      handler({
-        signal,
-        isRefreshing: Boolean(prevSecurityResult),
-      }),
-  });
+  const abortQuery = () => queryClient.cancelQueries({ queryKey, exact: true });
+
+  requestInfo.signal?.addEventListener('abort', abortQuery);
+
+  const securityResult = await queryClient
+    .fetchQuery({
+      queryKey,
+      queryFn: ({ signal }) =>
+        handler({
+          signal,
+          isRefreshing: Boolean(prevSecurityResult),
+        }),
+    })
+    .catch((error) => {
+      throw requestInfo.signal?.aborted ? requestInfo.signal.reason : error;
+    })
+    .finally(
+      () => void requestInfo.signal?.removeEventListener('abort', abortQuery)
+    );
 
   if (!shallowEqualObjects(securityResult, prevSecurityResult)) {
     const securityRefreshInterval = getSecurityRefreshInterval(securityResult);

package/src/callbacks/useMutation.ts

@@ -59,7 +59,6 @@ export const useMutation: <
     {
       ...options,
       mutationKey,
-      // @ts-expect-error - Too complex to type
       mutationFn:
         options?.mutationFn ??
         (parameters

package/src/lib/__tests__/responseUtils.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+import { resolveResponse } from '../responseUtils.js';
+
+describe('resolveResponse', () => {
+  it('should handle Error without promise', async () => {
+    const testError = new Error('Test error');
+
+    const result = await resolveResponse<unknown, Error>(testError);
+
+    expect(result).toEqual({
+      error: testError,
+      response: undefined,
+      data: undefined,
+    });
+  });
+
+  it('should handle Response without promise', async () => {
+    const mockResponse = new Response(null);
+
+    // We use casting to bypass type checking, since we know that the function accepts Response
+    // without a promise in the implementation, although types do not allow it directly.
+    const result = await (resolveResponse as any)(mockResponse);
+
+    expect(result).toEqual({
+      error: expect.any(Error),
+      response: mockResponse,
+      data: undefined,
+    });
+    expect((result.error as Error).message).toBe(
+      'Unhandled response without promise to resolve'
+    );
+  });
+
+  it('should resolve promise with data and response', async () => {
+    const mockResponse = new Response(null);
+    const testData = { test: 'data' };
+    const dataPromise = Promise.resolve(testData);
+
+    const result = await resolveResponse<typeof testData, Error>(
+      mockResponse,
+      dataPromise
+    );
+
+    expect(result).toEqual({
+      data: testData,
+      response: mockResponse,
+      error: undefined,
+    });
+  });
+
+  it('should handle rejected promise with error and response', async () => {
+    const mockResponse = new Response(null);
+    const testError = new Error('Test rejection');
+    const dataPromise = Promise.reject(testError);
+
+    const result = await resolveResponse<unknown, Error>(
+      mockResponse,
+      dataPromise
+    );
+
+    expect(result).toEqual({
+      error: testError,
+      response: mockResponse,
+      data: undefined,
+    });
+  });
+
+  it('should handle custom error objects in rejected promise', async () => {
+    const mockResponse = new Response(null);
+    type CustomError = { code: string; message: string };
+    const customError: CustomError = {
+      code: 'CUSTOM_ERROR',
+      message: 'Custom error object',
+    };
+    const dataPromise = Promise.reject(customError);
+
+    const result = await resolveResponse<unknown, CustomError>(
+      mockResponse,
+      dataPromise
+    );
+
+    expect(result).toEqual({
+      error: customError,
+      response: mockResponse,
+      data: undefined,
+    });
+  });
+
+  it('should preserve response object when promise resolves', async () => {
+    const headers = new Headers();
+    headers.append('Content-Type', 'application/json');
+    const mockResponse = new Response('{"key":"value"}', { headers });
+    const testData = { key: 'value' };
+    const dataPromise = Promise.resolve(testData);
+
+    const result = await resolveResponse<typeof testData, Error>(
+      mockResponse,
+      dataPromise
+    );
+
+    expect(result.response).toBe(mockResponse);
+    expect(result.data).toEqual(testData);
+    expect(result.error).toBeUndefined();
+  });
+});

package/src/lib/responseUtils.ts

@@ -49,12 +49,21 @@ export function resolveResponse<TData, TError>(
   responseToReturn: Response | Error,
   responsePromise?: Promise<TData>
 ): Promise<RequestFnResponse<TData, TError>> {
-  if (!responsePromise)
-    return Promise.reject({
-      error: responseToReturn,
-      response: undefined,
-      data: undefined,
-    });
+  if (!responsePromise) {
+    if (responseToReturn instanceof Response) {
+      return Promise.resolve({
+        error: new Error('Unhandled response without promise to resolve'),
+        response: responseToReturn,
+        data: undefined,
+      });
+    } else {
+      return Promise.resolve({
+        error: responseToReturn,
+        response: undefined,
+        data: undefined,
+      });
+    }
+  }
 
   return responsePromise
     .then(

package/src/qraftAPIClient.ts

@@ -10,10 +10,10 @@ import type {
 import { createRecursiveProxy } from './lib/createRecursiveProxy.js';
 
 export interface CreateAPIBasicClientOptions {
-  requestFn<TData, TError>(
+  requestFn: (
     schema: OperationSchema,
     requestInfo: RequestFnInfo
-  ): Promise<RequestFnResponse<TData, TError>>;
+  ) => Promise<RequestFnResponse<any, any>>;
   baseUrl: string;
 }