@ronaldroe/micro-flow 1.0.0 → 1.2.1

package/dist/src/enums/workflow_event_names.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/workflow_event_names.js"],
+  "sourcesContent": ["/**\n * Enumeration of workflow lifecycle event names.\n * Workflows emit these events during their creation and execution lifecycle.\n * \n * @enum {string}\n * @readonly\n */\nconst workflow_event_names = {\n  WORKFLOW_BREAK_EXECUTED: 'workflow_break_executed',\n  WORKFLOW_CANCELLED: 'workflow_cancelled',\n  WORKFLOW_COMPLETE: 'workflow_complete',\n  WORKFLOW_CREATED: 'workflow_created',\n  WORKFLOW_ERRORED: 'workflow_errored',\n  WORKFLOW_FAILED: 'workflow_failed',\n  WORKFLOW_PAUSED: 'workflow_paused',\n  WORKFLOW_RESUMED: 'workflow_resumed',\n  WORKFLOW_RUNNING: 'workflow_running',\n  WORKFLOW_STEP_ADDED: 'workflow_step_added',\n  WORKFLOW_STEP_MOVED: 'workflow_step_moved',\n  WORKFLOW_STEP_REMOVED: 'workflow_step_removed',\n  WORKFLOW_STEP_SHIFTED: 'workflow_step_shifted',\n  WORKFLOW_STEP_SKIPPED: 'workflow_step_skipped',\n  WORKFLOW_STEPS_ADDED: 'workflow_steps_added',\n  WORKFLOW_STEPS_CLEARED: 'workflow_steps_cleared',\n}\n\nexport default workflow_event_names;\n"],
+  "mappings": "AAOA,MAAMA,EAAuB,CAC3B,wBAAyB,0BACzB,mBAAoB,qBACpB,kBAAmB,oBACnB,iBAAkB,mBAClB,iBAAkB,mBAClB,gBAAiB,kBACjB,gBAAiB,kBACjB,iBAAkB,mBAClB,iBAAkB,mBAClB,oBAAqB,sBACrB,oBAAqB,sBACrB,sBAAuB,wBACvB,sBAAuB,wBACvB,sBAAuB,wBACvB,qBAAsB,uBACtB,uBAAwB,wBAC1B,EAEA,IAAOC,EAAQD",
+  "names": ["workflow_event_names", "workflow_event_names_default"]
+}

package/dist/src/enums/workflow_statuses.js

@@ -0,0 +1,2 @@
+const e={CANCELLED:"cancelled",COMPLETE:"complete",CREATED:"created",ERRORED:"errored",FROZEN:"frozen",FAILED:"failed",PAUSED:"paused",PENDING:"pending",RUNNING:"running",SKIPPED:"skipped"};var E=e;export{E as default};
+//# sourceMappingURL=workflow_statuses.js.map

package/dist/src/enums/workflow_statuses.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/workflow_statuses.js"],
+  "sourcesContent": ["/**\n * Enumeration of possible workflow execution statuses.\n * Workflows transition through these statuses during their lifecycle.\n * \n * @enum {string}\n * @readonly\n */\nconst workflow_statuses = {\n  CANCELLED: 'cancelled',\n  COMPLETE: 'complete',\n  CREATED: 'created',\n  ERRORED: 'errored',\n  FROZEN: 'frozen',\n  FAILED: 'failed',\n  PAUSED: 'paused',\n  PENDING: 'pending',\n  RUNNING: 'running',\n  SKIPPED: 'skipped'\n};\n\nexport default workflow_statuses;\n"],
+  "mappings": "AAOA,MAAMA,EAAoB,CACxB,UAAW,YACX,SAAU,WACV,QAAS,UACT,QAAS,UACT,OAAQ,SACR,OAAQ,SACR,OAAQ,SACR,QAAS,UACT,QAAS,UACT,QAAS,SACX,EAEA,IAAOC,EAAQD",
+  "names": ["workflow_statuses", "workflow_statuses_default"]
+}

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@ronaldroe/micro-flow",
-  "version": "1.0.0",
+  "version": "1.2.1",
   "description": "A lightweight, flexible workflow orchestration library for Node.js and browser environments. Build complex, sequential processes with ease using an intuitive API that supports conditional logic, flow control, event handling, and state management.",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "scripts": {
     "build": "node build.js",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -32,7 +37,7 @@
   },
   "homepage": "https://github.com/starkeysoft/micro-flow#readme",
   "files": [
-    "index.js",
+    "dist/",
     "src/",
     "README.md",
     "LICENSE"
@@ -42,8 +47,7 @@
   },
   "dependencies": {
     "date-fns": "^4.1.0",
-    "node-schedule": "^2.1.1",
-    "uuid": "^13.0.0"
+    "node-schedule": "^2.1.1"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.14",

package/src/classes/base.js

@@ -1,4 +1,4 @@
-import { v4 as uuidv4 } from 'uuid';
+import crypto from 'crypto';
 import { base_types } from '../enums/index.js';
 import State from './state.js';
 
@@ -15,14 +15,13 @@ export default class Base {
    * @param {string} [options.base_type=base_types.STEP] - Type of the base instance.
    */
   constructor({ name, base_type = base_types.STEP }) {
-    this.id = uuidv4();
+    this.id = crypto.randomUUID();
     this.name = name ?? `${base_type}-${this.id}`;
 
     this.base_type = base_type;
     this.timing = {
       cancel_time: null,
       complete_time: null,
-      end_time: null,
       execution_time_ms: null,
       start_time: null,
     }
@@ -54,7 +53,7 @@ export default class Base {
     }
 
     const logMessage = message ? `\n[${this.base_type.toUpperCase()} - ${this.name}] ${message}` : `\n[${this.base_type.toUpperCase()} - ${this.name}] Event: ${event_name}`;
-    const logType = event_name.endsWith('_FAILED') ? 'error' : 'log';
+    const logType = event_name.endsWith('_failed') ? 'error' : 'log';
 
     console[logType](logMessage);
   }
@@ -105,7 +104,7 @@ export default class Base {
    * Marks the instance as running and sets the start time.
    */
   markAsRunning() {
-    this.timing.start_time = new Date();
+    this.timing.start_time = this.timing.start_time ?? new Date();
     this.status = State.get('statuses')[this.base_type].RUNNING;
 
     this.log(

package/src/classes/events/event.js

@@ -1,12 +1,11 @@
 import { errors, warnings } from '../../enums/index.js';
-import Broadcast from './broadcast.js';
 
 /**
  * Event class for micro-flow
  * Provides a simple event emitter implementation for workflow steps and state changes.
  *
  * This class is used for emitting and listening to events within workflows and steps.
- * For broadcasting events across multiple workflows or listeners, see the Broadcast class.
+ * For broadcasting events across multiple workflows or listeners, it uses BroadcastChannel.
  */
 class Event extends EventTarget {
   /**
@@ -50,9 +49,9 @@ class Event extends EventTarget {
     const result = this.dispatchEvent(custom_event);
 
     try {
-      const channel = new Broadcast(event_name);
-      channel.send(workingData);
-      channel.destroy();
+      const channel = new BroadcastChannel(event_name);
+      channel.postMessage(workingData);
+      channel.close();
     } catch (e) {
       console.warn(warnings.BROADCAST_FAILED, e);
     }
@@ -63,11 +62,19 @@ class Event extends EventTarget {
    * Listen for broadcasts on a given event name (channel).
    * @param {string} event_name - The event name/channel to listen for.
    * @param {Function} listener - Callback for broadcasted data.
-   * @returns {Broadcast} Returns the Broadcast instance for manual control.
+   * @returns {BroadcastChannel} Returns the channel with send() and destroy() aliases.
    */
   onBroadcast(event_name, listener) {
-    const channel = new Broadcast(event_name);
-    channel.onReceive(listener);
+    const channel = new BroadcastChannel(event_name);
+    channel.onmessage = (event) => {
+      listener(event.data);
+    };
+    channel.send = (data) => {
+      channel.postMessage(data);
+    };
+    channel.destroy = () => {
+      channel.close();
+    };
     return channel;
   }
 
@@ -75,7 +82,7 @@ class Event extends EventTarget {
    * Listen for both local and broadcast events.
    * @param {string} event_name - The event name/channel to listen for.
    * @param {Function} listener - Callback for event data.
-   * @returns {Object} Returns { event: this, broadcast: Broadcast instance }
+    * @returns {Object} Returns { event: this, broadcast: BroadcastChannel }
    */
   onAny(event_name, listener) {
     this.on(event_name, listener);

package/src/classes/events/index.js

@@ -1,4 +1,4 @@
-export { default as Broadcast } from './broadcast.js';
 export { default as Event } from './event.js';
+export { default as StateEvent } from './state_event.js';
 export { default as StepEvent } from './step_event.js';
 export { default as WorkflowEvent } from './workflow_event.js';

package/src/classes/events/state_event.js

@@ -0,0 +1,28 @@
+import { Event } from './index.js';
+import { state_event_names } from '../../enums/index.js';
+
+/**
+ * Manages state-specific events by extending the base Event class.
+ * @class StateEvent
+ * @extends Event
+ */
+export default class StateEvent extends Event {
+  event_names = state_event_names;
+
+  /**
+   * Creates a new StateEvent instance and registers all state events.
+   * @constructor
+   */
+  constructor() {
+    super();
+    this.registerStateEvents();
+  }
+
+  /**
+   * Registers all state event names defined in the state_event_names enum.
+   * @returns {void}
+   */
+  registerStateEvents() {
+    this.registerEvents(this.event_names);
+  }
+}

package/src/classes/state.js

@@ -1,8 +1,9 @@
 import { errors, warnings } from '../enums/errors.js';
-import { StepEvent, WorkflowEvent } from './events/index.js';
+import { StepEvent, WorkflowEvent, StateEvent } from './events/index.js';
 import {
   base_types,
   conditional_step_comparators,
+  state_event_names,
   step_event_names,
   step_statuses,
   step_types,
@@ -11,7 +12,7 @@ import {
   workflow_statuses,
 } from '../enums/index.js';
 
-let state = {
+const defaultState = {
   messages: {
     errors,
     warnings,
@@ -22,11 +23,13 @@ let state = {
   },
   event_names: {
     workflow: workflow_event_names,
-    step: step_event_names
+    step: step_event_names,
+    state: state_event_names,
   },
   events: {
     workflow: new WorkflowEvent(),
-    step: new StepEvent()
+    step: new StepEvent(),
+    state: new StateEvent(),
   },
   types: {
     base_types,
@@ -35,7 +38,13 @@ let state = {
   },
   workflows: {},
   conditional_step_comparators
-}
+};
+
+let state = { ...defaultState };
+
+// Module-level shortcuts for events and event_names
+const events = state.events;
+const event_names = state.event_names;
 
 /**
  * Singleton class representing the global state for workflows, steps, and processes.
@@ -56,21 +65,62 @@ class State {
     if (!path) {
       throw new Error(errors.INVALID_STATE_PATH);
     }
-
-    const parts = this.parsePath(path);
+    
+    const parts = State.parsePath(path);
     let current = state;
-
+    
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
-
+      
       if (!Object.prototype.hasOwnProperty.call(current, part) || typeof current[part] !== 'object') {
         return;
       }
-
+      
       current = current[part];
     }
-
+    
     delete current[parts[parts.length - 1]];
+
+    events.state.emit(event_names.state.DELETED, { state });
+  }
+
+  /**
+   * Iterates over a collection (array or object) located at the specified state path,
+   * executing a callback function for each item.
+   * 
+   * @param {string} path - The path of the state property to iterate over.
+   * @param {Function} callback - The function to execute for each item in the collection.
+   * @throws {Error} Throws if the state property at the path is not an array or object.
+   */
+  static async each(path, callback) {
+    const collection = State.get(path);
+    
+    if (Array.isArray(collection)) {
+      for (const [index, item] of collection.entries()) {
+        events.state.emit(event_names.state.EACH, { state });
+        await callback(item, index);
+      }
+    } else if (
+      typeof collection === 'object' &&
+      Object.prototype.toString.call(collection) === '[object Object]'
+    ) {
+      for (const key of Object.keys(collection)) {
+        events.state.emit(event_names.state.EACH, { state });
+        await callback(collection[key], key);
+      }
+    } else {
+      throw new Error(errors.VALUE_NOT_ITERABLE);
+    }
+  }
+
+  /**
+   * Freezes the entire state object, making it immutable.
+   * @returns {void}
+   */
+  static freeze() {
+    const frozenState = Object.freeze(state);
+    events.state.emit(event_names.state.FROZEN, { state });
+    return frozenState;
   }
 
   /**
@@ -79,53 +129,94 @@ class State {
    * @param {string} path - The path of the state property to get. Supports both dot notation
    * (e.g., "user.profile.name") and bracket notation (e.g., "users[0].name" or "data['key-name']").
    * Special values:
-   * - Falsy values (null, undefined, false): Returns entire state object
-   * - "*" or "": Returns entire state object
+   * - Falsy values (null, undefined, false, ""): Returns entire state object
+   * - "*": Returns entire state object
    * @param {*} [defaultValue=null] - Default value to return if the path doesn't exist.
+   * @param {string} [type='string'] - The output type to convert the value to.
+   * Supported types: "string", "number", "boolean".
    * @returns {*} The value of the state property, or defaultValue if not found. null if not found
    * and no defaultValue provided.
+   * @throws {Error} Throws if the value cannot be converted to the specified type.
    */
-  static get(path, defaultValue = null) {
+  static get(path, defaultValue = null, type = null) {
+    let gotten = state;
     if (!path || ['*', ''].includes(path)) {
-      return state;
+      events.state.emit(event_names.state.GET, { state: gotten ?? defaultValue });
+      return gotten;
     }
 
-    return this.getFromPropertyPath(path) ?? defaultValue;
-  }
+    gotten = State.getFromPropertyPath(path, false) ?? defaultValue;
 
-  /**
-   * Gets the entire state object.
-   * @returns {Object} The entire state object.
-   */
-  static getState() {
-    return state;
+    if (type) {
+      try {
+        switch (type) {
+          case 'string':
+            gotten = String(gotten);
+            break;
+          case 'number':
+            gotten = Number(gotten);
+            break;
+          case 'boolean':
+            gotten = Boolean(gotten);
+            break;
+          default:
+            break;
+        }
+      } catch (error) {
+        console.error("Error converting state value: ", error);
+      }
+    }
+
+    events.state.emit(event_names.state.GET, { state: gotten });
+
+    return gotten ?? defaultValue;
   }
 
   /**
-   * Sets the value of a state property using dot-notation or bracket-notation path access.
-   * Creates intermediate objects if they don't exist.
+   * Resolves a nested property path within the state object.
+   * Supports both dot notation and bracket notation.
    * 
-   * @param {string} path - The path of the state property to set. Supports both dot notation
-   * (e.g., "user.profile.name") and bracket notation (e.g., "users[0].name" or "data['key-name']").
-   * @param {*} value - The value to set for the state property.
-   * @returns {void}
-   * @throws {Error} Throws if path is empty or invalid.
+   * @param {string} path - The path to the property (e.g., "user.profile.name", "users[0].name", "data['key-name']").
+   * @param {boolean} [emit=true] - Whether to emit the GET_FROM_PROPERTY_PATH event.
+   * @returns {*} The value at the specified path, or undefined if not found.
    */
-  static set(path, value) {
-    if (!path) {
-      throw new Error(errors.INVALID_STATE_PATH);
+  static getFromPropertyPath(path, emit = true) {
+    const parts = State.parsePath(path);
+    let current = state;
+
+    for (const part of parts) {
+      if (current && Object.prototype.hasOwnProperty.call(current, part)) {
+        current = current[part];
+      } else {
+        return undefined;
+      }
+    }
+
+    if (emit) {
+      events.state.emit(event_names.state.GET_FROM_PROPERTY_PATH, { state });
     }
 
-    this.setToPropertyPath(path, value);
+    return current;
+  }
+
+  /**
+   * Gets the entire state object.
+   * @returns {Object} The entire state object.
+   */
+  static getState() {
+    events.state.emit(event_names.state.GET_STATE, { state });
+    return state;
   }
 
   /**
    * Merges an object into the current State.
    * @param {Object} newState - The object to merge into the current State.
-   * @returns {void}
+   * @returns {object} The updated state object.
    */
   static merge(newState) {
     state = { ...state, ...newState };
+    events.state.emit(event_names.state.MERGE, { state });
+    return state;
   }
 
   /**
@@ -146,25 +237,36 @@ class State {
   }
 
   /**
-   * Resolves a nested property path within the state object.
-   * Supports both dot notation and bracket notation.
-   * 
-   * @param {string} path - The path to the property (e.g., "user.profile.name", "users[0].name", "data['key-name']").
-   * @returns {*} The value at the specified path, or undefined if not found.
+   * Resets the state to its default values.
+   * @returns {object} The reset state object.
    */
-  static getFromPropertyPath(path) {
-    const parts = this.parsePath(path);
-    let current = state;
+  static reset() {
+    state = { 
+      ...defaultState,
+      workflows: {},  // Always create fresh to avoid shared reference mutation
+    };
+    events.state.emit(event_names.state.RESET, { state });
+    return state;
+  }
 
-    for (const part of parts) {
-      if (current && Object.prototype.hasOwnProperty.call(current, part)) {
-        current = current[part];
-      } else {
-        return undefined;
-      }
+  /**
+   * Sets the value of a state property using dot-notation or bracket-notation path access.
+   * Creates intermediate objects if they don't exist.
+   * 
+   * @param {string} path - The path of the state property to set. Supports both dot notation
+   * (e.g., "user.profile.name") and bracket notation (e.g., "users[0].name" or "data['key-name']").
+   * @param {*} value - The value to set for the state property.
+   * @returns {void}
+   * @throws {Error} Throws if path is empty or invalid.
+   */
+  static set(path, value) {
+    if (!path) {
+      throw new Error(errors.INVALID_STATE_PATH);
     }
 
-    return current;
+    events.state.emit(event_names.state.SET, { state });
+
+    State.setToPropertyPath(path, value, false);
   }
 
   /**
@@ -173,15 +275,16 @@ class State {
    * 
    * @param {string} path - The path to the property (e.g., "user.profile.name", "users[0].name", "data['key-name']").
    * @param {*} value - The value to set at the specified path.
+   * @param {boolean} [emit=true] - Whether to emit the SET_TO_PROPERTY_PATH event.
    */
-  static setToPropertyPath(path, value) {
-    const parts = this.parsePath(path);
+  static setToPropertyPath(path, value, emit = true) {
+    const parts = State.parsePath(path);
     let current = state;
-
+    
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
       const nextPart = parts[i + 1];
-
+      
       if (!Object.prototype.hasOwnProperty.call(current, part) || typeof current[part] !== 'object') {
         // Determine if next part is an array index (numeric)
         const isNextPartNumeric = /^\d+$/.test(nextPart);
@@ -189,6 +292,10 @@ class State {
       }
       current = current[part];
     }
+    
+    if (emit) {
+      events.state.emit(event_names.state.SET_TO_PROPERTY_PATH, { state });
+    }
 
     current[parts[parts.length - 1]] = value;
   }

package/src/classes/steps/case.js

@@ -0,0 +1,70 @@
+import LogicStep from './logic_step.js';
+import { conditional_step_comparators } from '../../enums/index.js';
+
+/**
+ * Case class representing a single case in a switch statement.
+ * Used in conjunction with SwitchStep to create switch/case logic.
+ * @class Case
+ * @extends LogicStep
+ */
+export default class Case extends LogicStep {
+  static step_name = 'case';
+
+  /**
+   * Creates a new Case instance.
+   * Note: Plain LogicStep instances can be used in place of Case, but they MUST have conditional.subject set.
+   * @param {Object} options - Configuration options.
+   * @param {string} [options.name] - Name of the case.
+   * @param {Object} [options.conditional] - Conditional configuration.
+   * @param {*|Function} [options.conditional.subject=null] - Subject to evaluate (typically set by SwitchStep). Can be a function.
+   * @param {conditional_step_comparators|string} [options.conditional.operator=null] - Comparison operator.
+   * @param {*|Function} [options.conditional.value=null] - Value to compare against. Can be a function that returns the value.
+   * @param {Function|Step|Workflow} [options.callable=async () => {}] - Function, Step, or Workflow to execute when case matches.
+   * @param {boolean} [options.force_subject_override=false] - Force override of subject even if already set.
+   */
+  constructor({
+    name,
+    conditional = {
+      subject: null,
+      operator: null,
+      value: null,
+    },
+    callable = async () => {},
+    force_subject_override = false,
+  }) {
+    super({
+      name,
+      step_type: Case.step_name,
+      callable,
+    });
+
+    this.conditional_config = conditional;
+    this.force_subject_override = force_subject_override;
+
+    this.is_matched = false;
+  }
+
+  /**
+   * Sets the switch subject from the parent SwitchStep.
+   * Automatically sets the conditional subject if not already set or if force_subject_override is true.
+   * @param {*} subject - The subject value from the SwitchStep.
+   * @throws {Error} If no subject is provided and conditional.subject is not set.
+   * @throws {Error} If the resulting conditional configuration is invalid.
+   */
+  set switch_subject(subject) {
+    const subjectProvided = subject !== null && subject !== undefined;
+    const hasExistingSubject = this.conditional_config.subject !== null && this.conditional_config.subject !== undefined;
+
+    if (!subjectProvided && !hasExistingSubject) {
+      throw new Error(`No subject set for case step: ${this.name}, using default equality check`);
+    }
+
+    if (subjectProvided && (!hasExistingSubject || this.force_subject_override)) {
+      this.conditional_config.subject = subject;
+    }
+
+    if (!this.conditionalIsValid()) {
+      throw new Error(`Invalid conditional configuration for case step: ${this.name}`);
+    }
+  }
+}

package/src/classes/steps/conditional_step.js

@@ -1,4 +1,5 @@
-import { LogicStep } from './index.js';
+import LogicStep from './logic_step.js';
+import { conditional_step_comparators } from '../../enums/index.js';
 
 /**
  * ConditionalStep class for branching logic based on conditions.
@@ -13,9 +14,9 @@ export default class ConditionalStep extends LogicStep {
    * @param {Object} options - Configuration options.
    * @param {string} [options.name] - Name of the step.
    * @param {Object} [options.conditional] - Conditional configuration.
-   * @param {*} [options.conditional.subject] - Subject to evaluate.
-   * @param {string} [options.conditional.operator] - Comparison operator.
-   * @param {*} [options.conditional.value] - Value to compare against.
+   * @param {*|Function} [options.conditional.subject] - Subject to evaluate. Can be a function that returns the value.
+   * @param {conditional_step_comparators|string} [options.conditional.operator] - Comparison operator.
+   * @param {*|Function} [options.conditional.value] - Value to compare against. Can be a function that returns the value.
    * @param {Function|Step|Workflow} [options.true_callable=async () => {}] - Callable to execute if condition is true.
    * @param {Function|Step|Workflow} [options.false_callable=async () => {}] - Callable to execute if condition is false.
    */
@@ -34,8 +35,18 @@ export default class ConditionalStep extends LogicStep {
       conditional
     });
 
-    this.true_callable = true_callable;
-    this.false_callable = false_callable;
+    // Bind function callables to this step instance for state access
+    if (typeof true_callable === 'function') {
+      this.true_callable = true_callable.bind(this);
+    } else {
+      this.true_callable = true_callable;
+    }
+
+    if (typeof false_callable === 'function') {
+      this.false_callable = false_callable.bind(this);
+    } else {
+      this.false_callable = false_callable;
+    }
 
     this.callable = this.conditional.bind(this);
   }
@@ -60,6 +71,7 @@ export default class ConditionalStep extends LogicStep {
       if (typeof true_callable === 'function') {
         result = await true_callable();
       } else {
+        true_callable.parentWorkflowId = this.parentWorkflowId;
         result = await true_callable.execute();
       }
     } else {
@@ -71,10 +83,11 @@ export default class ConditionalStep extends LogicStep {
       if (typeof false_callable === 'function') {
         result = await false_callable();
       } else {
+        false_callable.parentWorkflowId = this.parentWorkflowId;
         result = await false_callable.execute();
       }
     }
 
-    return result;
+    return { message: `Conditional step ${this.name} completed`, result };
   }
 }