@live-change/task-service 0.8.140 → 0.8.142

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/task-service",
-  "version": "0.8.140",
+  "version": "0.8.142",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -22,8 +22,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@live-change/framework": "^0.8.140",
-    "@live-change/relations-plugin": "^0.8.140"
+    "@live-change/framework": "^0.8.142",
+    "@live-change/relations-plugin": "^0.8.142"
   },
-  "gitHead": "3ef5bdce082ec616466a7df4756deeb64e113f7c"
+  "gitHead": "6c6de9015268e09f3517dc2dbb28e673ea19fe74"
 }

package/{task.js → task.ts}

@@ -1,7 +1,8 @@
 import App from '@live-change/framework'
+// @ts-ignore:next-line
 const app = App.app()
 
-import crypto from 'crypto'
+import * as crypto from 'crypto'
 
 import PQueue from 'p-queue'
 
@@ -87,12 +88,72 @@ async function startTask(taskFunction, props, causeType, cause){
   return { task: taskObject.id, taskObject, promise, causeType, cause }
 }
 
-export default function task(definition, serviceDefinition) {
+interface TaskExecuteApi {
+  id: string,
+  run: (taskFunction, props, progressFactor) => Promise<any>,
+  progress: (current, total, action, opts) => void,
+  trigger: (trigger, props) => Promise<any>,
+  triggerService: (trigger, props, returnArray) => Promise<any>
+}
+
+interface TaskExecuteContext {
+  task: TaskExecuteApi,
+  trigger: (trigger, props) => Promise<any>,
+  triggerService: (trigger, props, returnArray) => Promise<any>,
+  causeType: string,
+  cause: string
+}
+
+interface TaskDefinition {
+  /**
+   * Task name
+   */
+  name: string,
+
+  /**
+   * Maximum number of retries
+   */
+  maxRetries?: number,
+
+  /**
+   * Task execution function
+   * @param props - task properties/parameters
+   * @param context - task context
+   * @param emit - event emitter function
+   * @returns {Promise<any>} - task result promise
+   */
+  execute: (props, context: TaskExecuteContext, emit) => Promise<any>,
+
+  /**
+   * Cleanup function
+   * @param props - task properties/parameters
+   * @param context - task context
+   * @returns {Promise<void>} - cleanup result promise
+   */
+  cleanup?: (props, context: TaskExecuteContext) => Promise<void>,
+
+  /**
+   * Fallback function
+   * @param props - task properties/parameters
+   * @param context - task context
+   * @param error - error object
+   * @returns {Promise<any>} - fallback result
+   */
+  fallback?: (props, context: TaskExecuteContext, error) => any
+}
+
+type TaskFunction = (props, context: TaskExecuteContext, emit, reportProgress) => Promise<any>
+
+export default function task(definition:TaskDefinition, serviceDefinition) {
   if(!definition) throw new Error('Task definition is not defined')
   if(!serviceDefinition) throw new Error('Service definition is not defined')
-  const taskFunction = async (props, context, emit, reportProgress = () => {}) => {
-    if(!emit) emit = (events) =>
-      app.emitEvents(definition.name, Array.isArray(events) ? events : [events], {})
+  const taskFunction = async (props, context,
+                              emit = events => app.emitEvents(definition.name, Array.isArray(events) ? events : [events], {}),
+                              reportProgress = (current, total, selfProgress) => {}) => {
+    if(!emit) {
+      emit = (events) =>
+        app.emitEvents(serviceDefinition.name, Array.isArray(events) ? events : [events], {})
+    }
 
     let taskObject = context.taskObject
       ?? await createOrReuseTask(definition, props, context.causeType, context.cause)
@@ -127,7 +188,7 @@ export default function task(definition, serviceDefinition) {
       })
     }
 
-    let selfProgress = { current: 0, total: 0 }
+    let selfProgress = { current: 0, total: 0, action: undefined }
     const subtasksProgress = []
     let progressUpdateTimer, lastProgressUpdate = 0
     const progressThrottleTime = 400
@@ -159,7 +220,7 @@ export default function task(definition, serviceDefinition) {
         ...context,
         task: {
           id: taskObject.id,
-          async run(taskFunction, props, progressFactor = 1) {
+          async run(taskFunction: TaskFunction, props, progressFactor = 1) {
             if(typeof taskFunction !== 'function') {
               console.log("TASK FUNCTION", taskFunction)
               throw new Error('Task function is not a function')
@@ -176,7 +237,7 @@ export default function task(definition, serviceDefinition) {
                 causeType: 'task_Task',
                 cause: taskObject.id
               },
-              (events) => app.emitEvents(definition.name,
+              (events) => app.emitEvents(serviceDefinition.name,
                 Array.isArray(events) ? events : [events], {}),
               (current, total, action) => {
                 subtaskProgress.current = current
@@ -213,7 +274,7 @@ export default function task(definition, serviceDefinition) {
         }
       }
       try {
-        const result = await definition.execute(props, runContext)
+        const result = await definition.execute(props, runContext, emit)
         await updateTask({
           state: 'done',
           doneAt: new Date(),