bpmn-elements 8.2.4 → 9.1.0

package/src/eventDefinitions/CompensateEventDefinition.js

@@ -1,5 +1,5 @@
-import {brokerSafeId} from '../shared';
-import {cloneContent, cloneMessage, shiftParent} from '../messageHelper';
+import {brokerSafeId} from '../shared.js';
+import {cloneContent, cloneMessage, shiftParent} from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kExecuteMessage = Symbol.for('executeMessage');
@@ -20,29 +20,33 @@ 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});
   }
 }
 
-const proto = CompensateEventDefinition.prototype;
-
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(CompensateEventDefinition.prototype, 'executionId', {
   get() {
     const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
 
-proto.execute = function execute(executeMessage) {
+CompensateEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
-proto.executeCatch = function executeCatch(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;
@@ -50,18 +54,13 @@ proto.executeCatch = function executeCatch(executeMessage) {
   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}`,
@@ -69,27 +68,24 @@ proto.executeCatch = function executeCatch(executeMessage) {
 
   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',
+  }));
 };
 
-proto.executeThrow = function executeThrow(executeMessage) {
+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, {
@@ -102,8 +98,7 @@ proto.executeThrow = function executeThrow(executeMessage) {
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
 
-proto._onCollect = function onCollect(routingKey, message) {
-
+CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey, message) {
   switch (routingKey) {
     case 'execute.error':
     case 'execute.completed': {
@@ -112,68 +107,79 @@ proto._onCollect = function onCollect(routingKey, message) {
   }
 };
 
-proto._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
-  const output = message.content.message;
+CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompensateApiMessage(routingKey, 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);
 
+  this[kCompensateQ].queueMessage({routingKey: 'execute.compensated'}, cloneContent(executeContent));
+
+  broker.publish('execution', 'execute.compensating', 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), {noAck: true, consumerTag: '_convey-messages'});
+  return this._compensate();
+};
 
-  for (const association of this[kAssociations]) association.complete(cloneMessage(message));
+CompensateEventDefinition.prototype._compensate = function compensate() {
+  return this[kCompensateQ].consume(this._onCollected.bind(this), {noAck: true, consumerTag: '_convey-messages'});
+};
 
-  function onDepleted() {
-    compensateQ.off('depleted', onDepleted);
-    return broker.publish('execution', 'execute.completed', 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', cloneContent(message.content, {cancelActivity: false}));
   }
+  for (const association of this[kAssociations]) association.take(cloneMessage(message));
 };
 
-proto._onCollected = function onCollected(routingKey, message) {
-  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));
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+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();
     }
   }
 };
 
-proto._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();
 };
 
-proto._debug = function debug(msg) {
+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

@@ -1,5 +1,5 @@
-import {cloneContent, shiftParent} from '../messageHelper';
-import {ActivityError} from '../error/Errors';
+import {cloneContent, shiftParent} from '../messageHelper.js';
+import {ActivityError} from '../error/Errors.js';
 
 const kExecuteMessage = Symbol.for('executeMessage');
 
@@ -18,21 +18,19 @@ export default function ConditionalEventDefinition(activity, eventDefinition) {
   this.logger = environment.Logger(type.toLowerCase());
 }
 
-const proto = ConditionalEventDefinition.prototype;
-
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
   get() {
     const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
 
-proto.execute = function execute(executeMessage) {
+ConditionalEventDefinition.prototype.execute = function execute(executeMessage) {
   this[kExecuteMessage] = executeMessage;
   return this.isWaiting ? this.executeWait(executeMessage) : this.executeCatch(executeMessage);
 };
 
-proto.executeWait = function executeWait(executeMessage) {
+ConditionalEventDefinition.prototype.executeWait = function executeWait(executeMessage) {
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
   const parentExecutionId = parent.executionId;
@@ -59,11 +57,13 @@ proto.executeWait = function executeWait(executeMessage) {
   broker.publish('event', 'activity.wait', waitContent);
 };
 
-proto.executeCatch = function executeCatch(executeMessage) {
+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}`,
   });
@@ -76,9 +76,17 @@ proto.executeCatch = function executeCatch(executeMessage) {
     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);
 };
 
-proto._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
+ConditionalEventDefinition.prototype._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
   const messageType = message.properties.type;
 
   switch (messageType) {
@@ -95,7 +103,7 @@ proto._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
   }
 };
 
-proto._evaluateWait = function evaluate(message) {
+ConditionalEventDefinition.prototype._evaluateWait = function evaluate(message) {
   const executeMessage = this[kExecuteMessage];
   const broker = this.broker, executeContent = executeMessage.content;
 
@@ -116,13 +124,13 @@ proto._evaluateWait = function evaluate(message) {
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output}));
 };
 
-proto._stopWait = function stopWait() {
+ConditionalEventDefinition.prototype._stopWait = function stopWait() {
   const broker = this.broker, executionId = this.executionId;
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_parent-signal-${executionId}`);
 };
 
-proto._onAttachedCompleted = function onAttachedCompleted(routingKey, message) {
+ConditionalEventDefinition.prototype._onAttachedCompleted = function onAttachedCompleted(routingKey, message) {
   this._stopCatch();
 
   const executeMessage = this[kExecuteMessage];
@@ -144,7 +152,7 @@ proto._onAttachedCompleted = function onAttachedCompleted(routingKey, message) {
   }
 };
 
-proto._onCatchApiMessage = function onCatchApiMessage(routingKey, message) {
+ConditionalEventDefinition.prototype._onCatchApiMessage = function onCatchApiMessage(routingKey, message) {
   const messageType = message.properties.type;
   switch (messageType) {
     case 'discard': {
@@ -159,12 +167,12 @@ proto._onCatchApiMessage = function onCatchApiMessage(routingKey, message) {
   }
 };
 
-proto._stopCatch = function stopCatch() {
+ConditionalEventDefinition.prototype._stopCatch = function stopCatch() {
   const {executionId, index} = this[kExecuteMessage].content;
   this.activity.attachedTo.broker.cancel(`_onend-${executionId}_${index}`);
   this.broker.cancel(`_api-${executionId}_${index}`);
 };
 
-proto._debug = function debug(msg) {
+ConditionalEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };

package/src/eventDefinitions/ErrorEventDefinition.js

@@ -1,5 +1,5 @@
-import {brokerSafeId} from '../shared';
-import {cloneContent, shiftParent} from '../messageHelper';
+import {brokerSafeId} from '../shared.js';
+import {cloneContent, shiftParent} from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kMessageQ = Symbol.for('messageQ');
@@ -36,20 +36,18 @@ export default function ErrorEventDefinition(activity, eventDefinition) {
   }
 }
 
-const proto = ErrorEventDefinition.prototype;
-
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(ErrorEventDefinition.prototype, 'executionId', {
   get() {
     const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
 
-proto.execute = function execute(executeMessage) {
+ErrorEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
-proto.executeCatch = function executeCatch(executeMessage) {
+ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
   this[kExecuteMessage] = executeMessage;
   this[kCompleted] = false;
 
@@ -81,6 +79,8 @@ proto.executeCatch = function executeCatch(executeMessage) {
       consumerTag: `_onerror-${executionId}`,
     });
     broker.publish('execution', 'execute.expect', cloneContent(executeContent, {
+      pattern: 'activity.error',
+      exchange: 'execution',
       expectRoutingKey,
       expect: {...info.message},
     }));
@@ -97,7 +97,7 @@ proto.executeCatch = function executeCatch(executeMessage) {
   broker.publish('event', 'activity.wait', waitContent);
 };
 
-proto.executeThrow = function executeThrow(executeMessage) {
+ErrorEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
 
@@ -120,7 +120,7 @@ proto.executeThrow = function executeThrow(executeMessage) {
   }));
 };
 
-proto._onErrorMessage = function onErrorMessage(routingKey, message) {
+ErrorEventDefinition.prototype._onErrorMessage = function onErrorMessage(routingKey, message) {
   const error = message.content.error;
   if (!this[kReferenceElement]) return this._catchError(routingKey, message, error);
 
@@ -132,7 +132,7 @@ proto._onErrorMessage = function onErrorMessage(routingKey, message) {
   return this._catchError(routingKey, message, error);
 };
 
-proto._onThrowApiMessage = function onThrowApiMessage(routingKey, message) {
+ErrorEventDefinition.prototype._onThrowApiMessage = function onThrowApiMessage(routingKey, message) {
   const error = message.content.message;
   if (!this[kReferenceElement]) return this._catchError(routingKey, message, error);
 
@@ -141,7 +141,7 @@ proto._onThrowApiMessage = function onThrowApiMessage(routingKey, message) {
   return this._catchError(routingKey, message, error);
 };
 
-proto._catchError = function catchError(routingKey, message, error) {
+ErrorEventDefinition.prototype._catchError = function catchError(routingKey, message, error) {
   this[kCompleted] = true;
 
   this._stop();
@@ -171,7 +171,7 @@ proto._catchError = function catchError(routingKey, message, error) {
   }));
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+ErrorEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
 
   switch (messageType) {
@@ -187,7 +187,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._stop = function stop() {
+ErrorEventDefinition.prototype._stop = function stop() {
   const broker = this.broker, executionId = this.executionId;
   broker.cancel(`_onthrow-${executionId}`);
   broker.cancel(`_onerror-${executionId}`);
@@ -195,7 +195,7 @@ proto._stop = function stop() {
   this[kMessageQ].purge();
 };
 
-proto._getReferenceInfo = function getReferenceInfo(message) {
+ErrorEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
   const referenceElement = this[kReferenceElement];
   if (!referenceElement) {
     return {
@@ -214,6 +214,6 @@ proto._getReferenceInfo = function getReferenceInfo(message) {
   return result;
 };
 
-proto._debug = function debug(msg) {
+ErrorEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };

package/src/eventDefinitions/EscalationEventDefinition.js

@@ -1,6 +1,6 @@
-import getPropertyValue from '../getPropertyValue';
-import {brokerSafeId} from '../shared';
-import {cloneContent, shiftParent} from '../messageHelper';
+import getPropertyValue from '../getPropertyValue.js';
+import {brokerSafeId} from '../shared.js';
+import {cloneContent, shiftParent} from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kMessageQ = Symbol.for('messageQ');
@@ -36,20 +36,18 @@ export default function EscalationEventDefinition(activity, eventDefinition) {
   }
 }
 
-const proto = EscalationEventDefinition.prototype;
-
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(EscalationEventDefinition.prototype, 'executionId', {
   get() {
     const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
 
-proto.execute = function execute(executeMessage) {
+EscalationEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
-proto.executeCatch = function executeCatch(executeMessage) {
+EscalationEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
   this[kExecuteMessage] = executeMessage;
   this[kCompleted] = false;
 
@@ -82,7 +80,7 @@ proto.executeCatch = function executeCatch(executeMessage) {
   broker.publish('event', 'activity.wait', waitContent);
 };
 
-proto.executeThrow = function executeThrow(executeMessage) {
+EscalationEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
 
@@ -102,7 +100,7 @@ proto.executeThrow = function executeThrow(executeMessage) {
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
 
-proto._onCatchMessage = function onCatchMessage(routingKey, message) {
+EscalationEventDefinition.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
   const info = this[kReference];
   if (getPropertyValue(message, 'content.message.id') !== info.message.id) return;
 
@@ -127,7 +125,7 @@ proto._onCatchMessage = function onCatchMessage(routingKey, message) {
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output, state: 'catch'}));
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+EscalationEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'escalate': {
       return this._onCatchMessage(routingKey, message);
@@ -144,13 +142,13 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._stop = function stop() {
+EscalationEventDefinition.prototype._stop = function stop() {
   const broker = this.broker, executionId = this.executionId;
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_onescalate-${executionId}`);
 };
 
-proto._getReferenceInfo = function getReferenceInfo(message) {
+EscalationEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
   const referenceElement = this[kReferenceElement];
   if (!referenceElement) {
     return {
@@ -168,6 +166,6 @@ proto._getReferenceInfo = function getReferenceInfo(message) {
   return result;
 };
 
-proto._debug = function debug(msg) {
+EscalationEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };

package/src/eventDefinitions/EventDefinitionExecution.js

@@ -1,4 +1,4 @@
-import {cloneContent, unshiftParent, shiftParent, cloneParent} from '../messageHelper';
+import {cloneContent, unshiftParent, shiftParent, cloneParent} from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kExecuteMessage = Symbol.for('executeMessage');
@@ -15,23 +15,21 @@ export default function EventDefinitionExecution(activity, eventDefinitions, com
   this[kExecuteMessage] = null;
 }
 
-const proto = EventDefinitionExecution.prototype;
-
-Object.defineProperty(proto, 'completed', {
+Object.defineProperty(EventDefinitionExecution.prototype, 'completed', {
   enumerable: true,
   get() {
     return this[kCompleted];
   },
 });
 
-Object.defineProperty(proto, 'stopped', {
+Object.defineProperty(EventDefinitionExecution.prototype, 'stopped', {
   enumerable: true,
   get() {
     return this[kStopped];
   },
 });
 
-proto.execute = function execute(executeMessage) {
+EventDefinitionExecution.prototype.execute = function execute(executeMessage) {
   const content = executeMessage.content;
 
   if (content.isDefinitionScope) return this._executeDefinition(executeMessage);
@@ -82,7 +80,7 @@ proto.execute = function execute(executeMessage) {
   }
 };
 
-proto._onApiMessage = function onApiMessage(_, message) {
+EventDefinitionExecution.prototype._onApiMessage = function onApiMessage(_, message) {
   const messageType = message.properties.type;
   switch (messageType) {
     case 'stop':
@@ -91,7 +89,7 @@ proto._onApiMessage = function onApiMessage(_, message) {
   }
 };
 
-proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
+EventDefinitionExecution.prototype._onExecuteMessage = function onExecuteMessage(routingKey, message) {
   switch (routingKey) {
     case 'execute.completed': {
       this._stop();
@@ -111,7 +109,7 @@ proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
   }
 };
 
-proto._complete = function complete(message) {
+EventDefinitionExecution.prototype._complete = function complete(message) {
   const {executionId, type, index, parent} = message.content;
   this[kCompleted] = true;
 
@@ -127,7 +125,7 @@ proto._complete = function complete(message) {
   this.broker.publish('execution', this.completedRoutingKey, completeContent, {correlationId: message.properties.correlationId});
 };
 
-proto._executeDefinition = function executeDefinition(message) {
+EventDefinitionExecution.prototype._executeDefinition = function executeDefinition(message) {
   const {executionId, index} = message.content;
   const ed = this.eventDefinitions[index];
   if (!ed) return this.activity.logger.warn(`<${executionId} (${this.id})> found no event definition on index ${index}`);
@@ -135,12 +133,12 @@ proto._executeDefinition = function executeDefinition(message) {
   ed.execute(message);
 };
 
-proto._stop = function stop() {
+EventDefinitionExecution.prototype._stop = function stop() {
   this[kStopped] = true;
   this.broker.cancel('_eventdefinition-execution-execute-tag');
   this.broker.cancel('_eventdefinition-execution-api-tag');
 };
 
-proto._debug = function debug(executionId, msg) {
+EventDefinitionExecution.prototype._debug = function debug(executionId, msg) {
   this.activity.logger.debug(`<${executionId} (${this.id})> ${msg}`);
 };