bpmn-elements 9.0.0 → 9.1.0

package/dist/tasks/SubProcess.js

@@ -191,10 +191,11 @@ SubProcessBehaviour.prototype._onExecutionCompleted = function onExecutionComple
         broker.cancel(message.fields.consumerTag);
         break;
       }
+    case 'cancel':
     case 'discard':
       {
         broker.cancel(message.fields.consumerTag);
-        broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content));
+        broker.publish('execution', 'execute.' + messageType, (0, _messageHelper.cloneContent)(content));
         break;
       }
     case 'completed':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -46,8 +46,8 @@
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
     "@babel/cli": "^7.21.0",
-    "@babel/core": "^7.21.3",
-    "@babel/preset-env": "^7.20.2",
+    "@babel/core": "^7.21.4",
+    "@babel/preset-env": "^7.21.4",
     "@babel/register": "^7.21.0",
     "bpmn-moddle": "^8.0.1",
     "c8": "^7.13.0",
@@ -55,7 +55,7 @@
     "chai": "^4.3.7",
     "chronokinesis": "^4.0.1",
     "debug": "^4.3.4",
-    "eslint": "^8.36.0",
+    "eslint": "^8.37.0",
     "eslint-plugin-import": "^2.27.5",
     "got": "^12.6.0",
     "mocha": "^10.1.0",

package/src/EventBroker.js

@@ -48,6 +48,7 @@ function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
   const runQ = broker.assertQueue('run-q', {durable: true, autoDelete: false});
   const formatRunQ = broker.assertQueue('format-run-q', {durable: true, autoDelete: false});
   const executionQ = broker.assertQueue('execution-q', {durable: true, autoDelete: false});
+  broker.assertQueue('inbound-q', {durable: true, autoDelete: false});
 
   broker.bindQueue(runQ.name, 'run', 'run.#');
   broker.bindQueue(formatRunQ.name, 'format', 'run.#');

package/src/Tracker.js

@@ -0,0 +1,73 @@
+export function ActivityTracker(parentId) {
+  this.id = parentId;
+  this.status = { wait: [], execute: [], timer: [] };
+}
+
+Object.defineProperty(ActivityTracker.prototype, 'activityStatus', {
+  get() {
+    const status = this.status;
+    if (status.execute.length) return 'executing';
+    if (status.timer.length) return 'timer';
+    return status.wait.length ? 'wait' : 'idle';
+  },
+});
+
+ActivityTracker.prototype.track = function track(routingKey, message) {
+  const content = message.content;
+  if (content.isSequenceFlow) return;
+  if (content.isSubProcess) return;
+  const executionId = content.executionId;
+
+  switch (routingKey) {
+    case 'activity.enter':
+    case 'activity.discard':
+    case 'activity.start':
+    case 'activity.execution.completed':
+    case 'activity.execution.error':
+    case 'activity.end':
+      this._executing(executionId);
+      break;
+    case 'activity.execution.outbound.take':
+    case 'activity.detach':
+    case 'activity.wait': {
+      if (content.isMultiInstance) this._waiting(content.parent.executionId);
+      else this._waiting(executionId);
+      break;
+    }
+    case 'activity.timer':
+      this._timer(content.parent.executionId);
+      break;
+    case 'activity.leave':
+      this._leave(executionId);
+      break;
+  }
+};
+
+ActivityTracker.prototype._executing = function executing(id) {
+  const {wait, execute} = this.status;
+  if (execute.indexOf(id) === -1) execute.push(id);
+  let idx;
+  if ((idx = wait.indexOf(id)) !== -1) wait.splice(idx, 1);
+};
+
+ActivityTracker.prototype._waiting = function waiting(id) {
+  const {wait, execute} = this.status;
+  if (wait.indexOf(id) === -1) wait.push(id);
+  let idx;
+  if ((idx = execute.indexOf(id)) !== -1) execute.splice(idx, 1);
+};
+
+ActivityTracker.prototype._timer = function timerFn(id) {
+  const {timer, execute} = this.status;
+  if (timer.indexOf(id) === -1) timer.push(id);
+  let idx;
+  if ((idx = execute.indexOf(id)) !== -1) execute.splice(idx, 1);
+};
+
+ActivityTracker.prototype._leave = function leave(id) {
+  const {wait, execute, timer} = this.status;
+  let idx;
+  if ((idx = wait.indexOf(id)) !== -1) wait.splice(idx, 1);
+  if ((idx = execute.indexOf(id)) !== -1) execute.splice(idx, 1);
+  if ((idx = timer.indexOf(id)) !== -1) timer.splice(idx, 1);
+};

package/src/activity/Activity.js

@@ -1,5 +1,5 @@
 import ActivityExecution from './ActivityExecution.js';
-import {brokerSafeId, getUniqueId} from '../shared.js';
+import {getUniqueId} from '../shared.js';
 import {ActivityApi} from '../Api.js';
 import {ActivityBroker} from '../EventBroker.js';
 import {Formatter} from '../MessageFormatter.js';
@@ -18,6 +18,7 @@ const kFlows = Symbol.for('flows');
 const kFormatter = Symbol.for('formatter');
 const kMessageHandlers = Symbol.for('messageHandlers');
 const kStateMessage = Symbol.for('stateMessage');
+const kActivated = Symbol.for('activated');
 
 export default Activity;
 
@@ -39,6 +40,7 @@ function Activity(Behaviour, activityDef, context) {
     taken: 0,
     discarded: 0,
   };
+  const isForCompensation = !!behaviour.isForCompensation;
 
   let attachedToActivity, attachedTo;
   if (attachedToRef) {
@@ -56,7 +58,14 @@ function Activity(Behaviour, activityDef, context) {
 
   const inboundSequenceFlows = context.getInboundSequenceFlows(id);
   const inboundAssociations = context.getInboundAssociations(id);
-  const inboundTriggers = attachedToActivity ? [attachedToActivity] : inboundSequenceFlows.slice();
+  let inboundTriggers;
+  if (attachedToActivity) {
+    inboundTriggers = [attachedToActivity];
+  } else if (isForCompensation) {
+    inboundTriggers = inboundAssociations.slice();
+  } else {
+    inboundTriggers = inboundSequenceFlows.slice();
+  }
   const outboundSequenceFlows = context.getOutboundSequenceFlows(id);
   const flows = this[kFlows] = {
     inboundSequenceFlows,
@@ -67,7 +76,6 @@ function Activity(Behaviour, activityDef, context) {
     outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows),
   };
 
-  const isForCompensation = !!behaviour.isForCompensation;
   const isParallelJoin = activityDef.isParallelGateway && flows.inboundSequenceFlows.length > 1;
   this[kFlags] = {
     isEnd: flows.outboundSequenceFlows.length === 0,
@@ -89,19 +97,6 @@ function Activity(Behaviour, activityDef, context) {
     onExecutionMessage: this._onExecutionMessage.bind(this),
   };
 
-  const onInboundEvent = this._onInboundEvent.bind(this);
-  broker.assertQueue('inbound-q', {durable: true, autoDelete: false});
-  if (isForCompensation) {
-    for (const trigger of inboundAssociations) {
-      trigger.broker.subscribeTmp('event', '#', onInboundEvent, {noAck: true, consumerTag: `_inbound-${id}`});
-    }
-  } else {
-    for (const trigger of inboundTriggers) {
-      if (trigger.isSequenceFlow) trigger.broker.subscribeTmp('event', 'flow.#', onInboundEvent, {noAck: true, consumerTag: `_inbound-${id}`});
-      else trigger.broker.subscribeTmp('event', 'activity.#', onInboundEvent, {noAck: true, consumerTag: `_inbound-${id}`});
-    }
-  }
-
   this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed) => new ed.Behaviour(this, ed, this.context));
   this[kExtensions] = context.loadExtensions(this);
 }
@@ -198,6 +193,12 @@ Object.defineProperty(Activity.prototype, 'isSubProcess', {
     return this[kFlags].isSubProcess;
   },
 });
+Object.defineProperty(Activity.prototype, 'isTransaction', {
+  enumerable: true,
+  get() {
+    return this[kFlags].isTransaction;
+  },
+});
 
 Object.defineProperty(Activity.prototype, 'isMultiInstance', {
   enumerable: true,
@@ -242,12 +243,15 @@ Object.defineProperty(Activity.prototype, 'eventDefinitions', {
 });
 
 Activity.prototype.activate = function activate() {
-  if (this[kFlags].isForCompensation) return;
+  this[kActivated] = true;
+  this.addInboundListeners();
   return this._consumeInbound();
 };
 
 Activity.prototype.deactivate = function deactivate() {
+  this[kActivated] = false;
   const broker = this.broker;
+  this.removeInboundListeners();
   broker.cancel('_run-on-inbound');
   broker.cancel('_format-consumer');
 };
@@ -326,9 +330,26 @@ Activity.prototype.discard = function discard(discardContent) {
   this._consumeRunQ();
 };
 
+Activity.prototype.addInboundListeners = function addInboundListeners() {
+  const onInboundEvent = this._onInboundEvent.bind(this);
+  const triggerConsumerTag = `_inbound-${this.id}`;
+  for (const trigger of this[kFlows].inboundTriggers) {
+    if (trigger.isSequenceFlow) trigger.broker.subscribeTmp('event', 'flow.#', onInboundEvent, {noAck: true, consumerTag: triggerConsumerTag});
+    else if (this.isForCompensation) trigger.broker.subscribeTmp('event', 'association.#', onInboundEvent, {noAck: true, consumerTag: triggerConsumerTag});
+    else trigger.broker.subscribeTmp('event', 'activity.#', onInboundEvent, {noAck: true, consumerTag: triggerConsumerTag});
+  }
+};
+
+Activity.prototype.removeInboundListeners = function removeInboundListeners() {
+  const triggerConsumerTag = `_inbound-${this.id}`;
+  for (const trigger of this[kFlows].inboundTriggers) {
+    trigger.broker.cancel(triggerConsumerTag);
+  }
+};
+
 Activity.prototype.stop = function stop() {
-  if (!this[kConsuming]) return;
-  return this.getApi().stop();
+  if (!this[kConsuming]) return this.broker.cancel('_run-on-inbound');
+  return this.getApi(this[kStateMessage]).stop();
 };
 
 Activity.prototype.next = function next() {
@@ -394,6 +415,7 @@ Activity.prototype._discardRun = function discardRun() {
 
   const execution = this[kExec].execution;
   if (execution && !execution.completed) return;
+
   switch (status) {
     case 'executing':
     case 'error':
@@ -427,6 +449,8 @@ Activity.prototype._shakeOutbound = function shakeOutbound(sourceMessage) {
 };
 
 Activity.prototype._consumeInbound = function consumeInbound() {
+  if (!this[kActivated]) return;
+
   if (this.status) return;
   const inboundQ = this.broker.getQueue('inbound-q');
   if (this[kFlags].isParallelJoin) {
@@ -438,7 +462,6 @@ Activity.prototype._consumeInbound = function consumeInbound() {
 
 Activity.prototype._onInbound = function onInbound(routingKey, message) {
   message.ack();
-  const id = this.id;
   const broker = this.broker;
   broker.cancel('_run-on-inbound');
 
@@ -460,16 +483,6 @@ Activity.prototype._onInbound = function onInbound(routingKey, message) {
       if (content.discardSequence) discardSequence = content.discardSequence.slice();
       return this._runDiscard({inbound, discardSequence});
     }
-    case 'association.complete': {
-      broker.cancel('_run-on-inbound');
-
-      const compensationId = `${brokerSafeId(id)}_${brokerSafeId(content.sequenceId)}`;
-      this.logger.debug(`<${id}> completed compensation with id <${compensationId}>`);
-
-      return this._publishEvent('compensation.end', this._createMessage({
-        executionId: compensationId,
-      }));
-    }
   }
 };
 
@@ -516,7 +529,6 @@ Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message)
 
 Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message) {
   const {fields, content, properties} = message;
-  const id = this.id;
   const inboundQ = this.broker.getQueue('inbound-q');
 
   switch (routingKey) {
@@ -534,25 +546,6 @@ Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message
     case 'flow.take':
     case 'flow.discard':
       return inboundQ.queueMessage(fields, cloneContent(content), properties);
-    case 'association.discard': {
-      this.logger.debug(`<${id}> compensation discarded`);
-      return inboundQ.purge();
-    }
-    case 'association.complete': {
-      if (!this[kFlags].isForCompensation) break;
-
-      inboundQ.queueMessage(fields, cloneContent(content), properties);
-
-      const compensationId = `${brokerSafeId(id)}_${brokerSafeId(content.sequenceId)}`;
-      this._publishEvent('compensation.start', this._createMessage({
-        executionId: compensationId,
-        placeholder: true,
-      }));
-
-      this.logger.debug(`<${id}> start compensation with id <${compensationId}>`);
-
-      return this._consumeInbound();
-    }
   }
 };
 
@@ -631,6 +624,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
     case 'run.execute.passthrough': {
       const execution = this.execution;
       if (!isRedelivered && execution) {
+        if (execution.completed) return message.ack();
         this[kExecuteMessage] = message;
         return execution.passthrough(message);
       }
@@ -739,6 +733,7 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
       broker.publish('run', 'run.discarded', content, {correlationId});
       break;
     }
+    case 'execution.cancel':
     case 'execution.discard':
       this.status = 'discarded';
       broker.publish('run', 'run.discarded', content, {correlationId});
@@ -756,7 +751,6 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
 Activity.prototype._ackRunExecuteMessage = function ackRunExecuteMessage() {
   if (this.environment.settings.step) return;
   const executeMessage = this[kExecuteMessage];
-  this[kExecuteMessage] = null;
   executeMessage.ack();
 };
 

package/src/activity/ActivityExecution.js

@@ -178,10 +178,12 @@ ActivityExecution.prototype._onExecuteMessage = function onExecuteMessage(routin
       if (!this[kPostponed].length) return this.broker.publish('execution', 'execute.start', cloneContent(this[kExecuteMessage].content));
       break;
     }
+    case 'execute.cancel':
+      return this._onExecutionDiscarded('cancel', message);
     case 'execute.error':
+      return this._onExecutionDiscarded('error', message);
     case 'execute.discard':
-      return this._onExecutionDiscarded(message);
-    case 'execute.cancel':
+      return this._onExecutionDiscarded('discard', message);
     case 'execute.completed': {
       if (isRedelivered) {
         message.ack();
@@ -261,7 +263,7 @@ ActivityExecution.prototype._onExecutionCompleted = function onExecutionComplete
   this._publishExecutionCompleted('completed', {...postponedMsg.content, ...message.content}, message.properties.correlationId);
 };
 
-ActivityExecution.prototype._onExecutionDiscarded = function onExecutionDiscarded(message) {
+ActivityExecution.prototype._onExecutionDiscarded = function onExecutionDiscarded(discardType, message) {
   const postponedMsg = this._ackPostponed(message);
   const {isRootScope, error} = message.content;
   if (!isRootScope && !postponedMsg) return;
@@ -284,11 +286,7 @@ ActivityExecution.prototype._onExecutionDiscarded = function onExecutionDiscarde
   postponed.splice(0);
   for (const api of subApis) api.discard();
 
-  if (error) {
-    return this._publishExecutionCompleted('error', cloneContent(message.content, {error}), correlationId);
-  }
-
-  this._publishExecutionCompleted('discard', message.content, correlationId);
+  this._publishExecutionCompleted(discardType, cloneContent(message.content), correlationId);
 };
 
 ActivityExecution.prototype._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {

package/src/definition/Definition.js

@@ -106,6 +106,12 @@ Object.defineProperty(Definition.prototype, 'stopped', {
   },
 });
 
+Object.defineProperty(Definition.prototype, 'activityStatus', {
+  get() {
+    return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+  },
+});
+
 Definition.prototype.run = function run(optionsOrCallback, optionalCallback) {
   const [runOptions, callback] = getOptionsAndCallback(optionsOrCallback, optionalCallback);
   if (this.isRunning) {
@@ -182,8 +188,6 @@ Definition.prototype.recover = function recover(state) {
 
 Definition.prototype.shake = function shake(startId) {
   let result = {};
-  const broker = this.broker;
-
   let bps;
   if (startId) {
     const startActivity = this.getActivityById(startId);
@@ -193,30 +197,29 @@ Definition.prototype.shake = function shake(startId) {
     bps = [bp];
   } else bps = this.getProcesses();
 
-  bps.forEach(shakeProcess);
+  bps.forEach((bp) => {
+    result = {...result, ...this._shakeProcess(bp, startId)};
+  });
 
   return result;
+};
 
-  function shakeProcess(shakeBp) {
-    let shovel;
-    if (!shakeBp.isRunning) {
-      shovel = shakeBp.broker.createShovel('shaker', {
-        exchange: 'event',
-        pattern: '*.shake#',
-      }, {
-        broker,
-        exchange: 'event',
-      });
-    }
+Definition.prototype._shakeProcess = function shakeProcess(shakeBp, startId) {
+  let shovel;
+  if (!shakeBp.isRunning) {
+    shovel = shakeBp.broker.createShovel('shaker', {
+      exchange: 'event',
+      pattern: '*.shake#',
+    }, {
+      broker: this.broker,
+      exchange: 'event',
+    });
+  }
 
-    const shakeResult = shakeBp.shake(startId);
-    if (shovel) shakeBp.broker.closeShovel('shaker');
+  const shakeResult = shakeBp.shake(startId);
+  if (shovel) shakeBp.broker.closeShovel('shaker');
 
-    result = {
-      ...result,
-      ...shakeResult,
-    };
-  }
+  return shakeResult;
 };
 
 Definition.prototype.getState = function getState() {

package/src/definition/DefinitionExecution.js

@@ -101,6 +101,32 @@ Object.defineProperty(DefinitionExecution.prototype, 'isRunning', {
   },
 });
 
+Object.defineProperty(DefinitionExecution.prototype, 'activityStatus', {
+  get() {
+    let status = 'idle';
+    const running = this[kProcesses].running;
+    if (!running || !running.length) return status;
+
+    for (const bp of running) {
+      const bpStatus = bp.activityStatus;
+      switch (bp.activityStatus) {
+        case 'idle':
+          break;
+        case 'executing':
+          return bpStatus;
+        case 'timer':
+          status = bpStatus;
+          break;
+        case 'wait':
+          if (status === 'idle') status = bpStatus;
+          break;
+      }
+    }
+
+    return status;
+  },
+});
+
 DefinitionExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Definition execution requires message');
   const content = executeMessage.content;

package/src/eventDefinitions/CancelEventDefinition.js

@@ -1,7 +1,5 @@
-import {brokerSafeId} from '../shared.js';
 import {cloneContent, shiftParent} from '../messageHelper.js';
 
-const kMessageQ = Symbol.for('cancelQ');
 const kCompleted = Symbol.for('completed');
 const kExecuteMessage = Symbol.for('executeMessage');
 
@@ -11,19 +9,12 @@ export default function CancelEventDefinition(activity, eventDefinition) {
 
   this.id = id;
   this.type = type;
-  const reference = this.reference = {referenceType: 'cancel'};
+  this.reference = {referenceType: 'cancel'};
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.environment = environment;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
-
-  if (!isThrowing) {
-    this[kCompleted] = false;
-    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 400});
-  }
 }
 
 Object.defineProperty(CancelEventDefinition.prototype, 'executionId', {
@@ -46,88 +37,57 @@ CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMess
   const parentExecutionId = parent.executionId;
 
   const broker = this.broker;
-  const onCatchMessage = this._onCatchMessage.bind(this);
-  this[kMessageQ].consume(onCatchMessage, {
-    noAck: true,
-    consumerTag: `_oncancel-${executionId}`,
-  });
 
-  if (this[kCompleted]) return;
+  this._debug('expect cancel');
 
-  const onApiMessage = this._onApiMessage.bind(this);
-  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
-    noAck: true,
-    consumerTag: `_api-parent-${executionId}`,
-  });
-  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+  broker.subscribeTmp('api', `activity.#.${parent.executionId}#`, this._onApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-${executionId}`,
   });
 
-  this._debug('expect cancel');
-
-  const exchangeKey = `execute.canceled.${executionId}`;
-  broker.subscribeOnce('execution', exchangeKey, onCatchMessage, {
+  const expectRoutingKey = `execute.cancelled.${executionId}`;
+  broker.subscribeOnce('execution', expectRoutingKey, this._onCatchMessage.bind(this), {
     consumerTag: `_onattached-cancel-${executionId}`,
   });
 
   broker.publish('execution', 'execute.expect', cloneContent(executeContent, {
-    pattern: '#.cancel',
+    pattern: 'activity.execution.cancel',
     exchange: 'execution',
-    exchangeKey,
+    expectRoutingKey,
   }));
+
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    condition: this.condition,
+    expect: 'cancel',
+  });
+  waitContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.wait', waitContent);
 };
 
 CancelEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
-  const {isTransaction} = this.environment.variables.content || {};
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
 
-  this.logger.debug(`<${executionId} (${this.activity.id})> throw cancel${isTransaction ? ' transaction' : ''}`);
+  this.logger.debug(`<${executionId} (${this.activity.id})> throw cancel`);
 
   const broker = this.broker;
   const cancelContent = cloneContent(executeContent, {
-    isTransaction,
     executionId: parent.executionId,
     state: 'throw',
   });
   cancelContent.parent = shiftParent(parent);
 
-  broker.publish('event', 'activity.cancel', cancelContent, {type: 'cancel', delegate: isTransaction});
+  broker.publish('event', 'activity.cancel', cancelContent, { type: 'cancel' });
 
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
 
 CancelEventDefinition.prototype._onCatchMessage = function onCatchMessage(_, message) {
-  if (message.content && message.content.isTransaction) return this._onCancelTransaction(_, message);
-
-  this._debug(`cancel caught from <${message.content.id}>`);
-  return this._complete(message.content.message);
-};
-
-CancelEventDefinition.prototype._onCancelTransaction = function onCancelTransaction(_, message) {
-  const broker = this.broker, executionId = this.executionId;
-  const executeContent = this[kExecuteMessage].content;
-  broker.cancel(`_oncancel-${executionId}`);
-
-  this._debug(`cancel transaction thrown by <${message.content.id}>`);
-
-  broker.assertExchange('cancel', 'topic');
-  broker.publish('execution', 'execute.detach', cloneContent(executeContent, {
-    pattern: '#',
-    bindExchange: 'cancel',
-    sourceExchange: 'event',
-    sourcePattern: '#',
-  }));
-
-  broker.publish('event', 'activity.compensate', cloneContent(message.content, {
-    state: 'throw',
-  }), {type: 'compensate', delegate: true});
-
-  broker.subscribeTmp('cancel', 'activity.leave', (__, {content: msg}) => {
-    if (msg.id !== executeContent.attachedTo) return;
-    return this._complete(message.content.message);
-  }, {noAck: true, consumerTag: `_oncancelend-${executionId}`});
+  const content = message.content;
+  this._debug(`cancel caught from <${content.id}>`);
+  return this._complete(content.message);
 };
 
 CancelEventDefinition.prototype._complete = function complete(output) {
@@ -158,12 +118,8 @@ CancelEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey
 
 CancelEventDefinition.prototype._stop = function stop() {
   const broker = this.broker, executionId = this.executionId;
-  broker.cancel(`_api-parent-${executionId}`);
-  broker.cancel(`_api-${executionId}`);
-  broker.cancel(`_oncancel-${executionId}`);
-  broker.cancel(`_oncancelend-${executionId}`);
   broker.cancel(`_onattached-cancel-${executionId}`);
-  this[kMessageQ].purge();
+  broker.cancel(`_api-${executionId}`);
 };
 
 CancelEventDefinition.prototype._debug = function debug(msg) {