feat(utils): Added as-uncaught-error helper

Author: hrajchert

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acamica/task",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Promise replacement made with TypeScript more suitable for functional programming and error handling",
   "keywords": [
     "async",

src/index.ts

@@ -1,2 +1,2 @@
-export * from './case-error';
+export * from './utils';
 export * from './task';

src/task.ts

@@ -44,7 +44,7 @@ export class Task <T, E> {
         });
     }
 
-    static fromPromise<TResult> (promise: Promise<TResult>): Task<TResult, any> {
+    static fromPromise<TResult, EResult = any> (promise: Promise<TResult>): Task<TResult, EResult> {
         return new Task((outerResolve, outerReject) => {
             promise.then(outerResolve, err => outerReject(err));
         });

src/utils/as-uncaught-error.ts

@@ -0,0 +1,4 @@
+import { Task, UncaughtError } from '../task';
+export function asUncaughtError (error: any): Task<never, UncaughtError> {
+    return Task.reject(new UncaughtError(error));
+}

src/utils/index.ts

@@ -1 +1,2 @@
 export * from './case-error';
+export * from './as-uncaught-error';

test/task.test.ts

@@ -124,6 +124,7 @@ describe('Task', () => {
             );
 
         });
+
         it('Should work with rejected promises', (cb) => {
             // GIVEN: A task created from a rejected promise
             const resolved = Task.fromPromise(Promise.reject('buu'));
@@ -134,6 +135,32 @@ describe('Task', () => {
                 jestAssertNever(cb)
             );
         });
+
+        it('Should mantain any error when changed', (cb) => {
+            // GIVEN: A task created from a rejected promise
+            const task = Task.fromPromise(Promise.reject('buu'));
+
+            // WHEN: we chain it with some value
+            const result = task.chain(_ => Task.resolve(0));
+            // THEN: the task type should be Task<number, any> (check manually?)
+
+            // and the error should be the same
+            result.fork(
+                assertFork(cb, x => expect(x).toBe('buu')),
+                jestAssertUntypedNeverCalled(cb)
+            );
+        });
+
+        it('Should be able to set rejected type', (cb) => {
+            // GIVEN: A task created from a rejected promise
+            const resolved = Task.fromPromise<never, string>(Promise.reject('buu'));
+
+            // WHEN: we fork, THEN: it should call the error function with the rejected value
+            resolved.fork(
+                assertFork(cb, x => expect(x).toBe('buu')),
+                jestAssertNever(cb)
+            );
+        });
     });
     describe('chain', () => {
         it('Should handle functions that succeed', (cb) => {

test/utils/as-uncaught-error.test.ts

@@ -0,0 +1,20 @@
+import { Task, UncaughtError } from '../../src/task';
+import { asUncaughtError } from '../../src/utils/as-uncaught-error';
+import { assertFork, jestAssertNever, jestAssertUntypedNeverCalled } from '../jest-helper';
+
+describe('asUncaughtError', () => {
+    it('Should catch any error', (cb) => {
+        // GIVEN: A task created from a rejected promise (with any error type)
+        const task = Task.fromPromise(Promise.reject('something'));
+
+        // WHEN: We catch it as an UncaughtError
+        const result = task.catch(asUncaughtError);
+
+        // THEN: The Task is rejected with an UncaughtError and the types get more specific
+        //       than any
+        result.fork(
+            assertFork(cb, err => expect(err).toBeInstanceOf(UncaughtError)),
+            jestAssertNever(cb)
+        );
+    });
+});

test/utils/case-error.test.ts

@@ -39,7 +39,7 @@ const divideAndRejectPairs = (numerator: number, denominator: number) =>
 
 
 
-describe.only('caseError:', () => {
+describe('caseError:', () => {
     it('Should catch and resolve the cased error', (cb) => {
         // GIVEN: A task that fails with DivisionByZeroError
         const task = divideAndRejectPairs(2, 0);