codehooks-js 1.3.19 → 1.3.21

package/index.js

@@ -76,9 +76,14 @@ class Codehooks {
     this.queues[topic] = hook;
   };
 
-  worker = (name, ...hook) => {
-    this.workers[name] = hook;
-    this.queues[name] = hook; // legacy support
+  worker = async (name, hook, options={}) => {
+    this.workers[name] = [hook];
+    this.queues[name] = [hook]; // legacy support
+    
+    // add option to key-value store if options is not empty
+    if (Object.keys(options).length > 0) {
+      this.set(`queue_worker:${name}`, options);
+    }
   };
 
   job = (cronExpression, ...hook) => {

package/package.json

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

package/types/index.d.ts

@@ -891,31 +891,38 @@ export class Codehooks {
   ) => void;
   /**
    * Add application worker function
-   * @param {object} name a unique worker name or JSON configuration
-   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   * @param {string} name - Unique worker name
+   * @param {function} hook - Worker callback function with parameters (req, res, [next])
+   * @param {Record<string, any>} options - Optional configuration stored in key-value store under `worker:${name}` key in keyspace '_codehooks_worker_settings'
+   * 
    * @example
-   * app.worker('myworker', (data, job) => {
-   *  const {body:{payload}} = data
-   *  //console.debug('worker payload data', payload)
-   *  // do stuff with payload data
-   *  job.end()
+   * // Simple worker
+   * await app.worker('myworker', (req, res) => {
+   *  const {body:{payload}} = req
+   *  console.log('worker payload data', payload)
+   *  res.end()
    *})
+   * 
    * @example
-   * app.worker({name: 'myworker', workers: 5}, (data, job) => {
-   *  const {body:{payload}} = data
-   *  //console.debug('worker payload data', payload)
-   *  // do stuff with payload data
-   *  job.end()
-   *})
+   * // Worker with configuration stored in KV store
+   * await app.worker('myworker', (req, res) => {
+   *   const {body:{payload}} = req
+   *   console.log('Processing:', payload)
+   *   res.end()
+   * }, {
+   *   workers: 2,
+   *   timeout: 30000
+   * })
    */
   worker: (
-    name: string | object,
-    ...hook: ((
+    name: string,
+    hook: (
       request: httpRequest,
       response: httpResponse,
-      next: nextFunction
-    ) => any)[]
-  ) => void;
+      next?: nextFunction
+    ) => any,
+    options?: Record<string, any>
+  ) => Promise<void>;
   /**
    * Create cron background jobs
    * @example

package/workflow/engine.mjs

@@ -23,7 +23,8 @@ class Workflow extends EventEmitter {
     #description = null; // workflow description
     #defaultStepOptions = { // default step options
         timeout: 30000, // timeout for a step
-        maxRetries: 3 // maximum number of retries for a step
+        maxRetries: 3, // maximum number of retries for a step
+        workers: 1 // number of workers for a step
     };
 
     /**
@@ -154,6 +155,36 @@ class Workflow extends EventEmitter {
         return this.#steps;
     }
 
+    /**
+     * Get the number of workers for a specific step
+     * @param {string} stepName - Name of the step
+     * @returns {number} The number of workers for the step
+     */
+    getWorkersForStep(stepName) {
+        const stepConfig = this.#steps[stepName];
+        return stepConfig?.workers ?? this.#defaultStepOptions.workers ?? 1;
+    }
+
+    /**
+     * Set the default number of workers for steps
+     * @param {number} workers - Number of workers
+     * @throws {Error} If workers is not a positive number
+     */
+    setDefaultWorkers(workers) {
+        if (typeof workers !== 'number' || workers <= 0) {
+            throw new Error('Workers must be a positive number');
+        }
+        this.#defaultStepOptions.workers = workers;
+    }
+
+    /**
+     * Get the default number of workers
+     * @returns {number} The default number of workers
+     */
+    getDefaultWorkers() {
+        return this.#defaultStepOptions.workers;
+    }
+
     /**
      * Configure the steps engine
      * @param {Object} config - Configuration object
@@ -161,6 +192,7 @@ class Workflow extends EventEmitter {
      * @param {string} config.queuePrefix - Queue prefix
      * @param {number} config.timeout - Timeout in milliseconds
      * @param {number} config.maxStepCount - Maximum step count
+     * @param {number} config.workers - Default number of workers for steps
      * @param {Object} config.steps - Steps configuration
      */
     configure(config) {
@@ -176,6 +208,9 @@ class Workflow extends EventEmitter {
         if (config.maxStepCount) {
             this.setMaxStepCount(config.maxStepCount);
         }
+        if (config.workers) {
+            this.setDefaultWorkers(config.workers);
+        }
         if (config.steps) {
             this.setStepsConfig(config.steps);
         }
@@ -345,6 +380,11 @@ class Workflow extends EventEmitter {
                                 return;
                             }
 
+                            // Additional safety check to prevent enqueueing null or invalid steps
+                            if (nextStep === null || nextStep === undefined || nextStep === 'null') {
+                                throw new Error(`Invalid nextStep value: ${nextStep}. This should have been caught earlier.`);
+                            }
+
                             // Enqueue the next step, single or parallel                            
                             if (Array.isArray(nextStep)) {
                                 const now = new Date().toISOString();
@@ -365,7 +405,7 @@ class Workflow extends EventEmitter {
                                         state: mergedState,
                                         options: options,
                                         instanceId: instanceId
-                                    });
+                                    }, { workers: this.getWorkersForStep(step) });
                                 }
                             } else {
                                 console.debug('enqueue step', nextStep, instanceId);
@@ -375,7 +415,7 @@ class Workflow extends EventEmitter {
                                     state: mergedState,
                                     options: options,
                                     instanceId: instanceId
-                                });
+                                }, { workers: this.getWorkersForStep(nextStep) });
                             }
                             this.emit('stepEnqueued', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
                             resolve();
@@ -429,7 +469,8 @@ class Workflow extends EventEmitter {
         // Validate each step in the definition
         for (const [stepName, step] of Object.entries(definition)) {
             try {
-                if (stepName !== undefined) {
+                // Skip null, undefined, or invalid step names
+                if (stepName !== undefined && stepName !== null && stepName !== 'null' && stepName.trim() !== '') {
                     console.debug('registering queue for step', `${this.#queuePrefix}_${name}_${stepName}`);
                     app.worker(`${this.#queuePrefix}_${name}_${stepName}`, async (req, res) => {
                         try {
@@ -502,7 +543,7 @@ class Workflow extends EventEmitter {
                     state: newState,
                     instanceId: newState._id,
                     options: {}
-                });
+                }, { workers: this.getWorkersForStep(firstStepName) });
                 resolve(newState);
             } catch (error) {
                 console.error('Error starting workflow:', error.message);
@@ -555,6 +596,12 @@ class Workflow extends EventEmitter {
         if (!state) {
             throw new Error(`No steps found with instanceId: ${instanceId}`);
         }
+        
+        // Check if the workflow has already completed
+        if (state.nextStep === null) {
+            throw new Error(`Workflow ${instanceId} has already completed and cannot be continued`);
+        }
+        
         if (reset) {
             // reset the step count
             // update all step counts to 0  
@@ -577,7 +624,7 @@ class Workflow extends EventEmitter {
                 state: state,
                 options: {},
                 instanceId: instanceId
-            });
+            }, { workers: this.getWorkersForStep(state.nextStep) });
 
             resolve({ instanceId });
         });