bpmn-elements 7.0.0 → 8.1.0

package/src/activity/ActivityExecution.js

@@ -1,11 +1,11 @@
 import {ActivityApi} from '../Api';
 import {cloneContent, cloneMessage} from '../messageHelper';
 
-const completedSymbol = Symbol.for('completed');
-const executeQSymbol = Symbol.for('executeQ');
-const executeMessageSymbol = Symbol.for('executeMessage');
-const messageHandlersSymbol = Symbol.for('messageHandlers');
-const postponedSymbol = Symbol.for('postponed');
+const kCompleted = Symbol.for('completed');
+const kExecuteQ = Symbol.for('executeQ');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kPostponed = Symbol.for('postponed');
 
 export default ActivityExecution;
 
@@ -14,11 +14,11 @@ function ActivityExecution(activity, context) {
   this.context = context;
   this.id = activity.id;
   this.broker = activity.broker;
-  this[postponedSymbol] = [];
-  this[completedSymbol] = false;
-  this[executeQSymbol] = this.broker.assertQueue('execute-q', {durable: true, autoDelete: false});
+  this[kPostponed] = [];
+  this[kCompleted] = false;
+  this[kExecuteQ] = this.broker.assertQueue('execute-q', {durable: true, autoDelete: false});
 
-  this[messageHandlersSymbol] = {
+  this[kMessageHandlers] = {
     onParentApiMessage: this._onParentApiMessage.bind(this),
     onExecuteMessage: this._onExecuteMessage.bind(this),
   };
@@ -29,7 +29,7 @@ const proto = ActivityExecution.prototype;
 Object.defineProperty(proto, 'completed', {
   enumerable: true,
   get() {
-    return this[completedSymbol];
+    return this[kCompleted];
   },
 });
 
@@ -39,14 +39,14 @@ proto.execute = function execute(executeMessage) {
   if (!executionId) throw new Error('Execution requires execution id');
 
   this.executionId = executionId;
-  const initMessage = this[executeMessageSymbol] = cloneMessage(executeMessage, {
+  const initMessage = this[kExecuteMessage] = cloneMessage(executeMessage, {
     executionId,
     state: 'start',
     isRootScope: true,
   });
 
   if (executeMessage.fields.redelivered) {
-    this[postponedSymbol].splice(0);
+    this[kPostponed].splice(0);
     this._debug('resume execution');
 
     if (!this.source) this.source = new this.activity.Behaviour(this.activity, this.context);
@@ -62,21 +62,21 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.activate = function activate() {
-  if (this[completedSymbol]) return;
+  if (this[kCompleted]) return;
 
   const broker = this.broker;
   const batchSize = this.activity.environment.settings.batchSize || 50;
   broker.bindQueue('execute-q', 'execution', 'execute.#', {priority: 100});
 
-  const {onExecuteMessage, onParentApiMessage} = this[messageHandlersSymbol];
-  this[executeQSymbol].assertConsumer(onExecuteMessage, {
+  const {onExecuteMessage, onParentApiMessage} = this[kMessageHandlers];
+  this[kExecuteQ].assertConsumer(onExecuteMessage, {
     exclusive: true,
     prefetch: batchSize * 2,
     priority: 100,
     consumerTag: '_activity-execute',
   });
 
-  if (this[completedSymbol]) return this.deactivate();
+  if (this[kCompleted]) return this.deactivate();
 
   broker.subscribeTmp('api', `activity.*.${this.executionId}`, onParentApiMessage, {
     noAck: true,
@@ -93,15 +93,15 @@ proto.deactivate = function deactivate() {
 };
 
 proto.discard = function discard() {
-  if (this[completedSymbol]) return;
-  const initMessage = this[executeMessageSymbol];
+  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) {
   const self = this;
-  if (!apiMessage) apiMessage = this[executeMessageSymbol];
+  if (!apiMessage) apiMessage = this[kExecuteMessage];
 
   if (self.source.getApi) {
     const sourceApi = self.source.getApi(apiMessage);
@@ -111,7 +111,7 @@ proto.getApi = function getApi(apiMessage) {
   const api = ActivityApi(self.broker, apiMessage);
 
   api.getExecuting = function getExecuting() {
-    return self[postponedSymbol].reduce((result, msg) => {
+    return self[kPostponed].reduce((result, msg) => {
       if (msg.content.executionId === apiMessage.content.executionId) return result;
       result.push(self.getApi(msg));
       return result;
@@ -127,14 +127,14 @@ proto.passthrough = function passthrough(executeMessage) {
 };
 
 proto.getPostponed = function getPostponed() {
-  let apis = this[postponedSymbol].map((msg) => this.getApi(msg));
+  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() {
-  const result = {completed: this[completedSymbol]};
+  const result = {completed: this[kCompleted]};
   const source = this.source;
 
   if (!source || !source.getState) return result;
@@ -142,10 +142,10 @@ proto.getState = function getState() {
 };
 
 proto.recover = function recover(state) {
-  this[postponedSymbol].splice(0);
+  this[kPostponed].splice(0);
 
   if (!state) return this;
-  if ('completed' in state) this[completedSymbol] = state.completed;
+  if ('completed' in state) this[kCompleted] = state.completed;
 
   const source = this.source = new this.activity.Behaviour(this.activity, this.context);
   if (source.recover) {
@@ -156,7 +156,7 @@ proto.recover = function recover(state) {
 };
 
 proto.stop = function stop() {
-  const executeMessage = this[executeMessageSymbol];
+  const executeMessage = this[kExecuteMessage];
   if (!executeMessage) return;
   this.getApi(executeMessage).stop();
 };
@@ -177,7 +177,7 @@ proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
 
   switch (routingKey) {
     case 'execute.resume.execution': {
-      if (!this[postponedSymbol].length) return this.broker.publish('execution', 'execute.start', cloneContent(this[executeMessageSymbol].content));
+      if (!this[kPostponed].length) return this.broker.publish('execution', 'execute.start', cloneContent(this[kExecuteMessage].content));
       break;
     }
     case 'execute.error':
@@ -215,7 +215,7 @@ proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
 
 proto._onStateChangeMessage = function onStateChangeMessage(message) {
   const {ignoreIfExecuting, executionId} = message.content;
-  const postponed = this[postponedSymbol];
+  const postponed = this[kPostponed];
   const idx = postponed.findIndex((msg) => msg.content.executionId === executionId);
   let previousMsg;
   if (idx > -1) {
@@ -237,7 +237,7 @@ proto._onStateChangeMessage = function onStateChangeMessage(message) {
 proto._onExecutionCompleted = function onExecutionCompleted(message) {
   const postponedMsg = this._ackPostponed(message);
   if (!postponedMsg) return;
-  const postponed = this[postponedSymbol];
+  const postponed = this[kPostponed];
 
   const {executionId, keep, isRootScope} = message.content;
   if (!isRootScope) {
@@ -250,7 +250,7 @@ proto._onExecutionCompleted = function onExecutionCompleted(message) {
   }
 
   this._debug('completed execution', executionId);
-  this[completedSymbol] = true;
+  this[kCompleted] = true;
 
   message.ack(true);
 
@@ -268,7 +268,7 @@ proto._onExecutionDiscarded = function onExecutionDiscarded(message) {
   const {isRootScope, error} = message.content;
   if (!isRootScope && !postponedMsg) return;
 
-  const postponed = this[postponedSymbol];
+  const postponed = this[kPostponed];
   const correlationId = message.properties.correlationId;
   if (!error && !isRootScope) {
     message.ack();
@@ -294,7 +294,7 @@ proto._onExecutionDiscarded = function onExecutionDiscarded(message) {
 };
 
 proto._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {
-  this[completedSymbol] = true;
+  this[kCompleted] = true;
 
   this.broker.publish('execution', `execution.${completionType}`, {
     ...completeContent,
@@ -305,7 +305,7 @@ proto._publishExecutionCompleted = function publishExecutionCompleted(completion
 proto._ackPostponed = function ackPostponed(completeMessage) {
   const {executionId: eid} = completeMessage.content;
 
-  const postponed = this[postponedSymbol];
+  const postponed = this[kPostponed];
   const idx = postponed.findIndex(({content: c}) => c.executionId === eid);
   if (idx === -1) return;
   const [msg] = postponed.splice(idx, 1);
@@ -316,9 +316,9 @@ proto._ackPostponed = function ackPostponed(completeMessage) {
 proto._onParentApiMessage = function onParentApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'error':
-      return this[executeQSymbol].queueMessage({routingKey: 'execute.error'}, {error: message.content.error});
+      return this[kExecuteQ].queueMessage({routingKey: 'execute.error'}, {error: message.content.error});
     case 'discard':
-      return this[executeQSymbol].queueMessage({routingKey: 'execute.discard'}, cloneContent(this[executeMessageSymbol].content));
+      return this[kExecuteQ].queueMessage({routingKey: 'execute.discard'}, cloneContent(this[kExecuteMessage].content));
     case 'stop': {
       return this._onStop(message);
     }
@@ -345,7 +345,7 @@ proto._debug = function debug(logMessage, executionId) {
 
 function getExecuteMessage(message) {
   const result = cloneMessage(message, {
-    ...(message.fields.redelivered ? {isRecovered: true} : undefined),
+    ...(message.fields.redelivered && {isRecovered: true}),
     ignoreIfExecuting: undefined,
   });
   return result;

package/src/activity/Message.js

@@ -16,7 +16,7 @@ export default function Message(messageDef, context) {
       id,
       type,
       messageType: 'message',
-      ...(name ? {name: environment.resolveExpression(name, executionMessage)} : undefined),
+      ...(name && {name: environment.resolveExpression(name, executionMessage)}),
       parent: {...parent},
     };
   }

package/src/activity/Signal.js

@@ -16,7 +16,7 @@ export default function Signal(signalDef, context) {
       id,
       type,
       messageType: 'signal',
-      ...(name ? {name: environment.resolveExpression(name, executionMessage)} : undefined),
+      ...(name && {name: environment.resolveExpression(name, executionMessage)}),
       parent: {...parent},
     };
   }

package/src/definition/Definition.js

@@ -5,14 +5,14 @@ import {getUniqueId, getOptionsAndCallback} from '../shared';
 import {makeErrorFromMessage} from '../error/Errors';
 import {cloneMessage, cloneContent} from '../messageHelper';
 
-const consumingSymbol = Symbol.for('consuming');
-const countersSymbol = Symbol.for('counters');
-const execSymbol = Symbol.for('exec');
-const executeMessageSymbol = Symbol.for('executeMessage');
-const messageHandlersSymbol = Symbol.for('messageHandlers');
-const stateMessageSymbol = Symbol.for('stateMessage');
-const statusSymbol = Symbol.for('status');
-const stoppedSymbol = Symbol.for('stopped');
+const kConsuming = Symbol.for('consuming');
+const kCounters = Symbol.for('counters');
+const kExec = Symbol.for('execution');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kStateMessage = Symbol.for('stateMessage');
+const kStatus = Symbol.for('status');
+const kStopped = Symbol.for('stopped');
 
 export default Definition;
 
@@ -21,6 +21,7 @@ export function Definition(context, options) {
   if (!context) throw new Error('No context');
 
   const {id, name, type = 'definition'} = context;
+
   this.id = id;
   this.type = type;
   this.name = name;
@@ -34,16 +35,16 @@ export function Definition(context, options) {
     this.context = context;
   }
 
-  this[countersSymbol] = {
+  this[kCounters] = {
     completed: 0,
     discarded: 0,
   };
 
-  this[stoppedSymbol] = false;
-  this[execSymbol] = {};
+  this[kStopped] = false;
+  this[kExec] = {};
 
   const onBrokerReturn = this._onBrokerReturnFn.bind(this);
-  this[messageHandlersSymbol] = {
+  this[kMessageHandlers] = {
     onBrokerReturn,
     onApiMessage: this._onApiMessage.bind(this),
     onRunMessage: this._onRunMessage.bind(this),
@@ -67,28 +68,28 @@ const proto = Definition.prototype;
 Object.defineProperty(proto, 'counters', {
   enumerable: true,
   get() {
-    return {...this[countersSymbol]};
+    return {...this[kCounters]};
   },
 });
 
 Object.defineProperty(proto, 'execution', {
   enumerable: true,
   get() {
-    return this[execSymbol].execution;
+    return this[kExec].execution;
   },
 });
 
 Object.defineProperty(proto, 'executionId', {
   enumerable: true,
   get() {
-    return this[execSymbol].executionId;
+    return this[kExec].executionId;
   },
 });
 
 Object.defineProperty(proto, 'isRunning', {
   enumerable: true,
   get() {
-    if (!this[consumingSymbol]) return false;
+    if (!this[kConsuming]) return false;
     return !!this.status;
   },
 });
@@ -96,14 +97,14 @@ Object.defineProperty(proto, 'isRunning', {
 Object.defineProperty(proto, 'status', {
   enumerable: true,
   get() {
-    return this[statusSymbol];
+    return this[kStatus];
   },
 });
 
 Object.defineProperty(proto, 'stopped', {
   enumerable: true,
   get() {
-    return this[stoppedSymbol];
+    return this[kStopped];
   },
 });
 
@@ -119,7 +120,7 @@ proto.run = function run(optionsOrCallback, optionalCallback) {
     addConsumerCallbacks(this, callback);
   }
 
-  const exec = this[execSymbol];
+  const exec = this[kExec];
   exec.executionId = getUniqueId(this.id);
   const content = this._createMessage({...runOptions});
 
@@ -142,7 +143,7 @@ proto.resume = function resume(callback) {
     throw err;
   }
 
-  this[stoppedSymbol] = false;
+  this[kStopped] = false;
   if (!this.status) return this;
 
   if (callback) {
@@ -161,13 +162,13 @@ proto.recover = function recover(state) {
   if (this.isRunning) throw new Error('cannot recover running definition');
   if (!state) return this;
 
-  this[stoppedSymbol] = !!state.stopped;
-  this[statusSymbol] = state.status;
+  this[kStopped] = !!state.stopped;
+  this[kStatus] = state.status;
 
-  const exec = this[execSymbol];
+  const exec = this[kExec];
   exec.executionId = state.executionId;
   if (state.counters) {
-    this[countersSymbol] = {...this[countersSymbol], ...state.counters};
+    this[kCounters] = {...this[kCounters], ...state.counters};
   }
 
   this.environment.recover(state.environment);
@@ -254,9 +255,9 @@ proto.getProcessById = function getProcessById(processId) {
 };
 
 proto.getActivityById = function getActivityById(childId) {
-  const siblings = this.getProcesses();
-  for (const sibling of siblings) {
-    const child = sibling.getActivityById(childId);
+  const bps = this.getProcesses();
+  for (const bp of bps) {
+    const child = bp.getActivityById(childId);
     if (child) return child;
   }
   return null;
@@ -275,7 +276,7 @@ proto.getPostponed = function getPostponed(...args) {
 proto.getApi = function getApi(message) {
   const execution = this.execution;
   if (execution) return execution.getApi(message);
-  message = message || this[stateMessageSymbol];
+  message = message || this[kStateMessage];
   if (!message) throw new Error('Definition is not running');
   return DefinitionApi(this.broker, message);
 };
@@ -307,9 +308,9 @@ proto.stop = function stop() {
 };
 
 proto._activateRunConsumers = function activateRunConsumers() {
-  this[consumingSymbol] = true;
+  this[kConsuming] = true;
   const broker = this.broker;
-  const {onApiMessage, onRunMessage} = this[messageHandlersSymbol];
+  const {onApiMessage, onRunMessage} = this[kMessageHandlers];
   broker.subscribeTmp('api', `definition.*.${this.executionId}`, onApiMessage, {
     noAck: true,
     consumerTag: '_definition-api',
@@ -325,7 +326,7 @@ proto._deactivateRunConsumers = function deactivateRunConsumers() {
   broker.cancel('_definition-api');
   broker.cancel('_definition-run');
   broker.cancel('_definition-execution');
-  this[consumingSymbol] = false;
+  this[kConsuming] = false;
 };
 
 proto._createMessage = function createMessage(override) {
@@ -344,14 +345,14 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
     return this._onResumeMessage(message);
   }
 
-  const exec = this[execSymbol];
-  this[stateMessageSymbol] = message;
+  const exec = this[kExec];
+  this[kStateMessage] = message;
 
   switch (routingKey) {
     case 'run.enter': {
       this.logger.debug(`<${this.executionId} (${this.id})> enter`);
 
-      this[statusSymbol] = 'entered';
+      this[kStatus] = 'entered';
       if (fields.redelivered) break;
 
       exec.execution = undefined;
@@ -360,18 +361,18 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
     }
     case 'run.start': {
       this.logger.debug(`<${this.executionId} (${this.id})> start`);
-      this[statusSymbol] = 'start';
+      this[kStatus] = 'start';
       this._publishEvent('start', content);
       break;
     }
     case 'run.execute': {
-      this[statusSymbol] = 'executing';
+      this[kStatus] = 'executing';
       const executeMessage = cloneMessage(message);
       if (fields.redelivered && !exec.execution) {
         executeMessage.fields.redelivered = undefined;
       }
-      this[executeMessageSymbol] = message;
-      this.broker.getQueue('execution-q').assertConsumer(this[messageHandlersSymbol].onExecutionMessage, {
+      this[kExecuteMessage] = message;
+      this.broker.getQueue('execution-q').assertConsumer(this[kMessageHandlers].onExecutionMessage, {
         exclusive: true,
         consumerTag: '_definition-execution',
       });
@@ -385,12 +386,12 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
       return exec.execution.execute(executeMessage);
     }
     case 'run.end': {
-      if (this.status === 'end') break;
+      if (this[kStatus] === 'end') break;
 
-      this[countersSymbol].completed++;
+      this[kCounters].completed++;
 
       this.logger.debug(`<${this.executionId} (${this.id})> completed`);
-      this[statusSymbol] = 'end';
+      this[kStatus] = 'end';
       this.broker.publish('run', 'run.leave', content);
       this._publishEvent('end', content);
       break;
@@ -403,17 +404,17 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
       break;
     }
     case 'run.discarded': {
-      if (this.status === 'discarded') break;
+      if (this[kStatus] === 'discarded') break;
 
-      this[countersSymbol].discarded++;
+      this[kCounters].discarded++;
 
-      this[statusSymbol] = 'discarded';
+      this[kStatus] = 'discarded';
       this.broker.publish('run', 'run.leave', content);
       break;
     }
     case 'run.leave': {
       message.ack();
-      this[statusSymbol] = undefined;
+      this[kStatus] = undefined;
       this._deactivateRunConsumers();
 
       this._publishEvent('leave', this._createMessage());
@@ -427,7 +428,7 @@ proto._onRunMessage = function onRunMessage(routingKey, message) {
 proto._onResumeMessage = function onResumeMessage(message) {
   message.ack();
 
-  const stateMessage = this[stateMessageSymbol];
+  const stateMessage = this[kStateMessage];
 
   switch (stateMessage.fields.routingKey) {
     case 'run.discarded':
@@ -465,8 +466,8 @@ proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
     }
   }
 
-  const executeMessage = this[executeMessageSymbol];
-  this[executeMessageSymbol] = null;
+  const executeMessage = this[kExecuteMessage];
+  this[kExecuteMessage] = null;
   executeMessage.ack();
 };
 
@@ -488,7 +489,7 @@ proto._publishEvent = function publishEvent(action, content, msgOpts) {
 };
 
 proto._onStop = function onStop() {
-  this[stoppedSymbol] = true;
+  this[kStopped] = true;
   this._deactivateRunConsumers();
   return this._publishEvent('stop', this._createMessage());
 };
@@ -502,7 +503,7 @@ proto._onBrokerReturnFn = function onBrokerReturn(message) {
 };
 
 proto._reset = function reset() {
-  this[execSymbol].executionId = undefined;
+  this[kExec].executionId = undefined;
   this._deactivateRunConsumers();
   this.broker.purgeQueue('run-q');
   this.broker.purgeQueue('execution-q');