added result property to AsyncTask #1

Author: jetako

packages/mst-async-task/.eslintrc.js

@@ -50,6 +50,7 @@ module.exports = {
     'no-trailing-spaces': 0,
     'quotes': [0, 'single', 'avoid-escape'],
 
+    '@typescript-eslint/explicit-module-boundary-types': 0,
     '@typescript-eslint/no-explicit-any': 0,
     '@typescript-eslint/no-unused-vars': [1, { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }]
   }

packages/mst-async-task/__tests__/runTask.test.ts

@@ -50,6 +50,7 @@ describe('runTask()', () => {
               throw new Error('failed')
             }
             exec(() => self.value = 'ok')
+            return 'result'
           }),
           runNoSignal: () => runTask(self.task, function*({ exec }) {
             yield sleep()
@@ -76,7 +77,9 @@ describe('runTask()', () => {
       expect(result).toBeInstanceOf(AsyncTaskResult)
       expect(result.status).toBe(AsyncTaskStatus.COMPLETE)
       expect(result.error).toBeUndefined()
+      expect(result.value).toBe('result')
       expect(store.task.status).toBe(AsyncTaskStatus.COMPLETE)
+      expect(store.task.result).toBe('result')
       expect(store.value).toBe('ok')
     })
 
@@ -96,6 +99,7 @@ describe('runTask()', () => {
       await promise
       store.task.reset()
       expect(store.task.status).toBe(AsyncTaskStatus.INIT)
+      expect(store.task.result).toBeUndefined()
     })
 
     it('aborts the task when abort() is called while pending', async () => {

packages/mst-async-task/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mst-async-task",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Manage the lifecycles of asynchronous flows in Mobx-State-Tree",
   "main": "dist/mst-async-task.js",
   "umd:main": "dist/mst-async-task.umd.js",

packages/mst-async-task/src/AsyncTask.ts

@@ -17,7 +17,8 @@ export const AsyncTask = types
       ]),
       AsyncTaskStatus.INIT
     ),
-    error: types.maybe(types.frozen<Error>())
+    error: types.maybe(types.frozen<Error>()),
+    result: types.maybe(types.frozen<any>())
   })
   .views(self => {
     return {
@@ -62,14 +63,16 @@ export const AsyncTask = types
       abort()
       self.status = AsyncTaskStatus.INIT
       self.error = undefined
+      self.result = undefined
     }
 
     /**
      * Used internally by `runTask()`. This should not be called directly.
      */
-    const _resolve = (status: AsyncTaskStatus, error?: Error) => {
+    const _resolve = (status: AsyncTaskStatus, error?: Error, result?: any) => {
       self.status = status
       self.error = error
+      self.result = result
       delete (self as IAsyncTask)._abortController
     }
 

packages/mst-async-task/src/lib.ts

@@ -9,10 +9,12 @@ export enum AsyncTaskStatus {
 export class AsyncTaskResult {
   status: AsyncTaskStatus
   error?: Error
+  value?: any
 
-  constructor(status: AsyncTaskStatus, error?: Error) {
+  constructor(status: AsyncTaskStatus, error?: Error, value?: any) {
     this.status = status
     this.error = error
+    this.value = value
   }
 }
 

packages/mst-async-task/src/runTask.ts

@@ -109,9 +109,9 @@ export async function runTask(
         }
 
         return result
-      } catch (error) {
+      } catch (err) {
         parentAbortSignal = null
-        throw error
+        throw err
       }
     }
 
@@ -122,10 +122,10 @@ export async function runTask(
   task.error = undefined
   task._abortController = abortController
 
-  const [status, error]: [AsyncTaskStatus, Error?] = await new Promise(async resolve => {
-    const done = (result: [AsyncTaskStatus, Error?]) => {
+  const [status, error, result]: [AsyncTaskStatus, Error?, any?] = await new Promise(async resolve => {
+    const done = (args: [AsyncTaskStatus, Error?, any?]) => {
       signal.removeEventListener('abort', abortHandler)
-      resolve(result)
+      resolve(args)
     }
 
     const abortHandler = () => {
@@ -142,20 +142,20 @@ export async function runTask(
     signal.addEventListener('abort', abortHandler)
 
     try {
-      await flow(generator)({ signal, exec })
-      done([AsyncTaskStatus.COMPLETE])
-    } catch (error) {
-      if (error instanceof AsyncTaskAbortError) {
-        done([AsyncTaskStatus.ABORTED, error])
+      const result = await flow(generator)({ signal, exec })
+      done([AsyncTaskStatus.COMPLETE, undefined, result])
+    } catch (err) {
+      if (err instanceof AsyncTaskAbortError) {
+        done([AsyncTaskStatus.ABORTED, err])
       } else {
-        done([AsyncTaskStatus.FAILED, error])
+        done([AsyncTaskStatus.FAILED, err])
       }
     }
   })
 
   if (isAlive(task) && task.pending && !signal.aborted) {
-    task._resolve(status, error)
+    task._resolve(status, error, result)
   }
 
-  return new AsyncTaskResult(status, error)
+  return new AsyncTaskResult(status, error, result)
 }