codehooks-js 1.3.2 → 1.3.4

package/package.json

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

package/types/index.d.ts

@@ -64,6 +64,10 @@ declare class Codehooks {
     crudlify: (schema?: {}, options?: {}) => Promise<import("./crudlify/lib/eventhooks.mjs").EventHooks>;
     createWorkflow: (name: any, description: any, steps: any, options?: {}) => {
         definitions: Map<any, any>;
+        configure(config: {
+            collectionName: string;
+            queuePrefix: string;
+        }): void;
         getDefinition(stepsName: string, stepName: string): Function;
         validateStepDefinition(step: Function): void;
         handleNextStep(stepsName: string, nextStep: string | null, newState: any, instanceId: string, options: any): Promise<string | string[]>;

package/types/workflow/engine.d.mts

@@ -30,6 +30,16 @@ declare class StepsEngine extends EventEmitter<[never]> {
     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
+     */
+    configure(config: {
+        collectionName: string;
+        queuePrefix: string;
+    }): void;
     /**
      * Get the step definition for a specific step
      * @param {string} stepsName - Name of the steps workflow

package/types/workflow/index.d.mts

@@ -2,6 +2,10 @@ export namespace StepsConfig {
     export { setCollectionName };
     export { setQueuePrefix };
 }
+export const configure: (config: {
+    collectionName: string;
+    queuePrefix: string;
+}) => void;
 export { Steps };
 export default StepsEngine;
 import { setCollectionName } from './engine.mjs';

package/workflow/engine.mjs

@@ -20,8 +20,8 @@ class StepsEngine extends EventEmitter {
     static instance = null;
     
     // Configuration
-    static collectionName = 'stepsdata';
-    static queuePrefix = 'stepsqueue';
+    static collectionName = 'workflowdata';
+    static queuePrefix = 'workflowqueue';
 
     /**
      * Set the collection name for storing steps data
@@ -47,6 +47,21 @@ class StepsEngine extends EventEmitter {
         StepsEngine.queuePrefix = prefix.trim();
     }
 
+    /**
+     * Configure the steps engine
+     * @param {Object} config - Configuration object
+     * @param {string} config.collectionName - Collection name
+     * @param {string} config.queuePrefix - Queue prefix
+     */
+    configure(config) {
+        if (config.collectionName) {
+            StepsEngine.setCollectionName(config.collectionName);
+        }
+        if (config.queuePrefix) {
+            StepsEngine.setQueuePrefix(config.queuePrefix);
+        }
+    }
+
     /**
      * Get the singleton instance of StepsEngine
      * @returns {StepsEngine} The singleton instance
@@ -114,8 +129,6 @@ class StepsEngine extends EventEmitter {
                 return results;
             }
 
-            const isFinished = nextStep === null;
-
             // Handle single next step
             StepsEngine.getInstance().emit('stepStarted', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
             const connection = await Datastore.open();
@@ -124,29 +137,20 @@ class StepsEngine extends EventEmitter {
             // Update the existing steps state in the database
             newState = await connection.updateOne(StepsEngine.collectionName,
                 { _id: instanceId },
-                { $set: { ...newState, nextStep: nextStep, updatedAt: new Date().toISOString(), isFinished: isFinished } });
+                { $set: { ...newState, nextStep: nextStep, updatedAt: new Date().toISOString() } });
             
             StepsEngine.getInstance().emit('stateUpdated', { workflowName: stepsName, state: newState, instanceId });
             
+            
+            
             // Get the next step function
             const func = StepsEngine.getInstance().getDefinition(stepsName, nextStep);
 
-            // Check if the step is waiting for input
-            if (options && options.waitForInput === true) {
-                console.log('Steps workflow is paused, waiting for input for at step', nextStep);
-                this.emit('stepWaiting', { workflowName: stepsName, step: nextStep, instanceId });
-                return;
-            }
-
             try {
                 // Call the next step function with the step context
                 func.call(this, {...newState, instanceId: newState._id}, async function (nextStep, userState, options) {
                     try {
-                        if (nextStep === null) {
-                            console.log('No next step, steps workflow completed');
-                            StepsEngine.getInstance().emit('completed', { message: 'Steps workflow completed', ...userState });
-                            return;
-                        }
+                        
                         // Protect system-level properties
                         const protectedState = {
                             _id: newState._id,
@@ -154,18 +158,32 @@ class StepsEngine extends EventEmitter {
                             createdAt: newState.createdAt,
                             updatedAt: newState.updatedAt,
                             instanceId: newState.instanceId,
-                            isFinished: newState.isFinished
+                            workflowName: newState.workflowName
                         };
                         
                         // Merge states with userState taking precedence, but protecting system fields
                         const mergedState = {
-                            ...newState,
+                            //...newState,
                             ...userState,
                             ...protectedState
                         };
 
+                        // If there is no next step, the workflow is completed
+                        if (nextStep === null) {
+                            delete mergedState._id;
+                            const completionTime = (new Date(mergedState.updatedAt) - new Date(mergedState.createdAt)) / 1000;
+                            console.log(`Workflow ${stepsName} ${instanceId} is completed in time: ${completionTime}s 🎉`);
+                            const db = await Datastore.open();
+                            await db.updateOne(StepsEngine.collectionName,
+                                { _id: instanceId },
+                                { $set: { ...mergedState, nextStep: null, updatedAt: new Date().toISOString() } });                            
+                            StepsEngine.getInstance().emit('completed', { message: 'Steps workflow completed', ...userState });
+                            return;
+                        }
+
                         // Enqueue the next step
-                        const qres = connection.enqueue(`${StepsEngine.queuePrefix}`, {
+                        //console.log('enqueuing step', `${StepsEngine.queuePrefix}_${stepsName}_${nextStep}`);
+                        connection.enqueue(`${StepsEngine.queuePrefix}_${stepsName}_${nextStep}`, {
                             stepsName: stepsName,
                             goto: nextStep,
                             state: mergedState,
@@ -180,7 +198,7 @@ class StepsEngine extends EventEmitter {
                     }
                 });
             } catch (error) {
-                console.error('Error in step function:', error.message);
+                console.error('Error in step function: '+nextStep, error.message);
                 const connection = await Datastore.open();
                 await connection.updateOne(StepsEngine.collectionName,
                     { _id: instanceId },
@@ -208,13 +226,14 @@ class StepsEngine extends EventEmitter {
         // Validate each step in the definition
         for (const [stepName, step] of Object.entries(definition)) {
             try {
-                if (stepName !== null) {
-                    app.worker(`${StepsEngine.queuePrefix}`, async (req, res) => {
+                if (stepName !== undefined) {
+                    //console.log('registering queue for step', `${StepsEngine.queuePrefix}_${name}_${stepName}`);
+                    app.worker(`${StepsEngine.queuePrefix}_${name}_${stepName}`, async (req, res) => {
                         const { stepsName, goto, state, instanceId, options } = req.body.payload;
                         try {
                             const qid = await StepsEngine.getInstance().handleNextStep(stepsName, goto, state, instanceId, options);
                         } catch (error) {
-                            console.error('Error in step function:', error.message);
+                            console.error('Error in step function: ' + stepName, error.message);
                         } finally {
                             res.end();
                         }
@@ -252,8 +271,8 @@ class StepsEngine extends EventEmitter {
                 const connection = await Datastore.open();
                 // Create a new steps state in the database
                 const newState = await connection.insertOne(StepsEngine.collectionName,
-                    { ...initialState, nextStep: firstStepName, createdAt: new Date().toISOString() });
-                const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}`, {
+                    { ...initialState, nextStep: firstStepName, createdAt: new Date().toISOString(), workflowName: name });
+                const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}_${name}_${firstStepName}`, {
                     stepsName: name,
                     goto: firstStepName,
                     state: newState,
@@ -319,7 +338,7 @@ class StepsEngine extends EventEmitter {
         StepsEngine.getInstance().emit('workflowContinued', { stepsName, step: state.nextStep, instanceId });                    
 
         return new Promise(async (resolve, reject) => {
-            const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}`, {
+            const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}_${stepsName}_${state.nextStep}`, {
                 stepsName,
                 goto: state.nextStep,
                 state: state,

package/workflow/index.mjs

@@ -6,6 +6,9 @@ export const StepsConfig = {
     setQueuePrefix
 };
 
+// Re-export the configure method
+export const configure = StepsEngine.configure;
+
 // Re-export the workflow instance
 export { Steps };