bpmn-elements 9.0.0 → 9.1.1

package/src/eventDefinitions/CompensateEventDefinition.js

@@ -20,9 +20,10 @@ export default function CompensateEventDefinition(activity, eventDefinition, con
 
   if (!isThrowing) {
     this[kCompleted] = false;
-    this[kAssociations] = context.getOutboundAssociations(id) || [];
+    this[kAssociations] = context.getOutboundAssociations(id);
     const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
     this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    this[kCompensateQ] = broker.assertQueue('compensate-q', {autoDelete: false, durable: true});
     broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 400});
   }
 }
@@ -41,6 +42,11 @@ CompensateEventDefinition.prototype.execute = function execute(executeMessage) {
 CompensateEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
   this[kExecuteMessage] = executeMessage;
   this[kCompleted] = false;
+  if (executeMessage.fields.routingKey === 'execute.compensating') {
+    this._debug('resumed at compensating');
+    this[kCompleted] = true;
+    return this._compensate();
+  }
 
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
@@ -48,18 +54,13 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
   this._debug('expect compensate');
 
   const broker = this.broker;
+  broker.cancel('_convey-messages');
   broker.assertExchange('compensate', 'topic');
-  this[kCompensateQ] = broker.assertQueue('compensate-q', {durable: true, autoDelete: false});
   broker.subscribeTmp('compensate', 'execute.#', this._onCollect.bind(this), {
     noAck: true,
     consumerTag: '_oncollect-messages',
   });
 
-  broker.publish('execution', 'execute.detach', cloneContent(executeContent, {
-    sourceExchange: 'execution',
-    bindExchange: 'compensate',
-  }));
-
   this[kMessageQ].consume(this._onCompensateApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_oncompensate-${executionId}`,
@@ -67,27 +68,24 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
 
   if (this[kCompleted]) return;
 
-  const onApiMessage = this._onApiMessage.bind(this);
-  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+  broker.subscribeTmp('api', `activity.#.${parent.executionId}#`, this._onApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-${executionId}`,
   });
 
-  const detachContent = cloneContent(executeContent, {
-    executionId: parent.executionId,
+  broker.publish('execution', 'execute.detach', cloneContent(executeContent, {
+    sourceExchange: 'execution',
     bindExchange: 'compensate',
-  });
-  detachContent.parent = shiftParent(parent);
-
-  broker.publish('event', 'activity.detach', detachContent);
+    expect: 'compensate',
+  }));
 };
 
 CompensateEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
-  const {executionId, parent} = executeContent;
+  const {parent} = executeContent;
   const parentExecutionId = parent && parent.executionId;
 
-  this.logger.debug(`<${executionId} (${this.activity.id})> throw compensate`);
+  this.logger.debug(`<${parentExecutionId} (${this.id})> throw compensate`);
 
   const broker = this.broker;
   const throwContent = cloneContent(executeContent, {
@@ -101,7 +99,6 @@ CompensateEventDefinition.prototype.executeThrow = function executeThrow(execute
 };
 
 CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey, message) {
-
   switch (routingKey) {
     case 'execute.error':
     case 'execute.completed': {
@@ -111,67 +108,78 @@ CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey,
 };
 
 CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
-  const output = message.content.message;
   this[kCompleted] = true;
+  const output = message.content.message;
+  const broker = this.broker;
+  const executeContent = this[kExecuteMessage].content;
 
-  this._stop();
+  this._stopCollect();
 
   this._debug('caught compensate event');
-  const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
+
   const catchContent = cloneContent(executeContent, {
     message: {...output},
     executionId: executeContent.parent.executionId,
   });
   catchContent.parent = shiftParent(catchContent.parent);
 
-  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
+  this[kCompensateQ].queueMessage({routingKey: 'execute.compensated'}, cloneContent(executeContent));
 
-  const compensateQ = this[kCompensateQ];
-  compensateQ.on('depleted', onDepleted);
-  compensateQ.consume(this._onCollected.bind(this), {noAck: true, consumerTag: '_convey-messages'});
+  broker.publish('execution', 'execute.compensating', cloneContent(executeContent, {message: {...output}}));
+  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
 
-  for (const association of this[kAssociations]) association.complete(cloneMessage(message));
+  return this._compensate();
+};
 
-  function onDepleted() {
-    compensateQ.off('depleted', onDepleted);
-    return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output, state: 'catch'}));
-  }
+CompensateEventDefinition.prototype._compensate = function compensate() {
+  return this[kCompensateQ].consume(this._onCollected.bind(this), {noAck: true, consumerTag: '_convey-messages'});
 };
 
 CompensateEventDefinition.prototype._onCollected = function onCollected(routingKey, message) {
+  if (routingKey === 'execute.compensated') {
+    const broker = this.broker;
+    broker.cancel('_convey-messages');
+    return this.broker.publish('execution', 'execute.completed', cloneContent(message.content, {cancelActivity: false}));
+  }
   for (const association of this[kAssociations]) association.take(cloneMessage(message));
 };
 
+CompensateEventDefinition.prototype._onDiscardApiMessage = function onDiscardApiMessage(routingKey, message) {
+  this[kCompleted] = true;
+  this._stop();
+  this[kCompensateQ].purge();
+  for (const association of this[kAssociations]) association.discard(cloneMessage(message));
+  return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content));
+};
+
 CompensateEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
-
   switch (messageType) {
     case 'compensate': {
       return this._onCompensateApiMessage(routingKey, message);
     }
     case 'discard': {
-      this[kCompleted] = true;
-      this._stop();
-      for (const association of this[kAssociations]) association.discard(cloneMessage(message));
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content));
+      return this._onDiscardApiMessage(routingKey, message);
     }
     case 'stop': {
-      this._stop();
-      break;
+      return this._stop();
     }
   }
 };
 
-CompensateEventDefinition.prototype._stop = function stop() {
+CompensateEventDefinition.prototype._stopCollect = function stopCollect() {
   const broker = this.broker, executionId = this.executionId;
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_oncompensate-${executionId}`);
   broker.cancel('_oncollect-messages');
-  broker.cancel('_convey-messages');
   this[kMessageQ].purge();
 };
 
+CompensateEventDefinition.prototype._stop = function stop() {
+  this._stopCollect();
+  this.broker.cancel('_convey-messages');
+};
+
 CompensateEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };

package/src/eventDefinitions/ConditionalEventDefinition.js

@@ -59,9 +59,11 @@ ConditionalEventDefinition.prototype.executeWait = function executeWait(executeM
 
 ConditionalEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
   const executeContent = executeMessage.content;
-  const {executionId, index} = executeContent;
+  const {executionId, index, parent} = executeContent;
+  const parentExecutionId = parent.executionId;
 
-  this.broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-${executionId}_${index}`,
   });
@@ -74,6 +76,14 @@ ConditionalEventDefinition.prototype.executeCatch = function executeCatch(execut
     priority: 300,
     consumerTag: `_onend-${executionId}_${index}`,
   });
+
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    condition: this.condition,
+  });
+  waitContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.wait', waitContent);
 };
 
 ConditionalEventDefinition.prototype._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {

package/src/eventDefinitions/ErrorEventDefinition.js

@@ -79,6 +79,8 @@ ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessa
       consumerTag: `_onerror-${executionId}`,
     });
     broker.publish('execution', 'execute.expect', cloneContent(executeContent, {
+      pattern: 'activity.error',
+      exchange: 'execution',
       expectRoutingKey,
       expect: {...info.message},
     }));

package/src/events/BoundaryEvent.js

@@ -96,7 +96,7 @@ BoundaryEventBehaviour.prototype._onExecutionMessage = function onExecutionMessa
 };
 
 BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, {content}) {
-  if (!this.cancelActivity && !content.cancelActivity) {
+  if (content.cancelActivity === false || !this.cancelActivity && !content.cancelActivity) {
     this._stop();
     return this.broker.publish('execution', 'execute.completed', cloneContent(content, {isDefinitionScope: false, cancelActivity: false}));
   }
@@ -106,6 +106,7 @@ BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, {content
   const inbound = this[kExecuteMessage].content.inbound;
   const attachedToContent = inbound && inbound[0];
   const attachedTo = this.attachedTo;
+
   this.activity.logger.debug(`<${this.executionId} (${this.id})> cancel ${attachedTo.status} activity <${attachedToContent.executionId} (${attachedToContent.id})>`);
 
   attachedTo.getApi({content: attachedToContent}).discard();
@@ -113,6 +114,7 @@ BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, {content
 
 BoundaryEventBehaviour.prototype._onAttachedLeave = function onAttachedLeave(_, {content}) {
   if (content.id !== this.attachedTo.id) return;
+
   this._stop();
   const completeContent = this[kCompleteContent];
   if (!completeContent) return this.broker.publish('execution', 'execute.discard', this[kExecuteMessage].content);
@@ -120,24 +122,26 @@ BoundaryEventBehaviour.prototype._onAttachedLeave = function onAttachedLeave(_,
 };
 
 BoundaryEventBehaviour.prototype._onExpectMessage = function onExpectMessage(_, {content}) {
-  const {executionId, expectRoutingKey} = content;
+  const {executionId, expectRoutingKey, pattern, exchange} = content;
   const attachedTo = this.attachedTo;
 
   const errorConsumerTag = `_bound-error-listener-${executionId}`;
   this[kAttachedTags].push(errorConsumerTag);
 
-  attachedTo.broker.subscribeTmp('event', 'activity.error', (__, errorMessage) => {
-    if (errorMessage.content.id !== attachedTo.id) return;
-    this.broker.publish('execution', expectRoutingKey, cloneContent(errorMessage.content));
+  attachedTo.broker.subscribeTmp('event', pattern, (__, message) => {
+    if (message.content.id !== attachedTo.id) return;
+    this.broker.publish(exchange, expectRoutingKey, cloneContent(message.content, {attachedTo: attachedTo.id}), {...message.properties, mandatory: false});
   }, {
     noAck: true,
     consumerTag: errorConsumerTag,
-    priority: 300,
+    priority: 400,
   });
 };
 
-BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_, {content}) {
-  const id = this.id, executionId = this.executionId, attachedTo = this.attachedTo;
+BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_, message) {
+  const content = message.content;
+  const {executionId, parent} = this[kExecuteMessage].content;
+  const id = this.id, attachedTo = this.attachedTo;
   this.activity.logger.debug(`<${executionId} (${id})> detach from activity <${attachedTo.id}>`);
   this._stop(true);
 
@@ -157,6 +161,14 @@ BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_,
     cloneMessage,
   });
 
+  const detachContent = cloneContent(content, {
+    executionId,
+  });
+  detachContent.parent = parent;
+
+  this.activity.removeInboundListeners();
+  broker.publish('event', 'activity.detach', detachContent);
+
   broker.subscribeOnce('execution', 'execute.bound.completed', (__, {content: completeContent}) => {
     this._stop();
     this.broker.publish('execution', 'execute.completed', cloneContent(completeContent));

package/src/flows/Association.js

@@ -20,7 +20,6 @@ export default function Association(associationDef, {environment}) {
   const logger = this.logger = environment.Logger(type.toLowerCase());
 
   this[kCounters] = {
-    complete: 0,
     take: 0,
     discard: 0,
   };
@@ -59,15 +58,6 @@ Association.prototype.discard = function discard(content = {}) {
   return true;
 };
 
-Association.prototype.complete = function complete(content = {}) {
-  this.logger.debug(`<${this.id}> completed target <${this.targetId}>`);
-  ++this[kCounters].complete;
-
-  this._publishEvent('complete', content);
-
-  return true;
-};
-
 Association.prototype.getState = function getState() {
   return this._createMessageContent({
     counters: this.counters,

package/src/gateways/EventBasedGateway.js

@@ -40,7 +40,6 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
 
   const broker = this.activity.broker;
   broker.subscribeOnce('api', `activity.stop.${executionId}`, () => this._stop(), {
-    noAck: true,
     consumerTag: '_api-stop-execution',
   });
 
@@ -49,7 +48,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
 };
 
 EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompleted(executeMessage, _, message, owner) {
-  const {id: targetId, exexutionId: targetExecutionId} = message.content;
+  const {id: targetId, executionId: targetExecutionId} = message.content;
   const executeContent = executeMessage.content;
   const executionId = executeContent.executionId;
   this.activity.logger.debug(`<${executionId} (${this.id})> <${targetExecutionId}> completed run, discarding the rest`);

package/src/process/Process.js

@@ -107,6 +107,12 @@ Object.defineProperty(Process.prototype, 'status', {
   },
 });
 
+Object.defineProperty(Process.prototype, 'activityStatus', {
+  get() {
+    return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+  },
+});
+
 Process.prototype.init = function init(useAsExecutionId) {
   const exec = this[kExec];
   const initExecutionId = exec.initExecutionId = useAsExecutionId || getUniqueId(this.id);

package/src/process/ProcessExecution.js

@@ -1,6 +1,7 @@
 import {ProcessApi} from '../Api.js';
 import {cloneContent, cloneMessage, pushParent} from '../messageHelper.js';
 import {getUniqueId} from '../shared.js';
+import {ActivityTracker} from '../Tracker.js';
 
 export default ProcessExecution;
 
@@ -13,14 +14,16 @@ const kMessageHandlers = Symbol.for('messageHandlers');
 const kParent = Symbol.for('parent');
 const kStatus = Symbol.for('status');
 const kStopped = Symbol.for('stopped');
+const kTracker = Symbol.for('activity tracker');
 
 function ProcessExecution(parentActivity, context) {
-  const {id, type, broker, isSubProcess} = parentActivity;
+  const {id, type, broker, isSubProcess, isTransaction} = parentActivity;
 
   this[kParent] = parentActivity;
   this.id = id;
   this.type = type;
   this.isSubProcess = isSubProcess;
+  this.isTransaction = isSubProcess && isTransaction;
   this.broker = broker;
   this.environment = context.environment;
   this.context = context;
@@ -44,6 +47,7 @@ function ProcessExecution(parentActivity, context) {
   this[kStopped] = false;
   this[kActivated] = false;
   this[kStatus] = 'init';
+  this[kTracker] = new ActivityTracker(id);
   this.executionId = undefined;
 
   this[kMessageHandlers] = {
@@ -87,6 +91,12 @@ Object.defineProperty(ProcessExecution.prototype, 'isRunning', {
   },
 });
 
+Object.defineProperty(ProcessExecution.prototype, 'activityStatus', {
+  get() {
+    return this[kTracker].activityStatus;
+  },
+});
+
 ProcessExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Process execution requires message');
   if (!executeMessage.content || !executeMessage.content.executionId) throw new Error('Process execution requires execution id');
@@ -139,6 +149,7 @@ ProcessExecution.prototype.resume = function resume() {
   const status = this.status;
   if (status === 'init') return this._start();
 
+  const tracker = this[kTracker];
   for (const msg of postponed.slice()) {
     const activity = this.getActivityById(msg.content.id);
     if (!activity) continue;
@@ -148,6 +159,8 @@ ProcessExecution.prototype.resume = function resume() {
       msg.ack();
       continue;
     }
+
+    tracker.track(msg.fields.routingKey, msg);
     activity.resume();
   }
 
@@ -261,6 +274,14 @@ ProcessExecution.prototype.discard = function discard() {
   }, {type: 'discard'});
 };
 
+ProcessExecution.prototype.cancel = function discard() {
+  return this[kActivityQ].queueMessage({ routingKey: 'execution.cancel' }, {
+    id: this.id,
+    type: this.type,
+    executionId: this.executionId,
+  }, { type: 'cancel' });
+};
+
 ProcessExecution.prototype.getState = function getState() {
   const {children, flows, outboundMessageFlows, associations} = this[kElements];
   return {
@@ -291,6 +312,10 @@ ProcessExecution.prototype.getSequenceFlows = function getSequenceFlows() {
   return this[kElements].flows.slice();
 };
 
+ProcessExecution.prototype.getAssociations = function getAssociations() {
+  return this[kElements].associations.slice();
+};
+
 ProcessExecution.prototype.getApi = function getApi(message) {
   if (!message) return ProcessApi(this.broker, this[kExecuteMessage]);
 
@@ -332,6 +357,7 @@ ProcessExecution.prototype._start = function start() {
   }
 
   for (const a of startActivities) a.init();
+  this[kStatus] = 'executing';
   for (const a of startActivities) a.run();
 
   postponed.splice(0);
@@ -478,10 +504,10 @@ ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKe
 
   if (delegate) delegate = this._onDelegateEvent(message);
 
+  this[kTracker].track(routingKey, message);
   this.broker.publish('event', routingKey, content, {...message.properties, delegate, mandatory: false});
   if (shaking) return this._onShookEnd(message);
   if (!isDirectChild) return;
-  if (content.isAssociation) return;
 
   switch (routingKey) {
     case 'process.terminate':
@@ -508,6 +534,16 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
     case 'execution.discard':
       message.ack();
       return this._onDiscard(message);
+    case 'execution.discard.detached': {
+      message.ack();
+      for (const detached of this[kElements].detachedActivities) {
+        this._getChildApi(detached).discard();
+      }
+      return;
+    }
+    case 'execution.cancel':
+      message.ack();
+      return this._onCancel(message);
     case 'activity.error.caught': {
       const prevMsg = this[kElements].postponed.find((msg) => {
         return msg.content.executionId === content.executionId;
@@ -515,7 +551,6 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       if (!prevMsg) return message.ack();
       break;
     }
-    case 'activity.compensation.end':
     case 'flow.looped':
     case 'activity.leave':
       return this._onChildCompleted(message);
@@ -528,14 +563,16 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       this[kElements].detachedActivities.push(cloneMessage(message));
       break;
     }
+    case 'activity.cancel': {
+      if (this.isTransaction) this._onCancel(message);
+      break;
+    }
     case 'activity.discard':
-    case 'activity.compensation.start':
     case 'activity.enter': {
-      this[kStatus] = 'executing';
       if (!content.inbound) break;
 
       for (const inbound of content.inbound) {
-        if (!inbound.isSequenceFlow) continue;
+        if (!inbound.isSequenceFlow && !inbound.isAssociation) continue;
         const inboundMessage = this._popPostponed(inbound);
         if (inboundMessage) inboundMessage.ack();
       }
@@ -566,7 +603,7 @@ ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
   const {postponed, detachedActivities} = this[kElements];
 
   const postponedIdx = postponed.findIndex((msg) => {
-    if (msg.content.isSequenceFlow) return msg.content.sequenceId === byContent.sequenceId;
+    if (msg.content.isSequenceFlow || msg.content.isAssociation) return msg.content.sequenceId === byContent.sequenceId;
     return msg.content.executionId === byContent.executionId;
   });
 
@@ -598,9 +635,12 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
 
   this._debug(`left <${id}> (${type}), pending runs ${postponedCount}, ${postponed.map((a) => a.content.id).join(',')}`);
 
-  if (postponedCount === detachedActivities.length) {
-    for (const api of this.getPostponed()) api.discard();
-    return;
+  if (postponedCount && postponedCount === detachedActivities.length) {
+    return this[kActivityQ].queueMessage({ routingKey: 'execution.discard.detached' }, {
+      id: this.id,
+      type: this.type,
+      executionId: this.executionId,
+    }, { type: 'cancel' });
   }
 
   if (isEnd && startActivities.length) {
@@ -636,35 +676,47 @@ ProcessExecution.prototype._onDiscard = function onDiscard() {
   const running = this[kElements].postponed.splice(0);
   this._debug(`discard process execution (discard child executions ${running.length})`);
 
-  for (const flow of this.getSequenceFlows()) flow.stop();
-  for (const msg of running) this._getChildApi(msg).discard();
+  if (this.isSubProcess) {
+    this.stop();
+  } else {
+    for (const flow of this.getSequenceFlows()) flow.stop();
+    for (const flow of this.getAssociations()) flow.stop();
+    for (const msg of running) this._getChildApi(msg).discard();
+  }
 
   this[kActivityQ].purge();
   return this._complete('discard');
 };
 
-ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const executionId = this.executionId;
-  const broker = this.broker;
-  if (message.properties.delegate) {
-    const correlationId = message.properties.correlationId || getUniqueId(executionId);
-    this._debug(`delegate api ${routingKey} message to children, with correlationId <${correlationId}>`);
-
-    let consumed = false;
-    broker.subscribeTmp('event', 'activity.consumed', (_, msg) => {
-      if (msg.properties.correlationId === correlationId) {
-        consumed = true;
-        this._debug(`delegated api message was consumed by ${msg.content ? msg.content.executionId : 'unknown'}`);
-      }
-    }, {consumerTag: `_ct-delegate-${correlationId}`, noAck: true});
+ProcessExecution.prototype._onCancel = function onCancel() {
+  const running = this[kElements].postponed.slice(0);
+  const isTransaction = this.isTransaction;
 
-    for (const child of this[kElements].children) {
-      if (child.placeholder) continue;
-      child.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
-      if (consumed) break;
+  if (isTransaction) {
+    this._debug(`cancel transaction execution (cancel child executions ${running.length})`);
+    this[kStatus] = 'cancel';
+    this.broker.publish('event', 'transaction.cancel', cloneMessage(this[kExecuteMessage], {
+      state: 'cancel',
+    }));
+
+    for (const msg of running) {
+      if (msg.content.expect === 'compensate') {
+        this._getChildApi(msg).sendApiMessage('compensate');
+      } else if (!msg.content.isForCompensation) {
+        this._getChildApi(msg).discard();
+      }
     }
+  } else {
+    this._debug(`cancel process execution (cancel child executions ${running.length})`);
+    for (const msg of running) {
+      this._getChildApi(msg).discard();
+    }
+  }
+};
 
-    return broker.cancel(`_ct-delegate-${correlationId}`);
+ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
+  if (message.properties.delegate) {
+    return this._delegateApiMessage(routingKey, message);
   }
 
   if (this.id !== message.content.id) {
@@ -676,19 +728,56 @@ ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, mes
   if (this.executionId !== message.content.executionId) return;
 
   switch (message.properties.type) {
+    case 'cancel':
+      return this.cancel(message);
     case 'discard':
       return this.discard(message);
     case 'stop':
-      this[kActivityQ].queueMessage({routingKey: 'execution.stop'}, cloneContent(message.content), {persistent: false});
+      this[kActivityQ].queueMessage({ routingKey: 'execution.stop' }, cloneContent(message.content), { persistent: false });
       break;
   }
 };
 
+ProcessExecution.prototype._delegateApiMessage = function delegateApiMessage(routingKey, message, continueOnConsumed) {
+  const correlationId = message.properties.correlationId || getUniqueId(this.executionId);
+  this._debug(`delegate api ${routingKey} message to children, with correlationId <${correlationId}>`);
+
+  const broker = this.broker;
+  let consumed = false;
+  broker.subscribeTmp('event', 'activity.consumed', (_, msg) => {
+    if (msg.properties.correlationId === correlationId) {
+      consumed = true;
+      this._debug(`delegated api message was consumed by ${msg.content ? msg.content.executionId : 'unknown'}`);
+    }
+  }, { consumerTag: `_ct-delegate-${correlationId}`, noAck: true });
+
+  for (const child of this[kElements].children) {
+    if (child.placeholder) continue;
+    child.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
+    if (consumed && !continueOnConsumed) break;
+  }
+
+  return broker.cancel(`_ct-delegate-${correlationId}`);
+};
+
 ProcessExecution.prototype._complete = function complete(completionType, content) {
   this._deactivate();
-  this._debug(`process execution ${completionType}`);
   this[kCompleted] = true;
-  if (this.status !== 'terminated') this[kStatus] = completionType;
+
+  const status = this.status;
+  switch (this.status) {
+    case 'cancel':
+      this._debug('process execution cancelled');
+    case 'discard':
+      completionType = status;
+      break;
+    case 'terminated':
+      break;
+    default:
+      this._debug(`process execution ${completionType}`);
+      this[kStatus] = completionType;
+  }
+
   const broker = this.broker;
   this[kActivityQ].delete();
 
@@ -705,11 +794,12 @@ ProcessExecution.prototype._terminate = function terminate(message) {
 
   const running = this[kElements].postponed.splice(0);
   for (const flow of this.getSequenceFlows()) flow.stop();
+  for (const flow of this.getAssociations()) flow.stop();
 
   for (const msg of running) {
-    const {id: postponedId, isSequenceFlow} = msg.content;
+    const {id: postponedId, isSequenceFlow, isAssociation} = msg.content;
     if (postponedId === message.content.id) continue;
-    if (isSequenceFlow) continue;
+    if (isSequenceFlow || isAssociation) continue;
     this._getChildApi(msg).stop();
     msg.ack();
   }