bpmn-elements 6.0.1 → 7.0.0

package/src/tasks/LoopCharacteristics.js

@@ -1,15 +1,19 @@
-import {ActivityError} from '../error/Errors';
-import {cloneContent, cloneMessage, unshiftParent} from '../messageHelper';
+import {RunError} from '../error/Errors';
+import {cloneContent, cloneMessage, unshiftParent, cloneParent} from '../messageHelper';
 
 export default function LoopCharacteristics(activity, loopCharacteristics) {
-  const {id, broker, environment} = activity;
-  const {batchSize = 50} = environment.settings;
+  this.activity = activity;
+  this.loopCharacteristics = loopCharacteristics;
   const {type = 'LoopCharacteristics', behaviour = {}} = loopCharacteristics;
-  const {isSequential = false, collection: collectionExpression, elementVariable = 'item'} = behaviour;
+  this.type = type;
+  const {isSequential = false, collection} = behaviour;
+  this.isSequential = isSequential;
+  this.collection = collection;
 
   let completionCondition, startCondition, loopCardinality;
   if ('loopCardinality' in behaviour) loopCardinality = behaviour.loopCardinality;
   else if ('loopMaximum' in behaviour) loopCardinality = behaviour.loopMaximum;
+  this.loopCardinality = loopCardinality;
 
   if (behaviour.loopCondition) {
     if (behaviour.testBefore) startCondition = behaviour.loopCondition;
@@ -19,323 +23,320 @@ export default function LoopCharacteristics(activity, loopCharacteristics) {
     completionCondition = behaviour.completionCondition;
   }
 
-  const loopType = getLoopType();
-  if (!loopType) return;
+  if (collection) {
+    this.loopType = 'collection';
+    this.elementVariable = behaviour.elementVariable || 'item';
+  } else if (completionCondition) this.loopType = 'complete condition';
+  else if (startCondition) this.loopType = 'start condition';
+  else if (loopCardinality) this.loopType = 'cardinality';
 
-  const {debug} = environment.Logger(type.toLowerCase());
-  const executeConsumerTag = '_execute-q-multi-instance-tag';
-  broker.cancel(executeConsumerTag);
+  this.characteristics = null;
+  this.execution = null;
+}
 
-  const apiConsumerTag = '_api-multi-instance-tag';
-  broker.cancel(apiConsumerTag);
+LoopCharacteristics.prototype.execute = function execute(executeMessage) {
+  if (!executeMessage) throw new TypeError('LoopCharacteristics execution requires message');
+  const chr = this.characteristics = this.characteristics || new Characteristics(this.activity, this.loopCharacteristics, executeMessage);
+  if (chr.cardinality === 0) return chr.complete();
 
-  let loopSettings;
+  const execution = this.isSequential ? new SequentialLoopCharacteristics(this.activity, chr) : new ParallelLoopCharacteristics(this.activity, chr);
+  return execution.execute(executeMessage);
+};
 
-  const characteristicsApi = {
-    type,
-    loopType,
-    collection: collectionExpression,
-    elementVariable,
-    isSequential,
-    loopCardinality,
-    execute,
-  };
+function SequentialLoopCharacteristics(activity, characteristics) {
+  this.activity = activity;
+  this.id = activity.id;
+  this.characteristics = characteristics;
+}
 
-  return characteristicsApi;
+SequentialLoopCharacteristics.prototype.execute = function execute(executeMessage) {
+  const {routingKey: executeRoutingKey, redelivered: isRedelivered} = executeMessage.fields || {};
+  const chr = this.characteristics;
+  if (!chr.cardinality && !chr.startCondition && !chr.completionCondition) {
+    throw new RunError(`<${this.id}> cardinality, collection, or condition is required in sequential loops`, executeMessage);
+  }
 
-  function getLoopType() {
-    if (collectionExpression) return 'collection';
-    if (completionCondition) return 'complete condition';
-    if (startCondition) return 'start condition';
-    if (loopCardinality) return 'cardinality';
+  let startIndex = 0;
+  if (isRedelivered && executeRoutingKey === 'execute.iteration.next') {
+    startIndex = executeMessage.content.index;
   }
+  chr.subscribe(this._onCompleteMessage.bind(this));
 
-  function execute(executeMessage) {
-    if (!executeMessage) throw new Error('LoopCharacteristics execution requires message');
-    const {routingKey: executeRoutingKey, redelivered: isRedelivered} = executeMessage.fields || {};
-    const {executionId: parentExecutionId} = executeMessage.content;
-    if (!getCharacteristics()) return;
+  return this._startNext(startIndex, isRedelivered);
+};
 
-    try {
-      return isSequential ? executeSequential() : executeParallel();
-    } catch (err) {
-      return activity.emitFatal(new ActivityError(err.message, executeMessage, err), executeMessage.content);
-    }
+SequentialLoopCharacteristics.prototype._startNext = function startNext(index, ignoreIfExecuting) {
+  const chr = this.characteristics;
+  const content = chr.next(index);
+  if (!content) return;
 
-    function executeSequential() {
-      const {cardinality, getContent: getStartContent} = getCharacteristics();
-      if (cardinality === 0) return complete();
-      if (!cardinality && !startCondition && !completionCondition) return activity.emitFatal(new ActivityError(`<${id}> cardinality, collection, or condition is required in sequential loops`, executeMessage), getStartContent());
-
-      let startIndex = 0;
-
-      if (isRedelivered && executeRoutingKey === 'execute.iteration.next') {
-        startIndex = executeMessage.content.index;
-      }
-      subscribe(onCompleteMessage);
-
-      return startNext(startIndex, isRedelivered);
-
-      function startNext(index, ignoreIfExecuting) {
-        const content = next(index);
-        if (!content) return;
-
-        const characteristics = getCharacteristics();
-        if (startCondition && isConditionMet(startCondition, {content})) {
-          debug(`<${parentExecutionId} (${id})> start condition met`);
-          return;
-        }
-
-        debug(`<${content.executionId} (${id})>`, ignoreIfExecuting ? 'resume' : 'start', `sequential iteration index ${content.index}`);
-        broker.publish('execution', 'execute.iteration.next', {
-          ...content,
-          ...characteristics.getContent(),
-          index,
-          preventComplete: true,
-          output: characteristics.output.slice(),
-          state: 'iteration.next',
-        });
-
-        broker.publish('execution', 'execute.start', {...content, ignoreIfExecuting});
-        return content;
-      }
-
-      function onCompleteMessage(_, message) {
-        const {content} = message;
-        const loopOutput = getCharacteristics().output;
-        if (content.output !== undefined) loopOutput[content.index] = content.output;
-
-        broker.publish('execution', 'execute.iteration.completed', {
-          ...message.content,
-          ...getCharacteristics().getContent(),
-          preventComplete: true,
-          output: loopOutput.slice(),
-          state: 'iteration.completed',
-        });
-
-        if (isConditionMet(completionCondition, message, loopOutput)) {
-          debug(`<${parentExecutionId} (${id})> complete condition met`);
-        } else if (startNext(content.index + 1)) return;
-
-        debug(`<${parentExecutionId} (${id})> sequential loop completed`);
-
-        return complete(content);
-      }
-
-      function complete(content) {
-        stop();
-
-        const {getContent, output} = getCharacteristics();
-
-        return broker.publish('execution', 'execute.completed', {
-          ...content,
-          ...getContent(),
-          output,
-        });
-      }
-    }
+  if (chr.isStartConditionMet({content})) {
+    chr.debug('start condition met');
+    return;
+  }
 
-    function executeParallel() {
-      const {cardinality, getContent: getStartContent} = getCharacteristics();
-
-      if (cardinality === 0) return complete();
-      if (!cardinality) return activity.emitFatal(new ActivityError(`<${id}> cardinality or collection is required in parallel loops`, executeMessage), getStartContent());
-
-      let index = 0, running = 0;
-      if (isRedelivered) {
-        if (!isNaN(executeMessage.content.index)) index = executeMessage.content.index;
-        if (!isNaN(executeMessage.content.running)) running = executeMessage.content.running;
-      }
-      subscribe(onCompleteMessage);
-
-      if (isRedelivered) return;
-
-      return startBatch();
-
-      function startBatch() {
-        const {output: loopOutput, getContent} = getCharacteristics();
-        const batch = [];
-
-        let startContent = next(index);
-        do {
-          debug(`<${parentExecutionId} (${id})> start parallel iteration index ${index}`);
-          batch.push(startContent);
-          running++;
-          index++;
-
-          if (index >= cardinality || running >= batchSize) {
-            break;
-          }
-        } while ((startContent = next(index)));
-
-        broker.publish('execution', 'execute.iteration.batch', {
-          ...getContent(),
-          index,
-          running,
-          output: loopOutput,
-          preventComplete: true,
-        });
-
-        for (const content of batch) {
-          broker.publish('execution', 'execute.start', content);
-        }
-      }
-
-      function onCompleteMessage(_, message) {
-        const {content} = message;
-        const {output: loopOutput} = getCharacteristics();
-        if (content.output !== undefined) loopOutput[content.index] = content.output;
-
-        running--;
-
-        broker.publish('execution', 'execute.iteration.completed', {
-          ...content,
-          ...getCharacteristics().getContent(),
-          index,
-          running,
-          output: loopOutput,
-          state: 'iteration.completed',
-          preventComplete: true,
-        });
-
-        if (running <= 0 && !next(index)) {
-          return complete(content);
-        }
-
-        if (isConditionMet(completionCondition, message)) {
-          return complete(content);
-        }
-
-        if (running <= 0) {
-          running = 0;
-          startBatch();
-        }
-      }
-
-      function complete(content) {
-        stop();
-
-        const {getContent, output} = getCharacteristics();
-
-        return broker.publish('execution', 'execute.completed', {
-          ...content,
-          ...getContent(),
-          output,
-        });
-      }
-    }
+  chr.debug(`${ignoreIfExecuting ? 'resume' : 'start'} sequential iteration index ${content.index}`);
+  const broker = this.activity.broker;
+  broker.publish('execution', 'execute.iteration.next', {
+    ...content,
+    ...chr.getContent(),
+    index,
+    preventComplete: true,
+    output: chr.output.slice(),
+    state: 'iteration.next',
+  });
+
+  broker.publish('execution', 'execute.start', {...content, ignoreIfExecuting});
+  return content;
+};
+
+SequentialLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(_, message) {
+  const {content} = message;
+  const chr = this.characteristics;
+  const loopOutput = chr.output;
+
+  if (content.output !== undefined) loopOutput[content.index] = content.output;
+
+  this.activity.broker.publish('execution', 'execute.iteration.completed', {
+    ...message.content,
+    ...chr.getContent(),
+    preventComplete: true,
+    output: loopOutput.slice(),
+    state: 'iteration.completed',
+  });
+
+  if (chr.isCompletionConditionMet(message, loopOutput)) {
+    chr.debug('complete condition met');
+  } else if (this._startNext(content.index + 1)) return;
+
+  chr.debug('sequential loop completed');
+
+  return chr.complete(content);
+};
+
+function ParallelLoopCharacteristics(activity, characteristics) {
+  this.activity = activity;
+  this.id = activity.id;
+  this.characteristics = characteristics;
+  this.running = 0;
+  this.index = 0;
+}
 
-    function next(index) {
-      const executionId = `${parentExecutionId}_${index}`;
+ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage) {
+  const chr = this.characteristics;
+  if (!chr.cardinality) throw new RunError(`<${this.id}> cardinality or collection is required in parallel loops`, executeMessage);
 
-      const {cardinality, collection, parent, getContent} = getCharacteristics();
-      const content = {
-        ...getContent(),
-        isRootScope: undefined,
-        executionId,
-        isMultiInstance: true,
-        index,
-        parent,
-      };
+  const isRedelivered = executeMessage.fields.redelivered;
+  if (isRedelivered) {
+    if (!isNaN(executeMessage.content.index)) this.index = executeMessage.content.index;
+    if (!isNaN(executeMessage.content.running)) this.running = executeMessage.content.running;
+  }
+  chr.subscribe(this._onCompleteMessage.bind(this));
+
+  if (isRedelivered) return;
 
-      if (isComplete(content)) return;
+  return this._startBatch();
+};
 
-      if (collection) {
-        content[elementVariable] = collection[index];
-      }
+ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
+  const chr = this.characteristics;
+  const cardinality = chr.cardinality;
+  const batch = [];
 
-      return content;
+  let startContent = chr.next(this.index);
+  do {
+    chr.debug(`start parallel iteration index ${this.index}`);
+    batch.push(startContent);
+    this.running++;
+    this.index++;
 
-      function isComplete() {
-        if (cardinality > 0 && index >= cardinality) return true;
-        if (collection && index >= collection.length) return true;
-      }
+    if (this.index >= cardinality || this.running >= chr.batchSize) {
+      break;
     }
+  } while ((startContent = chr.next(this.index)));
+
+  const broker = this.activity.broker;
+  broker.publish('execution', 'execute.iteration.batch', {
+    ...chr.getContent(),
+    index: this.index,
+    running: this.running,
+    output: chr.output,
+    preventComplete: true,
+  });
+
+  for (const content of batch) {
+    broker.publish('execution', 'execute.start', content);
+  }
+};
+
+ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(_, message) {
+  const chr = this.characteristics;
+  const {content} = message;
+  if (content.output !== undefined) chr.output[content.index] = content.output;
+
+  this.running--;
+
+  this.activity.broker.publish('execution', 'execute.iteration.completed', {
+    ...content,
+    ...chr.getContent(),
+    index: this.index,
+    running: this.running,
+    output: chr.output,
+    state: 'iteration.completed',
+    preventComplete: true,
+  });
+
+  if (this.running <= 0 && !chr.next(this.index)) {
+    return chr.complete(content);
+  }
 
-    function getCharacteristics() {
-      if (loopSettings) return loopSettings;
+  if (chr.isCompletionConditionMet(message)) {
+    return chr.complete(content);
+  }
+
+  if (this.running <= 0) {
+    this.running = 0;
+    this._startBatch();
+  }
+};
 
-      const collection = getCollection();
-      const cardinality = getCardinality(collection);
+function Characteristics(activity, loopCharacteristics, executeMessage) {
+  this.activity = activity;
+  const behaviour = this.behaviour = loopCharacteristics.behaviour || {};
+  this.message = executeMessage;
 
-      const messageContent = {
-        ...cloneContent(executeMessage.content),
-        loopCardinality: cardinality,
-        isSequential,
-        output: undefined,
-      };
+  const type = this.type = loopCharacteristics.type || 'LoopCharacteristics';
+  this.id = activity.id;
+  this.broker = activity.broker;
+  this.parentExecutionId = executeMessage.content.executionId;
 
-      if (cardinality !== undefined && isNaN(cardinality) || cardinality < 0) {
-        return activity.emitFatal(new ActivityError(`<${id}> invalid loop cardinality >${cardinality}<`, executeMessage), messageContent);
-      }
+  this.isSequential = behaviour.isSequential || false;
+  this.output = executeMessage.content.output || [];
+  this.parent = unshiftParent(executeMessage.content.parent, executeMessage.content);
 
-      const output = executeMessage.content.output || [];
+  if ('loopCardinality' in behaviour) this.loopCardinality = behaviour.loopCardinality;
+  else if ('loopMaximum' in behaviour) this.loopCardinality = behaviour.loopMaximum;
 
-      const parent = unshiftParent(executeMessage.content.parent, executeMessage.content);
+  if (behaviour.loopCondition) {
+    if (behaviour.testBefore) this.startCondition = behaviour.loopCondition;
+    else this.completionCondition = behaviour.loopCondition;
+  }
+  if (behaviour.completionCondition) {
+    this.completionCondition = behaviour.completionCondition;
+  }
 
-      loopSettings = {
-        cardinality,
-        collection,
-        messageContent,
-        output,
-        parent,
-        getContent() {
-          return cloneContent(messageContent);
-        },
-      };
+  const collection = this.collection = this.getCollection();
+  if (collection) {
+    this.elementVariable = behaviour.elementVariable || 'item';
+  }
+  this.cardinality = this.getCardinality(collection);
 
-      return loopSettings;
-    }
+  this.onApiMessage = this.onApiMessage.bind(this);
 
-    function getCardinality(collection) {
-      const collectionLen = Array.isArray(collection) ? collection.length : undefined;
-      if (!loopCardinality) {
-        return collectionLen;
-      }
-      const value = environment.resolveExpression(loopCardinality, executeMessage);
-      if (value === undefined) return collectionLen;
-      return Number(value);
-    }
+  const environment = activity.environment;
+  this.logger = environment.Logger(type.toLowerCase());
+  this.batchSize = environment.settings.batchSize || 50;
+}
 
-    function getCollection() {
-      if (!collectionExpression) return;
-      debug(`<${id}> has collection`);
-      return environment.resolveExpression(collectionExpression, executeMessage);
-    }
+Characteristics.prototype.getContent = function getContent() {
+  return {
+    ...cloneContent(this.message.content),
+    loopCardinality: this.cardinality,
+    isSequential: this.isSequential,
+    output: undefined,
+  };
+};
+
+Characteristics.prototype.next = function next(index) {
+  const cardinality = this.cardinality;
+  if (cardinality > 0 && index >= cardinality) return;
+
+  const collection = this.collection;
+  if (collection && index >= collection.length) return;
+
+  const content = {
+    ...this.getContent(),
+    isRootScope: undefined,
+    executionId: `${this.parentExecutionId}_${index}`,
+    isMultiInstance: true,
+    parent: cloneParent(this.parent),
+    index,
+  };
 
-    function subscribe(onIterationCompleteMessage) {
-      broker.subscribeTmp('api', `activity.*.${parentExecutionId}`, onApiMessage, {noAck: true, consumerTag: apiConsumerTag}, {priority: 400});
-      broker.subscribeTmp('execution', 'execute.*', onComplete, {noAck: true, consumerTag: executeConsumerTag, priority: 300});
-
-      function onComplete(routingKey, message, ...args) {
-        if (!message.content.isMultiInstance) return;
-        switch (routingKey) {
-          case 'execute.cancel':
-          case 'execute.completed':
-            return onIterationCompleteMessage(routingKey, message, ...args);
-        }
-      }
-    }
+  if (collection) {
+    content[this.elementVariable] = collection[index];
   }
 
-  function onApiMessage(_, message) {
-    switch (message.properties.type) {
-      case 'stop':
-      case 'discard':
-        stop();
-        break;
+  return content;
+};
+
+Characteristics.prototype.getCardinality = function getCardinality(collection) {
+  const collectionLen = this.collection && Array.isArray(collection) ? collection.length : undefined;
+  if (!this.loopCardinality) {
+    return collectionLen;
+  }
+  const value = this.activity.environment.resolveExpression(this.loopCardinality, this.message);
+  if (value !== undefined && isNaN(value) || value < 0) {
+    throw new RunError(`<${this.id}> invalid loop cardinality >${value}<`, this.message);
+  }
+  if (value === undefined) return collectionLen;
+  return Number(value);
+};
+
+Characteristics.prototype.getCollection = function getCollection() {
+  const collectionExpression = this.behaviour.collection;
+  if (!collectionExpression) return;
+  return this.activity.environment.resolveExpression(collectionExpression, this.message);
+};
+
+Characteristics.prototype.isStartConditionMet = function isStartConditionMet(message) {
+  if (!this.startCondition) return false;
+  return this.activity.environment.resolveExpression(this.startCondition, cloneMessage(message));
+};
+
+Characteristics.prototype.isCompletionConditionMet = function isCompletionConditionMet(message) {
+  if (!this.completionCondition) return false;
+  return this.activity.environment.resolveExpression(this.completionCondition, cloneMessage(message, {loopOutput: this.output}));
+};
+
+Characteristics.prototype.complete = function complete(content) {
+  this.stop();
+
+  return this.broker.publish('execution', 'execute.completed', {
+    ...content,
+    ...this.getContent(),
+    output: this.output,
+  });
+};
+
+Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMessage) {
+  this.broker.subscribeTmp('api', `activity.*.${this.parentExecutionId}`, this.onApiMessage, {noAck: true, consumerTag: '_api-multi-instance-tag'}, {priority: 400});
+  this.broker.subscribeTmp('execution', 'execute.*', onComplete, {noAck: true, consumerTag: '_execute-q-multi-instance-tag', priority: 300});
+
+  function onComplete(routingKey, message, ...args) {
+    if (!message.content.isMultiInstance) return;
+    switch (routingKey) {
+      case 'execute.cancel':
+      case 'execute.completed':
+        return onIterationCompleteMessage(routingKey, message, ...args);
     }
   }
-
-  function stop() {
-    broker.cancel(executeConsumerTag);
-    broker.cancel(apiConsumerTag);
+};
+
+Characteristics.prototype.onApiMessage = function onApiMessage(_, message) {
+  switch (message.properties.type) {
+    case 'stop':
+    case 'discard':
+      this.stop();
+      break;
   }
+};
 
-  function isConditionMet(condition, message, loopOutput) {
-    if (!condition) return false;
-    const testContext = cloneMessage(message, {loopOutput});
-    return environment.resolveExpression(condition, testContext);
-  }
-}
+Characteristics.prototype.stop = function stop() {
+  this.broker.cancel('_execute-q-multi-instance-tag');
+  this.broker.cancel('_api-multi-instance-tag');
+};
 
+Characteristics.prototype.debug = function debug(msg) {
+  this.logger.debug(`<${this.parentExecutionId} (${this.id})> ${msg}`);
+};