bpmn-elements 8.2.4 → 9.1.0

package/dist/{src/process → process}/ProcessExecution.js

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _Api = require("../Api");
-var _messageHelper = require("../messageHelper");
-var _shared = require("../shared");
+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),
@@ -60,36 +65,40 @@ function ProcessExecution(parentActivity, context) {
     onMessageFlowEvent: this._onMessageFlowEvent.bind(this)
   };
 }
-const proto = ProcessExecution.prototype;
-Object.defineProperty(proto, 'stopped', {
+Object.defineProperty(ProcessExecution.prototype, 'stopped', {
   enumerable: true,
   get() {
     return this[kStopped];
   }
 });
-Object.defineProperty(proto, 'completed', {
+Object.defineProperty(ProcessExecution.prototype, 'completed', {
   enumerable: true,
   get() {
     return this[kCompleted];
   }
 });
-Object.defineProperty(proto, 'status', {
+Object.defineProperty(ProcessExecution.prototype, 'status', {
   enumerable: true,
   get() {
     return this[kStatus];
   }
 });
-Object.defineProperty(proto, 'postponedCount', {
+Object.defineProperty(ProcessExecution.prototype, 'postponedCount', {
   get() {
     return this[kElements].postponed.length;
   }
 });
-Object.defineProperty(proto, 'isRunning', {
+Object.defineProperty(ProcessExecution.prototype, 'isRunning', {
   get() {
     return this[kActivated];
   }
 });
-proto.execute = function execute(executeMessage) {
+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');
   const executionId = this.executionId = executeMessage.content.executionId;
@@ -111,7 +120,7 @@ proto.execute = function execute(executeMessage) {
   this._start();
   return true;
 };
-proto.resume = function resume() {
+ProcessExecution.prototype.resume = function resume() {
   this._debug(`resume process execution at ${this.status}`);
   if (this[kCompleted]) return this._complete('completed');
   this._activate();
@@ -132,6 +141,7 @@ proto.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;
@@ -141,12 +151,13 @@ proto.resume = function resume() {
       msg.ack();
       continue;
     }
+    tracker.track(msg.fields.routingKey, msg);
     activity.resume();
   }
   if (this[kCompleted]) return;
   if (!postponed.length && status === 'executing') return this._complete('completed');
 };
-proto.recover = function recover(state) {
+ProcessExecution.prototype.recover = function recover(state) {
   if (!state) return this;
   this.executionId = state.executionId;
   this[kStopped] = state.stopped;
@@ -183,7 +194,7 @@ proto.recover = function recover(state) {
   }
   return this;
 };
-proto.shake = function shake(fromId) {
+ProcessExecution.prototype.shake = function shake(fromId) {
   let executing = true;
   const id = this.id;
   if (!this.isRunning) {
@@ -224,10 +235,10 @@ proto.shake = function shake(fromId) {
   this.broker.cancel(`_shaker-${this.executionId}`);
   return result;
 };
-proto.stop = function stop() {
+ProcessExecution.prototype.stop = function stop() {
   this.getApi().stop();
 };
-proto.getPostponed = function getPostponed(filterFn) {
+ProcessExecution.prototype.getPostponed = function getPostponed(filterFn) {
   const result = [];
   for (const msg of this[kElements].postponed.slice()) {
     const api = this._getChildApi(msg);
@@ -237,7 +248,7 @@ proto.getPostponed = function getPostponed(filterFn) {
   }
   return result;
 };
-proto.discard = function discard() {
+ProcessExecution.prototype.discard = function discard() {
   this[kStatus] = 'discard';
   return this[kActivityQ].queueMessage({
     routingKey: 'execution.discard'
@@ -249,7 +260,18 @@ proto.discard = function discard() {
     type: 'discard'
   });
 };
-proto.getState = function getState() {
+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,
@@ -277,16 +299,19 @@ proto.getState = function getState() {
     })
   };
 };
-proto.getActivities = function getActivities() {
+ProcessExecution.prototype.getActivities = function getActivities() {
   return this[kElements].children.slice();
 };
-proto.getActivityById = function getActivityById(activityId) {
+ProcessExecution.prototype.getActivityById = function getActivityById(activityId) {
   return this[kElements].children.find(child => child.id === activityId);
 };
-proto.getSequenceFlows = function getSequenceFlows() {
+ProcessExecution.prototype.getSequenceFlows = function getSequenceFlows() {
   return this[kElements].flows.slice();
 };
-proto.getApi = function getApi(message) {
+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;
   if (content.executionId !== this.executionId) {
@@ -304,7 +329,7 @@ proto.getApi = function getApi(message) {
   };
   return api;
 };
-proto._start = function start() {
+ProcessExecution.prototype._start = function start() {
   if (this[kElements].children.length === 0) {
     return this._complete('completed');
   }
@@ -323,6 +348,7 @@ proto._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);
@@ -331,7 +357,7 @@ proto._start = function start() {
     consumerTag: `_process-activity-${this.executionId}`
   });
 };
-proto._activate = function activate() {
+ProcessExecution.prototype._activate = function activate() {
   const {
     onApiMessage,
     onMessageFlowEvent,
@@ -395,7 +421,7 @@ proto._activate = function activate() {
   }
   this[kActivated] = true;
 };
-proto._deactivate = function deactivate() {
+ProcessExecution.prototype._deactivate = function deactivate() {
   const broker = this.broker;
   const executionId = this.executionId;
   broker.cancel(`_process-api-consumer-${executionId}`);
@@ -423,7 +449,7 @@ proto._deactivate = function deactivate() {
   }
   this[kActivated] = false;
 };
-proto._onDelegateEvent = function onDelegateEvent(message) {
+ProcessExecution.prototype._onDelegateEvent = function onDelegateEvent(message) {
   const eventType = message.properties.type;
   let delegate = true;
   const content = message.content;
@@ -446,10 +472,10 @@ proto._onDelegateEvent = function onDelegateEvent(message) {
   });
   return delegate;
 };
-proto._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
+ProcessExecution.prototype._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
   this.broker.publish('message', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
 };
-proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+ProcessExecution.prototype._onActivityEvent = function onActivityEvent(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return;
   const content = message.content;
   const parent = content.parent = content.parent || {};
@@ -466,6 +492,7 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
     });
   }
   if (delegate) delegate = this._onDelegateEvent(message);
+  this[kTracker].track(routingKey, message);
   this.broker.publish('event', routingKey, content, {
     ...message.properties,
     delegate,
@@ -473,7 +500,6 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   });
   if (shaking) return this._onShookEnd(message);
   if (!isDirectChild) return;
-  if (content.isAssociation) return;
   switch (routingKey) {
     case 'process.terminate':
       return this[kActivityQ].queueMessage({
@@ -490,7 +516,7 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
     ...message.properties
   });
 };
-proto._onChildMessage = function onChildMessage(routingKey, message) {
+ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return message.ack();
   const content = message.content;
   switch (routingKey) {
@@ -503,6 +529,17 @@ proto._onChildMessage = function onChildMessage(routingKey, message) {
     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 => {
@@ -511,7 +548,6 @@ proto._onChildMessage = function onChildMessage(routingKey, message) {
         if (!prevMsg) return message.ack();
         break;
       }
-    case 'activity.compensation.end':
     case 'flow.looped':
     case 'activity.leave':
       return this._onChildCompleted(message);
@@ -523,14 +559,17 @@ proto._onChildMessage = function onChildMessage(routingKey, message) {
         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();
         }
@@ -557,18 +596,18 @@ proto._onChildMessage = function onChildMessage(routingKey, message) {
       }
   }
 };
-proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
+ProcessExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   const previousMsg = this._popPostponed(message.content);
   if (previousMsg) previousMsg.ack();
   if (postponeMessage) this[kElements].postponed.push(message);
 };
-proto._popPostponed = function popPostponed(byContent) {
+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;
   });
   let postponedMsg;
@@ -579,7 +618,7 @@ proto._popPostponed = function popPostponed(byContent) {
   if (detachedIdx > -1) detachedActivities.splice(detachedIdx, 1);
   return postponedMsg;
 };
-proto._onChildCompleted = function onChildCompleted(message) {
+ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message) {
   this._stateChangeMessage(message, false);
   if (message.fields.redelivered) return message.ack();
   const {
@@ -599,9 +638,16 @@ proto._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;
@@ -618,7 +664,7 @@ proto._onChildCompleted = function onChildCompleted(message) {
     }
   }
 };
-proto._stopExecution = function stopExecution(message) {
+ProcessExecution.prototype._stopExecution = function stopExecution(message) {
   const postponedCount = this.postponedCount;
   this._debug(`stop process execution (stop child executions ${postponedCount})`);
   if (postponedCount) {
@@ -634,37 +680,46 @@ proto._stopExecution = function stopExecution(message) {
     persistent: false
   });
 };
-proto._onDiscard = function onDiscard() {
+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');
 };
-proto._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);
@@ -673,6 +728,8 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
   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':
@@ -684,11 +741,43 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
       break;
   }
 };
-proto._complete = function complete(completionType, content) {
+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, {
@@ -702,36 +791,38 @@ proto._complete = function complete(completionType, content) {
     mandatory: completionType === 'error'
   });
 };
-proto._terminate = function terminate(message) {
+ProcessExecution.prototype._terminate = function terminate(message) {
   this[kStatus] = 'terminated';
   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();
   }
   this[kActivityQ].purge();
 };
-proto._getFlowById = function getFlowById(flowId) {
+ProcessExecution.prototype._getFlowById = function getFlowById(flowId) {
   return this[kElements].flows.find(f => f.id === flowId);
 };
-proto._getAssociationById = function getAssociationById(associationId) {
+ProcessExecution.prototype._getAssociationById = function getAssociationById(associationId) {
   return this[kElements].associations.find(a => a.id === associationId);
 };
-proto._getMessageFlowById = function getMessageFlowById(flowId) {
+ProcessExecution.prototype._getMessageFlowById = function getMessageFlowById(flowId) {
   return this[kElements].outboundMessageFlows.find(f => f.id === flowId);
 };
-proto._getChildById = function getChildById(childId) {
+ProcessExecution.prototype._getChildById = function getChildById(childId) {
   return this.getActivityById(childId) || this._getFlowById(childId);
 };
-proto._getChildApi = function getChildApi(message) {
+ProcessExecution.prototype._getChildApi = function getChildApi(message) {
   const content = message.content;
   let child = this._getChildById(content.id);
   if (child) return child.getApi(message);
@@ -744,11 +835,11 @@ proto._getChildApi = function getChildApi(message) {
     if (child) return child.getApi(message);
   }
 };
-proto._onShookEnd = function onShookEnd(message) {
+ProcessExecution.prototype._onShookEnd = function onShookEnd(message) {
   const routingKey = message.fields.routingKey;
   if (routingKey !== 'activity.shake.end') return;
   this[kElements].startSequences[message.content.id] = (0, _messageHelper.cloneMessage)(message);
 };
-proto._debug = function debugMessage(logMessage) {
+ProcessExecution.prototype._debug = function debugMessage(logMessage) {
   this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };

package/dist/{src/tasks → tasks}/CallActivity.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.CallActivityBehaviour = CallActivityBehaviour;
 exports.default = CallActivity;
-var _Activity = _interopRequireDefault(require("../activity/Activity"));
-var _Errors = require("../error/Errors");
-var _messageHelper = require("../messageHelper");
+var _Activity = _interopRequireDefault(require("../activity/Activity.js"));
+var _Errors = require("../error/Errors.js");
+var _messageHelper = require("../messageHelper.js");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function CallActivity(activityDef, context) {
   return new _Activity.default(CallActivityBehaviour, activityDef, context);
@@ -26,8 +26,7 @@ function CallActivityBehaviour(activity) {
   this.broker = activity.broker;
   this.environment = activity.environment;
 }
-const proto = CallActivityBehaviour.prototype;
-proto.execute = function execute(executeMessage) {
+CallActivityBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;
   if (loopCharacteristics && executeContent.isRootScope) {
@@ -62,7 +61,7 @@ proto.execute = function execute(executeMessage) {
     type: 'call'
   });
 };
-proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, executeMessage, routingKey, message) {
+CallActivityBehaviour.prototype._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, executeMessage, routingKey, message) {
   if (!message.properties.delegate) return;
   const {
     content: delegateContent
@@ -89,7 +88,7 @@ proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, exe
   });
   return this._onApiMessage(calledElement, executeMessage, routingKey, message);
 };
-proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routingKey, message) {
+CallActivityBehaviour.prototype._onApiMessage = function onApiMessage(calledElement, executeMessage, routingKey, message) {
   const {
     type: messageType,
     correlationId
@@ -132,7 +131,7 @@ proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routi
       });
   }
 };
-proto._stop = function stop(executionId) {
+CallActivityBehaviour.prototype._stop = function stop(executionId) {
   const broker = this.broker;
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);

package/dist/{src/tasks → tasks}/LoopCharacteristics.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = LoopCharacteristics;
-var _Errors = require("../error/Errors");
-var _messageHelper = require("../messageHelper");
+var _Errors = require("../error/Errors.js");
+var _messageHelper = require("../messageHelper.js");
 function LoopCharacteristics(activity, loopCharacteristics) {
   this.activity = activity;
   this.loopCharacteristics = loopCharacteristics;