codehooks-js 1.3.7 → 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

@@ -207,11 +207,14 @@ class StepsEngine extends EventEmitter {
                                 // 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].nextStep = nextStep;
+                                //fresh.parallelSteps[mergedState.nextStep].previousStep = mergedState.previousStep || null;                           
                                 delete fresh._id;
-                                await connection.updateOne(StepsEngine.collectionName,
+                                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) {
@@ -219,6 +222,14 @@ class StepsEngine extends EventEmitter {
                                     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');
                                 }
                             }
@@ -241,7 +252,7 @@ class StepsEngine extends EventEmitter {
                             if (Array.isArray(nextStep)) {
                                 const now = new Date().toISOString();
                                 const metadata = nextStep.reduce((acc, step) => {
-                                    acc[step] = { done: false, startTime: now };
+                                    acc[step] = { done: false, startTime: now, previousStep: mergedState.previousStep };
                                     return acc;
                                 }, {});
                                 const metadataDoc = await connection.updateOne(StepsEngine.collectionName,