bpmn-elements 8.2.4 → 9.1.0

package/src/process/ProcessExecution.js

@@ -1,6 +1,7 @@
-import {ProcessApi} from '../Api';
-import {cloneContent, cloneMessage, pushParent} from '../messageHelper';
-import {getUniqueId} from '../shared';
+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] = {
@@ -54,42 +58,46 @@ function ProcessExecution(parentActivity, context) {
   };
 }
 
-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');
 
@@ -115,7 +123,7 @@ proto.execute = function execute(executeMessage) {
   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');
@@ -141,6 +149,7 @@ proto.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;
@@ -150,6 +159,8 @@ proto.resume = function resume() {
       msg.ack();
       continue;
     }
+
+    tracker.track(msg.fields.routingKey, msg);
     activity.resume();
   }
 
@@ -158,7 +169,7 @@ proto.resume = function resume() {
   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;
 
@@ -204,7 +215,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) {
@@ -239,11 +250,11 @@ proto.shake = function shake(fromId) {
   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);
@@ -254,7 +265,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'}, {
     id: this.id,
@@ -263,7 +274,15 @@ 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, outboundMessageFlows, associations} = this[kElements];
   return {
     executionId: this.executionId,
@@ -281,19 +300,23 @@ 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 ProcessApi(this.broker, this[kExecuteMessage]);
 
   const content = message.content;
@@ -317,7 +340,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');
   }
@@ -334,6 +357,7 @@ proto._start = function start() {
   }
 
   for (const a of startActivities) a.init();
+  this[kStatus] = 'executing';
   for (const a of startActivities) a.run();
 
   postponed.splice(0);
@@ -344,7 +368,7 @@ proto._start = function start() {
   });
 };
 
-proto._activate = function activate() {
+ProcessExecution.prototype._activate = function activate() {
   const {onApiMessage, onMessageFlowEvent, onActivityEvent} = this[kMessageHandlers];
 
   if (!this.isSubProcess) {
@@ -406,7 +430,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}`);
@@ -436,7 +460,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;
 
@@ -459,11 +483,11 @@ 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, 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;
@@ -480,10 +504,10 @@ 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, mandatory: false});
   if (shaking) return this._onShookEnd(message);
   if (!isDirectChild) return;
-  if (content.isAssociation) return;
 
   switch (routingKey) {
     case 'process.terminate':
@@ -495,7 +519,7 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   this[kActivityQ].queueMessage(message.fields, cloneContent(content), {persistent: true, ...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;
@@ -510,6 +534,16 @@ 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) => {
         return msg.content.executionId === content.executionId;
@@ -517,7 +551,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);
@@ -530,14 +563,16 @@ proto._onChildMessage = function onChildMessage(routingKey, message) {
       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();
       }
@@ -558,17 +593,17 @@ 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;
   });
 
@@ -583,7 +618,7 @@ proto._popPostponed = function popPostponed(byContent) {
   return postponedMsg;
 };
 
-proto._onChildCompleted = function onChildCompleted(message) {
+ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message) {
   this._stateChangeMessage(message, false);
   if (message.fields.redelivered) return message.ack();
 
@@ -600,9 +635,12 @@ proto._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) {
@@ -619,7 +657,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) {
@@ -633,40 +671,52 @@ proto._stopExecution = function stopExecution(message) {
   }, {type: 'stopped', 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 || 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;
+
+  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 child of this[kElements].children) {
-      if (child.placeholder) continue;
-      child.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
-      if (consumed) break;
+    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) {
@@ -678,19 +728,56 @@ 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':
-      this[kActivityQ].queueMessage({routingKey: 'execution.stop'}, cloneContent(message.content), {persistent: false});
+      this[kActivityQ].queueMessage({ routingKey: 'execution.stop' }, cloneContent(message.content), { persistent: false });
       break;
   }
 };
 
-proto._complete = function complete(completionType, content) {
+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();
 
@@ -701,17 +788,18 @@ proto._complete = function complete(completionType, content) {
   }), {type: completionType, 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} = 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();
   }
@@ -719,23 +807,23 @@ proto._terminate = function terminate(message) {
   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);
@@ -754,12 +842,12 @@ proto._getChildApi = function getChildApi(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] = cloneMessage(message);
 };
 
-proto._debug = function debugMessage(logMessage) {
+ProcessExecution.prototype._debug = function debugMessage(logMessage) {
   this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };

package/src/tasks/CallActivity.js

@@ -1,6 +1,6 @@
-import Activity from '../activity/Activity';
-import {ActivityError} from '../error/Errors';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {ActivityError} from '../error/Errors.js';
+import {cloneContent} from '../messageHelper.js';
 
 export default function CallActivity(activityDef, context) {
   return new Activity(CallActivityBehaviour, activityDef, context);
@@ -18,9 +18,7 @@ export function CallActivityBehaviour(activity) {
   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) {
@@ -59,7 +57,7 @@ proto.execute = function execute(executeMessage) {
   });
 };
 
-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} = message;
   if (!delegateContent || !delegateContent.message) return;
@@ -82,7 +80,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} = message.properties;
   const executeContent = executeMessage.content;
 
@@ -123,7 +121,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/src/tasks/LoopCharacteristics.js

@@ -1,5 +1,5 @@
-import {RunError} from '../error/Errors';
-import {cloneContent, cloneMessage, unshiftParent, cloneParent} from '../messageHelper';
+import {RunError} from '../error/Errors.js';
+import {cloneContent, cloneMessage, unshiftParent, cloneParent} from '../messageHelper.js';
 
 export default function LoopCharacteristics(activity, loopCharacteristics) {
   this.activity = activity;