bpmn-elements 8.2.4 → 9.1.0

package/src/definition/DefinitionExecution.js

@@ -1,7 +1,7 @@
-import getPropertyValue from '../getPropertyValue';
-import {DefinitionApi} from '../Api';
-import {brokerSafeId} from '../shared';
-import {cloneContent, cloneMessage, pushParent, cloneParent} from '../messageHelper';
+import getPropertyValue from '../getPropertyValue.js';
+import {DefinitionApi} from '../Api.js';
+import {brokerSafeId} from '../shared.js';
+import {cloneContent, cloneMessage, pushParent, cloneParent} from '../messageHelper.js';
 
 const kActivated = Symbol.for('activated');
 const kProcessesQ = Symbol.for('processesQ');
@@ -61,49 +61,73 @@ export default function DefinitionExecution(definition, context) {
   };
 }
 
-const proto = DefinitionExecution.prototype;
-
-Object.defineProperty(proto, 'stopped', {
+Object.defineProperty(DefinitionExecution.prototype, 'stopped', {
   enumerable: true,
   get() {
     return this[kStopped];
   },
 });
 
-Object.defineProperty(proto, 'completed', {
+Object.defineProperty(DefinitionExecution.prototype, 'completed', {
   enumerable: true,
   get() {
     return this[kCompleted];
   },
 });
 
-Object.defineProperty(proto, 'status', {
+Object.defineProperty(DefinitionExecution.prototype, 'status', {
   enumerable: true,
   get() {
     return this[kStatus];
   },
 });
 
-Object.defineProperty(proto, 'processes', {
+Object.defineProperty(DefinitionExecution.prototype, 'processes', {
   enumerable: true,
   get() {
     return this[kProcesses].running;
   },
 });
 
-Object.defineProperty(proto, 'postponedCount', {
+Object.defineProperty(DefinitionExecution.prototype, 'postponedCount', {
   get() {
     return this[kProcesses].postponed.length;
   },
 });
 
-Object.defineProperty(proto, 'isRunning', {
+Object.defineProperty(DefinitionExecution.prototype, 'isRunning', {
   get() {
     return this[kActivated];
   },
 });
 
-proto.execute = function execute(executeMessage) {
+Object.defineProperty(DefinitionExecution.prototype, 'activityStatus', {
+  get() {
+    let status = 'idle';
+    const running = this[kProcesses].running;
+    if (!running || !running.length) return status;
+
+    for (const bp of running) {
+      const bpStatus = bp.activityStatus;
+      switch (bp.activityStatus) {
+        case 'idle':
+          break;
+        case 'executing':
+          return bpStatus;
+        case 'timer':
+          status = bpStatus;
+          break;
+        case 'wait':
+          if (status === 'idle') status = bpStatus;
+          break;
+      }
+    }
+
+    return status;
+  },
+});
+
+DefinitionExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Definition execution requires message');
   const content = executeMessage.content;
   const executionId = this.executionId = content.executionId;
@@ -139,7 +163,7 @@ proto.execute = function execute(executeMessage) {
   return true;
 };
 
-proto.resume = function resume() {
+DefinitionExecution.prototype.resume = function resume() {
   this._debug(`resume ${this[kStatus]} definition execution`);
 
   if (this[kCompleted]) return this._complete('completed');
@@ -157,7 +181,7 @@ proto.resume = function resume() {
   for (const bp of running) bp.resume();
 };
 
-proto.recover = function recover(state) {
+DefinitionExecution.prototype.recover = function recover(state) {
   if (!state) return this;
   this.executionId = state.executionId;
 
@@ -189,11 +213,11 @@ proto.recover = function recover(state) {
   return this;
 };
 
-proto.stop = function stop() {
+DefinitionExecution.prototype.stop = function stop() {
   this.getApi().stop();
 };
 
-proto.getProcesses = function getProcesses() {
+DefinitionExecution.prototype.getProcesses = function getProcesses() {
   const {running, processes} = this[kProcesses];
   const result = running.slice();
   for (const bp of processes) {
@@ -202,29 +226,29 @@ proto.getProcesses = function getProcesses() {
   return result;
 };
 
-proto.getProcessById = function getProcessById(processId) {
+DefinitionExecution.prototype.getProcessById = function getProcessById(processId) {
   return this.getProcesses().find((bp) => bp.id === processId);
 };
 
-proto.getProcessesById = function getProcessesById(processId) {
+DefinitionExecution.prototype.getProcessesById = function getProcessesById(processId) {
   return this.getProcesses().filter((bp) => bp.id === processId);
 };
 
-proto.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
+DefinitionExecution.prototype.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
   const running = this[kProcesses].running;
   return running.find((bp) => bp.executionId === processExecutionId);
 };
 
-proto.getRunningProcesses = function getRunningProcesses() {
+DefinitionExecution.prototype.getRunningProcesses = function getRunningProcesses() {
   const running = this[kProcesses].running;
   return running.filter((bp) => bp.executionId);
 };
 
-proto.getExecutableProcesses = function getExecutableProcesses() {
+DefinitionExecution.prototype.getExecutableProcesses = function getExecutableProcesses() {
   return this[kProcesses].executable.slice();
 };
 
-proto.getState = function getState() {
+DefinitionExecution.prototype.getState = function getState() {
   return {
     executionId: this.executionId,
     stopped: this[kStopped],
@@ -234,7 +258,7 @@ proto.getState = function getState() {
   };
 };
 
-proto.getApi = function getApi(apiMessage) {
+DefinitionExecution.prototype.getApi = function getApi(apiMessage) {
   if (!apiMessage) apiMessage = this[kExecuteMessage] || {content: this._createMessage()};
 
   const content = apiMessage.content;
@@ -257,7 +281,7 @@ proto.getApi = function getApi(apiMessage) {
   return api;
 };
 
-proto.getPostponed = function getPostponed(...args) {
+DefinitionExecution.prototype.getPostponed = function getPostponed(...args) {
   const running = this[kProcesses].running;
   return running.reduce((result, p) => {
     result = result.concat(p.getPostponed(...args));
@@ -265,7 +289,7 @@ proto.getPostponed = function getPostponed(...args) {
   }, []);
 };
 
-proto._start = function start() {
+DefinitionExecution.prototype._start = function start() {
   const {ids, executable, postponed} = this[kProcesses];
   if (!ids.length) {
     return this._complete('completed');
@@ -287,7 +311,7 @@ proto._start = function start() {
   });
 };
 
-proto._activate = function activate(processList) {
+DefinitionExecution.prototype._activate = function activate(processList) {
   this.broker.subscribeTmp('api', '#', this[kMessageHandlers].onApiMessage, {
     noAck: true,
     consumerTag: '_definition-api-consumer',
@@ -296,7 +320,7 @@ proto._activate = function activate(processList) {
   this[kActivated] = true;
 };
 
-proto._activateProcess = function activateProcess(bp) {
+DefinitionExecution.prototype._activateProcess = function activateProcess(bp) {
   const handlers = this[kMessageHandlers];
 
   bp.broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
@@ -330,7 +354,7 @@ proto._activateProcess = function activateProcess(bp) {
   });
 };
 
-proto._onChildEvent = function onChildEvent(routingKey, originalMessage) {
+DefinitionExecution.prototype._onChildEvent = function onChildEvent(routingKey, originalMessage) {
   const message = cloneMessage(originalMessage);
   const content = message.content;
   const parent = content.parent = content.parent || {};
@@ -348,14 +372,14 @@ proto._onChildEvent = function onChildEvent(routingKey, originalMessage) {
   this[kProcessesQ].queueMessage(message.fields, cloneContent(content), message.properties);
 };
 
-proto._deactivate = function deactivate() {
+DefinitionExecution.prototype._deactivate = function deactivate() {
   this.broker.cancel('_definition-api-consumer');
   this.broker.cancel(`_definition-activity-${this.executionId}`);
   for (const bp of this[kProcesses].running) this._deactivateProcess(bp);
   this[kActivated] = false;
 };
 
-proto._deactivateProcess = function deactivateProcess(bp) {
+DefinitionExecution.prototype._deactivateProcess = function deactivateProcess(bp) {
   bp.broker.cancel('_definition-outbound-message-consumer');
   bp.broker.cancel('_definition-activity-consumer');
   bp.broker.cancel('_definition-signal-consumer');
@@ -364,7 +388,7 @@ proto._deactivateProcess = function deactivateProcess(bp) {
   bp.broker.cancel('_definition-call-cancel-consumer');
 };
 
-proto._onProcessMessage = function onProcessMessage(routingKey, message) {
+DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(routingKey, message) {
   const content = message.content;
   const isRedelivered = message.fields.redelivered;
   const {id: childId, inbound} = content;
@@ -429,7 +453,7 @@ proto._onProcessMessage = function onProcessMessage(routingKey, message) {
   }
 };
 
-proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
+DefinitionExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   let previousMsg;
   const postponed = this[kProcesses].postponed;
   const idx = postponed.findIndex((msg) => msg.content.executionId === message.content.executionId);
@@ -441,7 +465,7 @@ proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage
   if (postponeMessage) postponed.push(message);
 };
 
-proto._onProcessCompleted = function onProcessCompleted(message) {
+DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(message) {
   this._stateChangeMessage(message, false);
   if (message.fields.redelivered) return message.ack();
 
@@ -459,7 +483,7 @@ proto._onProcessCompleted = function onProcessCompleted(message) {
   }
 };
 
-proto._onStopped = function onStopped(message) {
+DefinitionExecution.prototype._onStopped = function onStopped(message) {
   const running = this[kProcesses].running;
   this._debug(`stop definition execution (stop process executions ${running.length})`);
   this[kProcessesQ].close();
@@ -472,7 +496,7 @@ proto._onStopped = function onStopped(message) {
   }), {type: 'stopped', persistent: false});
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+DefinitionExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
   const delegate = message.properties.delegate;
 
@@ -494,7 +518,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._startProcessesByMessage = function startProcessesByMessage(reference) {
+DefinitionExecution.prototype._startProcessesByMessage = function startProcessesByMessage(reference) {
   const {processes: bps, running} = this[kProcesses];
   if (bps.length < 2) return;
 
@@ -523,7 +547,7 @@ proto._startProcessesByMessage = function startProcessesByMessage(reference) {
   }
 };
 
-proto._onMessageOutbound = function onMessageOutbound(routingKey, message) {
+DefinitionExecution.prototype._onMessageOutbound = function onMessageOutbound(routingKey, message) {
   const content = message.content;
   const {target, source} = content;
 
@@ -553,7 +577,7 @@ proto._onMessageOutbound = function onMessageOutbound(routingKey, message) {
   targetProcess.sendMessage(message);
 };
 
-proto._onCallActivity = function onCallActivity(routingKey, message) {
+DefinitionExecution.prototype._onCallActivity = function onCallActivity(routingKey, message) {
   const content = message.content;
   const {calledElement, id: fromId, executionId: fromExecutionId, name: fromName, parent: fromParent} = content;
   if (!calledElement) return;
@@ -584,7 +608,7 @@ proto._onCallActivity = function onCallActivity(routingKey, message) {
   targetProcess.run({inbound: [cloneContent(content)]});
 };
 
-proto._onCancelCallActivity = function onCancelCallActivity(routingKey, message) {
+DefinitionExecution.prototype._onCancelCallActivity = function onCancelCallActivity(routingKey, message) {
   const {calledElement, id: fromId, executionId: fromExecutionId, parent: fromParent} = message.content;
   if (!calledElement) return;
 
@@ -597,7 +621,7 @@ proto._onCancelCallActivity = function onCancelCallActivity(routingKey, message)
   targetProcess.getApi().discard();
 };
 
-proto._onDelegateMessage = function onDelegateMessage(routingKey, executeMessage) {
+DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(routingKey, executeMessage) {
   const content = executeMessage.content;
   const messageType = executeMessage.properties.type;
   const delegateMessage = executeMessage.content.message;
@@ -623,14 +647,14 @@ proto._onDelegateMessage = function onDelegateMessage(routingKey, executeMessage
   }), {type: messageType});
 };
 
-proto._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
+DefinitionExecution.prototype._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
   const running = this[kProcesses].running;
   const idx = running.findIndex((p) => p.executionId === processExecutionId);
   if (idx === -1) return;
   return running.splice(idx, 1)[0];
 };
 
-proto._complete = function complete(completionType, content, options) {
+DefinitionExecution.prototype._complete = function complete(completionType, content, options) {
   this._deactivate();
   const stateMessage = this[kExecuteMessage];
   this._debug(`definition execution ${completionType} in ${Date.now() - stateMessage.properties.timestamp}ms`);
@@ -647,7 +671,7 @@ proto._complete = function complete(completionType, content, options) {
   }, {type: completionType, mandatory: completionType === 'error', ...options});
 };
 
-proto._createMessage = function createMessage(content = {}) {
+DefinitionExecution.prototype._createMessage = function createMessage(content = {}) {
   return {
     id: this.id,
     type: this.type,
@@ -657,7 +681,7 @@ proto._createMessage = function createMessage(content = {}) {
   };
 };
 
-proto._getProcessApi = function getProcessApi(message) {
+DefinitionExecution.prototype._getProcessApi = function getProcessApi(message) {
   const content = message.content;
   let api = this._getProcessApiByExecutionId(content.executionId, message);
   if (api) return api;
@@ -675,12 +699,12 @@ proto._getProcessApi = function getProcessApi(message) {
   }
 };
 
-proto._getProcessApiByExecutionId = function getProcessApiByExecutionId(parentExecutionId, message) {
+DefinitionExecution.prototype._getProcessApiByExecutionId = function getProcessApiByExecutionId(parentExecutionId, message) {
   const processInstance = this.getProcessByExecutionId(parentExecutionId);
   if (!processInstance) return;
   return processInstance.getApi(message);
 };
 
-proto._debug = function debug(logMessage) {
+DefinitionExecution.prototype._debug = function debug(logMessage) {
   this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };

package/src/error/Errors.js

@@ -1,4 +1,4 @@
-import {cloneMessage} from '../messageHelper';
+import {cloneMessage} from '../messageHelper.js';
 
 class ActivityError extends Error {
   constructor(description, sourceMessage, inner) {

package/src/eventDefinitions/CancelEventDefinition.js

@@ -1,7 +1,5 @@
-import {brokerSafeId} from '../shared';
-import {cloneContent, shiftParent} from '../messageHelper';
+import {cloneContent, shiftParent} from '../messageHelper.js';
 
-const kMessageQ = Symbol.for('cancelQ');
 const kCompleted = Symbol.for('completed');
 const kExecuteMessage = Symbol.for('executeMessage');
 
@@ -11,35 +9,26 @@ export default function CancelEventDefinition(activity, eventDefinition) {
 
   this.id = id;
   this.type = type;
-  const reference = this.reference = {referenceType: 'cancel'};
+  this.reference = {referenceType: 'cancel'};
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.environment = environment;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
-
-  if (!isThrowing) {
-    this[kCompleted] = false;
-    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 400});
-  }
 }
 
-const proto = CancelEventDefinition.prototype;
-
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(CancelEventDefinition.prototype, 'executionId', {
   get() {
     const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
 
-proto.execute = function execute(executeMessage) {
+CancelEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
-proto.executeCatch = function executeCatch(executeMessage) {
+CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
   this[kExecuteMessage] = executeMessage;
   this[kCompleted] = false;
 
@@ -48,91 +37,60 @@ proto.executeCatch = function executeCatch(executeMessage) {
   const parentExecutionId = parent.executionId;
 
   const broker = this.broker;
-  const onCatchMessage = this._onCatchMessage.bind(this);
-  this[kMessageQ].consume(onCatchMessage, {
-    noAck: true,
-    consumerTag: `_oncancel-${executionId}`,
-  });
 
-  if (this[kCompleted]) return;
+  this._debug('expect cancel');
 
-  const onApiMessage = this._onApiMessage.bind(this);
-  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
-    noAck: true,
-    consumerTag: `_api-parent-${executionId}`,
-  });
-  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+  broker.subscribeTmp('api', `activity.#.${parent.executionId}#`, this._onApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-${executionId}`,
   });
 
-  this._debug('expect cancel');
-
-  const exchangeKey = `execute.canceled.${executionId}`;
-  broker.subscribeOnce('execution', exchangeKey, onCatchMessage, {
+  const expectRoutingKey = `execute.cancelled.${executionId}`;
+  broker.subscribeOnce('execution', expectRoutingKey, this._onCatchMessage.bind(this), {
     consumerTag: `_onattached-cancel-${executionId}`,
   });
 
   broker.publish('execution', 'execute.expect', cloneContent(executeContent, {
-    pattern: '#.cancel',
+    pattern: 'activity.execution.cancel',
     exchange: 'execution',
-    exchangeKey,
+    expectRoutingKey,
   }));
+
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    condition: this.condition,
+    expect: 'cancel',
+  });
+  waitContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.wait', waitContent);
 };
 
-proto.executeThrow = function executeThrow(executeMessage) {
-  const {isTransaction} = this.environment.variables.content || {};
+CancelEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
 
-  this.logger.debug(`<${executionId} (${this.activity.id})> throw cancel${isTransaction ? ' transaction' : ''}`);
+  this.logger.debug(`<${executionId} (${this.activity.id})> throw cancel`);
 
   const broker = this.broker;
   const cancelContent = cloneContent(executeContent, {
-    isTransaction,
     executionId: parent.executionId,
     state: 'throw',
   });
   cancelContent.parent = shiftParent(parent);
 
-  broker.publish('event', 'activity.cancel', cancelContent, {type: 'cancel', delegate: isTransaction});
+  broker.publish('event', 'activity.cancel', cancelContent, { type: 'cancel' });
 
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
 
-proto._onCatchMessage = function onCatchMessage(_, message) {
-  if (message.content && message.content.isTransaction) return this._onCancelTransaction(_, message);
-
-  this._debug(`cancel caught from <${message.content.id}>`);
-  return this._complete(message.content.message);
-};
-
-proto._onCancelTransaction = function onCancelTransaction(_, message) {
-  const broker = this.broker, executionId = this.executionId;
-  const executeContent = this[kExecuteMessage].content;
-  broker.cancel(`_oncancel-${executionId}`);
-
-  this._debug(`cancel transaction thrown by <${message.content.id}>`);
-
-  broker.assertExchange('cancel', 'topic');
-  broker.publish('execution', 'execute.detach', cloneContent(executeContent, {
-    pattern: '#',
-    bindExchange: 'cancel',
-    sourceExchange: 'event',
-    sourcePattern: '#',
-  }));
-
-  broker.publish('event', 'activity.compensate', cloneContent(message.content, {
-    state: 'throw',
-  }), {type: 'compensate', delegate: true});
-
-  broker.subscribeTmp('cancel', 'activity.leave', (__, {content: msg}) => {
-    if (msg.id !== executeContent.attachedTo) return;
-    return this._complete(message.content.message);
-  }, {noAck: true, consumerTag: `_oncancelend-${executionId}`});
+CancelEventDefinition.prototype._onCatchMessage = function onCatchMessage(_, message) {
+  const content = message.content;
+  this._debug(`cancel caught from <${content.id}>`);
+  return this._complete(content.message);
 };
 
-proto._complete = function complete(output) {
+CancelEventDefinition.prototype._complete = function complete(output) {
   this[kCompleted] = true;
   this._stop();
   this._debug('completed');
@@ -143,7 +101,7 @@ proto._complete = function complete(output) {
   return this.broker.publish('execution', 'execute.completed', content);
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+CancelEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'discard': {
       this[kCompleted] = true;
@@ -158,16 +116,12 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._stop = function stop() {
+CancelEventDefinition.prototype._stop = function stop() {
   const broker = this.broker, executionId = this.executionId;
-  broker.cancel(`_api-parent-${executionId}`);
-  broker.cancel(`_api-${executionId}`);
-  broker.cancel(`_oncancel-${executionId}`);
-  broker.cancel(`_oncancelend-${executionId}`);
   broker.cancel(`_onattached-cancel-${executionId}`);
-  this[kMessageQ].purge();
+  broker.cancel(`_api-${executionId}`);
 };
 
-proto._debug = function debug(msg) {
+CancelEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };