catch-match 2.0.1 → 3.0.0

package/README.md

@@ -39,6 +39,10 @@ try {
 //> final
 ```
 
+## Features
+
+Supporting sync/async functions
+
 ## Getting started
 
 ```shell
@@ -100,3 +104,46 @@ const result = $try(() => {
 
 console.log(result); // { error: SyntaxError, result: undefined }
 ```
+
+## Promises example
+
+```typescript
+class AuthError extends Error {}
+
+function proc(event: string) {
+  return $try(() => new Promise((resolve, reject) => {
+    switch (event) {
+      case 'resolve':
+        resolve('resolved')
+        break;
+      case 'reject':
+        reject('rejected')
+        break;
+      case 'syntax':
+        throw SyntaxError
+      case 'auth':
+        throw AuthError
+      case 'error':
+        throw 'error'
+      default:
+        throw 'other errors'
+    }
+  }).catch('error', () => {
+    // console.log('error')
+  }).catch([SyntaxError, AuthError], (error) => {
+    // console.log(error)
+  }).other((error) => {
+    // console.log(error)
+  }).finally(({ value, error }) => {
+    // console.log({ value, error })
+  })
+}
+
+await proc('resolve') // { value: 'resolved' }}
+await proc('reject')  // { error: 'rejected' }
+
+await proc('syntax')  // { error: SyntaxError }
+await proc('auth')    // { error: AuthError }
+await proc('error')   // { error: 'error' }
+await proc('other')   // { error: 'other errors' }
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catch-match",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "repository": {
     "url": "https://github.com/kobzarvs/catch-match"
   },
@@ -12,7 +12,13 @@
     "errors",
     "exceptions",
     "throw",
-    "finally"
+    "finally",
+    "promises",
+    "resolve",
+    "reject",
+    "flow",
+    "control",
+    "process"
   ],
   "main": "dist/main.js",
   "scripts": {

package/src/__tests__/main.test.ts

@@ -1,223 +1,502 @@
-import $try from '../main';
-
-test('should be return result from `finally` branch', () => {
-  let matchReferenceError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
-
-  const result = $try(() => {
-    return [1, 2, 3];
-  }).catch(ReferenceError, () => {
-    matchReferenceError();
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
-  }).other((error) => {
-    matchOther(error);
-  }).finally(({ result, error }) => {
-    matchFinally({ result, error });
-    return result;
-  });
-
-  expect(matchReferenceError).not.toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).toBeCalled();
-  expect(result).toEqual({ error: undefined, result: [1, 2, 3] });
-});
-
-test('should be match single exception', () => {
-  let matchReferenceError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
-
-  const result = $try(() => {
-    throw ReferenceError;
-  }).catch(ReferenceError, () => {
-    matchReferenceError();
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
-  }).other((error) => {
-    matchOther(error);
-  }).finally(({ result, error }) => {
-    matchFinally({ result, error });
-    return result;
-  });
-
-  expect(matchReferenceError).toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).toBeCalled();
-  expect(result).toEqual({ error: ReferenceError, result: undefined });
-});
-
-test('should be match array of exceptions', () => {
-  let matchReferenceError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
-
-  const result = $try(() => {
-    throw SyntaxError;
-  }).catch(ReferenceError, () => {
-    matchReferenceError();
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
-  }).other((error) => {
-    matchOther(error);
-  }).finally(({ result, error }) => {
-    matchFinally({ result, error });
-    return result;
-  });
-
-  expect(matchReferenceError).not.toBeCalled();
-  expect(matchArrayOfErrors).toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).toBeCalled();
-  expect(result).toEqual({ error: SyntaxError, result: undefined });
-});
-
-test('should be match any type of exception', () => {
-  let matchReferenceError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
-
-  const result = $try(() => {
-    throw 'error';
-  }).catch(ReferenceError, () => {
-    matchReferenceError();
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
-  }).other((error) => {
-    matchOther(error);
-  }).finally(({ result, error }) => {
-    matchFinally({ result, error });
-    return result;
-  });
-
-  expect(matchReferenceError).not.toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).toBeCalled();
-  expect(matchFinally).toBeCalled();
-  expect(result).toEqual({ error: 'error', result: undefined });
-});
-
-test('should be match custom exceptions', () => {
-  let matchCustomError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
-
-  class CustomError extends Error {
-  }
-
-  const result = $try(() => {
-    throw CustomError;
-  }).catch(CustomError, () => {
-    matchCustomError();
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
-  }).other((error) => {
-    matchOther(error);
-  }).finally(({ result, error }) => {
-    matchFinally({ result, error });
-    return result;
-  });
-
-  expect(matchCustomError).toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).toBeCalled();
-  expect(result).toEqual({ error: CustomError, result: undefined });
-});
-
-test('should be return result from `finally` branch without `other`', () => {
-  let matchCustomError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
-
-  class CustomError extends Error {
-  }
-
-  const result = $try(() => {
-    throw CustomError;
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
-  }).finally(({ result, error }) => {
-    matchFinally({ result, error });
-    return result;
-  });
-
-  expect(matchCustomError).not.toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).toBeCalled();
-  expect(result).toEqual({ error: CustomError, result: undefined });
-});
-
-
-test('should be return result from `catch` branch', () => {
-  let matchCustomError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
+import $try, { PromisedTryReturn } from '../main';
+
+describe('sync version', () => {
+  test('should be return result from `finally` branch', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return [1, 2, 3];
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => { //?
+      matchFinally({ value, error });
+    });
+
+    expect(matchReferenceError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: undefined, value: [1, 2, 3] });
+  });
 
-  class CustomError extends Error {
-  }
+  test('should be match single exception', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw ReferenceError;
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchReferenceError).toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: ReferenceError, value: undefined });
+  });
 
-  const result = $try(() => {
-    throw CustomError;
-  }).catch([TypeError, SyntaxError], () => {
-    matchArrayOfErrors();
+  test('should be match array of exceptions', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw SyntaxError;
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchReferenceError).not.toBeCalled();
+    expect(matchArrayOfErrors).toBeCalledWith(SyntaxError);
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: SyntaxError, value: undefined });
   });
 
-  expect(matchCustomError).not.toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).not.toBeCalled();
-  expect(result).toMatchObject({ error: CustomError, result: undefined });
-});
+  test('should be match any type of exception', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw 'error';
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchReferenceError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: 'error', value: undefined });
+  });
 
+  test('should be match custom exceptions', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).catch(CustomError, () => {
+      matchCustomError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+    });
+
+    expect(matchCustomError).toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
 
-test('should be return result from `other` branch', () => {
-  let matchCustomError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
+  test('should be return result from `finally` branch without `other`', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
 
-  class CustomError extends Error {
-  }
+  test('should be return result from `catch` branch', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
 
-  const result = $try(() => {
-    throw CustomError;
-  }).other((error) => {
-    matchOther(error);
+  test('should be return result from `other` branch', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).toBeCalledWith(CustomError);
+    expect(matchFinally).not.toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
   });
 
-  expect(matchCustomError).not.toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).toBeCalledWith(CustomError);
-  expect(matchFinally).not.toBeCalled();
-  expect(result).toMatchObject({ error: CustomError, result: undefined });
+  test('should be return result without branches', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw SyntaxError;
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+    expect(result).toMatchObject({ error: SyntaxError, value: undefined });
+  });
 });
 
+/**
+ * async tests
+ */
+describe('promised version', () => {
+  test('resolve try', async () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return Promise.resolve(42);
+    });
+
+    await result;
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: 42,
+      error: undefined,
+    });
+  });
+  test('reject try', async () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return Promise.reject(42);
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 42,
+    });
+  });
+  test('throw try', async () => {
+    const result = $try(() => {
+      return new Promise(() => {
+        throw new Error('error');
+      });
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+
+    expect(await result).toEqual({
+      value: undefined,
+      error: Error('error'),
+    });
+  });
 
-test('should be return result without branches', () => {
-  let matchCustomError = jest.fn();
-  let matchArrayOfErrors = jest.fn();
-  let matchOther = jest.fn();
-  let matchFinally = jest.fn();
+  test('resolve try.catch', async () => {
+    let matchError = jest.fn();
+    let matchSyntaxError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return Promise.resolve(42);
+    }).catch(Error, () => {
+      matchError();
+    }).catch(SyntaxError, () => {
+      matchSyntaxError();
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(matchError).not.toBeCalled();
+    expect(matchSyntaxError).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: 42,
+      error: undefined,
+    });
+  });
+  test('reject try.catch', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return Promise.reject(123);
+    }).catch(Error, () => {
+      matchOther();
+    }).catch(123, () => {
+      matchError();
+    }).catch('error', () => {
+      matchOther();
+    });
+
+    await result; //?
+
+    expect(matchOther).not.toBeCalled();
+    expect(matchError).toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 123,
+    });
+  });
+  test('throw try.catch', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return new Promise(() => {
+        throw 'error';
+      });
+    }).catch(Error, () => {
+      matchOther();
+    }).catch(123, () => {
+      matchError();
+    }).catch('error', () => {
+      matchOther();
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 'error',
+    });
+
+    expect(matchOther).toBeCalledTimes(1);
+    expect(matchError).not.toBeCalled();
+  });
 
-  const result = $try(() => {
-    throw SyntaxError;
+  test('resolve try.other', async () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return Promise.resolve('ok');
+    }).other(({ value, error }) => {
+      matchOther({ value, error });
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: 'ok',
+      error: undefined,
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+  });
+  test('reject try.other', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return Promise.reject('error');
+    }).catch('error1', () => {
+      matchError();
+    }).catch('error2', () => {
+      matchError();
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 'error',
+    });
+
+    expect(matchError).not.toBeCalled();
+    expect(matchOther).toBeCalledWith('error');
+  });
+  test('throw try.other', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return new Promise(() => {
+        throw 'error';
+      });
+    }).catch('error1', () => {
+      matchError();
+    }).catch('error2', () => {
+      matchError();
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 'error',
+    });
+
+    expect(matchError).not.toBeCalled();
+    expect(matchOther).toBeCalledWith('error');
   });
 
-  expect(matchCustomError).not.toBeCalled();
-  expect(matchArrayOfErrors).not.toBeCalled();
-  expect(matchOther).not.toBeCalled();
-  expect(matchFinally).not.toBeCalled();
-  expect(result).toMatchObject({ error: SyntaxError, result: undefined });
+  test('when throw should be match array or exception', async () => {
+    let matchSingleError = jest.fn();
+    let matchArrayError = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const attach = (ctx: PromisedTryReturn<any>) => {
+      return ctx.catch(SyntaxError, () => {
+        matchSingleError(SyntaxError);
+      }).catch([ReferenceError, SyntaxError], (error) => {
+        matchArrayError(error);
+      }).other((error) => {
+        matchOther(error);
+      }).finally(({ value, error }) => {
+        matchFinally({ value, error });
+      });
+    };
+
+    const testSingle = $try(() => new Promise(() => {
+      throw SyntaxError;
+    }));
+
+    const testArray = $try(() => new Promise(() => {
+      throw ReferenceError;
+    }));
+
+    const testOther = $try(() => new Promise(() => {
+      throw TypeError;
+    }));
+
+    const testResolve = $try(() => new Promise((resolve) => {
+      resolve('ok');
+    }));
+
+    const testReject = $try(() => new Promise((_, reject) => {
+      reject('reject');
+    }));
+
+    const resultSingle = attach(testSingle);
+    const resultArray = attach(testArray);
+    const resultOther = attach(testOther);
+    const resultResolve = attach(testResolve);
+    const resultReject = attach(testReject);
+
+    expect(resultSingle).toBeInstanceOf(Promise);
+    expect(resultArray).toBeInstanceOf(Promise);
+    expect(resultOther).toBeInstanceOf(Promise);
+    expect(resultResolve).toBeInstanceOf(Promise);
+    expect(resultReject).toBeInstanceOf(Promise);
+
+    expect(await resultSingle).toEqual({
+      value: undefined,
+      error: SyntaxError,
+    });
+    expect(await resultArray).toEqual({
+      value: undefined,
+      error: ReferenceError,
+    });
+    expect(await resultOther).toEqual({
+      value: undefined,
+      error: TypeError,
+    });
+    expect(await resultResolve).toEqual({
+      value: 'ok',
+    });
+    expect(await resultReject).toEqual({
+      error: 'reject',
+    });
+  });
 });

package/src/main.ts

@@ -1,71 +1,127 @@
-export type ResultType<Rsult, ErrorType> = {
-  result?: Rsult;
-  error?: ErrorType;
-};
+export type ErrrorHandler<ErrorType> = (error?: ErrorType) => void
 
-export type ErrrorHandler<ErrorType> = (error?: ErrorType) => void;
+export type FinallyCallback<Result, ErrorType = any> = (params: ResultType<Result, ErrorType>) => void
 
-export type FinallyCallback<Result, ErrorType> = ((params: ResultType<Result, ErrorType>) => Result | void | undefined);
+export type TryBody<Result> = () => Result | Promise<Result> | never
 
-export type TryReturn<Result, ErrorType = any> = {
-  catch: (error: ErrorType | ErrorType[], handler: ErrrorHandler<ErrorType>) => TryReturn<Result, ErrorType>;
-  other: (handler: ErrrorHandler<ErrorType>) => Pick<TryReturn<Result, ErrorType>, 'finally'>,
-  finally: (callback?: FinallyCallback<Result, ErrorType>) => ResultType<Result, ErrorType>,
-  result: Result,
-  error: ErrorType
+export type ResultType<Result, ErrorType = any> = {
+  value?: Result;
+  error?: ErrorType;
 }
 
-export type TryBody<Result> = () => Result | never;
+export type FinallyReturn<Return, ErrorType = any> =
+  ResultType<Return, ErrorType>
+
+export type OtherReturn<Return, ErrorType = any> =
+  FinallyReturn<Return, ErrorType> &
+  {
+    finally: (callback: FinallyCallback<Return, ErrorType>) => ResultType<Return, ErrorType>
+  }
+
+export type CatchReturn<Return, ErrorType = any> =
+  FinallyReturn<Return, ErrorType> &
+  OtherReturn<Return, ErrorType> &
+  {
+    catch: (error: ErrorType | ErrorType[], handler: ErrrorHandler<ErrorType>) => TryReturn<Return, ErrorType>;
+    other: (handler: ErrrorHandler<ErrorType>) => Pick<TryReturn<Return, ErrorType>, 'finally' | 'value' | 'error'>,
+  }
+
+export type TryReturn<Return, ErrorType = any> =
+  CatchReturn<Return, ErrorType>
 
-export function $try<Return>(body: TryBody<Return>): TryReturn<Return> {
+export type PromisedTryReturn<Return> =
+  TryReturn<Return> |
+  (Promise<ResultType<Return>> & TryReturn<Return>)
+
+export function $try<Return>(body: TryBody<Return>): PromisedTryReturn<Return> {
   let caught = false;
-  let error: any | { constructor?: any; };
-  let result: Return | any;
-  const isSameInstance = (e1: any) => e1 === error || e1 === error?.constructor;
+  let error: any | { constructor?: any; } | Promise<any | { constructor?: any; }>;
+  let bodyResponse: Return | Promise<Return>;
+  let result: PromisedTryReturn<Return>;
 
-  try {
-    result = body();
-  } catch (e) {
-    error = e;
+  const isSameError = (e1: any, error: any) => e1 === error || e1 === error?.constructor;
+
+  function handleErrors(err: any[], err2: any, handler: { (error?: any): void; (error?: any): void; (): any }) {
+    if (isSameError(err, err2) || (Array.isArray(err) && err.some(e => isSameError(e, err2)))) {
+      handler(err2);
+      caught = true;
+    }
   }
 
-  const chain: TryReturn<typeof result, typeof error> = {
+  function buildResult(br: typeof bodyResponse): ResultType<Return> | Promise<ResultType<Return>> {
+    if (br instanceof Promise) {
+      const bodyPromise = br as Promise<Return>;
+      return new Promise<ResultType<Return>>(async (resolve) => {
+        bodyPromise.then((response: any) => {
+          resolve({
+            value: response,
+            error: undefined,
+          });
+        }).catch((e: any) => {
+          resolve({
+            value: undefined,
+            error: e,
+          });
+        });
+      });
+    } else {
+      return {
+        value: br,
+        error: undefined,
+      };
+    }
+  }
+
+  const chain: TryReturn<Return, typeof error> = {
     catch: (err, handler) => {
-      if (!err || !handler) {
-        return chain;
+      if (result instanceof Promise) {
+        result.then((response) => {
+          typeof response.error !== 'undefined' && !caught && handleErrors(err, response.error, handler);
+        });
+      } else {
+        error && !caught && handleErrors(err, error, handler);
       }
-      if (isSameInstance(err)) {
-        handler && handler();
-        caught = true;
-      } else if (Array.isArray(err) && err.some(isSameInstance)) {
-        handler && handler();
-        caught = true;
-      }
-      return chain;
+      return result;
     },
 
-    other: (handler) => {
-      if (!caught && error) {
-        handler && handler(error);
+    other: (callback) => {
+      if (result instanceof Promise) {
+        result.then((response) => {
+          typeof response.error !== 'undefined' && !caught && callback(response.error);
+        });
+      } else {
+        typeof result.error !== 'undefined' && !caught && callback && callback(result.error);
       }
-      return {
-        finally: chain.finally,
-        result,
-        error,
-      };
+      return result;
     },
 
-    finally: (callback?) => {
-      return {
-        result: callback ? callback({ result, error }) : result,
-        error,
-      };
+    finally: (callback) => {
+      if (result instanceof Promise) {
+        result.then((response) => {
+          callback(response);
+        });
+      } else {
+        callback({
+          value: result.value,
+          error: result.error,
+        });
+      }
+      return result;
     },
-    result,
-    error,
   };
 
-  return chain;
+  try {
+    bodyResponse = body();
+    result = Object.assign(buildResult(bodyResponse), chain);
+  } catch (e) {
+    error = e;
+    result = Object.assign(chain, {
+      value: undefined,
+      error: e,
+    });
+  }
+
+  return result;
 }
 
 export default $try;