Merge pull request #331 from OpenAPI-Qraft/fix/resolve-response-fn

fix: ensure `resolveResponse` always resolves promises.

Author: radist2s

.changeset/eight-coats-brake.md

@@ -0,0 +1,9 @@
+---
+'@openapi-qraft/react': patch
+---
+
+Ensure `resolveResponse` always **resolves** promises.
+
+This change modifies the `resolveResponse` function to always return a resolved Promise
+rather than rejecting when no `responsePromise` is provided. This brings the function's
+behavior in line with the `requestFn` pattern, ensuring consistent error handling.

packages/react-client/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();
+  });
+});

packages/react-client/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(