bpmn-elements 9.0.0 → 9.1.0

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 Changelog
 =========
 
+# 9.1.0
+
+- refactor compensation and transaction functionality
+- fix event based gateway bug when/if a subsequent event completes immediately
+- add somewhat expirimental activityStatus property to process and definition, tracked by Tracker that tracks executing, wait, and timer activity
+
 # 9.0.0
 
 - Turn into module with exports for node

package/README.md

@@ -1,7 +1,7 @@
 bpmn-elements
 =============
 
-[![Build Status](https://app.travis-ci.com/paed01/bpmn-elements.svg?branch=master)](https://app.travis-ci.com/paed01/bpmn-elements)[![Coverage Status](https://coveralls.io/repos/github/paed01/bpmn-elements/badge.svg?branch=master)](https://coveralls.io/github/paed01/bpmn-elements?branch=master)
+[![Build](https://github.com/paed01/bpmn-elements/actions/workflows/build.yaml/badge.svg)](https://github.com/paed01/bpmn-elements/actions/workflows/build.yaml)[![Coverage Status](https://coveralls.io/repos/github/paed01/bpmn-elements/badge.svg?branch=master)](https://coveralls.io/github/paed01/bpmn-elements?branch=master)
 
 Isomorphic JavaScript BPMN 2.0 workflow elements suitable for bundling into frontend script or just required into your nodejs project.
 

package/dist/EventBroker.js

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

package/dist/Tracker.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ActivityTracker = ActivityTracker;
+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/dist/activity/Activity.js

@@ -24,6 +24,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');
 var _default = Activity;
 exports.default = _default;
 function Activity(Behaviour, activityDef, context) {
@@ -54,6 +55,7 @@ function Activity(Behaviour, activityDef, context) {
     taken: 0,
     discarded: 0
   };
+  const isForCompensation = !!behaviour.isForCompensation;
   let attachedToActivity, attachedTo;
   if (attachedToRef) {
     attachedTo = attachedToRef.id;
@@ -73,7 +75,14 @@ function Activity(Behaviour, activityDef, context) {
   this.emitFatal = emitFatal;
   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,
@@ -83,7 +92,6 @@ function Activity(Behaviour, activityDef, context) {
     outboundSequenceFlows,
     outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows)
   };
-  const isForCompensation = !!behaviour.isForCompensation;
   const isParallelJoin = activityDef.isParallelGateway && flows.inboundSequenceFlows.length > 1;
   this[kFlags] = {
     isEnd: flows.outboundSequenceFlows.length === 0,
@@ -103,29 +111,6 @@ function Activity(Behaviour, activityDef, context) {
     onApiMessage: this._onApiMessage.bind(this),
     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);
 }
@@ -213,6 +198,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,
   get() {
@@ -252,11 +243,14 @@ 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 +320,31 @@ Activity.prototype.discard = function discard(discardContent) {
   broker.publish('run', 'run.discard', (0, _messageHelper.cloneContent)(this[kStateMessage].content));
   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() {
   if (!this.environment.settings.step) return;
@@ -423,6 +439,7 @@ Activity.prototype._shakeOutbound = function shakeOutbound(sourceMessage) {
   for (const flow of this[kFlows].outboundSequenceFlows) flow.shake(message);
 };
 Activity.prototype._consumeInbound = function consumeInbound() {
+  if (!this[kActivated]) return;
   if (this.status) return;
   const inboundQ = this.broker.getQueue('inbound-q');
   if (this[kFlags].isParallelJoin) {
@@ -437,7 +454,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');
   const content = message.content;
@@ -461,15 +477,6 @@ Activity.prototype._onInbound = function onInbound(routingKey, message) {
           discardSequence
         });
       }
-    case 'association.complete':
-      {
-        broker.cancel('_run-on-inbound');
-        const compensationId = `${(0, _shared.brokerSafeId)(id)}_${(0, _shared.brokerSafeId)(content.sequenceId)}`;
-        this.logger.debug(`<${id}> completed compensation with id <${compensationId}>`);
-        return this._publishEvent('compensation.end', this._createMessage({
-          executionId: compensationId
-        }));
-      }
   }
 };
 Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message) {
@@ -521,7 +528,6 @@ Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message
     content,
     properties
   } = message;
-  const id = this.id;
   const inboundQ = this.broker.getQueue('inbound-q');
   switch (routingKey) {
     case 'activity.enter':
@@ -540,23 +546,6 @@ Activity.prototype._onInboundEvent = function onInboundEvent(routingKey, message
     case 'flow.take':
     case 'flow.discard':
       return inboundQ.queueMessage(fields, (0, _messageHelper.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, (0, _messageHelper.cloneContent)(content), properties);
-        const compensationId = `${(0, _shared.brokerSafeId)(id)}_${(0, _shared.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();
-      }
   }
 };
 Activity.prototype._consumeRunQ = function consumeRunQ() {
@@ -640,6 +629,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       {
         const execution = this.execution;
         if (!isRedelivered && execution) {
+          if (execution.completed) return message.ack();
           this[kExecuteMessage] = message;
           return execution.passthrough(message);
         }
@@ -763,6 +753,7 @@ Activity.prototype._onExecutionMessage = function onExecutionMessage(routingKey,
         });
         break;
       }
+    case 'execution.cancel':
     case 'execution.discard':
       this.status = 'discarded';
       broker.publish('run', 'run.discarded', content, {
@@ -783,7 +774,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();
 };
 Activity.prototype._doRunLeave = function doRunLeave(message, isDiscarded, onOutbound) {

package/dist/activity/ActivityExecution.js

@@ -171,10 +171,12 @@ ActivityExecution.prototype._onExecuteMessage = function onExecuteMessage(routin
         if (!this[kPostponed].length) return this.broker.publish('execution', 'execute.start', (0, _messageHelper.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) {
@@ -257,7 +259,7 @@ ActivityExecution.prototype._onExecutionCompleted = function onExecutionComplete
     ...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,
@@ -280,12 +282,7 @@ ActivityExecution.prototype._onExecutionDiscarded = function onExecutionDiscarde
   const subApis = this.getPostponed();
   postponed.splice(0);
   for (const api of subApis) api.discard();
-  if (error) {
-    return this._publishExecutionCompleted('error', (0, _messageHelper.cloneContent)(message.content, {
-      error
-    }), correlationId);
-  }
-  this._publishExecutionCompleted('discard', message.content, correlationId);
+  this._publishExecutionCompleted(discardType, (0, _messageHelper.cloneContent)(message.content), correlationId);
 };
 ActivityExecution.prototype._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {
   this[kCompleted] = true;

package/dist/definition/Definition.js

@@ -109,6 +109,11 @@ Object.defineProperty(Definition.prototype, 'stopped', {
     return this[kStopped];
   }
 });
+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] = (0, _shared.getOptionsAndCallback)(optionsOrCallback, optionalCallback);
   if (this.isRunning) {
@@ -173,7 +178,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);
@@ -182,26 +186,28 @@ Definition.prototype.shake = function shake(startId) {
     if (!bp) return;
     bps = [bp];
   } else bps = this.getProcesses();
-  bps.forEach(shakeProcess);
-  return result;
-  function shakeProcess(shakeBp) {
-    let shovel;
-    if (!shakeBp.isRunning) {
-      shovel = shakeBp.broker.createShovel('shaker', {
-        exchange: 'event',
-        pattern: '*.shake#'
-      }, {
-        broker,
-        exchange: 'event'
-      });
-    }
-    const shakeResult = shakeBp.shake(startId);
-    if (shovel) shakeBp.broker.closeShovel('shaker');
+  bps.forEach(bp => {
     result = {
       ...result,
-      ...shakeResult
+      ...this._shakeProcess(bp, startId)
     };
+  });
+  return result;
+};
+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');
+  return shakeResult;
 };
 Definition.prototype.getState = function getState() {
   return this._createMessage({

package/dist/definition/DefinitionExecution.js

@@ -96,6 +96,29 @@ Object.defineProperty(DefinitionExecution.prototype, 'isRunning', {
     return this[kActivated];
   }
 });
+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/dist/eventDefinitions/CancelEventDefinition.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = CancelEventDefinition;
-var _shared = require("../shared.js");
 var _messageHelper = require("../messageHelper.js");
-const kMessageQ = Symbol.for('cancelQ');
 const kCompleted = Symbol.for('completed');
 const kExecuteMessage = Symbol.for('executeMessage');
 function CancelEventDefinition(activity, eventDefinition) {
@@ -19,7 +17,7 @@ function CancelEventDefinition(activity, eventDefinition) {
   const type = eventDefinition.type;
   this.id = id;
   this.type = type;
-  const reference = this.reference = {
+  this.reference = {
     referenceType: 'cancel'
   };
   this.isThrowing = isThrowing;
@@ -27,18 +25,6 @@ function CancelEventDefinition(activity, eventDefinition) {
   this.environment = environment;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
-  if (!isThrowing) {
-    this[kCompleted] = false;
-    const messageQueueName = `${reference.referenceType}-${(0, _shared.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', {
   get() {
@@ -59,88 +45,50 @@ CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMess
   } = executeContent;
   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;
-  const onApiMessage = this._onApiMessage.bind(this);
-  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
-    noAck: true,
-    consumerTag: `_api-parent-${executionId}`
-  });
-  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+  this._debug('expect cancel');
+  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', (0, _messageHelper.cloneContent)(executeContent, {
-    pattern: '#.cancel',
+    pattern: 'activity.execution.cancel',
     exchange: 'execution',
-    exchangeKey
+    expectRoutingKey
   }));
+  const waitContent = (0, _messageHelper.cloneContent)(executeContent, {
+    executionId: parentExecutionId,
+    condition: this.condition,
+    expect: 'cancel'
+  });
+  waitContent.parent = (0, _messageHelper.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 = (0, _messageHelper.cloneContent)(executeContent, {
-    isTransaction,
     executionId: parent.executionId,
     state: 'throw'
   });
   cancelContent.parent = (0, _messageHelper.shiftParent)(parent);
   broker.publish('event', 'activity.cancel', cancelContent, {
-    type: 'cancel',
-    delegate: isTransaction
+    type: 'cancel'
   });
   return broker.publish('execution', 'execute.completed', (0, _messageHelper.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', (0, _messageHelper.cloneContent)(executeContent, {
-    pattern: '#',
-    bindExchange: 'cancel',
-    sourceExchange: 'event',
-    sourcePattern: '#'
-  }));
-  broker.publish('event', 'activity.compensate', (0, _messageHelper.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) {
   this[kCompleted] = true;
@@ -171,12 +119,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) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);