codehooks-js 1.2.20 → 1.3.1

package/types/webserver.d.mts

@@ -1,3 +1,2 @@
-export function serveStatic(options: any, app: any, filestore: any): void;
+export function serveStatic(options: any, app: any, filestore: any, hook: any, fsoptions: 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

@@ -0,0 +1,123 @@
+export const setCollectionName: any;
+export const setQueuePrefix: any;
+export const Steps: StepsEngine;
+declare const _default: StepsEngine;
+export default _default;
+/**
+ * StepsEngine class that manages step-based workflows
+ * @extends EventEmitter
+ */
+declare class StepsEngine extends EventEmitter<[never]> {
+    static instance: any;
+    static collectionName: string;
+    static queuePrefix: string;
+    /**
+     * Set the collection name for storing steps data
+     * @param {string} name - Collection name
+     * @throws {Error} If name is not a non-empty string
+     */
+    static setCollectionName(name: string): void;
+    /**
+     * Set the queue prefix for steps jobs
+     * @param {string} prefix - Queue prefix
+     * @throws {Error} If prefix is not a non-empty string
+     */
+    static setQueuePrefix(prefix: string): void;
+    /**
+     * Get the singleton instance of StepsEngine
+     * @returns {StepsEngine} The singleton instance
+     */
+    static getInstance(): StepsEngine;
+    constructor();
+    definitions: Map<any, any>;
+    /**
+     * Get the step definition for a specific step
+     * @param {string} stepsName - Name of the steps workflow
+     * @param {string} stepName - Name of the step
+     * @returns {Function} The step function
+     * @throws {Error} If steps definition or step function not found
+     */
+    getDefinition(stepsName: string, stepName: string): Function;
+    /**
+     * Validate a step definition
+     * @param {Function} step - The step function to validate
+     * @throws {Error} If step definition is invalid
+     */
+    validateStepDefinition(step: Function): void;
+    /**
+     * Handle the next step in the workflow
+     * @param {string} stepsName - Name of the steps workflow
+     * @param {string|null} nextStep - Name of the next step or null if finished
+     * @param {Object} newState - The new state to set
+     * @param {string} instanceId - ID of the steps instance
+     * @param {Object} options - Step options (waitForInput, timeout, retry, abort)
+     * @returns {Promise<string|string[]>} Queue ID(s) for the next step(s)
+     * @throws {Error} If step execution fails
+     */
+    handleNextStep(stepsName: string, nextStep: string | null, newState: any, instanceId: string, options: any): Promise<string | string[]>;
+    /**
+     * Register a new steps workflow
+     * @param {Codehooks} app - Codehooks application instance
+     * @param {string} name - Unique identifier for the steps workflow
+     * @param {string} description - Human-readable description
+     * @param {Object} definition - Object containing step definitions
+     * @returns {Promise<string>} The registered steps name
+     * @throws {Error} If step definition is invalid
+     */
+    register(app: Codehooks, name: string, description: string, definition: any): Promise<string>;
+    /**
+     * Start a new steps instance
+     * @param {string} name - Name of the steps workflow to start
+     * @param {Object} initialState - Initial state for the steps instance
+     * @returns {Promise<{id: string}>} The steps instance ID
+     * @throws {Error} If starting steps fails
+     */
+    start(name: string, initialState: any): Promise<{
+        id: string;
+    }>;
+    /**
+     * Update the state of a steps instance
+     * @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>;
+    /**
+     * Set the complete state of a steps instance
+     * @param {string} instanceId - ID of the steps instance
+     * @param {Object} state - Complete state to set
+     * @returns {Promise<void>}
+     */
+    setState(instanceId: string, { _id, state }: any): Promise<void>;
+    /**
+     * Continue a paused steps instance
+     * @param {string} stepsName - Name of the steps workflow
+     * @param {string} instanceId - ID of the steps instance
+     * @returns {Promise<{qId: string}>} Queue ID for the continued step
+     * @throws {Error} If steps instance not found
+     */
+    continue(stepsName: string, instanceId: string): Promise<{
+        qId: string;
+    }>;
+    /**
+     * Get the status of a steps instance
+     * @param {string} id - ID of the steps instance
+     * @returns {Promise<Object>} The steps status
+     */
+    getStepsStatus(id: string): Promise<any>;
+    /**
+     * List all steps instances matching a filter
+     * @param {Object} filter - Filter criteria for steps workflows
+     * @returns {Promise<Array>} List of steps instances
+     */
+    getInstances(filter: any): Promise<any[]>;
+    /**
+     * Cancel a steps instance
+     * @param {string} id - ID of the steps instance to cancel
+     * @returns {Promise<Object>} The cancellation result
+     */
+    cancelSteps(id: string): Promise<any>;
+}
+import { EventEmitter } from 'events';

package/types/workflow/engine.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.mts","sourceRoot":"","sources":["../../workflow/engine.mjs"],"names":[],"mappings":"AAsXA,oCAAiF;AACjF,iCAA2E;AAG3E,gCAA+C;;;AAnX/C;;;GAGG;AACH;IAQI,qBAAuB;IAGvB,8BAAoC;IACpC,2BAAkC;IAElC;;;;OAIG;IACH,+BAHW,MAAM,QAQhB;IAED;;;;OAIG;IACH,8BAHW,MAAM,QAQhB;IAED;;;OAGG;IACH,sBAFa,WAAW,CAOvB;IA3CG,iBAA4B;IA6ChC;;;;;;OAMG;IACH,yBALW,MAAM,YACN,MAAM,YAehB;IAED;;;;OAIG;IACH,6CAOC;IAED;;;;;;;;;OASG;IACH,0BARW,MAAM,YACN,MAAM,GAAC,IAAI,6BAEX,MAAM,iBAEJ,OAAO,CAAC,MAAM,GAAC,MAAM,EAAE,CAAC,CA4FpC;IAED;;;;;;;;OAQG;IACH,cAPW,SAAS,QACT,MAAM,eACN,MAAM,oBAEJ,OAAO,CAAC,MAAM,CAAC,CA6B3B;IAED;;;;;;OAMG;IACH,YALW,MAAM,sBAEJ,OAAO,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,CAAC,CAgCjC;IAED;;;;;;OAMG;IACH,uBALW,MAAM,cACN,MAAM,eAEJ,OAAO,KAAQ,CAW3B;IAED;;;;;OAKG;IACH,qBAJW,MAAM,wBAEJ,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;;;OAMG;IACH,oBALW,MAAM,cACN,MAAM,GACJ,OAAO,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAwBlC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,KAAQ,CAQ3B;IAED;;;;OAIG;IACH,wBAFa,OAAO,OAAO,CAS1B;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,KAAQ,CAW3B;CACJ"}

package/types/workflow/index.d.mts

@@ -0,0 +1,10 @@
+export namespace StepsConfig {
+    export { setCollectionName };
+    export { setQueuePrefix };
+}
+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';

package/types/workflow/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../workflow/index.mjs"],"names":[],"mappings":";;;;;;kCAAsE,cAAc;+BAAd,cAAc;sBAAd,cAAc;wBAAd,cAAc"}

package/webserver.mjs

@@ -69,8 +69,9 @@ export function serveStatic(options, app, filestore, hook, fsoptions) {
 
             // get mime type
             const type = mime.getType(filePath)
-            console.debug('Serve file', filePath, type)
+            
             const filestream = await filestore.getReadStream(filePath, fsoptions);
+            console.debug('Serve file', filePath, type)
             res.set('Content-Type', type || 'application/octet-stream');
             if (options.headers) {
                 res.headers(options.headers);
@@ -91,7 +92,7 @@ export function serveStatic(options, app, filestore, hook, fsoptions) {
                 })
 
         } catch (error) {
-            console.debug("Error message", error.message)
+            console.debug("Error serving file", filePath, error.message)
             if (options.notFound) {
                 // read default file
                 // add directory filesystem path
@@ -103,6 +104,7 @@ export function serveStatic(options, app, filestore, hook, fsoptions) {
                 const type = mime.getType(filePath)
                 const filestream = await filestore.getReadStream(filePath, fsoptions);
                 res.set('Content-Type', type || 'application/octet-stream');
+                res.status(404);
                 filestream
                 .on('data', (buf) => {
                     res.write(buf, 'buffer')
@@ -168,28 +170,53 @@ async function ejs(viewFile, data, settings, cb) {
     }
 }
 
+let layoutFile = null;
 async function handlebars(viewFile, data, settings, cb) {
     try {
+        const db = await Datastore.open();
         let engine = settings['view engine'].hbs || settings['view engine'].handlebars;  
         let layout = settings['layout']; 
         let views = settings['views'];     
         let tmpl = null;
-        if (tmplCache[viewFile]) {            
-            tmpl = tmplCache[viewFile];
-        } else {
-            //console.log('Hbs view init', layout, views)
-            if (layout) {
-                const layoutPath = `${layout}`;
-                //console.log('Layout path', layoutPath)
-                const layoutFile = await _coho_fs.readFile(layoutPath, {source: true});
-                //console.log('Layout file', layoutFile)
-                engine.registerPartial('layout', layoutFile);
+        //console.log('Hbs view init', layout, views)
+        if (layout) {
+            const layoutPath = `${layout}`;
+            
+            if (!layoutFile) {
+                
+                const cachedLayout = await db.get(`hbs:layout:${layout}`);
+                if (cachedLayout) {
+                    console.debug('Layout load from cache', layoutPath)
+                    layoutFile = cachedLayout;
+                } else {
+                    console.debug('Layout load from file', layoutPath)
+                    layoutFile = await _coho_fs.readFile(layoutPath, {source: true});
+                    db.set(`hbs:layout:${layout}`, layoutFile);
+                }
             }
-            const txtfile = await _coho_fs.readFile(`${settings.views}/${viewFile}.hbs`, {source: true});
-            //console.log('Txtfile', txtfile)
+            //console.log('Layout file', layoutFile)
+            engine.registerPartial('layout', layoutFile);
+        }
+        let txtfile = await db.get(`hbs:${viewFile}`);
+        
+        if (tmplCache[viewFile] !== undefined) {            
+            console.debug('Render view from cache', tmplCache[viewFile])
+            tmpl = tmplCache[viewFile];
+            return cb(null, tmpl(data));        
+        }
+        if (txtfile) {
+            console.debug('Render view from db')
             tmplCache[viewFile] = engine.compile(txtfile);
             tmpl = tmplCache[viewFile];
-        }                
+            return cb(null, tmpl(data));        
+        }
+         
+                    
+        txtfile = await _coho_fs.readFile(`${settings.views}/${viewFile}.hbs`, {source: true});
+        console.debug('Creating hbs template', viewFile)
+        tmplCache[viewFile] = engine.compile(txtfile);
+        tmpl = tmplCache[viewFile];
+        db.set(`hbs:${viewFile}`, txtfile);             
         cb(null, tmpl(data));        
     } catch (err) {
         console.error('Handle bars engine error:', err)

package/workflow/engine.mjs

@@ -0,0 +1,384 @@
+/*
+Implements a steps engine that uses Codehooks.io as the state storage and queues for persistent workers.
+The engine manages step transitions, state persistence, and event handling for step-based workflows.
+*/
+
+import { EventEmitter } from 'events';
+
+/**
+ * StepsEngine class that manages step-based workflows
+ * @extends EventEmitter
+ */
+class StepsEngine extends EventEmitter {
+
+    constructor() {
+        super();
+        this.definitions = new Map();
+    }
+
+    // Singleton instance
+    static instance = null;
+    
+    // Configuration
+    static collectionName = 'stepsdata';
+    static queuePrefix = 'stepsqueue';
+
+    /**
+     * Set the collection name for storing steps data
+     * @param {string} name - Collection name
+     * @throws {Error} If name is not a non-empty string
+     */
+    static setCollectionName(name) {
+        if (typeof name !== 'string' || !name.trim()) {
+            throw new Error('Collection name must be a non-empty string');
+        }
+        StepsEngine.collectionName = name.trim();
+    }
+
+    /**
+     * Set the queue prefix for steps jobs
+     * @param {string} prefix - Queue prefix
+     * @throws {Error} If prefix is not a non-empty string
+     */
+    static setQueuePrefix(prefix) {
+        if (typeof prefix !== 'string' || !prefix.trim()) {
+            throw new Error('Queue prefix must be a non-empty string');
+        }
+        StepsEngine.queuePrefix = prefix.trim();
+    }
+
+    /**
+     * Get the singleton instance of StepsEngine
+     * @returns {StepsEngine} The singleton instance
+     */
+    static getInstance() {
+        if (!StepsEngine.instance) {
+            StepsEngine.instance = new StepsEngine();
+        }
+        return StepsEngine.instance;
+    }
+    
+    /**
+     * Get the step definition for a specific step
+     * @param {string} stepsName - Name of the steps workflow
+     * @param {string} stepName - Name of the step
+     * @returns {Function} The step function
+     * @throws {Error} If steps definition or step function not found
+     */
+    getDefinition(stepsName, stepName) {
+        const stepsDef = this.definitions.get(stepsName);
+        if (!stepsDef) {
+            throw new Error(`No Steps definition found for: ${stepsName}`);
+        }
+        // Get the specific step function from that workflow
+        const stepFunc = stepsDef[stepName];
+        if (!stepFunc) {
+            throw new Error(`No step function found for: ${stepName} in steps ${stepsName}`);
+        }
+        return stepFunc;
+    }
+
+    /**
+     * Validate a step definition
+     * @param {Function} step - The step function to validate
+     * @throws {Error} If step definition is invalid
+     */
+    validateStepDefinition(step) {
+        if (typeof step !== 'function') {
+            throw new Error('Step definition must be a function');
+        }
+        if (step.length !== 2) {
+            throw new Error('Step definition must accept exactly 2 parameters');
+        }
+    }
+
+    /**
+     * Handle the next step in the workflow
+     * @param {string} stepsName - Name of the steps workflow
+     * @param {string|null} nextStep - Name of the next step or null if finished
+     * @param {Object} newState - The new state to set
+     * @param {string} instanceId - ID of the steps instance
+     * @param {Object} options - Step options (waitForInput, timeout, retry, abort)
+     * @returns {Promise<string|string[]>} Queue ID(s) for the next step(s)
+     * @throws {Error} If step execution fails
+     */
+    async handleNextStep(stepsName, nextStep, newState, instanceId, options) {
+        try {
+            // Handle array of next steps
+            if (Array.isArray(nextStep)) {
+                const results = [];
+                for (const step of nextStep) {
+                    const qid = await this.handleNextStep(stepsName, step, newState, instanceId, options);
+                    results.push(qid);
+                }
+                return results;
+            }
+
+            const isFinished = nextStep === null;
+
+            // Handle single next step
+            StepsEngine.getInstance().emit('stepStarted', { 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 } });
+            
+            StepsEngine.getInstance().emit('stateUpdated', { 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 });
+                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,
+                            nextStep: newState.nextStep,
+                            createdAt: newState.createdAt,
+                            updatedAt: newState.updatedAt,
+                            instanceId: newState.instanceId,
+                            isFinished: newState.isFinished
+                        };
+                        
+                        // Merge states with userState taking precedence, but protecting system fields
+                        const mergedState = {
+                            ...newState,
+                            ...userState,
+                            ...protectedState
+                        };
+
+                        // Enqueue the next step
+                        const qres = connection.enqueue(`${StepsEngine.queuePrefix}`, {
+                            stepsName: stepsName,
+                            goto: nextStep,
+                            state: mergedState,
+                            options: options,
+                            instanceId: instanceId
+                        });
+                        
+                        StepsEngine.getInstance().emit('stepEnqueued', { 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);
+                const connection = await Datastore.open();
+                await connection.updateOne(StepsEngine.collectionName,
+                    { _id: instanceId },
+                    { $set: { lastError: error.message, updatedAt: new Date().toISOString() } });
+                throw error;
+            }            
+        }
+        catch (error) {            
+            throw error;
+        }
+    }
+
+    /**
+     * Register a new steps workflow
+     * @param {Codehooks} app - Codehooks application instance
+     * @param {string} name - Unique identifier for the steps workflow
+     * @param {string} description - Human-readable description
+     * @param {Object} definition - Object containing step definitions
+     * @returns {Promise<string>} The registered steps name
+     * @throws {Error} If step definition is invalid
+     */
+    async register(app, name, description, definition) {
+        StepsEngine.getInstance().emit('stepsRegistered', { 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) => {
+                        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);
+                        } finally {
+                            res.end();
+                        }
+                    });
+                }
+            } catch (error) {
+                console.error(`Invalid step definition '${stepName}': ${error.message}`);
+                throw error;
+            }
+        }
+
+        this.definitions.set(name, definition);
+        return name;
+    }
+
+    /**
+     * Start a new steps instance
+     * @param {string} name - Name of the steps workflow to start
+     * @param {Object} initialState - Initial state for the steps instance
+     * @returns {Promise<{id: string}>} The steps instance ID
+     * @throws {Error} If starting steps fails
+     */
+    async start(name, initialState) {
+        StepsEngine.getInstance().emit('stepsStarted', { name, initialState });
+
+        return new Promise(async (resolve, reject) => {
+            try {
+                const funcs = this.definitions.get(name);
+                const firstStepName = Object.keys(funcs)[0];
+                const firstStep = funcs[firstStepName];
+                if (!firstStep) {
+                    reject(new Error('No start step defined in steps'));
+                    return;
+                }
+                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}`, {
+                    stepsName: name,
+                    goto: firstStepName,
+                    state: newState,
+                    instanceId: newState._id,
+                    options: {}
+                });
+                resolve(newState);
+            } catch (error) {
+                console.error('Error starting steps:', error.message);
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * Update the state of a steps instance
+     * @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
+     */
+    async updateState(stepsName, instanceId, state, options={continue: true}) {
+        StepsEngine.getInstance().emit('stepsStateUpdating', { stepsName, instanceId, state });
+        const connection = await Datastore.open();
+        return new Promise(async (resolve, reject) => {
+            const doc = await connection.updateOne(StepsEngine.collectionName, 
+                { _id: instanceId }, 
+                { $set: { ...state, updatedAt: new Date().toISOString() } });
+            if (options.continue) {
+                await this.continue(stepsName, instanceId);
+            } 
+            resolve({ ...doc });                       
+        });
+    }
+
+    /**
+     * Set the complete state of a steps instance
+     * @param {string} instanceId - ID of the steps instance
+     * @param {Object} state - Complete state to set
+     * @returns {Promise<void>}
+     */
+    async setState(instanceId, { _id, state }) {
+        const connection = await Datastore.open();
+        await connection.replaceOne(StepsEngine.collectionName, { _id: _id }, { ...state });
+    }
+
+    /**
+     * Continue a paused steps instance
+     * @param {string} stepsName - Name of the steps workflow
+     * @param {string} instanceId - ID of the steps instance
+     * @returns {Promise<{qId: string}>} Queue ID for the continued step
+     * @throws {Error} If steps instance not found
+     */
+    async continue(stepsName, instanceId) {
+        const connection = await Datastore.open();
+        const state = await connection.findOne(StepsEngine.collectionName, { _id: instanceId });
+        if (!state) {
+            throw new Error(`No steps found with instanceId: ${instanceId}`);
+        }
+        
+        console.log('continue state', state);
+        StepsEngine.getInstance().emit('stepContinued', { stepsName, step: state.nextStep, instanceId });                    
+
+        return new Promise(async (resolve, reject) => {
+            const { _id: ID } = await connection.enqueue(`${StepsEngine.queuePrefix}`, {
+                stepsName,
+                goto: state.nextStep,
+                state: state,
+                options: {},
+                instanceId: instanceId
+            });
+
+            resolve({ qId: ID });
+        });
+    }
+
+    /**
+     * Get the status of a steps instance
+     * @param {string} id - ID of the steps instance
+     * @returns {Promise<Object>} The steps status
+     */
+    async getStepsStatus(id) {
+        return new Promise(async (resolve, reject) => {
+            const connection = await Datastore.open();
+            const state = await connection.findOne(StepsEngine.collectionName, { _id: id });
+            resolve(state);
+        });
+    }
+
+    /**
+     * List all steps instances matching a filter
+     * @param {Object} filter - Filter criteria for steps workflows
+     * @returns {Promise<Array>} List of steps instances
+     */
+    async getInstances(filter) {
+        return new Promise(async (resolve, reject) => {
+            const connection = await Datastore.open();
+            const states = await connection.find(StepsEngine.collectionName, filter).toArray();
+            console.log('listSteps', StepsEngine.collectionName, filter, states.length);
+            resolve(states);
+        });
+    }
+
+    /**
+     * Cancel a steps instance
+     * @param {string} id - ID of the steps instance to cancel
+     * @returns {Promise<Object>} The cancellation result
+     */
+    async cancelSteps(id) {
+        StepsEngine.getInstance().emit('stepsCancelled', { id });
+        return new Promise(async (resolve, reject) => {
+            const connection = await Datastore.open();
+            const state = await connection.updateOne(StepsEngine.collectionName, 
+                { _id: id }, 
+                { $set: { status: 'cancelled' } });    
+            resolve(state);
+        });
+    }
+}
+
+// Export the static methods directly
+export const setCollectionName = StepsEngine.setCollectionName.bind(StepsEngine);
+export const setQueuePrefix = StepsEngine.setQueuePrefix.bind(StepsEngine);
+
+// Export the singleton instance
+export const Steps = StepsEngine.getInstance();
+export default StepsEngine.getInstance();

package/workflow/index.mjs

@@ -0,0 +1,13 @@
+import StepsEngine, { setCollectionName, setQueuePrefix, Steps } from './engine.mjs';
+
+// Re-export the static methods
+export const StepsConfig = {
+    setCollectionName,
+    setQueuePrefix
+};
+
+// Re-export the workflow instance
+export { Steps };
+
+// Export the engine as default
+export default StepsEngine;