bpmn-elements 9.0.0 → 9.1.1

package/dist/eventDefinitions/CompensateEventDefinition.js

@@ -29,12 +29,16 @@ function CompensateEventDefinition(activity, eventDefinition, context) {
   this.logger = environment.Logger(type.toLowerCase());
   if (!isThrowing) {
     this[kCompleted] = false;
-    this[kAssociations] = context.getOutboundAssociations(id) || [];
+    this[kAssociations] = context.getOutboundAssociations(id);
     const messageQueueName = `${reference.referenceType}-${(0, _shared.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
@@ -53,6 +57,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,
@@ -60,44 +69,34 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
   } = executeContent;
   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', (0, _messageHelper.cloneContent)(executeContent, {
-    sourceExchange: 'execution',
-    bindExchange: 'compensate'
-  }));
   this[kMessageQ].consume(this._onCompensateApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_oncompensate-${executionId}`
   });
   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 = (0, _messageHelper.cloneContent)(executeContent, {
-    executionId: parent.executionId,
-    bindExchange: 'compensate'
-  });
-  detachContent.parent = (0, _messageHelper.shiftParent)(parent);
-  broker.publish('event', 'activity.detach', detachContent);
+  broker.publish('execution', 'execute.detach', (0, _messageHelper.cloneContent)(executeContent, {
+    sourceExchange: 'execution',
+    bindExchange: 'compensate',
+    expect: 'compensate'
+  }));
 };
 CompensateEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {
-    executionId,
     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 = (0, _messageHelper.cloneContent)(executeContent, {
     executionId: parentExecutionId,
@@ -120,12 +119,12 @@ CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey,
   }
 };
 CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
-  const output = message.content.message;
   this[kCompleted] = true;
-  this._stop();
-  this._debug('caught compensate event');
+  const output = message.content.message;
   const broker = this.broker;
   const executeContent = this[kExecuteMessage].content;
+  this._stopCollect();
+  this._debug('caught compensate event');
   const catchContent = (0, _messageHelper.cloneContent)(executeContent, {
     message: {
       ...output
@@ -133,27 +132,42 @@ CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompens
     executionId: executeContent.parent.executionId
   });
   catchContent.parent = (0, _messageHelper.shiftParent)(catchContent.parent);
+  this[kCompensateQ].queueMessage({
+    routingKey: 'execute.compensated'
+  }, (0, _messageHelper.cloneContent)(executeContent));
+  broker.publish('execution', 'execute.compensating', (0, _messageHelper.cloneContent)(executeContent, {
+    message: {
+      ...output
+    }
+  }));
   broker.publish('event', 'activity.catch', catchContent, {
     type: 'catch'
   });
-  const compensateQ = this[kCompensateQ];
-  compensateQ.on('depleted', onDepleted);
-  compensateQ.consume(this._onCollected.bind(this), {
+  return this._compensate();
+};
+CompensateEventDefinition.prototype._compensate = function compensate() {
+  return this[kCompensateQ].consume(this._onCollected.bind(this), {
     noAck: true,
     consumerTag: '_convey-messages'
   });
-  for (const association of this[kAssociations]) association.complete((0, _messageHelper.cloneMessage)(message));
-  function onDepleted() {
-    compensateQ.off('depleted', onDepleted);
-    return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
-      output,
-      state: 'catch'
-    }));
-  }
 };
 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', (0, _messageHelper.cloneContent)(message.content, {
+      cancelActivity: false
+    }));
+  }
   for (const association of this[kAssociations]) association.take((0, _messageHelper.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((0, _messageHelper.cloneMessage)(message));
+  return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content));
+};
 CompensateEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
   switch (messageType) {
@@ -163,27 +177,26 @@ CompensateEventDefinition.prototype._onApiMessage = function onApiMessage(routin
       }
     case 'discard':
       {
-        this[kCompleted] = true;
-        this._stop();
-        for (const association of this[kAssociations]) association.discard((0, _messageHelper.cloneMessage)(message));
-        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.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/dist/eventDefinitions/ConditionalEventDefinition.js

@@ -66,9 +66,12 @@ ConditionalEventDefinition.prototype.executeCatch = function executeCatch(execut
   const executeContent = executeMessage.content;
   const {
     executionId,
-    index
+    index,
+    parent
   } = executeContent;
-  this.broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
+  const parentExecutionId = parent.executionId;
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-${executionId}_${index}`
   });
@@ -81,6 +84,12 @@ ConditionalEventDefinition.prototype.executeCatch = function executeCatch(execut
     priority: 300,
     consumerTag: `_onend-${executionId}_${index}`
   });
+  const waitContent = (0, _messageHelper.cloneContent)(executeContent, {
+    executionId: parentExecutionId,
+    condition: this.condition
+  });
+  waitContent.parent = (0, _messageHelper.shiftParent)(parent);
+  broker.publish('event', 'activity.wait', waitContent);
 };
 ConditionalEventDefinition.prototype._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
   const messageType = message.properties.type;

package/dist/eventDefinitions/ErrorEventDefinition.js

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

package/dist/events/BoundaryEvent.js

@@ -99,7 +99,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', (0, _messageHelper.cloneContent)(content, {
       isDefinitionScope: false,
@@ -129,25 +129,34 @@ BoundaryEventBehaviour.prototype._onExpectMessage = function onExpectMessage(_,
 }) {
   const {
     executionId,
-    expectRoutingKey
+    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, (0, _messageHelper.cloneContent)(errorMessage.content));
+  attachedTo.broker.subscribeTmp('event', pattern, (__, message) => {
+    if (message.content.id !== attachedTo.id) return;
+    this.broker.publish(exchange, expectRoutingKey, (0, _messageHelper.cloneContent)(message.content, {
+      attachedTo: attachedTo.id
+    }), {
+      ...message.properties,
+      mandatory: false
+    });
   }, {
     noAck: true,
     consumerTag: errorConsumerTag,
-    priority: 300
+    priority: 400
   });
 };
-BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_, {
-  content
-}) {
+BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_, message) {
+  const content = message.content;
+  const {
+    executionId,
+    parent
+  } = this[kExecuteMessage].content;
   const id = this.id,
-    executionId = this.executionId,
     attachedTo = this.attachedTo;
   this.activity.logger.debug(`<${executionId} (${id})> detach from activity <${attachedTo.id}>`);
   this._stop(true);
@@ -169,6 +178,12 @@ BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_,
   }, {
     cloneMessage: _messageHelper.cloneMessage
   });
+  const detachContent = (0, _messageHelper.cloneContent)(content, {
+    executionId
+  });
+  detachContent.parent = parent;
+  this.activity.removeInboundListeners();
+  broker.publish('event', 'activity.detach', detachContent);
   broker.subscribeOnce('execution', 'execute.bound.completed', (__, {
     content: completeContent
   }) => {

package/dist/flows/Association.js

@@ -32,7 +32,6 @@ function Association(associationDef, {
   this.environment = environment;
   const logger = this.logger = environment.Logger(type.toLowerCase());
   this[kCounters] = {
-    complete: 0,
     take: 0,
     discard: 0
   };
@@ -72,12 +71,6 @@ Association.prototype.discard = function discard(content = {}) {
   this._publishEvent('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/dist/gateways/EventBasedGateway.js

@@ -47,7 +47,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'
   });
   this[kCompleted] = false;
@@ -58,7 +57,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
 EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompleted(executeMessage, _, message, owner) {
   const {
     id: targetId,
-    exexutionId: targetExecutionId
+    executionId: targetExecutionId
   } = message.content;
   const executeContent = executeMessage.content;
   const executionId = executeContent.executionId;

package/dist/process/Process.js

@@ -117,6 +117,11 @@ Object.defineProperty(Process.prototype, 'status', {
     return this[kStatus];
   }
 });
+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 || (0, _shared.getUniqueId)(this.id);

package/dist/process/ProcessExecution.js

@@ -7,6 +7,7 @@ exports.default = void 0;
 var _Api = require("../Api.js");
 var _messageHelper = require("../messageHelper.js");
 var _shared = require("../shared.js");
+var _Tracker = require("../Tracker.js");
 var _default = ProcessExecution;
 exports.default = _default;
 const kActivated = Symbol.for('activated');
@@ -18,17 +19,20 @@ 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
+    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;
@@ -52,6 +56,7 @@ function ProcessExecution(parentActivity, context) {
   this[kStopped] = false;
   this[kActivated] = false;
   this[kStatus] = 'init';
+  this[kTracker] = new _Tracker.ActivityTracker(id);
   this.executionId = undefined;
   this[kMessageHandlers] = {
     onActivityEvent: this._onActivityEvent.bind(this),
@@ -88,6 +93,11 @@ Object.defineProperty(ProcessExecution.prototype, 'isRunning', {
     return this[kActivated];
   }
 });
+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');
@@ -131,6 +141,7 @@ ProcessExecution.prototype.resume = function resume() {
   if (this[kCompleted]) return;
   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;
@@ -140,6 +151,7 @@ ProcessExecution.prototype.resume = function resume() {
       msg.ack();
       continue;
     }
+    tracker.track(msg.fields.routingKey, msg);
     activity.resume();
   }
   if (this[kCompleted]) return;
@@ -248,6 +260,17 @@ 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,
@@ -285,6 +308,9 @@ ProcessExecution.prototype.getActivityById = function getActivityById(activityId
 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 (0, _Api.ProcessApi)(this.broker, this[kExecuteMessage]);
   const content = message.content;
@@ -322,6 +348,7 @@ ProcessExecution.prototype._start = function start() {
     for (const a of startActivities) a.shake();
   }
   for (const a of startActivities) a.init();
+  this[kStatus] = 'executing';
   for (const a of startActivities) a.run();
   postponed.splice(0);
   detachedActivities.splice(0);
@@ -465,6 +492,7 @@ 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,
@@ -472,7 +500,6 @@ ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKe
   });
   if (shaking) return this._onShookEnd(message);
   if (!isDirectChild) return;
-  if (content.isAssociation) return;
   switch (routingKey) {
     case 'process.terminate':
       return this[kActivityQ].queueMessage({
@@ -502,6 +529,17 @@ 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 => {
@@ -510,7 +548,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);
@@ -522,14 +559,17 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
         this[kElements].detachedActivities.push((0, _messageHelper.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();
         }
@@ -567,7 +607,7 @@ ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
     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;
   });
   let postponedMsg;
@@ -598,9 +638,16 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
     return this._complete('completed');
   }
   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) {
     const startSequences = this[kElements].startSequences;
@@ -637,33 +684,42 @@ ProcessExecution.prototype._onDiscard = function onDiscard() {
   this._deactivate();
   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 || (0, _shared.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'}`);
+ProcessExecution.prototype._onCancel = function onCancel() {
+  const running = this[kElements].postponed.slice(0);
+  const isTransaction = this.isTransaction;
+  if (isTransaction) {
+    this._debug(`cancel transaction execution (cancel child executions ${running.length})`);
+    this[kStatus] = 'cancel';
+    this.broker.publish('event', 'transaction.cancel', (0, _messageHelper.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();
       }
-    }, {
-      consumerTag: `_ct-delegate-${correlationId}`,
-      noAck: true
-    });
-    for (const child of this[kElements].children) {
-      if (child.placeholder) continue;
-      child.broker.publish('api', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
-      if (consumed) break;
     }
-    return broker.cancel(`_ct-delegate-${correlationId}`);
+  } else {
+    this._debug(`cancel process execution (cancel child executions ${running.length})`);
+    for (const msg of running) {
+      this._getChildApi(msg).discard();
+    }
+  }
+};
+ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
+  if (message.properties.delegate) {
+    return this._delegateApiMessage(routingKey, message);
   }
   if (this.id !== message.content.id) {
     const child = this.getActivityById(message.content.id);
@@ -672,6 +728,8 @@ 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':
@@ -683,11 +741,43 @@ ProcessExecution.prototype._onApiMessage = function onApiMessage(routingKey, mes
       break;
   }
 };
+ProcessExecution.prototype._delegateApiMessage = function delegateApiMessage(routingKey, message, continueOnConsumed) {
+  const correlationId = message.properties.correlationId || (0, _shared.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, (0, _messageHelper.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();
   return broker.publish(this._exchangeName, `execution.${completionType}.${this.executionId}`, (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
@@ -706,13 +796,15 @@ ProcessExecution.prototype._terminate = function terminate(message) {
   this._debug('terminating process execution');
   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
+      isSequenceFlow,
+      isAssociation
     } = msg.content;
     if (postponedId === message.content.id) continue;
-    if (isSequenceFlow) continue;
+    if (isSequenceFlow || isAssociation) continue;
     this._getChildApi(msg).stop();
     msg.ack();
   }