@medusajs/workflow-engine-redis 3.0.0-preview-20250410210150 → 3.0.0-preview-20251202120138

package/dist/services/workflow-orchestrator.js

@@ -16,14 +16,11 @@ exports.WorkflowOrchestratorService = void 0;
 const orchestration_1 = require("@medusajs/framework/orchestration");
 const utils_1 = require("@medusajs/framework/utils");
 const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
-const timers_1 = require("timers");
 const ulid_1 = require("ulid");
 const AnySubscriber = "any";
 class WorkflowOrchestratorService {
     constructor({ dataLoaderOnly, redisDistributedTransactionStorage, redisPublisher, redisSubscriber, sharedContainer, }) {
         this.instanceId = (0, ulid_1.ulid)();
-        this.subscribers = new Map();
-        this.activeStepsCount = 0;
         _WorkflowOrchestratorService_logger.set(this, void 0);
         this.container_ = sharedContainer;
         this.redisPublisher = redisPublisher;
@@ -36,9 +33,17 @@ class WorkflowOrchestratorService {
         }
         this.redisDistributedTransactionStorage_ =
             redisDistributedTransactionStorage;
-        this.redisSubscriber.on("message", async (_, message) => {
-            const { instanceId, data } = JSON.parse(message);
-            await this.notify(data, false, instanceId);
+        this.redisSubscriber.on("message", async (channel, message) => {
+            const workflowId = channel.split(":")[1];
+            if (!WorkflowOrchestratorService.subscribers.has(workflowId))
+                return;
+            try {
+                const { instanceId, data } = JSON.parse(message);
+                await this.notify(data, false, instanceId);
+            }
+            catch (error) {
+                __classPrivateFieldGet(this, _WorkflowOrchestratorService_logger, "f").error(`Failed to process Redis message: ${error}`);
+            }
         });
     }
     async onApplicationShutdown() {
@@ -47,16 +52,20 @@ class WorkflowOrchestratorService {
     async onApplicationPrepareShutdown() {
         // eslint-disable-next-line max-len
         await this.redisDistributedTransactionStorage_.onApplicationPrepareShutdown();
-        while (this.activeStepsCount > 0) {
-            await new Promise((resolve) => (0, timers_1.setTimeout)(resolve, 1000));
-        }
     }
     async onApplicationStart() {
         await this.redisDistributedTransactionStorage_.onApplicationStart();
     }
-    async triggerParentStep(transaction, result) {
+    async triggerParentStep(transaction, result, errors) {
         const metadata = transaction.flow.metadata;
-        const { parentStepIdempotencyKey } = metadata ?? {};
+        const { parentStepIdempotencyKey, cancelingFromParentStep } = metadata ?? {};
+        if (cancelingFromParentStep) {
+            /**
+             * If the sub workflow is cancelling from a parent step, we don't want to trigger the parent
+             * step.
+             */
+            return;
+        }
         if (parentStepIdempotencyKey) {
             const hasFailed = [
                 utils_1.TransactionState.REVERTED,
@@ -65,7 +74,7 @@ class WorkflowOrchestratorService {
             if (hasFailed) {
                 await this.setStepFailure({
                     idempotencyKey: parentStepIdempotencyKey,
-                    stepResponse: result,
+                    stepResponse: errors,
                     options: {
                         logOnError: true,
                     },
@@ -87,12 +96,12 @@ class WorkflowOrchestratorService {
         let { throwOnError, context } = options ?? {};
         throwOnError ??= true;
         context ??= {};
-        context.transactionId = transactionId ?? (0, ulid_1.ulid)();
+        context.transactionId = transactionId ?? "auto-" + (0, ulid_1.ulid)();
         const workflowId = (0, utils_1.isString)(workflowIdOrWorkflow)
             ? workflowIdOrWorkflow
             : workflowIdOrWorkflow.getName();
         if (!workflowId) {
-            throw new Error("Workflow ID is required");
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Workflow ID is required`);
         }
         const events = this.buildWorkflowEvents({
             customEventHandlers: eventHandlers,
@@ -101,17 +110,17 @@ class WorkflowOrchestratorService {
         });
         const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
         if (!exportedWorkflow) {
-            throw new Error(`Workflow with id "${workflowId}" not found.`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Workflow with id "${workflowId}" not found.`);
         }
+        const { onFinish, ...restEvents } = events;
         const originalOnFinishHandler = events.onFinish;
-        delete events.onFinish;
         const ret = await exportedWorkflow.run({
             input,
             throwOnError: false,
             logOnError,
             resultFrom,
             context,
-            events,
+            events: restEvents,
             container: container ?? this.container_,
         });
         const hasFinished = ret.transaction.hasFinished();
@@ -135,10 +144,13 @@ class WorkflowOrchestratorService {
                 result,
                 errors,
             });
-            await this.triggerParentStep(ret.transaction, result);
+            await this.triggerParentStep(ret.transaction, result, errors);
         }
-        if (throwOnError && ret.thrownError) {
-            throw ret.thrownError;
+        if (throwOnError && (ret.thrownError || ret.errors?.length)) {
+            if (ret.thrownError) {
+                throw ret.thrownError;
+            }
+            throw ret.errors[0].error;
         }
         return { acknowledgement, ...ret };
     }
@@ -156,18 +168,11 @@ class WorkflowOrchestratorService {
         if (!transactionId) {
             throw new Error("Transaction ID is required");
         }
-        const events = this.buildWorkflowEvents({
-            customEventHandlers: eventHandlers,
-            workflowId,
-            transactionId: transactionId,
-        });
         const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
         if (!exportedWorkflow) {
-            throw new Error(`Workflow with id "${workflowId}" not found.`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Workflow with id "${workflowId}" not found.`);
         }
-        const originalOnFinishHandler = events.onFinish;
-        delete events.onFinish;
-        const transaction = await this.getRunningTransaction(workflowId, transactionId, options);
+        const transaction = await this.getRunningTransaction(workflowId, transactionId, { ...options, isCancelling: true });
         if (!transaction) {
             if (!throwOnError) {
                 return {
@@ -180,20 +185,28 @@ class WorkflowOrchestratorService {
             }
             throw new Error("Transaction not found");
         }
+        const events = this.buildWorkflowEvents({
+            customEventHandlers: eventHandlers,
+            workflowId,
+            transactionId: transactionId,
+        });
+        const { onFinish, ...restEvents } = events;
+        const originalOnFinishHandler = events.onFinish;
         const ret = await exportedWorkflow.cancel({
             transaction,
             throwOnError: false,
             logOnError,
             context,
-            events,
+            events: restEvents,
             container: container ?? this.container_,
         });
         const hasFinished = ret.transaction.hasFinished();
         const metadata = ret.transaction.getFlow().metadata;
         const { parentStepIdempotencyKey } = metadata ?? {};
-        const hasFailed = [utils_1.TransactionState.FAILED].includes(ret.transaction.getFlow().state);
+        const transactionState = ret.transaction.getFlow().state;
+        const hasFailed = [utils_1.TransactionState.FAILED].includes(transactionState);
         const acknowledgement = {
-            transactionId: context.transactionId,
+            transactionId: transaction.transactionId,
             workflowId: workflowId,
             parentStepIdempotencyKey,
             hasFinished,
@@ -207,10 +220,13 @@ class WorkflowOrchestratorService {
                 result,
                 errors,
             });
-            await this.triggerParentStep(ret.transaction, result);
+            await this.triggerParentStep(ret.transaction, result, errors);
         }
-        if (throwOnError && ret.thrownError) {
-            throw ret.thrownError;
+        if (throwOnError && (ret.thrownError || ret.errors?.length)) {
+            if (ret.thrownError) {
+                throw ret.thrownError;
+            }
+            throw ret.errors[0].error;
         }
         return { acknowledgement, ...ret };
     }
@@ -230,6 +246,47 @@ class WorkflowOrchestratorService {
         const transaction = await flow.getRunningTransaction(transactionId, context);
         return transaction;
     }
+    async retryStep({ idempotencyKey, options, }) {
+        const { context, logOnError, container, events: eventHandlers, } = options ?? {};
+        let { throwOnError } = options ?? {};
+        throwOnError ??= true;
+        const [idempotencyKey_, { workflowId, transactionId }] = this.buildIdempotencyKeyAndParts(idempotencyKey);
+        const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
+        if (!exportedWorkflow) {
+            throw new Error(`Workflow with id "${workflowId}" not found.`);
+        }
+        const events = this.buildWorkflowEvents({
+            customEventHandlers: eventHandlers,
+            transactionId,
+            workflowId,
+        });
+        const { onFinish, ...restEvents } = events;
+        const originalOnFinishHandler = events.onFinish;
+        const ret = await exportedWorkflow.retryStep({
+            idempotencyKey: idempotencyKey_,
+            context,
+            throwOnError: false,
+            logOnError,
+            events: restEvents,
+            container: container ?? this.container_,
+        });
+        if (ret.transaction.hasFinished()) {
+            const { result, errors } = ret;
+            await originalOnFinishHandler({
+                transaction: ret.transaction,
+                result,
+                errors,
+            });
+            await this.triggerParentStep(ret.transaction, result, errors);
+        }
+        if (throwOnError && (ret.thrownError || ret.errors?.length)) {
+            if (ret.thrownError) {
+                throw ret.thrownError;
+            }
+            throw ret.errors[0].error;
+        }
+        return ret;
+    }
     async setStepSuccess({ idempotencyKey, stepResponse, options, }) {
         const { context, logOnError, resultFrom, container, events: eventHandlers, } = options ?? {};
         let { throwOnError } = options ?? {};
@@ -244,15 +301,15 @@ class WorkflowOrchestratorService {
             transactionId,
             workflowId,
         });
+        const { onFinish, ...restEvents } = events;
         const originalOnFinishHandler = events.onFinish;
-        delete events.onFinish;
         const ret = await exportedWorkflow.registerStepSuccess({
             idempotencyKey: idempotencyKey_,
             context,
             resultFrom,
             throwOnError: false,
             logOnError,
-            events,
+            events: restEvents,
             response: stepResponse,
             container: container ?? this.container_,
         });
@@ -263,15 +320,18 @@ class WorkflowOrchestratorService {
                 result,
                 errors,
             });
-            await this.triggerParentStep(ret.transaction, result);
+            await this.triggerParentStep(ret.transaction, result, errors);
         }
-        if (throwOnError && ret.thrownError) {
-            throw ret.thrownError;
+        if (throwOnError && (ret.thrownError || ret.errors?.length)) {
+            if (ret.thrownError) {
+                throw ret.thrownError;
+            }
+            throw ret.errors[0].error;
         }
         return ret;
     }
     async setStepFailure({ idempotencyKey, stepResponse, options, }) {
-        const { context, logOnError, resultFrom, container, events: eventHandlers, } = options ?? {};
+        const { context, logOnError, resultFrom, container, events: eventHandlers, forcePermanentFailure, } = options ?? {};
         let { throwOnError } = options ?? {};
         throwOnError ??= true;
         const [idempotencyKey_, { workflowId, transactionId }] = this.buildIdempotencyKeyAndParts(idempotencyKey);
@@ -284,17 +344,18 @@ class WorkflowOrchestratorService {
             transactionId,
             workflowId,
         });
+        const { onFinish, ...restEvents } = events;
         const originalOnFinishHandler = events.onFinish;
-        delete events.onFinish;
         const ret = await exportedWorkflow.registerStepFailure({
             idempotencyKey: idempotencyKey_,
             context,
             resultFrom,
             throwOnError: false,
             logOnError,
-            events,
+            events: restEvents,
             response: stepResponse,
             container: container ?? this.container_,
+            forcePermanentFailure,
         });
         if (ret.transaction.hasFinished()) {
             const { result, errors } = ret;
@@ -303,45 +364,51 @@ class WorkflowOrchestratorService {
                 result,
                 errors,
             });
-            await this.triggerParentStep(ret.transaction, result);
+            await this.triggerParentStep(ret.transaction, result, errors);
         }
-        if (throwOnError && ret.thrownError) {
-            throw ret.thrownError;
+        if (throwOnError && (ret.thrownError || ret.errors?.length)) {
+            if (ret.thrownError) {
+                throw ret.thrownError;
+            }
+            throw ret.errors[0].error;
         }
         return ret;
     }
     subscribe({ workflowId, transactionId, subscriber, subscriberId, }) {
         subscriber._id = subscriberId;
-        const subscribers = this.subscribers.get(workflowId) ?? new Map();
+        const subscribers = WorkflowOrchestratorService.subscribers.get(workflowId) ?? new Map();
         // Subscribe instance to redis
-        if (!this.subscribers.has(workflowId)) {
+        if (!WorkflowOrchestratorService.subscribers.has(workflowId)) {
             void this.redisSubscriber.subscribe(this.getChannelName(workflowId));
         }
         const handlerIndex = (handlers) => {
-            return handlers.indexOf((s) => s === subscriber || s._id === subscriberId);
+            return handlers.findIndex((s) => s === subscriber || s._id === subscriberId);
         };
         if (transactionId) {
             const transactionSubscribers = subscribers.get(transactionId) ?? [];
             const subscriberIndex = handlerIndex(transactionSubscribers);
             if (subscriberIndex !== -1) {
-                transactionSubscribers.slice(subscriberIndex, 1);
+                transactionSubscribers.splice(subscriberIndex, 1);
             }
             transactionSubscribers.push(subscriber);
             subscribers.set(transactionId, transactionSubscribers);
-            this.subscribers.set(workflowId, subscribers);
+            WorkflowOrchestratorService.subscribers.set(workflowId, subscribers);
             return;
         }
         const workflowSubscribers = subscribers.get(AnySubscriber) ?? [];
         const subscriberIndex = handlerIndex(workflowSubscribers);
         if (subscriberIndex !== -1) {
-            workflowSubscribers.slice(subscriberIndex, 1);
+            workflowSubscribers.splice(subscriberIndex, 1);
         }
         workflowSubscribers.push(subscriber);
         subscribers.set(AnySubscriber, workflowSubscribers);
-        this.subscribers.set(workflowId, subscribers);
+        WorkflowOrchestratorService.subscribers.set(workflowId, subscribers);
     }
     unsubscribe({ workflowId, transactionId, subscriberOrId, }) {
-        const subscribers = this.subscribers.get(workflowId) ?? new Map();
+        const subscribers = WorkflowOrchestratorService.subscribers.get(workflowId);
+        if (!subscribers) {
+            return;
+        }
         const filterSubscribers = (handlers) => {
             return handlers.filter((handler) => {
                 return handler._id
@@ -349,81 +416,99 @@ class WorkflowOrchestratorService {
                     : handler !== subscriberOrId;
             });
         };
-        // Unsubscribe instance
-        if (!this.subscribers.has(workflowId)) {
-            void this.redisSubscriber.unsubscribe(this.getChannelName(workflowId));
-        }
         if (transactionId) {
-            const transactionSubscribers = subscribers.get(transactionId) ?? [];
-            const newTransactionSubscribers = filterSubscribers(transactionSubscribers);
-            subscribers.set(transactionId, newTransactionSubscribers);
-            this.subscribers.set(workflowId, subscribers);
-            return;
+            const transactionSubscribers = subscribers.get(transactionId);
+            if (transactionSubscribers) {
+                const newTransactionSubscribers = filterSubscribers(transactionSubscribers);
+                if (newTransactionSubscribers.length) {
+                    subscribers.set(transactionId, newTransactionSubscribers);
+                }
+                else {
+                    subscribers.delete(transactionId);
+                }
+            }
+        }
+        else {
+            const workflowSubscribers = subscribers.get(AnySubscriber);
+            if (workflowSubscribers) {
+                const newWorkflowSubscribers = filterSubscribers(workflowSubscribers);
+                if (newWorkflowSubscribers.length) {
+                    subscribers.set(AnySubscriber, newWorkflowSubscribers);
+                }
+                else {
+                    subscribers.delete(AnySubscriber);
+                }
+            }
+        }
+        if (subscribers.size === 0) {
+            WorkflowOrchestratorService.subscribers.delete(workflowId);
+            void this.redisSubscriber.unsubscribe(this.getChannelName(workflowId));
         }
-        const workflowSubscribers = subscribers.get(AnySubscriber) ?? [];
-        const newWorkflowSubscribers = filterSubscribers(workflowSubscribers);
-        subscribers.set(AnySubscriber, newWorkflowSubscribers);
-        this.subscribers.set(workflowId, subscribers);
     }
     async notify(options, publish = true, instanceId = this.instanceId) {
         if (!publish && instanceId === this.instanceId) {
             return;
         }
-        if (publish) {
-            const channel = this.getChannelName(options.workflowId);
-            const message = JSON.stringify({
-                instanceId: this.instanceId,
-                data: options,
-            });
-            await this.redisPublisher.publish(channel, message);
-        }
-        const { eventType, workflowId, transactionId, errors, result, step, response, } = options;
-        const subscribers = this.subscribers.get(workflowId) ?? new Map();
-        const notifySubscribers = (handlers) => {
-            handlers.forEach((handler) => {
-                const args = {
-                    eventType,
-                    workflowId,
-                    transactionId,
-                    step,
-                    response,
-                    result,
-                    errors,
-                };
-                const isPromise = "then" in handler;
-                if (isPromise) {
-                    ;
-                    handler(args).catch((e) => {
-                        __classPrivateFieldGet(this, _WorkflowOrchestratorService_logger, "f").error(e);
+        const { workflowId, isFlowAsync } = options;
+        // Non-blocking Redis publishing
+        if (publish && isFlowAsync) {
+            setImmediate(async () => {
+                try {
+                    const channel = this.getChannelName(workflowId);
+                    const message = JSON.stringify({
+                        instanceId: this.instanceId,
+                        data: options,
                     });
+                    await this.redisPublisher.publish(channel, message);
                 }
-                else {
-                    try {
-                        handler(args);
-                    }
-                    catch (e) {
-                        __classPrivateFieldGet(this, _WorkflowOrchestratorService_logger, "f").error(e);
+                catch (error) {
+                    __classPrivateFieldGet(this, _WorkflowOrchestratorService_logger, "f").error(`Failed to publish to Redis: ${error}`);
+                }
+            });
+        }
+        // Process subscribers asynchronously
+        setImmediate(() => this.processSubscriberNotifications(options));
+    }
+    async processSubscriberNotifications(options) {
+        const { workflowId, transactionId, eventType } = options;
+        const subscribers = WorkflowOrchestratorService.subscribers.get(workflowId) ?? new Map();
+        const notifySubscribersAsync = async (handlers) => {
+            const promises = handlers.map(async (handler) => {
+                try {
+                    const result = handler(options);
+                    if (result && typeof result === "object" && "then" in result) {
+                        await result;
                     }
                 }
+                catch (error) {
+                    __classPrivateFieldGet(this, _WorkflowOrchestratorService_logger, "f").error(`Subscriber error: ${error}`);
+                }
             });
+            await (0, utils_1.promiseAll)(promises);
         };
+        const tasks = [];
         if (transactionId) {
             const transactionSubscribers = subscribers.get(transactionId) ?? [];
-            notifySubscribers(transactionSubscribers);
-            // removes transaction id subscribers on finish
+            if (transactionSubscribers.length > 0) {
+                tasks.push(notifySubscribersAsync(transactionSubscribers));
+            }
             if (eventType === "onFinish") {
                 subscribers.delete(transactionId);
             }
         }
         const workflowSubscribers = subscribers.get(AnySubscriber) ?? [];
-        notifySubscribers(workflowSubscribers);
+        if (workflowSubscribers.length > 0) {
+            tasks.push(notifySubscribersAsync(workflowSubscribers));
+        }
+        await (0, utils_1.promiseAll)(tasks);
     }
     getChannelName(workflowId) {
         return `orchestrator:${workflowId}`;
     }
     buildWorkflowEvents({ customEventHandlers, workflowId, transactionId, }) {
-        const notify = async ({ eventType, step, result, response, errors, }) => {
+        const notify = async ({ isFlowAsync, eventType, step, result, response, errors, state, }) => {
             await this.notify({
+                isFlowAsync,
                 workflowId,
                 transactionId,
                 eventType,
@@ -431,40 +516,66 @@ class WorkflowOrchestratorService {
                 step,
                 result,
                 errors,
+                state,
             });
         };
         return {
             onTimeout: async ({ transaction }) => {
                 customEventHandlers?.onTimeout?.({ transaction });
-                await notify({ eventType: "onTimeout" });
+                await notify({
+                    eventType: "onTimeout",
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onBegin: async ({ transaction }) => {
                 customEventHandlers?.onBegin?.({ transaction });
-                await notify({ eventType: "onBegin" });
+                await notify({
+                    eventType: "onBegin",
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onResume: async ({ transaction }) => {
                 customEventHandlers?.onResume?.({ transaction });
-                await notify({ eventType: "onResume" });
+                await notify({
+                    eventType: "onResume",
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onCompensateBegin: async ({ transaction }) => {
                 customEventHandlers?.onCompensateBegin?.({ transaction });
-                await notify({ eventType: "onCompensateBegin" });
+                await notify({
+                    eventType: "onCompensateBegin",
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onFinish: async ({ transaction, result, errors }) => {
                 customEventHandlers?.onFinish?.({ transaction, result, errors });
-                await notify({ eventType: "onFinish" });
+                await notify({
+                    eventType: "onFinish",
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                    result,
+                    errors,
+                    state: transaction.getFlow().state,
+                });
             },
             onStepBegin: async ({ step, transaction }) => {
                 customEventHandlers?.onStepBegin?.({ step, transaction });
-                this.activeStepsCount++;
-                await notify({ eventType: "onStepBegin", step });
+                await notify({
+                    eventType: "onStepBegin",
+                    step,
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onStepSuccess: async ({ step, transaction }) => {
                 const stepName = step.definition.action;
                 const response = await (0, workflows_sdk_1.resolveValue)(transaction.getContext().invoke[stepName], transaction);
                 customEventHandlers?.onStepSuccess?.({ step, transaction, response });
-                await notify({ eventType: "onStepSuccess", step, response });
-                this.activeStepsCount--;
+                await notify({
+                    eventType: "onStepSuccess",
+                    step,
+                    response,
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onStepFailure: async ({ step, transaction }) => {
                 const stepName = step.definition.action;
@@ -472,13 +583,20 @@ class WorkflowOrchestratorService {
                     .getErrors(orchestration_1.TransactionHandlerType.INVOKE)
                     .filter((err) => err.action === stepName);
                 customEventHandlers?.onStepFailure?.({ step, transaction, errors });
-                await notify({ eventType: "onStepFailure", step, errors });
-                this.activeStepsCount--;
+                await notify({
+                    eventType: "onStepFailure",
+                    step,
+                    errors,
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onStepAwaiting: async ({ step, transaction }) => {
                 customEventHandlers?.onStepAwaiting?.({ step, transaction });
-                await notify({ eventType: "onStepAwaiting", step });
-                this.activeStepsCount--;
+                await notify({
+                    eventType: "onStepAwaiting",
+                    step,
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onCompensateStepSuccess: async ({ step, transaction }) => {
                 const stepName = step.definition.action;
@@ -488,7 +606,12 @@ class WorkflowOrchestratorService {
                     transaction,
                     response,
                 });
-                await notify({ eventType: "onCompensateStepSuccess", step, response });
+                await notify({
+                    eventType: "onCompensateStepSuccess",
+                    step,
+                    response,
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
             onCompensateStepFailure: async ({ step, transaction }) => {
                 const stepName = step.definition.action;
@@ -496,7 +619,12 @@ class WorkflowOrchestratorService {
                     .getErrors(orchestration_1.TransactionHandlerType.COMPENSATE)
                     .filter((err) => err.action === stepName);
                 customEventHandlers?.onStepFailure?.({ step, transaction, errors });
-                await notify({ eventType: "onCompensateStepFailure", step, errors });
+                await notify({
+                    eventType: "onCompensateStepFailure",
+                    step,
+                    errors,
+                    isFlowAsync: transaction.getFlow().hasAsyncSteps,
+                });
             },
         };
     }
@@ -528,4 +656,5 @@ class WorkflowOrchestratorService {
 }
 exports.WorkflowOrchestratorService = WorkflowOrchestratorService;
 _WorkflowOrchestratorService_logger = new WeakMap();
+WorkflowOrchestratorService.subscribers = new Map();
 //# sourceMappingURL=workflow-orchestrator.js.map