codehooks-js 1.3.2 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehooks-js",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "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,48 +137,43 @@ 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 });
+            // If there is no next step, the workflow is completed
+            if (nextStep === null) {
+                console.log('No next step, steps workflow completed');
+                StepsEngine.getInstance().emit('completed', { message: 'Steps workflow completed', ...newState });
                 return;
             }
+            
+            // Get the next step function
+            const func = StepsEngine.getInstance().getDefinition(stepsName, nextStep);
 
             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,
                             nextStep: newState.nextStep,
                             createdAt: newState.createdAt,
                             updatedAt: newState.updatedAt,
-                            instanceId: newState.instanceId,
-                            isFinished: newState.isFinished
+                            instanceId: newState.instanceId
                         };
                         
                         // Merge states with userState taking precedence, but protecting system fields
                         const mergedState = {
-                            ...newState,
+                            //...newState,
                             ...userState,
                             ...protectedState
                         };
 
                         // Enqueue the next step
-                        const qres = connection.enqueue(`${StepsEngine.queuePrefix}`, {
+                        const qres = connection.enqueue(`${StepsEngine.queuePrefix}_${stepsName}`, {
                             stepsName: stepsName,
                             goto: nextStep,
                             state: mergedState,
@@ -180,7 +188,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 },
@@ -209,12 +217,12 @@ class StepsEngine extends EventEmitter {
         for (const [stepName, step] of Object.entries(definition)) {
             try {
                 if (stepName !== null) {
-                    app.worker(`${StepsEngine.queuePrefix}`, async (req, res) => {
+                    app.worker(`${StepsEngine.queuePrefix}_${name}`, 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();
                         }
@@ -253,7 +261,7 @@ class StepsEngine extends EventEmitter {
                 // 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}`, {
+                const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}_${name}`, {
                     stepsName: name,
                     goto: firstStepName,
                     state: newState,

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 };