codehooks-js 1.3.6 → 1.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehooks-js",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "type": "module",
   "description": "Codehooks.io official library - provides express.JS like syntax",
   "main": "index.js",

package/workflow/engine.mjs

@@ -151,43 +151,37 @@ class StepsEngine extends EventEmitter {
      * @throws {Error} If step execution fails
      */
     async handleNextStep(stepsName, nextStep, newState, instanceId, options) {
+        
+        // open the connection to the database
+        const connection = await Datastore.open();            
+
+        // Handle single next step
+        StepsEngine.getInstance().emit('stepStarted', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
+        
+        // remove the _id from the newState
+        delete newState._id;
+        // increment the step count
+        newState.stepCount[nextStep] = (newState.stepCount[nextStep] || 0) + 1;
+        // Update the existing steps state in the database
+        newState = await connection.updateOne(StepsEngine.collectionName,
+            { _id: instanceId },
+            { $set: { ...newState, nextStep: nextStep, updatedAt: new Date().toISOString(), stepCount: newState.stepCount } });
+        
+        StepsEngine.getInstance().emit('stateUpdated', { workflowName: stepsName, state: newState, instanceId });    
+        
         try {
-            // Handle array of next steps
-            if (Array.isArray(nextStep)) {
-                const results = [];
-                for (const step of nextStep) {
-                    const qid = await this.handleNextStep(stepsName, step, newState, instanceId, options);
-                    results.push(qid);
+            // Get the next step function
+            const func = StepsEngine.getInstance().getDefinition(stepsName, nextStep);
+
+            // Wrap the callback in a Promise to ensure proper async handling
+            await new Promise(async (resolve, reject) => {
+                // check if the step count is greater than the max step count
+                if (newState.stepCount[nextStep] > StepsEngine.maxStepCount) {
+                    reject(new Error(`Step ${nextStep} has been executed ${newState.stepCount[nextStep]} times, which is greater than the maximum step count of ${StepsEngine.maxStepCount}`));
+                    return;
                 }
-                return results;
-            }
-
-            // Handle single next step
-            StepsEngine.getInstance().emit('stepStarted', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
-            const connection = await Datastore.open();
-            // remove the _id from the newState
-            delete newState._id;
-            // increment the step count
-            newState.stepCount[nextStep] = (newState.stepCount[nextStep] || 0) + 1;
-            // Update the existing steps state in the database
-            newState = await connection.updateOne(StepsEngine.collectionName,
-                { _id: instanceId },
-                { $set: { ...newState, nextStep: nextStep, updatedAt: new Date().toISOString(), stepCount: newState.stepCount } });
-            
-            StepsEngine.getInstance().emit('stateUpdated', { workflowName: stepsName, state: newState, instanceId });                                
-            
-            try {
-                // Get the next step function
-                const func = StepsEngine.getInstance().getDefinition(stepsName, nextStep);
-
-                // Wrap the callback in a Promise to ensure proper async handling
-                await new Promise((resolve, reject) => {
-                    // check if the step count is greater than the max step count
-                    if (newState.stepCount[nextStep] > StepsEngine.maxStepCount) {
-                        reject(new Error(`Step ${nextStep} has been executed ${newState.stepCount[nextStep]} times, which is greater than the maximum step count of ${StepsEngine.maxStepCount}`));
-                        return;
-                    }
-                    func({...newState, instanceId: newState._id}, async (nextStep, userState, options) => {
+                try {
+                    await func({...newState, instanceId: newState._id}, async (nextStep, userState, options) => {
                         try {
                             // Protect system-level properties
                             const protectedState = {
@@ -197,7 +191,9 @@ class StepsEngine extends EventEmitter {
                                 updatedAt: newState.updatedAt,
                                 instanceId: newState.instanceId,
                                 workflowName: newState.workflowName,
-                                stepCount: newState.stepCount
+                                stepCount: newState.stepCount,
+                                parallelSteps: newState.parallelSteps,
+                                previousStep: newState.nextStep
                             };
                             
                             // Merge states with userState taking precedence, but protecting system fields
@@ -206,6 +202,27 @@ class StepsEngine extends EventEmitter {
                                 ...protectedState
                             };
 
+                            // update the parallel steps metadata
+                            if (mergedState.parallelSteps && mergedState.parallelSteps[mergedState.nextStep]) {
+                                // get a fresh copy of the parallel steps
+                                const fresh = await connection.findOne(StepsEngine.collectionName, { _id: instanceId });                                
+                                fresh.parallelSteps[mergedState.nextStep].done = true;
+                                fresh.parallelSteps[mergedState.nextStep].nextStep = nextStep;                           
+                                delete fresh._id;
+                                await connection.updateOne(StepsEngine.collectionName,
+                                    { _id: instanceId },
+                                    { $set: { ...fresh, parallelSteps: fresh.parallelSteps } }); 
+                                // Check if all parallel steps are done
+                                const allStepsDone = Object.values(fresh.parallelSteps).every(step => step.done);
+                                if (!allStepsDone) {
+                                    console.debug('Waiting for other parallel steps to complete');
+                                    resolve();
+                                    return;
+                                } else {
+                                    console.debug('All parallel steps are done');
+                                }
+                            }
+
                             // If there is no next step, the workflow is completed
                             if (nextStep === null) {
                                 delete mergedState._id;
@@ -220,16 +237,38 @@ class StepsEngine extends EventEmitter {
                                 return;
                             }
 
-                            // Enqueue the next step
-                            console.debug('enqueuing step', nextStep, instanceId);
-                            await connection.enqueue(`${StepsEngine.queuePrefix}_${stepsName}_${nextStep}`, {
+                            // Enqueue the next step, single or parallel                            
+                            if (Array.isArray(nextStep)) {
+                                const now = new Date().toISOString();
+                                const metadata = nextStep.reduce((acc, step) => {
+                                    acc[step] = { done: false, startTime: now };
+                                    return acc;
+                                }, {});
+                                const metadataDoc = await connection.updateOne(StepsEngine.collectionName,
+                                    { _id: instanceId },
+                                    { $set: { parallelSteps: metadata } });
+                                //console.log('metadataDoc', metadataDoc);
+                                // enqueue all steps in parallel
+                                for (const step of nextStep) {
+                                    console.debug('enqueue step', step, instanceId);
+                                    await connection.enqueue(`${StepsEngine.queuePrefix}_${stepsName}_${step}`, {
+                                        stepsName: stepsName,
+                                        goto: step,
+                                        state: mergedState,
+                                        options: options,
+                                        instanceId: instanceId
+                                    });
+                                }
+                            } else {
+                                console.debug('enqueue step', nextStep, instanceId);
+                                await connection.enqueue(`${StepsEngine.queuePrefix}_${stepsName}_${nextStep}`, {
                                 stepsName: stepsName,
                                 goto: nextStep,
                                 state: mergedState,
                                 options: options,
                                 instanceId: instanceId
                             });
-                            
+                            }                           
                             StepsEngine.getInstance().emit('stepEnqueued', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
                             resolve();
                         } catch (error) {
@@ -237,14 +276,15 @@ class StepsEngine extends EventEmitter {
                             reject(error);
                         }
                     });
-                });
-            } catch (error) {
-                throw error;
-            }            
-        }
-        catch (error) {            
+                } catch (error) {
+                    console.error('Error executing step function:', error);
+                    reject(error);
+                }
+            });
+        } catch (error) {
+            console.error('error in handleNextStep outer', error.message);
             throw error;
-        }
+        }            
     }
 
     /**
@@ -267,7 +307,7 @@ class StepsEngine extends EventEmitter {
                     app.worker(`${StepsEngine.queuePrefix}_${name}_${stepName}`, async function(req, res) {                        
                         try {                            
                             const { stepsName, goto, state, instanceId, options } = req.body.payload;
-                            console.debug('worker job', stepName, instanceId);
+                            console.debug('dequeue step', stepName, instanceId);
                             const qid = await StepsEngine.getInstance().handleNextStep(stepsName, goto, state, instanceId, options);
                         } catch (error) {
                             const { stepsName, goto, state, instanceId, options } = req.body.payload;
@@ -393,7 +433,7 @@ class StepsEngine extends EventEmitter {
                 instanceId: instanceId
             });
 
-            resolve({ qId: ID });
+            resolve({ instanceId });
         });
     }