bpmn-elements 8.2.4 → 9.1.0

package/src/activity/ActivityExecution.js

@@ -1,5 +1,5 @@
-import {ActivityApi} from '../Api';
-import {cloneContent, cloneMessage} from '../messageHelper';
+import {ActivityApi} from '../Api.js';
+import {cloneContent, cloneMessage} from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kExecuteQ = Symbol.for('executeQ');
@@ -24,16 +24,14 @@ function ActivityExecution(activity, context) {
   };
 }
 
-const proto = ActivityExecution.prototype;
-
-Object.defineProperty(proto, 'completed', {
+Object.defineProperty(ActivityExecution.prototype, 'completed', {
   enumerable: true,
   get() {
     return this[kCompleted];
   },
 });
 
-proto.execute = function execute(executeMessage) {
+ActivityExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Execution requires message');
   const executionId = executeMessage.content && executeMessage.content.executionId;
   if (!executionId) throw new Error('Execution requires execution id');
@@ -61,7 +59,7 @@ proto.execute = function execute(executeMessage) {
   this.broker.publish('execution', 'execute.start', cloneContent(initMessage.content));
 };
 
-proto.activate = function activate() {
+ActivityExecution.prototype.activate = function activate() {
   if (this[kCompleted]) return;
 
   const broker = this.broker;
@@ -85,21 +83,21 @@ proto.activate = function activate() {
   });
 };
 
-proto.deactivate = function deactivate() {
+ActivityExecution.prototype.deactivate = function deactivate() {
   const broker = this.broker;
   broker.cancel('_activity-api-execution');
   broker.cancel('_activity-execute');
   broker.unbindQueue('execute-q', 'execution', 'execute.#');
 };
 
-proto.discard = function discard() {
+ActivityExecution.prototype.discard = function discard() {
   if (this[kCompleted]) return;
   const initMessage = this[kExecuteMessage];
   if (!initMessage) return this.activity.logger.warn(`<${this.id}> is not executing`);
   this.getApi(initMessage).discard();
 };
 
-proto.getApi = function getApi(apiMessage) {
+ActivityExecution.prototype.getApi = function getApi(apiMessage) {
   const self = this;
   if (!apiMessage) apiMessage = this[kExecuteMessage];
 
@@ -121,19 +119,19 @@ proto.getApi = function getApi(apiMessage) {
   return api;
 };
 
-proto.passthrough = function passthrough(executeMessage) {
+ActivityExecution.prototype.passthrough = function passthrough(executeMessage) {
   if (!this.source) return this.execute(executeMessage);
   return this._sourceExecute(executeMessage);
 };
 
-proto.getPostponed = function getPostponed() {
+ActivityExecution.prototype.getPostponed = function getPostponed() {
   let apis = this[kPostponed].map((msg) => this.getApi(msg));
   if (!this.activity.isSubProcess || !this.source) return apis;
   apis = apis.concat(this.source.getPostponed());
   return apis;
 };
 
-proto.getState = function getState() {
+ActivityExecution.prototype.getState = function getState() {
   const result = {completed: this[kCompleted]};
   const source = this.source;
 
@@ -141,7 +139,7 @@ proto.getState = function getState() {
   return {...result, ...source.getState()};
 };
 
-proto.recover = function recover(state) {
+ActivityExecution.prototype.recover = function recover(state) {
   this[kPostponed].splice(0);
 
   if (!state) return this;
@@ -155,13 +153,13 @@ proto.recover = function recover(state) {
   return this;
 };
 
-proto.stop = function stop() {
+ActivityExecution.prototype.stop = function stop() {
   const executeMessage = this[kExecuteMessage];
   if (!executeMessage) return;
   this.getApi(executeMessage).stop();
 };
 
-proto._sourceExecute = function sourceExecute(executeMessage) {
+ActivityExecution.prototype._sourceExecute = function sourceExecute(executeMessage) {
   try {
     return this.source.execute(executeMessage);
   } catch (error) {
@@ -169,7 +167,7 @@ proto._sourceExecute = function sourceExecute(executeMessage) {
   }
 };
 
-proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
+ActivityExecution.prototype._onExecuteMessage = function onExecuteMessage(routingKey, message) {
   const {fields, content, properties} = message;
   const isRedelivered = fields.redelivered;
 
@@ -180,10 +178,12 @@ proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
       if (!this[kPostponed].length) return this.broker.publish('execution', 'execute.start', cloneContent(this[kExecuteMessage].content));
       break;
     }
+    case 'execute.cancel':
+      return this._onExecutionDiscarded('cancel', message);
     case 'execute.error':
+      return this._onExecutionDiscarded('error', message);
     case 'execute.discard':
-      return this._onExecutionDiscarded(message);
-    case 'execute.cancel':
+      return this._onExecutionDiscarded('discard', message);
     case 'execute.completed': {
       if (isRedelivered) {
         message.ack();
@@ -213,7 +213,7 @@ proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
   }
 };
 
-proto._onStateChangeMessage = function onStateChangeMessage(message) {
+ActivityExecution.prototype._onStateChangeMessage = function onStateChangeMessage(message) {
   const {ignoreIfExecuting, executionId} = message.content;
   const postponed = this[kPostponed];
   const idx = postponed.findIndex((msg) => msg.content.executionId === executionId);
@@ -234,7 +234,7 @@ proto._onStateChangeMessage = function onStateChangeMessage(message) {
   return true;
 };
 
-proto._onExecutionCompleted = function onExecutionCompleted(message) {
+ActivityExecution.prototype._onExecutionCompleted = function onExecutionCompleted(message) {
   const postponedMsg = this._ackPostponed(message);
   if (!postponedMsg) return;
   const postponed = this[kPostponed];
@@ -263,7 +263,7 @@ proto._onExecutionCompleted = function onExecutionCompleted(message) {
   this._publishExecutionCompleted('completed', {...postponedMsg.content, ...message.content}, message.properties.correlationId);
 };
 
-proto._onExecutionDiscarded = function onExecutionDiscarded(message) {
+ActivityExecution.prototype._onExecutionDiscarded = function onExecutionDiscarded(discardType, message) {
   const postponedMsg = this._ackPostponed(message);
   const {isRootScope, error} = message.content;
   if (!isRootScope && !postponedMsg) return;
@@ -286,14 +286,10 @@ proto._onExecutionDiscarded = function onExecutionDiscarded(message) {
   postponed.splice(0);
   for (const api of subApis) api.discard();
 
-  if (error) {
-    return this._publishExecutionCompleted('error', cloneContent(message.content, {error}), correlationId);
-  }
-
-  this._publishExecutionCompleted('discard', message.content, correlationId);
+  this._publishExecutionCompleted(discardType, cloneContent(message.content), correlationId);
 };
 
-proto._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {
+ActivityExecution.prototype._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {
   this[kCompleted] = true;
 
   this.broker.publish('execution', `execution.${completionType}`, {
@@ -302,7 +298,7 @@ proto._publishExecutionCompleted = function publishExecutionCompleted(completion
   }, {type: completionType, correlationId});
 };
 
-proto._ackPostponed = function ackPostponed(completeMessage) {
+ActivityExecution.prototype._ackPostponed = function ackPostponed(completeMessage) {
   const {executionId: eid} = completeMessage.content;
 
   const postponed = this[kPostponed];
@@ -313,7 +309,7 @@ proto._ackPostponed = function ackPostponed(completeMessage) {
   return msg;
 };
 
-proto._onParentApiMessage = function onParentApiMessage(routingKey, message) {
+ActivityExecution.prototype._onParentApiMessage = function onParentApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'error':
       return this[kExecuteQ].queueMessage({routingKey: 'execute.error'}, {error: message.content.error});
@@ -325,7 +321,7 @@ proto._onParentApiMessage = function onParentApiMessage(routingKey, message) {
   }
 };
 
-proto._onStop = function onStop(message) {
+ActivityExecution.prototype._onStop = function onStop(message) {
   const stoppedId = message && message.content && message.content.executionId;
   const running = this.getPostponed();
   for (const api of running) {
@@ -338,7 +334,7 @@ proto._onStop = function onStop(message) {
   this.broker.cancel('_activity-api-execution');
 };
 
-proto._debug = function debug(logMessage, executionId) {
+ActivityExecution.prototype._debug = function debug(logMessage, executionId) {
   executionId = executionId || this.executionId;
   this.activity.logger.debug(`<${executionId} (${this.id})> ${logMessage}`);
 };

package/src/activity/Dummy.js

@@ -1,4 +1,4 @@
-import {cloneParent} from '../messageHelper';
+import {cloneParent} from '../messageHelper.js';
 
 export default function DummyActivity(activityDef) {
   const {id, type = 'dummy', name, parent, behaviour} = activityDef;

package/src/activity/ExecutionScope.js

@@ -1,5 +1,5 @@
-import {cloneMessage} from '../messageHelper';
-import {ActivityError, BpmnError} from '../error/Errors';
+import {cloneMessage} from '../messageHelper.js';
+import {ActivityError, BpmnError} from '../error/Errors.js';
 
 export default function ExecutionScope(activity, initMessage) {
   const {id, type, environment, logger} = activity;

package/src/definition/Definition.js

@@ -1,9 +1,9 @@
-import DefinitionExecution from './DefinitionExecution';
-import {DefinitionApi} from '../Api';
-import {DefinitionBroker} from '../EventBroker';
-import {getUniqueId, getOptionsAndCallback} from '../shared';
-import {makeErrorFromMessage} from '../error/Errors';
-import {cloneMessage, cloneContent} from '../messageHelper';
+import DefinitionExecution from './DefinitionExecution.js';
+import {DefinitionApi} from '../Api.js';
+import {DefinitionBroker} from '../EventBroker.js';
+import {getUniqueId, getOptionsAndCallback} from '../shared.js';
+import {makeErrorFromMessage} from '../error/Errors.js';
+import {cloneMessage, cloneContent} from '../messageHelper.js';
 
 const kConsuming = Symbol.for('consuming');
 const kCounters = Symbol.for('counters');
@@ -63,30 +63,28 @@ export function Definition(context, options) {
   this.logger = environment.Logger(type.toLowerCase());
 }
 
-const proto = Definition.prototype;
-
-Object.defineProperty(proto, 'counters', {
+Object.defineProperty(Definition.prototype, 'counters', {
   enumerable: true,
   get() {
     return {...this[kCounters]};
   },
 });
 
-Object.defineProperty(proto, 'execution', {
+Object.defineProperty(Definition.prototype, 'execution', {
   enumerable: true,
   get() {
     return this[kExec].execution;
   },
 });
 
-Object.defineProperty(proto, 'executionId', {
+Object.defineProperty(Definition.prototype, 'executionId', {
   enumerable: true,
   get() {
     return this[kExec].executionId;
   },
 });
 
-Object.defineProperty(proto, 'isRunning', {
+Object.defineProperty(Definition.prototype, 'isRunning', {
   enumerable: true,
   get() {
     if (!this[kConsuming]) return false;
@@ -94,21 +92,27 @@ Object.defineProperty(proto, 'isRunning', {
   },
 });
 
-Object.defineProperty(proto, 'status', {
+Object.defineProperty(Definition.prototype, 'status', {
   enumerable: true,
   get() {
     return this[kStatus];
   },
 });
 
-Object.defineProperty(proto, 'stopped', {
+Object.defineProperty(Definition.prototype, 'stopped', {
   enumerable: true,
   get() {
     return this[kStopped];
   },
 });
 
-proto.run = function run(optionsOrCallback, optionalCallback) {
+Object.defineProperty(Definition.prototype, 'activityStatus', {
+  get() {
+    return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+  },
+});
+
+Definition.prototype.run = function run(optionsOrCallback, optionalCallback) {
   const [runOptions, callback] = getOptionsAndCallback(optionsOrCallback, optionalCallback);
   if (this.isRunning) {
     const err = new Error('definition is already running');
@@ -136,7 +140,7 @@ proto.run = function run(optionsOrCallback, optionalCallback) {
   return this;
 };
 
-proto.resume = function resume(callback) {
+Definition.prototype.resume = function resume(callback) {
   if (this.isRunning) {
     const err = new Error('cannot resume running definition');
     if (callback) return callback(err);
@@ -158,7 +162,7 @@ proto.resume = function resume(callback) {
   return this;
 };
 
-proto.recover = function recover(state) {
+Definition.prototype.recover = function recover(state) {
   if (this.isRunning) throw new Error('cannot recover running definition');
   if (!state) return this;
 
@@ -182,10 +186,8 @@ proto.recover = function recover(state) {
   return this;
 };
 
-proto.shake = function shake(startId) {
+Definition.prototype.shake = function shake(startId) {
   let result = {};
-  const broker = this.broker;
-
   let bps;
   if (startId) {
     const startActivity = this.getActivityById(startId);
@@ -195,33 +197,32 @@ proto.shake = function shake(startId) {
     bps = [bp];
   } else bps = this.getProcesses();
 
-  bps.forEach(shakeProcess);
+  bps.forEach((bp) => {
+    result = {...result, ...this._shakeProcess(bp, startId)};
+  });
 
   return result;
+};
 
-  function shakeProcess(shakeBp) {
-    let shovel;
-    if (!shakeBp.isRunning) {
-      shovel = shakeBp.broker.createShovel('shaker', {
-        exchange: 'event',
-        pattern: '*.shake#',
-      }, {
-        broker,
-        exchange: 'event',
-      });
-    }
+Definition.prototype._shakeProcess = function shakeProcess(shakeBp, startId) {
+  let shovel;
+  if (!shakeBp.isRunning) {
+    shovel = shakeBp.broker.createShovel('shaker', {
+      exchange: 'event',
+      pattern: '*.shake#',
+    }, {
+      broker: this.broker,
+      exchange: 'event',
+    });
+  }
 
-    const shakeResult = shakeBp.shake(startId);
-    if (shovel) shakeBp.broker.closeShovel('shaker');
+  const shakeResult = shakeBp.shake(startId);
+  if (shovel) shakeBp.broker.closeShovel('shaker');
 
-    result = {
-      ...result,
-      ...shakeResult,
-    };
-  }
+  return shakeResult;
 };
 
-proto.getState = function getState() {
+Definition.prototype.getState = function getState() {
   return this._createMessage({
     status: this.status,
     stopped: this.stopped,
@@ -232,29 +233,29 @@ proto.getState = function getState() {
   });
 };
 
-proto.getProcesses = function getProcesses() {
+Definition.prototype.getProcesses = function getProcesses() {
   const execution = this.execution;
   if (execution) return execution.getProcesses();
   return this.context.getProcesses();
 };
 
-proto.getExecutableProcesses = function getExecutableProcesses() {
+Definition.prototype.getExecutableProcesses = function getExecutableProcesses() {
   const execution = this.execution;
   if (execution) return execution.getExecutableProcesses();
   return this.context.getExecutableProcesses();
 };
 
-proto.getRunningProcesses = function getRunningProcesses() {
+Definition.prototype.getRunningProcesses = function getRunningProcesses() {
   const execution = this.execution;
   if (!execution) return [];
   return execution.getRunningProcesses();
 };
 
-proto.getProcessById = function getProcessById(processId) {
+Definition.prototype.getProcessById = function getProcessById(processId) {
   return this.getProcesses().find((p) => p.id === processId);
 };
 
-proto.getActivityById = function getActivityById(childId) {
+Definition.prototype.getActivityById = function getActivityById(childId) {
   const bps = this.getProcesses();
   for (const bp of bps) {
     const child = bp.getActivityById(childId);
@@ -263,17 +264,17 @@ proto.getActivityById = function getActivityById(childId) {
   return null;
 };
 
-proto.getElementById = function getElementById(elementId) {
+Definition.prototype.getElementById = function getElementById(elementId) {
   return this.context.getActivityById(elementId);
 };
 
-proto.getPostponed = function getPostponed(...args) {
+Definition.prototype.getPostponed = function getPostponed(...args) {
   const execution = this.execution;
   if (!execution) return [];
   return execution.getPostponed(...args);
 };
 
-proto.getApi = function getApi(message) {
+Definition.prototype.getApi = function getApi(message) {
   const execution = this.execution;
   if (execution) return execution.getApi(message);
   message = message || this[kStateMessage];
@@ -281,15 +282,15 @@ proto.getApi = function getApi(message) {
   return DefinitionApi(this.broker, message);
 };
 
-proto.signal = function signal(message) {
+Definition.prototype.signal = function signal(message) {
   return this.getApi().signal(message, {delegate: true});
 };
 
-proto.cancelActivity = function cancelActivity(message) {
+Definition.prototype.cancelActivity = function cancelActivity(message) {
   return this.getApi().cancel(message, {delegate: true});
 };
 
-proto.sendMessage = function sendMessage(message) {
+Definition.prototype.sendMessage = function sendMessage(message) {
   const messageContent = {message};
   let messageType = 'message';
   const reference = message && message.id && this.getElementById(message.id);
@@ -302,12 +303,12 @@ proto.sendMessage = function sendMessage(message) {
   return this.getApi().sendApiMessage(messageType, messageContent, {delegate: true});
 };
 
-proto.stop = function stop() {
+Definition.prototype.stop = function stop() {
   if (!this.isRunning) return;
   this.getApi().stop();
 };
 
-proto._activateRunConsumers = function activateRunConsumers() {
+Definition.prototype._activateRunConsumers = function activateRunConsumers() {
   this[kConsuming] = true;
   const broker = this.broker;
   const {onApiMessage, onRunMessage} = this[kMessageHandlers];
@@ -321,7 +322,7 @@ proto._activateRunConsumers = function activateRunConsumers() {
   });
 };
 
-proto._deactivateRunConsumers = function deactivateRunConsumers() {
+Definition.prototype._deactivateRunConsumers = function deactivateRunConsumers() {
   const broker = this.broker;
   broker.cancel('_definition-api');
   broker.cancel('_definition-run');
@@ -329,7 +330,7 @@ proto._deactivateRunConsumers = function deactivateRunConsumers() {
   this[kConsuming] = false;
 };
 
-proto._createMessage = function createMessage(override) {
+Definition.prototype._createMessage = function createMessage(override) {
   return {
     id: this.id,
     type: this.type,
@@ -339,7 +340,7 @@ proto._createMessage = function createMessage(override) {
   };
 };
 
-proto._onRunMessage = function onRunMessage(routingKey, message) {
+Definition.prototype._onRunMessage = function onRunMessage(routingKey, message) {
   const {content, fields} = message;
   if (routingKey === 'run.resume') {
     return this._onResumeMessage(message);
@@ -425,7 +426,7 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
   message.ack();
 };
 
-proto._onResumeMessage = function onResumeMessage(message) {
+Definition.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
 
   const stateMessage = this[kStateMessage];
@@ -446,7 +447,7 @@ proto._onResumeMessage = function onResumeMessage(message) {
   return this.broker.publish('run', stateMessage.fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
 };
 
-proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+Definition.prototype._onExecutionMessage = function onExecutionMessage(routingKey, message) {
   const {content, properties} = message;
   const messageType = properties.type;
 
@@ -471,7 +472,7 @@ proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
   executeMessage.ack();
 };
 
-proto._onApiMessage = function onApiMessage(routingKey, message) {
+Definition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   if (message.properties.type === 'stop') {
     const execution = this.execution;
     if (!execution || execution.completed) {
@@ -480,7 +481,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 
-proto._publishEvent = function publishEvent(action, content, msgOpts) {
+Definition.prototype._publishEvent = function publishEvent(action, content, msgOpts) {
   const execution = this.execution;
   this.broker.publish('event', `definition.${action}`, execution ? execution._createMessage(content) : cloneContent(content), {
     type: action,
@@ -488,13 +489,13 @@ proto._publishEvent = function publishEvent(action, content, msgOpts) {
   });
 };
 
-proto._onStop = function onStop() {
+Definition.prototype._onStop = function onStop() {
   this[kStopped] = true;
   this._deactivateRunConsumers();
   return this._publishEvent('stop', this._createMessage());
 };
 
-proto._onBrokerReturnFn = function onBrokerReturn(message) {
+Definition.prototype._onBrokerReturnFn = function onBrokerReturn(message) {
   if (message.properties.type === 'error') {
     this._deactivateRunConsumers();
     const err = makeErrorFromMessage(message);
@@ -502,14 +503,14 @@ proto._onBrokerReturnFn = function onBrokerReturn(message) {
   }
 };
 
-proto._reset = function reset() {
+Definition.prototype._reset = function reset() {
   this[kExec].executionId = undefined;
   this._deactivateRunConsumers();
   this.broker.purgeQueue('run-q');
   this.broker.purgeQueue('execution-q');
 };
 
-proto._debug = function debug(msg) {
+Definition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.id}> ${msg}`);
 };