better compatibility with promiseLike and synchronous functions, catch errors thrown synchronously

see #24

Author: slorber

src/index.ts

@@ -246,36 +246,32 @@ const useAsyncInternal = <R = UnknownResult, Args extends any[] = UnknownArgs>(
     isMounted() && CurrentPromise.is(p);
 
   const executeAsyncOperation = (...args: Args): Promise<R> => {
-    const promise: MaybePromise<R> = asyncFunction(...args);
+    // async ensures errors thrown synchronously are caught (ie, bug when formatting api payloads)
+    // async ensures promise-like and synchronous functions are handled correctly too
+    // see https://github.com/slorber/react-async-hook/issues/24
+    const promise: Promise<R> = (async () => asyncFunction(...args))();
     setCurrentParams(args);
-    if (promise instanceof Promise) {
-      CurrentPromise.set(promise);
-      AsyncState.setLoading();
-      promise.then(
-        result => {
-          if (shouldHandlePromise(promise)) {
-            AsyncState.setResult(result);
-          }
-          normalizedOptions.onSuccess(result, {
-            isCurrent: () => CurrentPromise.is(promise),
-          });
-        },
-        error => {
-          if (shouldHandlePromise(promise)) {
-            AsyncState.setError(error);
-          }
-          normalizedOptions.onError(error, {
-            isCurrent: () => CurrentPromise.is(promise),
-          });
+    CurrentPromise.set(promise);
+    AsyncState.setLoading();
+    promise.then(
+      result => {
+        if (shouldHandlePromise(promise)) {
+          AsyncState.setResult(result);
         }
-      );
-      return promise;
-    } else {
-      // We allow passing a non-async function (mostly for useAsyncCallback convenience)
-      const syncResult: R = promise;
-      AsyncState.setResult(syncResult);
-      return Promise.resolve<R>(syncResult);
-    }
+        normalizedOptions.onSuccess(result, {
+          isCurrent: () => CurrentPromise.is(promise),
+        });
+      },
+      error => {
+        if (shouldHandlePromise(promise)) {
+          AsyncState.setError(error);
+        }
+        normalizedOptions.onError(error, {
+          isCurrent: () => CurrentPromise.is(promise),
+        });
+      }
+    );
+    return promise;
   };
 
   const getLatestExecuteAsyncOperation = useGetter(executeAsyncOperation);

test/useAsync.test.ts

@@ -46,6 +46,30 @@ describe('useAync', () => {
     expect(onError).not.toHaveBeenCalled();
   });
 
+  it('should resolve a successful Jest mocked resolved value', async () => {
+    const onSuccess = jest.fn();
+    const onError = jest.fn();
+
+    const asyncFunction = jest.fn().mockResolvedValue(fakeResults);
+
+    const { result, waitForNextUpdate } = renderHook(() =>
+      useAsync(asyncFunction, [], {
+        onSuccess: () => onSuccess(),
+        onError: () => onError(),
+      })
+    );
+
+    expect(result.current.loading).toBe(true);
+
+    await waitForNextUpdate();
+
+    expect(result.current.result).toEqual(fakeResults);
+    expect(result.current.loading).toBe(false);
+    expect(result.current.error).toBeUndefined();
+    expect(onSuccess).toHaveBeenCalled();
+    expect(onError).not.toHaveBeenCalled();
+  });
+
   // TODO legacy: should we remove this behavior?
   it('should resolve a successful synchronous request', async () => {
     const onSuccess = jest.fn();