codehooks-js 1.3.6 → 1.3.8

package/types/webserver.d.mts

@@ -1,2 +1,3 @@
-export function serveStatic(options: any, app: any, filestore: any, hook: any, fsoptions: any): void;
+export function serveStatic(options: any, app: any, filestore: any): void;
 export function render(viewFile: any, data: any, settings: any, cb: any): Promise<any>;
+//# sourceMappingURL=webserver.d.mts.map

package/types/workflow/engine.d.mts

@@ -7,12 +7,10 @@ export default _default;
  * StepsEngine class that manages step-based workflows
  * @extends EventEmitter
  */
-declare class StepsEngine extends EventEmitter<[never]> {
+declare class StepsEngine {
     static instance: any;
     static collectionName: string;
     static queuePrefix: string;
-    static timeout: number;
-    static maxStepCount: number;
     /**
      * Set the collection name for storing steps data
      * @param {string} name - Collection name
@@ -25,37 +23,12 @@ declare class StepsEngine extends EventEmitter<[never]> {
      * @throws {Error} If prefix is not a non-empty string
      */
     static setQueuePrefix(prefix: string): void;
-    /**
-     * Set the timeout for steps jobs
-     * @param {number} timeout - Timeout in milliseconds
-     * @throws {Error} If timeout is not a positive number
-     */
-    static setTimeout(timeout: number): void;
-    /**
-     * Set the maximum step count for a steps workflow
-     * @param {number} maxStepCount - Maximum step count
-     * @throws {Error} If maxStepCount is not a positive number
-     */
-    static setMaxStepCount(maxStepCount: number): void;
     /**
      * Get the singleton instance of StepsEngine
      * @returns {StepsEngine} The singleton instance
      */
     static getInstance(): StepsEngine;
-    constructor();
-    definitions: Map<any, any>;
-    /**
-     * Configure the steps engine
-     * @param {Object} config - Configuration object
-     * @param {string} config.collectionName - Collection name
-     * @param {string} config.queuePrefix - Queue prefix
-     * @param {number} config.timeout - Timeout in milliseconds
-     */
-    configure(config: {
-        collectionName: string;
-        queuePrefix: string;
-        timeout: number;
-    }): void;
+    definitions: any;
     /**
      * Get the step definition for a specific step
      * @param {string} stepsName - Name of the steps workflow
@@ -106,10 +79,9 @@ declare class StepsEngine extends EventEmitter<[never]> {
      * @param {string} stepsName - Name of the steps workflow
      * @param {string} instanceId - ID of the steps instance
      * @param {Object} state - New state to update with
-     * @param {Object} options - Options for the update, { continue: false } to avoid continuing the the step
      * @returns {Promise<Object>} The updated state
      */
-    updateState(stepsName: string, instanceId: string, state: any, options?: any): Promise<any>;
+    updateState(stepsName: string, instanceId: string, state: any): Promise<any>;
     /**
      * Set the complete state of a steps instance
      * @param {string} instanceId - ID of the steps instance
@@ -127,13 +99,6 @@ declare class StepsEngine extends EventEmitter<[never]> {
     continue(stepsName: string, instanceId: string): Promise<{
         qId: string;
     }>;
-    /**
-     * Continue all timed out steps instances
-     * @returns {Promise<Array<{qId: string}>>} Array of results containing queue IDs for continued workflows
-     */
-    continueAllTimedOut(): Promise<Array<{
-        qId: string;
-    }>>;
     /**
      * Get the status of a steps instance
      * @param {string} id - ID of the steps instance
@@ -145,7 +110,7 @@ declare class StepsEngine extends EventEmitter<[never]> {
      * @param {Object} filter - Filter criteria for steps workflows
      * @returns {Promise<Array>} List of steps instances
      */
-    getInstances(filter: any): Promise<any[]>;
+    listSteps(filter: any): Promise<any[]>;
     /**
      * Cancel a steps instance
      * @param {string} id - ID of the steps instance to cancel
@@ -153,4 +118,4 @@ declare class StepsEngine extends EventEmitter<[never]> {
      */
     cancelSteps(id: string): Promise<any>;
 }
-import { EventEmitter } from 'events';
+//# sourceMappingURL=engine.d.mts.map

package/types/workflow/index.d.mts

@@ -2,14 +2,10 @@ export namespace StepsConfig {
     export { setCollectionName };
     export { setQueuePrefix };
 }
-export const configure: (config: {
-    collectionName: string;
-    queuePrefix: string;
-    timeout: number;
-}) => void;
 export { Steps };
 export default StepsEngine;
 import { setCollectionName } from './engine.mjs';
 import { setQueuePrefix } from './engine.mjs';
 import { Steps } from './engine.mjs';
 import StepsEngine from './engine.mjs';
+//# sourceMappingURL=index.d.mts.map

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,38 @@ 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;
+                                //fresh.parallelSteps[mergedState.nextStep].previousStep = mergedState.previousStep || null;                           
+                                delete fresh._id;
+                                const updated = await connection.updateOne(StepsEngine.collectionName,
+                                    { _id: instanceId },
+                                    { $set: { ...fresh, parallelSteps: fresh.parallelSteps } }); 
+                                //console.debug('updated', updated.parallelSteps);
+                                mergedState.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 {
+                                    // validate that all parallel steps have the same next step
+                                    const nextSteps = Object.values(fresh.parallelSteps).map(step => step.nextStep);
+                                    const uniqueNextSteps = [...new Set(nextSteps)];
+                                    if (uniqueNextSteps.length > 1) {
+                                        throw new Error('Parallel steps must join to the same next step');
+                                    }
+                                    // reset the parallel steps
+                                    mergedState.parallelSteps = {};
+                                    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 +248,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, previousStep: mergedState.previousStep };
+                                    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 +287,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 +318,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 +444,7 @@ class StepsEngine extends EventEmitter {
                 instanceId: instanceId
             });
 
-            resolve({ qId: ID });
+            resolve({ instanceId });
         });
     }