bpmn-elements 14.1.0 → 15.0.1

package/src/process/ProcessExecution.js

@@ -29,15 +29,15 @@ function ProcessExecution(parentActivity, context) {
   this.context = context;
 
   this[kElements] = {
+    postponed: new Set(),
     children: context.getActivities(id),
     associations: context.getAssociations(id),
     flows: context.getSequenceFlows(id),
     outboundMessageFlows: context.getMessageFlows(id),
     startActivities: [],
     triggeredByEvent: [],
-    detachedActivities: [],
+    detachedActivities: new Set(),
     startSequences: {},
-    postponed: [],
   };
 
   const exchangeName = (this._exchangeName = isSubProcess ? 'subprocess-execution' : 'execution');
@@ -76,7 +76,7 @@ Object.defineProperties(ProcessExecution.prototype, {
   },
   postponedCount: {
     get() {
-      return this[kElements].postponed.length;
+      return this[kElements].postponed.size;
     },
   },
   isRunning: {
@@ -130,8 +130,8 @@ ProcessExecution.prototype.resume = function resume() {
     for (const a of startActivities) a.shake();
   }
 
-  postponed.splice(0);
-  detachedActivities.splice(0);
+  postponed.clear();
+  detachedActivities.clear();
 
   this[kActivityQ].consume(this[kMessageHandlers].onChildMessage, {
     prefetch: 1000,
@@ -144,7 +144,7 @@ ProcessExecution.prototype.resume = function resume() {
   if (status === 'init') return this._start();
 
   const tracker = this[kTracker];
-  for (const msg of postponed.slice()) {
+  for (const msg of new Set(postponed)) {
     const activity = this.getActivityById(msg.content.id);
     if (!activity) continue;
     if (msg.content.placeholder) continue;
@@ -160,7 +160,7 @@ ProcessExecution.prototype.resume = function resume() {
 
   if (this[kCompleted]) return;
 
-  if (!postponed.length && status === 'executing') return this._complete('completed');
+  if (!postponed.size && status === 'executing') return this._complete('completed');
 };
 
 ProcessExecution.prototype.getState = function getState() {
@@ -283,7 +283,7 @@ ProcessExecution.prototype.stop = function stop() {
 
 ProcessExecution.prototype.getPostponed = function getPostponed(filterFn) {
   const result = [];
-  for (const msg of this[kElements].postponed.slice()) {
+  for (const msg of this[kElements].postponed) {
     const api = this._getChildApi(msg);
     if (!api) continue;
     if (filterFn && !filterFn(api)) continue;
@@ -347,11 +347,12 @@ ProcessExecution.prototype.getApi = function getApi(message) {
   const self = this;
 
   api.getExecuting = function getExecuting() {
-    return postponed.reduce((result, msg) => {
+    const result = [];
+    for (const msg of postponed) {
       const childApi = self._getChildApi(msg);
       if (childApi) result.push(childApi);
-      return result;
-    }, []);
+    }
+    return result;
   };
 
   return api;
@@ -377,8 +378,8 @@ ProcessExecution.prototype._start = function start() {
   this[kStatus] = 'executing';
   for (const a of startActivities) a.run();
 
-  postponed.splice(0);
-  detachedActivities.splice(0);
+  postponed.clear();
+  detachedActivities.clear();
   this[kActivityQ].assertConsumer(this[kMessageHandlers].onChildMessage, {
     prefetch: 1000,
     consumerTag: `_process-activity-${this.executionId}`,
@@ -565,9 +566,13 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       message.ack();
       return this._onCancel(message);
     case 'activity.error.caught': {
-      const prevMsg = this[kElements].postponed.find((msg) => {
-        return msg.content.executionId === content.executionId;
-      });
+      let prevMsg;
+      for (const msg of this[kElements].postponed) {
+        if (msg.content.executionId === content.executionId) {
+          prevMsg = msg;
+          break;
+        }
+      }
       if (!prevMsg) return message.ack();
       break;
     }
@@ -580,7 +585,7 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
 
   switch (routingKey) {
     case 'activity.detach': {
-      this[kElements].detachedActivities.push(cloneMessage(message));
+      this[kElements].detachedActivities.add(cloneMessage(message));
       break;
     }
     case 'activity.cancel': {
@@ -600,10 +605,13 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
       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;
-      });
+      let eventCaughtBy;
+      for (const msg of this[kElements].postponed) {
+        if (msg.fields.routingKey === 'activity.catch' && msg.content.source && msg.content.source.executionId === content.executionId) {
+          eventCaughtBy = msg;
+          break;
+        }
+      }
       if (eventCaughtBy) {
         this[kActivityQ].queueMessage({ routingKey: 'activity.error.caught' }, cloneContent(content), {
           persistent: true,
@@ -619,24 +627,38 @@ ProcessExecution.prototype._onChildMessage = function onChildMessage(routingKey,
 ProcessExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   const previousMsg = this._popPostponed(message.content);
   if (previousMsg) previousMsg.ack();
-  if (postponeMessage) this[kElements].postponed.push(message);
+  if (postponeMessage) this[kElements].postponed.add(message);
 };
 
 ProcessExecution.prototype._popPostponed = function popPostponed(byContent) {
   const { postponed, detachedActivities } = this[kElements];
 
-  const postponedIdx = postponed.findIndex((msg) => {
-    if (msg.content.isSequenceFlow || msg.content.isAssociation) return msg.content.sequenceId === byContent.sequenceId;
-    return msg.content.executionId === byContent.executionId;
-  });
-
   let postponedMsg;
-  if (postponedIdx > -1) {
-    postponedMsg = postponed.splice(postponedIdx, 1)[0];
+  if (byContent.sequenceId) {
+    for (const msg of postponed) {
+      if (!msg.content.isSequenceFlow && !msg.content.isAssociation) continue;
+      if (msg.content.sequenceId === byContent.sequenceId) {
+        postponedMsg = msg;
+        break;
+      }
+    }
+  } else {
+    for (const msg of postponed) {
+      if (msg.content.executionId === byContent.executionId) {
+        postponedMsg = msg;
+        break;
+      }
+    }
   }
 
-  const detachedIdx = detachedActivities.findIndex((msg) => msg.content.executionId === byContent.executionId);
-  if (detachedIdx > -1) detachedActivities.splice(detachedIdx, 1);
+  if (postponedMsg) postponed.delete(postponedMsg);
+
+  for (const msg of detachedActivities) {
+    if (msg.content.executionId === byContent.executionId) {
+      detachedActivities.delete(msg);
+      break;
+    }
+  }
 
   return postponedMsg;
 };
@@ -648,7 +670,7 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
   const { id, type, isEnd } = message.content;
 
   const { postponed, detachedActivities, startActivities } = this[kElements];
-  const postponedCount = postponed.length;
+  const postponedCount = postponed.size;
 
   if (!postponedCount) {
     this._debug(`left <${id}> (${type}), pending runs ${postponedCount}`);
@@ -657,9 +679,9 @@ ProcessExecution.prototype._onChildCompleted = function onChildCompleted(message
   }
 
   message.ack();
-  this._debug(`left <${id}> (${type}), pending runs ${postponedCount}, ${postponed.map((a) => a.content.id).join(',')}`);
+  this._debug(`left <${id}> (${type}), pending activities ${postponedCount}`);
 
-  if (postponedCount && postponedCount === detachedActivities.length) {
+  if (postponedCount && postponedCount === detachedActivities.size) {
     return this[kActivityQ].queueMessage(
       { routingKey: 'execution.discard.detached' },
       {
@@ -706,8 +728,11 @@ ProcessExecution.prototype._stopExecution = function stopExecution(message) {
 
 ProcessExecution.prototype._onDiscard = function onDiscard() {
   this._deactivate();
-  const running = this[kElements].postponed.splice(0);
-  this._debug(`discard process execution (discard child executions ${running.length})`);
+  const postponed = this[kElements].postponed;
+  const running = new Set(postponed);
+  postponed.clear();
+
+  this._debug(`discard process execution (discard child executions ${running.size})`);
 
   if (this.isSubProcess) {
     this.stop();
@@ -722,11 +747,13 @@ ProcessExecution.prototype._onDiscard = function onDiscard() {
 };
 
 ProcessExecution.prototype._onCancel = function onCancel() {
-  const running = this[kElements].postponed.slice(0);
+  const postponed = this[kElements].postponed;
+  const running = new Set(postponed);
+
   const isTransaction = this.isTransaction;
 
   if (isTransaction) {
-    this._debug(`cancel transaction execution (cancel child executions ${running.length})`);
+    this._debug(`cancel transaction execution (cancel child executions ${running.size})`);
     this[kStatus] = 'cancel';
     this.broker.publish(
       'event',
@@ -744,7 +771,7 @@ ProcessExecution.prototype._onCancel = function onCancel() {
       }
     }
   } else {
-    this._debug(`cancel process execution (cancel child executions ${running.length})`);
+    this._debug(`cancel process execution (cancel child executions ${running.size})`);
     for (const msg of running) {
       this._getChildApi(msg).discard();
     }
@@ -839,7 +866,10 @@ ProcessExecution.prototype._terminate = function terminate(message) {
   this[kStatus] = 'terminated';
   this._debug('terminating process execution');
 
-  const running = this[kElements].postponed.splice(0);
+  const postponed = this[kElements].postponed;
+  const running = new Set(postponed);
+  postponed.clear();
+
   for (const flow of this.getSequenceFlows()) flow.stop();
   for (const flow of this.getAssociations()) flow.stop();
 

package/src/shared.js

@@ -12,14 +12,6 @@ export function getUniqueId(prefix) {
   return `${brokerSafeId(prefix)}_${generateId()}`;
 }
 
-export function filterUndefined(obj) {
-  return Object.keys(obj).reduce((filtered, key) => {
-    const objValue = obj[key];
-    if (objValue !== undefined) filtered[key] = objValue;
-    return filtered;
-  }, {});
-}
-
 export function getOptionsAndCallback(optionsOrCallback, callback) {
   let options;
   if (typeof optionsOrCallback === 'function') {

package/src/tasks/LoopCharacteristics.js

@@ -146,12 +146,12 @@ ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage)
 ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
   const chr = this.characteristics;
   const cardinality = chr.cardinality;
-  const batch = [];
+  const batch = new Set();
 
   let startContent = chr.next(this.index);
   do {
     chr.debug(`start parallel iteration index ${this.index}`);
-    batch.push(startContent);
+    batch.add(startContent);
     this.running++;
     this.index++;
 

package/src/tasks/ScriptTask.js

@@ -29,8 +29,8 @@ ScriptTaskBehaviour.prototype.execute = function execute(executeMessage) {
     return loopCharacteristics.execute(executeMessage);
   }
 
-  const activity = this.activity,
-    scriptFormat = this.scriptFormat;
+  const activity = this.activity;
+  const scriptFormat = this.scriptFormat;
   const script = this.environment.getScript(scriptFormat, activity, cloneMessage(executeMessage));
   if (!script) {
     return activity.emitFatal(

package/src/tasks/SubProcess.js

@@ -3,7 +3,7 @@ import ProcessExecution from '../process/ProcessExecution.js';
 import { cloneContent } from '../messageHelper.js';
 
 const kExecutions = Symbol.for('executions');
-const kMessageHandlers = Symbol.for('messageHandlers');
+const kOnExecutionCompleted = Symbol.for('execution completed handler');
 
 export default function SubProcess(activityDef, context) {
   const triggeredByEvent = activityDef.behaviour && activityDef.behaviour.triggeredByEvent;
@@ -38,21 +38,19 @@ export function SubProcessBehaviour(activity, context) {
   this.broker = activity.broker;
   this.executionId = undefined;
 
-  this[kExecutions] = [];
-  this[kMessageHandlers] = {
-    onExecutionCompleted: this._onExecutionCompleted.bind(this),
-  };
+  this[kExecutions] = new Set();
+  this[kOnExecutionCompleted] = this._onExecutionCompleted.bind(this);
 }
 
 Object.defineProperties(SubProcessBehaviour.prototype, {
   execution: {
     get() {
-      return this[kExecutions][0];
+      return [...this[kExecutions]][0];
     },
   },
   executions: {
     get() {
-      return this[kExecutions].slice();
+      return [...this[kExecutions]];
     },
   },
 });
@@ -74,22 +72,20 @@ SubProcessBehaviour.prototype.execute = function execute(executeMessage) {
 };
 
 SubProcessBehaviour.prototype.getState = function getState() {
+  const states = [];
+  for (const pe of this[kExecutions]) {
+    const state = pe.getState();
+    state.environment = pe.environment.getState();
+    states.push(state);
+  }
+
   if (this.loopCharacteristics) {
     return {
-      executions: this[kExecutions].map((pe) => {
-        const state = pe.getState();
-        state.environment = pe.environment.getState();
-        return state;
-      }),
+      executions: states,
     };
   }
 
-  const execution = this.execution;
-  if (execution) {
-    const state = execution.getState();
-    state.environment = execution.environment.getState();
-    return state;
-  }
+  return states[0];
 };
 
 SubProcessBehaviour.prototype.recover = function recover(state) {
@@ -99,7 +95,7 @@ SubProcessBehaviour.prototype.recover = function recover(state) {
 
   const loopCharacteristics = this.loopCharacteristics;
   if (loopCharacteristics && state.executions) {
-    executions.splice(0);
+    executions.clear();
     for (const se of state.executions) {
       this.recover(se);
     }
@@ -107,7 +103,7 @@ SubProcessBehaviour.prototype.recover = function recover(state) {
   }
 
   if (!loopCharacteristics) {
-    executions.splice(0);
+    executions.clear();
   }
 
   const subEnvironment = this.environment.clone().recover(state.environment);
@@ -115,15 +111,16 @@ SubProcessBehaviour.prototype.recover = function recover(state) {
 
   const execution = new ProcessExecution(this.activity, subContext).recover(state);
 
-  executions.push(execution);
+  executions.add(execution);
   return execution;
 };
 
 SubProcessBehaviour.prototype.getPostponed = function getPostponed() {
-  return this[kExecutions].reduce((result, pe) => {
-    result = result.concat(pe.getPostponed());
-    return result;
-  }, []);
+  let postponed = [];
+  for (const pe of this[kExecutions]) {
+    postponed = postponed.concat(pe.getPostponed());
+  }
+  return postponed;
 };
 
 SubProcessBehaviour.prototype._upsertExecution = function upsertExecution(executeMessage) {
@@ -140,7 +137,7 @@ SubProcessBehaviour.prototype._upsertExecution = function upsertExecution(execut
   const subContext = this.context.clone(subEnvironment, this.activity);
 
   execution = new ProcessExecution(this.activity, subContext);
-  this[kExecutions].push(execution);
+  this[kExecutions].add(execution);
 
   this._addListeners(executionId);
 
@@ -148,7 +145,7 @@ SubProcessBehaviour.prototype._upsertExecution = function upsertExecution(execut
 };
 
 SubProcessBehaviour.prototype._addListeners = function addListeners(executionId) {
-  this.broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, this[kMessageHandlers].onExecutionCompleted, {
+  this.broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, this[kOnExecutionCompleted], {
     noAck: true,
     consumerTag: `_sub-process-execution-${executionId}`,
   });
@@ -184,10 +181,8 @@ SubProcessBehaviour.prototype._onExecutionCompleted = function onExecutionComple
 
 SubProcessBehaviour.prototype._completeExecution = function completeExecution(completeRoutingKey, content) {
   if (this.loopCharacteristics) {
-    const executions = this[kExecutions];
-    const executionIdx = executions.findIndex((pe) => pe.executionId === content.executionId);
-    if (executionIdx < 0) return;
-    executions.splice(executionIdx, 1);
+    const execution = this._getExecutionById(content.executionId);
+    this[kExecutions].delete(execution);
   }
 
   this.broker.publish('execution', completeRoutingKey, cloneContent(content));
@@ -203,11 +198,15 @@ SubProcessBehaviour.prototype.getApi = function getApi(apiMessage) {
     return execution.getApi(apiMessage);
   }
 
+  if (!content.parent.path) return;
+
   for (const pp of content.parent.path) {
     if ((execution = this._getExecutionById(pp.executionId))) return execution.getApi(apiMessage);
   }
 };
 
 SubProcessBehaviour.prototype._getExecutionById = function getExecutionById(executionId) {
-  return this[kExecutions].find((pe) => pe.executionId === executionId);
+  for (const pe of this[kExecutions]) {
+    if (pe.executionId === executionId) return pe;
+  }
 };

package/types/types.d.ts

@@ -220,7 +220,7 @@ declare interface DefinitionExecution {
   getProcessByExecutionId(processExecutionId: string): Process;
   getRunningProcesses(): Process[];
   getExecutableProcesses(): Process[];
-  getPostponed(filterFn: filterPostponed): Api<ElementBase>[];
+  getPostponed(filterFn?: filterPostponed): Api<ElementBase>[];
 }
 
 declare interface ActivityExecution {