codehooks-js 1.3.1 → 1.3.3

package/index.js

@@ -1,7 +1,7 @@
 import {agg} from './aggregation/index.mjs';
 import {crudlify as crud} from './crudlify/index.mjs';
 import {serveStatic as ws, render as renderView} from './webserver.mjs';
-import {Steps, StepsConfig} from './workflow/index.mjs';
+import {Steps as Workflow, StepsConfig as WorkflowConfig} from './workflow/index.mjs';
 
 function createRoute(str) {
   if(str instanceof RegExp) {
@@ -117,9 +117,9 @@ class Codehooks {
     })
   }
   
-  createSteps = (name, description, steps, options={}) => {
-    Steps.register(this, name, description, steps, options);
-    return Steps;
+  createWorkflow = (name, description, steps, options={}) => {
+    Workflow.register(this, name, description, steps, options);
+    return Workflow;
   }
 
   init = (hook) => {
@@ -193,10 +193,10 @@ export const aggregation = agg;
 export const crudlify = crud;
 export const coho = _coho;
 export const app = _coho;
-export const stepsconfig = StepsConfig;
+export const workflowconfig = WorkflowConfig;
 export {
-  Steps,
-  StepsConfig
+  Workflow,
+  WorkflowConfig
 };
 export const realtime = {
   createChannel: (path, ...hook) => {

package/package.json

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

package/types/index.d.ts

@@ -4,7 +4,7 @@ export const aggregation: typeof agg;
 export const crudlify: typeof crud;
 export const coho: Codehooks;
 export const app: Codehooks;
-export const stepsconfig: {
+export const workflowconfig: {
     setCollectionName: any;
     setQueuePrefix: any;
 };
@@ -62,8 +62,12 @@ declare class Codehooks {
     set: (key: any, val: any) => void;
     render: (view: any, data: any, cb: any) => Promise<void>;
     crudlify: (schema?: {}, options?: {}) => Promise<import("./crudlify/lib/eventhooks.mjs").EventHooks>;
-    createSteps: (name: any, description: any, steps: any, options?: {}) => {
+    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[]>;
@@ -124,7 +128,7 @@ declare class Codehooks {
     };
     addListener: (observer: any) => void;
 }
-import { Steps } from './workflow/index.mjs';
-import { StepsConfig } from './workflow/index.mjs';
+import { Steps as Workflow } from './workflow/index.mjs';
+import { StepsConfig as WorkflowConfig } from './workflow/index.mjs';
 declare const _coho: Codehooks;
-export { Steps, StepsConfig };
+export { Workflow, WorkflowConfig };

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,58 +129,51 @@ class StepsEngine extends EventEmitter {
                 return results;
             }
 
-            const isFinished = nextStep === null;
-
             // Handle single next step
-            StepsEngine.getInstance().emit('stepStarted', { stepsName, step: nextStep, state: newState, instanceId });
+            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;
             // 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', { stepsName, state: newState, instanceId });
+            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', { 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,
@@ -173,14 +181,14 @@ class StepsEngine extends EventEmitter {
                             instanceId: instanceId
                         });
                         
-                        StepsEngine.getInstance().emit('stepEnqueued', { stepsName, step: nextStep, state: newState, instanceId });
+                        StepsEngine.getInstance().emit('stepEnqueued', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
                     } catch (error) {
                         console.log('error', error.message);
                         throw error;
                     }
                 });
             } 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 },
@@ -203,18 +211,18 @@ class StepsEngine extends EventEmitter {
      * @throws {Error} If step definition is invalid
      */
     async register(app, name, description, definition) {
-        StepsEngine.getInstance().emit('stepsRegistered', { name, description });
+        StepsEngine.getInstance().emit('workflowCreated', { name, description });
 
         // 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) => {
+                    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();
                         }
@@ -238,7 +246,7 @@ class StepsEngine extends EventEmitter {
      * @throws {Error} If starting steps fails
      */
     async start(name, initialState) {
-        StepsEngine.getInstance().emit('stepsStarted', { name, initialState });
+        StepsEngine.getInstance().emit('workflowStarted', { name, initialState });
 
         return new Promise(async (resolve, reject) => {
             try {
@@ -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,
@@ -316,7 +324,7 @@ class StepsEngine extends EventEmitter {
         }
         
         console.log('continue state', state);
-        StepsEngine.getInstance().emit('stepContinued', { stepsName, step: state.nextStep, instanceId });                    
+        StepsEngine.getInstance().emit('workflowContinued', { stepsName, step: state.nextStep, instanceId });                    
 
         return new Promise(async (resolve, reject) => {
             const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}`, {
@@ -364,7 +372,7 @@ class StepsEngine extends EventEmitter {
      * @returns {Promise<Object>} The cancellation result
      */
     async cancelSteps(id) {
-        StepsEngine.getInstance().emit('stepsCancelled', { id });
+        StepsEngine.getInstance().emit('cancelled', { id });
         return new Promise(async (resolve, reject) => {
             const connection = await Datastore.open();
             const state = await connection.updateOne(StepsEngine.collectionName, 

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