codehooks-js 1.3.14 → 1.3.16

package/README.md

@@ -1,10 +1,11 @@
-# codehooks-js 
+# codehooks-js
 
 The official JavaScript/TypeScript library for [Codehooks.io](https://codehooks.io) - a serverless backend platform that provides everything you need to build and deploy backend applications.
 
 ## What is Codehooks.io?
 
 Codehooks.io is a complete serverless backend platform that combines:
+
 - **Database** - NoSQL document storage with MongoDB-like queries
 - **API Server** - Express.js-style routing and middleware
 - **Background Jobs** - Queues, workers, and scheduled tasks
@@ -16,7 +17,7 @@ All in one platform with zero infrastructure management.
 
 ## Quick Start
 
-Install the [Codehooks CLI](https://codehooks.io/docs/cli): 
+Install the [Codehooks CLI](https://codehooks.io/docs/cli):
 
 ```shell
 $ npm install -g codehooks
@@ -34,59 +35,65 @@ Example code for a serverless backend API and NoSQL database:
 
 ```javascript
 /*
-* REST API with NoSQL database storage.
-* Codehooks (c) example code.
-*/
+ * REST API with NoSQL database storage.
+ * Codehooks (c) example code.
+ */
 
-import {app, datastore} from 'codehooks-js';
+import { app, datastore } from 'codehooks-js';
 
 // Example GET route and a NoSQL database insert operation
 app.get('/myroute', async (req, res) => {
-  console.log("GET")
-  const conn = await datastore.open()    
-  const doc = await conn.insertOne('greetings', {"message": "Hello World!", "when": new Date()})
-  res.json({...doc})
+  console.log('GET');
+  const conn = await datastore.open();
+  const doc = await conn.insertOne('greetings', {
+    message: 'Hello World!',
+    when: new Date(),
+  });
+  res.json({ ...doc });
 });
 
 // Serve web content from the uploaded directory /static
-app.static({directory: "/static"})
+app.static({ directory: '/static' });
 
 // CRUD REST API for any collection
-app.crudlify({}, {prefix: "/"})
+app.crudlify({}, { prefix: '/' });
 
 // return app to serverless runtime engine
-export default app.init()
+export default app.init();
 ```
 
 ## TypeScript development
 
 Rename the index.js to index.ts or create a new index.ts file.
-Start developing using TypeScript and strong types shown in the example code below. 
+Start developing using TypeScript and strong types shown in the example code below.
 
 ```typescript
 /*
-* REST API with NoSQL database storage.
-* Codehooks (c) example code in TypeScript.
-*/
+ * REST API with NoSQL database storage.
+ * Codehooks (c) example code in TypeScript.
+ */
 
-import {app, datastore, httpResponse, httpRequest} from 'codehooks-js';
+import { app, datastore, httpResponse, httpRequest } from 'codehooks-js';
 
 // Example GET route and a NoSQL database insert operation
 app.get('/myroute', async (req: httpRequest, res: httpResponse) => {
-  console.log("GET")
-  const conn = await datastore.open()    
-  const doc = await conn.insertOne('greetings', {"message": "Hello World!", "when": new Date()})
-  res.json({...doc})
+  console.log('GET');
+  const conn = await datastore.open();
+  const doc = await conn.insertOne('greetings', {
+    message: 'Hello World!',
+    when: new Date(),
+  });
+  res.json({ ...doc });
 });
 
 // Serve web content from the uploaded directory /static
-app.static({directory: "/static"})
+app.static({ directory: '/static' });
 
 // CRUD REST API for any collection
-app.crudlify({}, {prefix: "/"})
+app.crudlify({}, { prefix: '/' });
 
 // return app to serverless runtime engine
-export default app.init()
+export default app.init();
 ```
 
 ## Compile
@@ -95,16 +102,11 @@ When running the `coho compile` command, it will automatically create a `tsconfi
 
 ```json
 {
-    "files": [
-        "./index.ts"
-    ],
-    "compilerOptions": {
-        "allowJs": true,
-        "lib": [
-            "ES6",
-            "dom"
-        ]
-    }
+  "files": ["./index.ts"],
+  "compilerOptions": {
+    "allowJs": true,
+    "lib": ["ES6", "dom"]
+  }
 }
 ```
 
@@ -131,7 +133,8 @@ Your backend application is now available at your project's endpoint URL. For ex
 
 ## Deploy
 
-From the project directory run: 
+From the project directory run:
+
 ```shell
 $ codehooks deploy
 ```
@@ -147,44 +150,50 @@ For complete documentation, visit [https://codehooks.io/docs](https://codehooks.
 The Codehooks class provides a comprehensive backend application framework with the following APIs:
 
 ### **HTTP Routing APIs**
+
 - **`post(path, ...hook)`** - Register POST route handlers
-- **`get(path, ...hook)`** - Register GET route handlers  
+- **`get(path, ...hook)`** - Register GET route handlers
 - **`put(path, ...hook)`** - Register PUT route handlers
 - **`patch(path, ...hook)`** - Register PATCH route handlers
 - **`delete(path, ...hook)`** - Register DELETE route handlers
 - **`all(path, ...hook)`** - Register handlers for all HTTP methods
 
 ### **Middleware & Authentication APIs**
+
 - **`use(...hook)`** - Register global middleware (supports string paths, RegExp, or function)
 - **`useRoute(route, ...hook)`** - Register route-specific middleware
 - **`auth(path, ...hook)`** - Register authentication middleware for specific paths
 
 ### **Background Processing APIs**
+
 - **`queue(topic, ...hook)`** - Register queue handlers for background processing
 - **`worker(name, ...hook)`** - Register worker functions (also adds to queues for legacy support)
 - **`job(cronExpression, ...hook)`** - Register scheduled cron jobs
 
 ### **Static File Serving APIs**
+
 - **`static(options, hook)`** - Serve static files from source code directory
 - **`storage(options, hook)`** - Serve files from blob storage directory
 
 ### **Template & Configuration APIs**
+
 - **`set(key, val)`** - Set application configuration settings
 - **`render(view, data, cb)`** - Render templates with data
 - **`crudlify(schema, options)`** - Auto-generate CRUD REST API endpoints
 
 ### **Real-time Communication APIs**
+
 - **`realtime(path, ...hook)`** - Set up server-sent events (SSE) channels for real-time communication
 
 ### **Workflow Management APIs**
+
 - **`createWorkflow(name, description, steps, options)`** - Create and register a new workflow instance
 
 ### **Application Lifecycle APIs**
+
 - **`init(hook)`** - Initialize the application and return manifest
 - **`start(hook)`** - Alias for `init()` method
 
-
-
 The Codehooks class serves as a comprehensive backend application framework that combines HTTP routing, background processing, real-time communication, and workflow management capabilities in a single, cohesive API.
 
 ## Datastore API Reference
@@ -192,18 +201,21 @@ The Codehooks class serves as a comprehensive backend application framework that
 The Datastore provides a unified interface for both NoSQL document storage and Key-Value operations. It supports MongoDB-like query syntax and provides streaming capabilities for large datasets.
 
 ### **Connection & Collection Management**
+
 - **`open()`** - Connect to the Datastore and return the API interface
 - **`collection(name)`** - Get a NoSQL collection by name for document operations
 
 ### **NoSQL Document Operations**
 
 #### **Read Operations**
+
 - **`getOne(collection, query)`** - Get a single document by ID or query
 - **`findOne(collection, query)`** - Alias for getOne
 - **`getMany(collection, query?, options?)`** - Get a stream of documents matching query
 - **`find(collection, query?, options?)`** - Alias for getMany
 
 #### **Write Operations**
+
 - **`insertOne(collection, document)`** - Insert a new document into a collection
 - **`updateOne(collection, query, document, updateOperators?, options?)`** - Update one document (patches existing data)
 - **`updateMany(collection, query, document, updateOperators?)`** - Update multiple documents
@@ -211,32 +223,38 @@ The Datastore provides a unified interface for both NoSQL document storage and K
 - **`replaceMany(collection, query, document, options?)`** - Replace multiple documents
 
 #### **Delete Operations**
+
 - **`removeOne(collection, query)`** - Remove one document by ID or query
 - **`removeMany(collection, query)`** - Remove multiple documents matching query
 
 #### **Schema Management**
+
 - **`createSchema(collection, schema)`** - Validate collection data against JSON-Schema
 - **`setSchema(collection, schema)`** - Alias for createSchema
 - **`removeSchema(collection)`** - Remove JSON-schema validation for collection
 - **`getSchema(collection)`** - Get JSON-schema for collection
 
 #### **Utility Operations**
+
 - **`count(collection)`** - Count documents in a collection
 
 ### **Key-Value Operations**
 
 #### **Basic Key-Value Operations**
+
 - **`set(key, value, options?)`** - Set a key-value pair
 - **`get(key, options?)`** - Get a value by key
 - **`getAll(keyPattern, options?)`** - Get all key-value pairs matching pattern
-- **`del(key, value)`** - Delete a key-value pair
+- **`del(key, options?)`** - Delete a key-value pair
 - **`delAll(keyPattern, options?)`** - Delete all key-value pairs matching pattern
 
 #### **Numeric Operations**
+
 - **`incr(key, value, options?)`** - Increment a numeric value
 - **`decr(key, value, options?)`** - Decrement a numeric value
 
 ### **Queue Operations**
+
 - **`enqueue(topic, document, options?)`** - Add a job to a queue for background processing
 - **`enqueueFromQuery(collection, query, topic, options?)`** - Queue each item from a database query
 
@@ -258,7 +276,10 @@ import { datastore } from 'codehooks-js';
 const conn = await datastore.open();
 
 // NoSQL operations
-const doc = await conn.insertOne('users', { name: 'John', email: 'john@example.com' });
+const doc = await conn.insertOne('users', {
+  name: 'John',
+  email: 'john@example.com',
+});
 const user = await conn.getOne('users', { _id: doc._id });
 const users = await conn.getMany('users', { active: true }).toArray();
 await conn.updateOne('users', { _id: doc._id }, { lastLogin: new Date() });
@@ -269,7 +290,10 @@ const session = await conn.get('user:123:session');
 await conn.incr('visits', 1);
 
 // Queue operations
-await conn.enqueue('emailWorker', { to: 'user@example.com', template: 'welcome' });
+await conn.enqueue('emailWorker', {
+  to: 'user@example.com',
+  template: 'welcome',
+});
 ```
 
 ### **Query Syntax**
@@ -278,22 +302,48 @@ The Datastore supports MongoDB-like query syntax:
 
 ```javascript
 // Simple equality
-{ status: 'active' }
+{
+  status: 'active';
+}
 
 // Comparison operators
-{ age: { $gt: 18 } }
-{ price: { $lte: 100 } }
+{
+  age: {
+    $gt: 18;
+  }
+}
+{
+  price: {
+    $lte: 100;
+  }
+}
 
 // Logical operators
-{ $and: [{ status: 'active' }, { age: { $gte: 18 } }] }
-{ $or: [{ category: 'A' }, { category: 'B' }] }
+{
+  $and: [{ status: 'active' }, { age: { $gte: 18 } }];
+}
+{
+  $or: [{ category: 'A' }, { category: 'B' }];
+}
 
 // Array operations
-{ tags: { $in: ['javascript', 'nodejs'] } }
-{ tags: { $all: ['javascript', 'nodejs'] } }
+{
+  tags: {
+    $in: ['javascript', 'nodejs'];
+  }
+}
+{
+  tags: {
+    $all: ['javascript', 'nodejs'];
+  }
+}
 
 // Regular expressions
-{ name: { $regex: /john/i } }
+{
+  name: {
+    $regex: /john/i;
+  }
+}
 ```
 
 ### **Options**
@@ -302,14 +352,20 @@ Many operations accept an options object for additional configuration:
 
 ```javascript
 // Upsert option for updates
-await conn.updateOne('users', { email: 'john@example.com' }, 
-  { lastLogin: new Date() }, {}, { upsert: true });
+await conn.updateOne(
+  'users',
+  { email: 'john@example.com' },
+  { lastLogin: new Date() },
+  {},
+  { upsert: true }
+);
 
 // Key-Value options
 await conn.set('key', 'value', { ttl: 3600000 }); // 1 hour TTL
 ```
 
 ### **Key Features:**
+
 1. **Express-style routing** with support for all HTTP methods
 2. **Middleware system** with global and route-specific middleware
 3. **Background processing** with queues, workers, and scheduled jobs

package/package.json

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

package/types/index.d.ts

@@ -401,7 +401,7 @@ export type DatastoreAPI = {
   /**
    * - Delete a key-value pair in the current Datastore
    */
-  del: (key: string, value: object) => Promise<any>;
+  del: (key: string, options?: object) => Promise<any>;
   /**
    * - Delete a range of key-value pairs in the current Datastore
    */
@@ -466,11 +466,11 @@ export type DatastoreAPI = {
    * @returns Promise with result
    */
   getSchema: (collection: string) => Promise<object>;
-   /**
-   * Count database collection items
-   * @returns Promise result
-   */
-   count: (collection: string) => Promise<object>;
+  /**
+  * Count database collection items
+  * @returns Promise result
+  */
+  count: (collection: string) => Promise<object>;
 };
 /**
  * Persistent NoSql and Kev-Value datastore
@@ -956,8 +956,8 @@ export class Codehooks {
    *  })
    * @returns void
    */
-  static: (options: any, 
-      ...hook: ((
+  static: (options: any,
+    ...hook: ((
       request: httpRequest,
       response: httpResponse,
       next: nextFunction
@@ -967,12 +967,12 @@ export class Codehooks {
    * @param {Object} options - {route: "/documents", directory: "/docs"}
    * @returns void
    */
-  storage: (options: any, 
+  storage: (options: any,
     ...hook: ((
-    request: httpRequest,
-    response: httpResponse,
-    next: nextFunction
-  ) => any)[]) => void;
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]) => void;
   /**
    * Configuration settings
    * @param {string} key
@@ -1067,31 +1067,31 @@ export type WorkflowEvents = {
    * @event
    */
   'workflowCreated': { name: string; description: string };
-  
+
   /**
    * Emitted when a new workflow instance is started
    * @event
    */
   'workflowStarted': { name: string; initialState: any };
-  
+
   /**
    * Emitted when a step begins execution
    * @event
    */
   'stepStarted': { workflowName: string; step: string; state: any; instanceId: string };
-  
+
   /**
    * Emitted when a step's state is updated
    * @event
    */
   'stateUpdated': { workflowName: string; state: any; instanceId: string };
-  
+
   /**
    * Emitted when a step is enqueued for execution
    * @event
    */
   'stepEnqueued': { workflowName: string; step: string; state: any; instanceId: string };
-  
+
   /**
    * Emitted when a workflow instance is continued after waiting
    * @event
@@ -1103,7 +1103,7 @@ export type WorkflowEvents = {
    * @event
    */
   'completed': { message: string; state: any };
-  
+
   /**
    * Emitted when a workflow instance is cancelled
    * @event
@@ -1121,9 +1121,9 @@ export type WorkflowEvents = {
  * Definition of a workflow step function
  */
 export type WorkflowDefinition = Record<string, (
-    state: any, 
-    callback: (nextStep: string | string[] | null, newState: any, options?: any) => void,
-    waiterFunction?: (waiter?: any) => void
+  state: any,
+  callback: (nextStep: string | string[] | null, newState: any, options?: any) => void,
+  waiterFunction?: (waiter?: any) => void
 ) => Promise<void>>;
 
 /**
@@ -1255,14 +1255,14 @@ export type Workflow = {
    * @returns Promise with the registered workflow name
    */
   register: (app: Codehooks) => Promise<string>;
-  
+
   /**
    * Start a new workflow instance
    * @param initialState - Initial state for the workflow instance
    * @returns Promise with the workflow instance
    */
   start: (initialState: any) => Promise<any>;
-  
+
   /**
    * Update the state of a workflow instance
    * @param instanceId - ID of the workflow instance
@@ -1271,7 +1271,7 @@ export type Workflow = {
    * @returns Promise with the updated state
    */
   updateState: (instanceId: string, state: any, options?: UpdateOptions) => Promise<any>;
-  
+
   /**
    * Set the complete state of a workflow instance
    * @param instanceId - ID of the workflow instance
@@ -1279,7 +1279,7 @@ export type Workflow = {
    * @returns Promise<void>
    */
   setState: (instanceId: string, stateData: { _id: string; state: any }) => Promise<void>;
-  
+
   /**
    * Continue a paused workflow instance
    * @param instanceId - ID of the workflow instance
@@ -1287,21 +1287,21 @@ export type Workflow = {
    * @returns Promise with the queue ID for the continued step
    */
   continue: (instanceId: string, reset?: boolean) => Promise<{ instanceId: string }>;
-  
+
   /**
    * Get the status of a workflow instance
    * @param id - ID of the workflow instance
    * @returns Promise with the workflow status
    */
   getStepsStatus: (id: string) => Promise<any>;
-  
+
   /**
    * Get all workflow instances matching a filter
    * @param filter - Filter criteria for workflows
    * @returns Promise with list of workflow instances
    */
   getInstances: (filter: any) => Promise<any[]>;
-  
+
   /**
    * Cancel a workflow instance
    * @param id - ID of the workflow instance to cancel
@@ -1309,6 +1309,27 @@ export type Workflow = {
    */
   cancelSteps: (id: string) => Promise<any>;
 
+  /**
+   * Get the status of a workflow instance (alias for getStepsStatus)
+   * @param id - ID of the workflow instance
+   * @returns Promise with the workflow status
+   */
+  getWorkflowStatus: (id: string) => Promise<any>;
+
+  /**
+   * Get the state of a workflow instance (alias for getStepsStatus)
+   * @param id - ID of the workflow instance
+   * @returns Promise with the workflow state
+   */
+  getState: (id: string) => Promise<any>;
+
+  /**
+   * Cancel a workflow instance (alias for cancelSteps)
+   * @param id - ID of the workflow instance to cancel
+   * @returns Promise with the cancellation result
+   */
+  cancelWorkflow: (id: string) => Promise<any>;
+
   /**
    * Register an event listener
    * @param event - Name of the event to listen for
@@ -1319,21 +1340,21 @@ export type Workflow = {
    * });
    */
   on: (event: WorkflowEvent, listener: (data: WorkflowEventData) => void) => Workflow;
-  
+
   /**
    * Register a one-time event listener
    * @param event - Name of the event to listen for
    * @param listener - Callback function to handle the event
    */
   once: (event: WorkflowEvent, listener: (data: WorkflowEventData) => void) => Workflow;
-  
+
   /**
    * Remove an event listener
    * @param event - Name of the event
    * @param listener - Callback function to remove
    */
   off: (event: WorkflowEvent, listener: (data: WorkflowEventData) => void) => Workflow;
-  
+
   /**
    * Emit an event
    * @param event - Name of the event to emit
@@ -1345,7 +1366,7 @@ export type Workflow = {
    * Continue all timed out workflow instances
    * @returns Promise with array of results containing queue IDs for continued workflows
    */
-  continueAllTimedOut: () => Promise<Array<{instanceId: string}>>;
+  continueAllTimedOut: () => Promise<Array<{ instanceId: string }>>;
 
   /**
    * Check if a specific step in a workflow instance has timed out
@@ -1427,7 +1448,7 @@ export type UpdateOptions = {
 /**
  * Workflow event types
  */
-export type WorkflowEvent = 
+export type WorkflowEvent =
   | 'workflowCreated'
   | 'workflowStarted'
   | 'workflowContinued'

package/types/workflow/engine.d.mts

@@ -117,5 +117,23 @@ declare class StepsEngine {
      * @returns {Promise<Object>} The cancellation result
      */
     cancelSteps(id: string): Promise<any>;
+    /**
+     * Get the status of a workflow instance (alias for getStepsStatus)
+     * @param {string} id - ID of the workflow instance
+     * @returns {Promise<Object>} The workflow status
+     */
+    getWorkflowStatus(id: string): Promise<any>;
+    /**
+     * Get the state of a workflow instance (alias for getStepsStatus)
+     * @param {string} id - ID of the workflow instance
+     * @returns {Promise<Object>} The workflow state
+     */
+    getState(id: string): Promise<any>;
+    /**
+     * Cancel a workflow instance (alias for cancelSteps)
+     * @param {string} id - ID of the workflow instance to cancel
+     * @returns {Promise<Object>} The cancellation result
+     */
+    cancelWorkflow(id: string): Promise<any>;
 }
 //# sourceMappingURL=engine.d.mts.map

package/workflow/engine.mjs

@@ -38,7 +38,7 @@ class Workflow extends EventEmitter {
         this.#definitions = new Map();
         this.#name = name;
         this.#description = description;
-        
+
         // Apply any configuration options
         if (options) {
             this.configure(options);
@@ -120,7 +120,7 @@ class Workflow extends EventEmitter {
      * @throws {Error} If maxStepCount is not a positive number
      */
     setMaxStepCount(maxStepCount) {
-        if (typeof maxStepCount !== 'number' || maxStepCount <= 0) {    
+        if (typeof maxStepCount !== 'number' || maxStepCount <= 0) {
             throw new Error('Maximum step count must be a positive number');
         }
         this.#maxStepCount = maxStepCount;
@@ -226,13 +226,13 @@ class Workflow extends EventEmitter {
      * @throws {Error} If step execution fails
      */
     async handleNextStep(stepsName, nextStep, newState, instanceId, options) {
-        
+
         // open the connection to the database
-        const connection = await DB.open();            
+        const connection = await DB.open();
 
         // Handle single next step
         this.emit('stepStarted', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
-        
+
         // remove the _id from the newState
         delete newState._id;
         // increment the step count
@@ -247,9 +247,9 @@ class Workflow extends EventEmitter {
         newState = await connection.updateOne(this.#collectionName,
             { _id: instanceId },
             { $set: { ...newState, nextStep: nextStep, updatedAt: new Date().toISOString(), stepCount: newState.stepCount } });
-        
-        this.emit('stateUpdated', { workflowName: stepsName, state: newState, instanceId });    
-        
+
+        this.emit('stateUpdated', { workflowName: stepsName, state: newState, instanceId });
+
         try {
             // Get the next step function
             const func = this.getDefinition(stepsName, nextStep);
@@ -267,14 +267,14 @@ class Workflow extends EventEmitter {
                             console.debug('waiter', state);
                             await connection.updateOne(this.#collectionName,
                                 { _id: instanceId },
-                                { $set: { ...state, updatedAt: new Date().toISOString() } });                            
+                                { $set: { ...state, updatedAt: new Date().toISOString() } });
                             resolve();
                             return;
                         } else {
                             resolve(); // no state update
                         }
                     }
-                    await func({...newState, instanceId: newState._id}, async (nextStep, userState, options) => {
+                    await func({ ...newState, instanceId: newState._id }, async (nextStep, userState, options) => {
                         try {
                             // Protect system-level properties
                             const protectedState = {
@@ -288,7 +288,7 @@ class Workflow extends EventEmitter {
                                 parallelSteps: newState.parallelSteps,
                                 previousStep: newState.nextStep
                             };
-                            
+
                             // Merge states with userState taking precedence, but protecting system fields
                             const mergedState = {
                                 ...userState,
@@ -302,14 +302,14 @@ class Workflow extends EventEmitter {
                             // update the parallel steps metadata
                             if (mergedState.parallelSteps && mergedState.parallelSteps[mergedState.nextStep]) {
                                 // get a fresh copy of the parallel steps
-                                const fresh = await connection.findOne(this.#collectionName, { _id: instanceId });                                
+                                const fresh = await connection.findOne(this.#collectionName, { _id: instanceId });
                                 fresh.parallelSteps[mergedState.nextStep].done = true;
                                 fresh.parallelSteps[mergedState.nextStep].nextStep = nextStep;
                                 //fresh.parallelSteps[mergedState.nextStep].previousStep = mergedState.previousStep || null;                           
                                 delete fresh._id;
                                 const updated = await connection.updateOne(this.#collectionName,
                                     { _id: instanceId },
-                                    { $set: { ...fresh, parallelSteps: fresh.parallelSteps } }); 
+                                    { $set: { ...fresh, parallelSteps: fresh.parallelSteps } });
                                 //console.debug('updated', updated.parallelSteps);
                                 mergedState.parallelSteps = fresh.parallelSteps;
                                 // Check if all parallel steps are done
@@ -335,12 +335,12 @@ class Workflow extends EventEmitter {
                             if (nextStep === null) {
                                 delete mergedState._id;
                                 const completionTime = (new Date(mergedState.updatedAt) - new Date(mergedState.createdAt));
-                                
+
                                 const finalresult = await connection.updateOne(this.#collectionName,
                                     { _id: instanceId },
-                                    { $set: { ...mergedState, nextStep: null, updatedAt: new Date().toISOString(), totalTime: completionTime } });                            
+                                    { $set: { ...mergedState, nextStep: null, updatedAt: new Date().toISOString(), totalTime: completionTime } });
                                 console.log(`Workflow ${stepsName} ${instanceId} is completed in time: ${completionTime / 1000}s 🎉`);
-                                this.emit('completed', { ...finalresult});
+                                this.emit('completed', { ...finalresult });
                                 resolve();
                                 return;
                             }
@@ -370,13 +370,13 @@ class Workflow extends EventEmitter {
                             } else {
                                 console.debug('enqueue step', nextStep, instanceId);
                                 await connection.enqueue(`${this.#queuePrefix}_${stepsName}_${nextStep}`, {
-                                stepsName: stepsName,
-                                goto: nextStep,
-                                state: mergedState,
-                                options: options,
-                                instanceId: instanceId
-                            });
-                            }                           
+                                    stepsName: stepsName,
+                                    goto: nextStep,
+                                    state: mergedState,
+                                    options: options,
+                                    instanceId: instanceId
+                                });
+                            }
                             this.emit('stepEnqueued', { workflowName: stepsName, step: nextStep, state: newState, instanceId });
                             resolve();
                         } catch (error) {
@@ -393,7 +393,7 @@ class Workflow extends EventEmitter {
         } catch (error) {
             console.error('error in handleNextStep outer', error.message);
             throw error;
-        }            
+        }
     }
 
     /**
@@ -424,15 +424,15 @@ class Workflow extends EventEmitter {
      * @private
      */
     async registerWithApp(app, name, description, definition) {
-        this.emit('workflowCreated', { name, description });        
+        this.emit('workflowCreated', { name, description });
 
         // Validate each step in the definition
         for (const [stepName, step] of Object.entries(definition)) {
             try {
                 if (stepName !== undefined) {
                     console.debug('registering queue for step', `${this.#queuePrefix}_${name}_${stepName}`);
-                    app.worker(`${this.#queuePrefix}_${name}_${stepName}`, async (req, res) => {                        
-                        try {                            
+                    app.worker(`${this.#queuePrefix}_${name}_${stepName}`, async (req, res) => {
+                        try {
                             const { stepsName, goto, state, instanceId, options } = req.body.payload;
                             console.debug('dequeue step', stepName, instanceId);
                             const qid = await this.handleNextStep(stepsName, goto, state, instanceId, options);
@@ -460,7 +460,7 @@ class Workflow extends EventEmitter {
         }
 
         // Store the definition
-        this.#definitions.set(name, definition);        
+        this.#definitions.set(name, definition);
 
         return name;
     }
@@ -472,13 +472,13 @@ class Workflow extends EventEmitter {
      * @throws {Error} If starting steps fails
      */
     async start(initialState) {
-        this.emit('workflowStarted', { name: this.#name, initialState });        
+        this.emit('workflowStarted', { name: this.#name, initialState });
 
         return new Promise(async (resolve, reject) => {
             try {
                 console.debug('Starting workflow', this.#name);
                 const funcs = this.#definitions.get(this.#name);
-                
+
                 if (!funcs) {
                     reject(new Error(`No workflow definition found for: ${this.#name}`));
                     return;
@@ -486,7 +486,7 @@ class Workflow extends EventEmitter {
 
                 const firstStepName = Object.keys(funcs)[0];
                 const firstStep = funcs[firstStepName];
-                
+
                 if (!firstStep) {
                     reject(new Error('No start step defined in workflow'));
                     return;
@@ -495,7 +495,7 @@ class Workflow extends EventEmitter {
                 const connection = await DB.open();
                 // Create a new workflow state in the database
                 const newState = await connection.insertOne(this.#collectionName,
-                    { ...initialState, nextStep: firstStepName, createdAt: new Date().toISOString(), workflowName: this.#name, stepCount: {  } });
+                    { ...initialState, nextStep: firstStepName, createdAt: new Date().toISOString(), workflowName: this.#name, stepCount: {} });
                 const { _id: ID } = await connection.enqueue(`${this.#queuePrefix}_${this.#name}_${firstStepName}`, {
                     stepsName: this.#name,
                     goto: firstStepName,
@@ -518,17 +518,17 @@ class Workflow extends EventEmitter {
      * @param {Object} options - Options for the update, { continue: false } to avoid continuing the the step
      * @returns {Promise<Object>} The updated state
      */
-    async updateState(instanceId, state, options={continue: true}) {
+    async updateState(instanceId, state, options = { continue: true }) {
         this.emit('stepsStateUpdating', { name: this.#name, instanceId, state });
         const connection = await DB.open();
         return new Promise(async (resolve, reject) => {
-            const doc = await connection.updateOne(this.#collectionName, 
-                { _id: instanceId }, 
+            const doc = await connection.updateOne(this.#collectionName,
+                { _id: instanceId },
                 { $set: { ...state, updatedAt: new Date().toISOString() } });
             if (options.continue) {
                 await this.continue(instanceId, false);
-            } 
-            resolve({ ...doc });                       
+            }
+            resolve({ ...doc });
         });
     }
 
@@ -549,7 +549,7 @@ class Workflow extends EventEmitter {
      * @returns {Promise<{qId: string}>} Queue ID for the continued step
      * @throws {Error} If steps instance not found
      */
-    async continue(instanceId, reset=false) {
+    async continue(instanceId, reset = false) {
         const connection = await DB.open();
         const state = await connection.findOne(this.#collectionName, { _id: instanceId });
         if (!state) {
@@ -565,10 +565,10 @@ class Workflow extends EventEmitter {
             // update the step count
             state.stepCount[state.nextStep] = { visits: 0, startTime: new Date().toISOString() };
         }
-        
+
         await connection.updateOne(this.#collectionName, { _id: instanceId }, { $set: { stepCount: state.stepCount } });
         console.debug('continue state', state);
-        this.emit('workflowContinued', { name: this.#name, step: state.nextStep, instanceId });                    
+        this.emit('workflowContinued', { name: this.#name, step: state.nextStep, instanceId });
 
         return new Promise(async (resolve, reject) => {
             const { _id: ID } = await connection.enqueue(`${this.#queuePrefix}_${this.#name}_${state.nextStep}`, {
@@ -589,7 +589,7 @@ class Workflow extends EventEmitter {
      */
     async continueAllTimedOut() {
         const db = await DB.open();
-        const timedOutWorkflows = await db.collection(this.#collectionName).find({nextStep: {$ne: null}}).toArray();
+        const timedOutWorkflows = await db.collection(this.#collectionName).find({ nextStep: { $ne: null } }).toArray();
         const now = new Date();
         const results = [];
         for (const workflow of timedOutWorkflows) {
@@ -598,7 +598,7 @@ class Workflow extends EventEmitter {
             if (diffMillis > this.#timeout) {
                 const diffMinutes = diffMillis / (1000 * 60);
                 console.log('Timed out:', workflow._id, workflow.nextStep, `(${diffMinutes.toFixed(1)} minutes old)`);
-                const result = await this.continue(workflow._id, true);    
+                const result = await this.continue(workflow._id, true);
                 console.log('Continued:', result._id);
                 results.push(result);
             }
@@ -642,13 +642,40 @@ class Workflow extends EventEmitter {
         this.emit('cancelled', { id });
         return new Promise(async (resolve, reject) => {
             const connection = await DB.open();
-            const state = await connection.updateOne(this.#collectionName, 
-                { _id: id }, 
-                { $set: { status: 'cancelled' } });    
+            const state = await connection.updateOne(this.#collectionName,
+                { _id: id },
+                { $set: { status: 'cancelled' } });
             resolve(state);
         });
     }
 
+    /**
+     * Get the status of a workflow instance (alias for getStepsStatus)
+     * @param {string} id - ID of the workflow instance
+     * @returns {Promise<Object>} The workflow status
+     */
+    async getWorkflowStatus(id) {
+        return this.getStepsStatus(id);
+    }
+
+    /**
+     * Get the state of a workflow instance (alias for getStepsStatus)
+     * @param {string} id - ID of the workflow instance
+     * @returns {Promise<Object>} The workflow state
+     */
+    async getState(id) {
+        return this.getStepsStatus(id);
+    }
+
+    /**
+     * Cancel a workflow instance (alias for cancelSteps)
+     * @param {string} id - ID of the workflow instance to cancel
+     * @returns {Promise<Object>} The cancellation result
+     */
+    async cancelWorkflow(id) {
+        return this.cancelSteps(id);
+    }
+
     /**
      * Check if a specific step in a workflow instance has timed out
      * @param {Object} workflow - The workflow instance
@@ -658,7 +685,7 @@ class Workflow extends EventEmitter {
     isStepTimedOut(workflow) {
         // Use previousStep if no stepName provided
         const stepToCheck = workflow.nextStep;
-        
+
         if (!stepToCheck || !workflow.stepCount || !workflow.stepCount[stepToCheck]) {
             console.debug('no step', stepToCheck, workflow.stepCount);
             return {
@@ -669,12 +696,12 @@ class Workflow extends EventEmitter {
         }
 
         const step = workflow.stepCount[stepToCheck];
-        
+
         // Get the timeout value for this step
         // First try step-specific config, then default options, finally fallback to global timeout
         const stepConfig = this.#steps[stepToCheck];
         const stepTimeout = stepConfig?.timeout ?? this.#defaultStepOptions.timeout ?? this.#timeout;
-        
+
         // If the step hasn't finished, check if it's been running too long
         console.debug('isStepTimedOut', stepToCheck, stepTimeout);
         if (!step.finishTime) {
@@ -716,7 +743,7 @@ class Workflow extends EventEmitter {
      */
     async findTimedOutSteps(filter = {}) {
         const db = await DB.open();
-        const workflows = await db.getMany(this.#collectionName, {"nextStep": {$ne: null}}).toArray();
+        const workflows = await db.getMany(this.#collectionName, { "nextStep": { $ne: null } }).toArray();
         if (workflows.length > 0) {
             console.debug('TimedOutSteps', workflows.length);
         }