bpmn-elements 8.2.0 → 8.2.2

package/dist/src/process/ProcessExecution.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _Api = require("../Api");
-
 var _messageHelper = require("../messageHelper");
-
 var _shared = require("../shared");
-
 var _default = ProcessExecution;
 exports.default = _default;
 const kActivated = Symbol.for('activated');
@@ -22,7 +18,6 @@ const kMessageHandlers = Symbol.for('messageHandlers');
 const kParent = Symbol.for('parent');
 const kStatus = Symbol.for('status');
 const kStopped = Symbol.for('stopped');
-
 function ProcessExecution(parentActivity, context) {
   const {
     id,
@@ -65,45 +60,35 @@ function ProcessExecution(parentActivity, context) {
     onMessageFlowEvent: this._onMessageFlowEvent.bind(this)
   };
 }
-
 const proto = ProcessExecution.prototype;
 Object.defineProperty(proto, 'stopped', {
   enumerable: true,
-
   get() {
     return this[kStopped];
   }
-
 });
 Object.defineProperty(proto, 'completed', {
   enumerable: true,
-
   get() {
     return this[kCompleted];
   }
-
 });
 Object.defineProperty(proto, 'status', {
   enumerable: true,
-
   get() {
     return this[kStatus];
   }
-
 });
 Object.defineProperty(proto, 'postponedCount', {
   get() {
     return this[kElements].postponed.length;
   }
-
 });
 Object.defineProperty(proto, 'isRunning', {
   get() {
     return this[kActivated];
   }
-
 });
-
 proto.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');
@@ -118,37 +103,26 @@ proto.execute = function execute(executeMessage) {
     durable: true,
     autoDelete: false
   });
-
   if (executeMessage.fields.redelivered) {
     return this.resume();
   }
-
   this._debug(`execute ${this.isSubProcess ? 'sub process' : 'process'}`);
-
   this._activate();
-
   this._start();
-
   return true;
 };
-
 proto.resume = function resume() {
   this._debug(`resume process execution at ${this.status}`);
-
   if (this[kCompleted]) return this._complete('completed');
-
   this._activate();
-
   const {
     startActivities,
     detachedActivities,
     postponed
   } = this[kElements];
-
   if (startActivities.length > 1) {
     for (const a of startActivities) a.shake();
   }
-
   postponed.splice(0);
   detachedActivities.splice(0);
   this[kActivityQ].consume(this[kMessageHandlers].onChildMessage, {
@@ -156,18 +130,15 @@ proto.resume = function resume() {
     consumerTag: `_process-activity-${this.executionId}`
   });
   if (this[kCompleted]) return;
-
   switch (this.status) {
     case 'init':
       return this._start();
-
     case 'executing':
       {
         if (!postponed.length) return this._complete('completed');
         break;
       }
   }
-
   for (const {
     content
   } of postponed.slice()) {
@@ -177,43 +148,34 @@ proto.resume = function resume() {
     activity.resume();
   }
 };
-
 proto.recover = function recover(state) {
   if (!state) return this;
   this.executionId = state.executionId;
   this[kStopped] = state.stopped;
   this[kCompleted] = state.completed;
   this[kStatus] = state.status;
-
   this._debug(`recover process execution at ${this.status}`);
-
   if (state.messageFlows) {
     for (const flowState of state.messageFlows) {
       const flow = this._getMessageFlowById(flowState.id);
-
       if (!flow) continue;
       flow.recover(flowState);
     }
   }
-
   if (state.associations) {
     for (const associationState of state.associations) {
       const association = this._getAssociationById(associationState.id);
-
       if (!association) continue;
       association.recover(associationState);
     }
   }
-
   if (state.flows) {
     for (const flowState of state.flows) {
       const flow = this._getFlowById(flowState.id);
-
       if (!flow) continue;
       flow.recover(flowState);
     }
   }
-
   if (state.children) {
     for (const childState of state.children) {
       const child = this.getActivityById(childState.id);
@@ -221,32 +183,25 @@ proto.recover = function recover(state) {
       child.recover(childState);
     }
   }
-
   return this;
 };
-
 proto.shake = function shake(fromId) {
   let executing = true;
   const id = this.id;
-
   if (!this.isRunning) {
     executing = false;
     this.executionId = (0, _shared.getUniqueId)(id);
-
     this._activate();
   }
-
   const toShake = fromId ? [this.getActivityById(fromId)].filter(Boolean) : this[kElements].startActivities;
   const result = {};
   this.broker.subscribeTmp('event', '*.shake.*', (routingKey, {
     content
   }) => {
     let isLooped = false;
-
     switch (routingKey) {
       case 'flow.shake.loop':
         isLooped = true;
-
       case 'activity.shake.end':
         {
           const {
@@ -255,7 +210,8 @@ proto.shake = function shake(fromId) {
           } = content;
           if (shakeParent.id !== id) return;
           result[shakeId] = result[shakeId] || [];
-          result[shakeId].push({ ...content,
+          result[shakeId].push({
+            ...content,
             isLooped
           });
           break;
@@ -265,31 +221,24 @@ proto.shake = function shake(fromId) {
     noAck: true,
     consumerTag: `_shaker-${this.executionId}`
   });
-
   for (const a of toShake) a.shake();
-
   if (!executing) this._deactivate();
   this.broker.cancel(`_shaker-${this.executionId}`);
   return result;
 };
-
 proto.stop = function stop() {
   this.getApi().stop();
 };
-
 proto.getPostponed = function getPostponed(filterFn) {
   return this[kElements].postponed.slice().reduce((result, msg) => {
     const api = this._getChildApi(msg);
-
     if (api) {
       if (filterFn && !filterFn(api)) return result;
       result.push(api);
     }
-
     return result;
   }, []);
 };
-
 proto.discard = function discard() {
   this[kStatus] = 'discard';
   return this[kActivityQ].queueMessage({
@@ -302,7 +251,6 @@ proto.discard = function discard() {
     type: 'discard'
   });
 };
-
 proto.getState = function getState() {
   const {
     children,
@@ -331,50 +279,40 @@ proto.getState = function getState() {
     })
   };
 };
-
 proto.getActivities = function getActivities() {
   return this[kElements].children.slice();
 };
-
 proto.getActivityById = function getActivityById(activityId) {
   return this[kElements].children.find(child => child.id === activityId);
 };
-
 proto.getSequenceFlows = function getSequenceFlows() {
   return this[kElements].flows.slice();
 };
-
 proto.getApi = function getApi(message) {
   if (!message) return (0, _Api.ProcessApi)(this.broker, this[kExecuteMessage]);
   const content = message.content;
-
   if (content.executionId !== this.executionId) {
     return this._getChildApi(message);
   }
-
   const api = (0, _Api.ProcessApi)(this.broker, message);
   const postponed = this[kElements].postponed;
   const self = this;
-
   api.getExecuting = function getExecuting() {
     return postponed.reduce((result, msg) => {
       const childApi = self._getChildApi(msg);
-
       if (childApi) result.push(childApi);
       return result;
     }, []);
   };
-
   return api;
 };
-
 proto._start = function start() {
   if (this[kElements].children.length === 0) {
     return this._complete('completed');
   }
-
   this[kStatus] = 'start';
-  const executeContent = { ...this[kExecuteMessage].content,
+  const executeContent = {
+    ...this[kExecuteMessage].content,
     state: this.status
   };
   this.broker.publish(this._exchangeName, 'execute.start', (0, _messageHelper.cloneContent)(executeContent));
@@ -383,15 +321,11 @@ proto._start = function start() {
     postponed,
     detachedActivities
   } = this[kElements];
-
   if (startActivities.length > 1) {
     for (const a of startActivities) a.shake();
   }
-
   for (const a of startActivities) a.init();
-
   for (const a of startActivities) a.run();
-
   postponed.splice(0);
   detachedActivities.splice(0);
   this[kActivityQ].assertConsumer(this[kMessageHandlers].onChildMessage, {
@@ -399,7 +333,6 @@ proto._start = function start() {
     consumerTag: `_process-activity-${this.executionId}`
   });
 };
-
 proto._activate = function activate() {
   const {
     onApiMessage,
@@ -419,7 +352,6 @@ proto._activate = function activate() {
     triggeredByEvent,
     children
   } = this[kElements];
-
   for (const flow of outboundMessageFlows) {
     flow.activate();
     flow.broker.subscribeTmp('event', '#', onMessageFlowEvent, {
@@ -428,7 +360,6 @@ proto._activate = function activate() {
       priority: 200
     });
   }
-
   for (const flow of flows) {
     flow.broker.subscribeTmp('event', '#', onActivityEvent, {
       consumerTag: '_process-flow-controller',
@@ -436,7 +367,6 @@ proto._activate = function activate() {
       priority: 200
     });
   }
-
   for (const association of associations) {
     association.broker.subscribeTmp('event', '#', onActivityEvent, {
       consumerTag: '_process-association-controller',
@@ -444,10 +374,8 @@ proto._activate = function activate() {
       priority: 200
     });
   }
-
   startActivities.splice(0);
   triggeredByEvent.splice(0);
-
   for (const activity of children) {
     if (activity.placeholder) continue;
     activity.activate(this);
@@ -459,10 +387,8 @@ proto._activate = function activate() {
     if (activity.isStart) startActivities.push(activity);
     if (activity.triggeredByEvent) triggeredByEvent.push(activity);
   }
-
   this[kActivated] = true;
 };
-
 proto._deactivate = function deactivate() {
   const broker = this.broker;
   const executionId = this.executionId;
@@ -474,40 +400,32 @@ proto._deactivate = function deactivate() {
     associations,
     outboundMessageFlows
   } = this[kElements];
-
   for (const activity of children) {
     if (activity.placeholder) continue;
     activity.broker.cancel('_process-activity-consumer');
     activity.deactivate();
   }
-
   for (const flow of flows) {
     flow.broker.cancel('_process-flow-controller');
   }
-
   for (const association of associations) {
     association.broker.cancel('_process-association-controller');
   }
-
   for (const flow of outboundMessageFlows) {
     flow.deactivate();
     flow.broker.cancel('_process-message-consumer');
   }
-
   this[kActivated] = false;
 };
-
 proto._onDelegateEvent = function onDelegateEvent(message) {
   const eventType = message.properties.type;
   let delegate = true;
   const content = message.content;
-
   if (content.message && content.message.id) {
     this._debug(`delegate ${eventType} event with id <${content.message.id}>`);
   } else {
     this._debug(`delegate ${eventType} anonymous event`);
   }
-
   for (const activity of this[kElements].triggeredByEvent) {
     if (activity.getStartActivities({
       referenceId: content.message && content.message.id,
@@ -517,17 +435,14 @@ proto._onDelegateEvent = function onDelegateEvent(message) {
       activity.run(content.message);
     }
   }
-
   this.getApi().sendApiMessage(eventType, content, {
     delegate: true
   });
   return delegate;
 };
-
 proto._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
   this.broker.publish('message', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
 };
-
 proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return;
   const content = message.content;
@@ -535,7 +450,6 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   let delegate = message.properties.delegate;
   const shaking = message.properties.type === 'shake';
   const isDirectChild = content.parent.id === this.id;
-
   if (isDirectChild) {
     parent.executionId = this.executionId;
   } else {
@@ -545,16 +459,15 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
       executionId: this.executionId
     });
   }
-
   if (delegate) delegate = this._onDelegateEvent(message);
-  this.broker.publish('event', routingKey, content, { ...message.properties,
+  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':
       return this[kActivityQ].queueMessage({
@@ -563,92 +476,86 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
         type: 'terminate',
         persistent: true
       });
-
     case 'activity.stop':
       return;
   }
-
   this[kActivityQ].queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), {
     persistent: true,
     ...message.properties
   });
 };
-
 proto._onChildMessage = function onChildMessage(routingKey, message) {
   if (message.fields.redelivered && message.properties.persistent === false) return message.ack();
   const content = message.content;
-
   switch (routingKey) {
     case 'execution.stop':
       message.ack();
       return this._stopExecution(message);
-
     case 'execution.terminate':
       message.ack();
       return this._terminate(message);
-
     case 'execution.discard':
       message.ack();
       return this._onDiscard(message);
-
+    case 'activity.error.caught':
+      {
+        const prevMsg = this[kElements].postponed.find(msg => {
+          return msg.content.executionId === content.executionId;
+        });
+        if (!prevMsg) return message.ack();
+        break;
+      }
     case 'activity.compensation.end':
     case 'flow.looped':
     case 'activity.leave':
       return this._onChildCompleted(message);
   }
-
   this._stateChangeMessage(message, true);
-
   switch (routingKey) {
     case 'activity.detach':
       {
         this[kElements].detachedActivities.push((0, _messageHelper.cloneMessage)(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;
-
           const inboundMessage = this._popPostponed(inbound);
-
           if (inboundMessage) inboundMessage.ack();
         }
-
         break;
       }
-
     case 'activity.error':
       {
         const eventCaughtBy = this[kElements].postponed.find(msg => {
           if (msg.fields.routingKey !== 'activity.catch') return;
           return msg.content.source && msg.content.source.executionId === content.executionId;
         });
-
         if (eventCaughtBy) {
+          this[kActivityQ].queueMessage({
+            routingKey: 'activity.error.caught'
+          }, (0, _messageHelper.cloneContent)(content), {
+            persistent: true,
+            ...message.properties
+          });
           return this._debug('error was caught');
         }
-
         return this._complete('error', {
           error: content.error
         });
       }
   }
 };
-
 proto._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) {
   const {
     postponed,
@@ -659,19 +566,15 @@ proto._popPostponed = function popPostponed(byContent) {
     return msg.content.executionId === byContent.executionId;
   });
   let postponedMsg;
-
   if (postponedIdx > -1) {
     postponedMsg = postponed.splice(postponedIdx, 1)[0];
   }
-
   const detachedIdx = detachedActivities.findIndex(msg => msg.content.executionId === byContent.executionId);
   if (detachedIdx > -1) detachedActivities.splice(detachedIdx, 1);
   return postponedMsg;
 };
-
 proto._onChildCompleted = function onChildCompleted(message) {
   this._stateChangeMessage(message, false);
-
   if (message.fields.redelivered) return message.ack();
   const {
     id,
@@ -684,29 +587,21 @@ proto._onChildCompleted = function onChildCompleted(message) {
     startActivities
   } = this[kElements];
   const postponedCount = postponed.length;
-
   if (!postponedCount) {
     this._debug(`left <${id}> (${type}), pending runs ${postponedCount}`);
-
     message.ack();
     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 (isEnd && startActivities.length) {
     const startSequences = this[kElements].startSequences;
-
     for (const msg of postponed) {
       const postponedId = msg.content.id;
       const startSequence = startSequences[postponedId];
-
       if (startSequence) {
         if (startSequence.content.sequence.some(({
           id: sid
@@ -717,84 +612,63 @@ proto._onChildCompleted = function onChildCompleted(message) {
     }
   }
 };
-
 proto._stopExecution = function stopExecution(message) {
   const postponedCount = this.postponedCount;
-
   this._debug(`stop process execution (stop child executions ${postponedCount})`);
-
   if (postponedCount) {
     for (const api of this.getPostponed()) api.stop();
   }
-
   this._deactivate();
-
   this[kStopped] = true;
-  return this.broker.publish(this._exchangeName, `execution.stopped.${this.executionId}`, { ...this[kExecuteMessage].content,
+  return this.broker.publish(this._exchangeName, `execution.stopped.${this.executionId}`, {
+    ...this[kExecuteMessage].content,
     ...(message && message.content)
   }, {
     type: 'stopped',
     persistent: false
   });
 };
-
 proto._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();
-
   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'}`);
       }
     }, {
       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}`);
   }
-
   if (this.id !== message.content.id) {
     const child = this.getActivityById(message.content.id);
     if (!child) return null;
     return child.broker.publish('api', routingKey, message.content, message.properties);
   }
-
   if (this.executionId !== message.content.executionId) return;
-
   switch (message.properties.type) {
     case 'discard':
       return this.discard(message);
-
     case 'stop':
       this[kActivityQ].queueMessage({
         routingKey: 'execution.stop'
@@ -804,18 +678,16 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
       break;
   }
 };
-
 proto._complete = function complete(completionType, content) {
   this._deactivate();
-
   this._debug(`process execution ${completionType}`);
-
   this[kCompleted] = true;
   if (this.status !== 'terminated') 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, {
-    output: { ...this.environment.output
+    output: {
+      ...this.environment.output
     },
     ...content,
     state: completionType
@@ -824,16 +696,11 @@ proto._complete = function complete(completionType, content) {
     mandatory: completionType === 'error'
   });
 };
-
 proto._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 msg of running) {
     const {
       id: postponedId,
@@ -841,54 +708,41 @@ proto._terminate = function terminate(message) {
     } = msg.content;
     if (postponedId === message.content.id) continue;
     if (isSequenceFlow) continue;
-
     this._getChildApi(msg).stop();
-
     msg.ack();
   }
-
   this[kActivityQ].purge();
 };
-
 proto._getFlowById = function getFlowById(flowId) {
   return this[kElements].flows.find(f => f.id === flowId);
 };
-
 proto._getAssociationById = function getAssociationById(associationId) {
   return this[kElements].associations.find(a => a.id === associationId);
 };
-
 proto._getMessageFlowById = function getMessageFlowById(flowId) {
   return this[kElements].outboundMessageFlows.find(f => f.id === flowId);
 };
-
 proto._getChildById = function getChildById(childId) {
   return this.getActivityById(childId) || this._getFlowById(childId);
 };
-
 proto._getChildApi = function getChildApi(message) {
   const content = message.content;
-
   let child = this._getChildById(content.id);
-
   if (child) return child.getApi(message);
   if (!content.parent) return;
   child = this._getChildById(content.parent.id);
   if (child) return child.getApi(message);
   if (!content.parent.path) return;
-
   for (const pp of content.parent.path) {
     child = this._getChildById(pp.id, message);
     if (child) return child.getApi(message);
   }
 };
-
 proto._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) {
   this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };