bpmn-elements 6.0.1 → 8.0.1

package/dist/src/tasks/LoopCharacteristics.js

@@ -10,25 +10,22 @@ var _Errors = require("../error/Errors");
 var _messageHelper = require("../messageHelper");
 
 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;
+  this.type = type;
   const {
     isSequential = false,
-    collection: collectionExpression,
-    elementVariable = 'item'
+    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;else completionCondition = behaviour.loopCondition;
@@ -38,344 +35,326 @@ 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';
+
+  this.characteristics = null;
+  this.execution = null;
+}
+
+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();
+  const execution = this.isSequential ? new SequentialLoopCharacteristics(this.activity, chr) : new ParallelLoopCharacteristics(this.activity, chr);
+  return execution.execute(executeMessage);
+};
+
+function SequentialLoopCharacteristics(activity, characteristics) {
+  this.activity = activity;
+  this.id = activity.id;
+  this.characteristics = characteristics;
+}
+
+SequentialLoopCharacteristics.prototype.execute = function execute(executeMessage) {
   const {
-    debug
-  } = environment.Logger(type.toLowerCase());
-  const executeConsumerTag = '_execute-q-multi-instance-tag';
-  broker.cancel(executeConsumerTag);
-  const apiConsumerTag = '_api-multi-instance-tag';
-  broker.cancel(apiConsumerTag);
-  let loopSettings;
-  const characteristicsApi = {
-    type,
-    loopType,
-    collection: collectionExpression,
-    elementVariable,
-    isSequential,
-    loopCardinality,
-    execute
-  };
-  return characteristicsApi;
+    routingKey: executeRoutingKey,
+    redelivered: isRedelivered
+  } = executeMessage.fields || {};
+  const chr = this.characteristics;
 
-  function getLoopType() {
-    if (collectionExpression) return 'collection';
-    if (completionCondition) return 'complete condition';
-    if (startCondition) return 'start condition';
-    if (loopCardinality) return 'cardinality';
+  if (!chr.cardinality && !chr.startCondition && !chr.completionCondition) {
+    throw new _Errors.RunError(`<${this.id}> cardinality, collection, or condition is required in sequential loops`, executeMessage);
   }
 
-  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;
-
-    try {
-      return isSequential ? executeSequential() : executeParallel();
-    } catch (err) {
-      return activity.emitFatal(new _Errors.ActivityError(err.message, executeMessage, err), executeMessage.content);
-    }
+  let startIndex = 0;
 
-    function executeSequential() {
-      const {
-        cardinality,
-        getContent: getStartContent
-      } = getCharacteristics();
-      if (cardinality === 0) return complete();
-      if (!cardinality && !startCondition && !completionCondition) return activity.emitFatal(new _Errors.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 (isRedelivered && executeRoutingKey === 'execute.iteration.next') {
+    startIndex = executeMessage.content.index;
+  }
 
-    function executeParallel() {
-      const {
-        cardinality,
-        getContent: getStartContent
-      } = getCharacteristics();
-      if (cardinality === 0) return complete();
-      if (!cardinality) return activity.emitFatal(new _Errors.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.subscribe(this._onCompleteMessage.bind(this));
+  return this._startNext(startIndex, isRedelivered);
+};
 
-    function next(index) {
-      const executionId = `${parentExecutionId}_${index}`;
-      const {
-        cardinality,
-        collection,
-        parent,
-        getContent
-      } = getCharacteristics();
-      const content = { ...getContent(),
-        isRootScope: undefined,
-        executionId,
-        isMultiInstance: true,
-        index,
-        parent
-      };
-      if (isComplete(content)) return;
-
-      if (collection) {
-        content[elementVariable] = collection[index];
-      }
-
-      return content;
-
-      function isComplete() {
-        if (cardinality > 0 && index >= cardinality) return true;
-        if (collection && index >= collection.length) return true;
-      }
-    }
+SequentialLoopCharacteristics.prototype._startNext = function startNext(index, ignoreIfExecuting) {
+  const chr = this.characteristics;
+  const content = chr.next(index);
+  if (!content) return;
 
-    function getCharacteristics() {
-      if (loopSettings) return loopSettings;
-      const collection = getCollection();
-      const cardinality = getCardinality(collection);
-      const messageContent = { ...(0, _messageHelper.cloneContent)(executeMessage.content),
-        loopCardinality: cardinality,
-        isSequential,
-        output: undefined
-      };
-
-      if (cardinality !== undefined && isNaN(cardinality) || cardinality < 0) {
-        return activity.emitFatal(new _Errors.ActivityError(`<${id}> invalid loop cardinality >${cardinality}<`, executeMessage), messageContent);
-      }
-
-      const output = executeMessage.content.output || [];
-      const parent = (0, _messageHelper.unshiftParent)(executeMessage.content.parent, executeMessage.content);
-      loopSettings = {
-        cardinality,
-        collection,
-        messageContent,
-        output,
-        parent,
-
-        getContent() {
-          return (0, _messageHelper.cloneContent)(messageContent);
-        }
-
-      };
-      return loopSettings;
+  if (chr.isStartConditionMet({
+    content
+  })) {
+    chr.debug('start condition met');
+    return;
+  }
+
+  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;
+}
+
+ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage) {
+  const chr = this.characteristics;
+  if (!chr.cardinality) throw new _Errors.RunError(`<${this.id}> cardinality or collection is required in parallel loops`, executeMessage);
+  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;
+  return this._startBatch();
+};
+
+ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
+  const chr = this.characteristics;
+  const cardinality = chr.cardinality;
+  const batch = [];
+  let startContent = chr.next(this.index);
+
+  do {
+    chr.debug(`start parallel iteration index ${this.index}`);
+    batch.push(startContent);
+    this.running++;
+    this.index++;
+
+    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);
+  }
+};
 
-    function getCardinality(collection) {
-      const collectionLen = Array.isArray(collection) ? collection.length : undefined;
+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);
+  }
 
-      if (!loopCardinality) {
-        return collectionLen;
-      }
+  if (chr.isCompletionConditionMet(message)) {
+    return chr.complete(content);
+  }
 
-      const value = environment.resolveExpression(loopCardinality, executeMessage);
-      if (value === undefined) return collectionLen;
-      return Number(value);
-    }
+  if (this.running <= 0) {
+    this.running = 0;
 
-    function getCollection() {
-      if (!collectionExpression) return;
-      debug(`<${id}> has collection`);
-      return environment.resolveExpression(collectionExpression, executeMessage);
-    }
+    this._startBatch();
+  }
+};
+
+function Characteristics(activity, loopCharacteristics, executeMessage) {
+  this.activity = activity;
+  const behaviour = this.behaviour = loopCharacteristics.behaviour || {};
+  this.message = executeMessage;
+  const type = this.type = loopCharacteristics.type || 'LoopCharacteristics';
+  this.id = activity.id;
+  this.broker = activity.broker;
+  this.parentExecutionId = executeMessage.content.executionId;
+  this.isSequential = behaviour.isSequential || false;
+  this.output = executeMessage.content.output || [];
+  this.parent = (0, _messageHelper.unshiftParent)(executeMessage.content.parent, executeMessage.content);
+  if ('loopCardinality' in behaviour) this.loopCardinality = behaviour.loopCardinality;else if ('loopMaximum' in behaviour) this.loopCardinality = behaviour.loopMaximum;
 
-    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 (behaviour.loopCondition) {
+    if (behaviour.testBefore) this.startCondition = behaviour.loopCondition;else this.completionCondition = behaviour.loopCondition;
   }
 
-  function onApiMessage(_, message) {
-    switch (message.properties.type) {
-      case 'stop':
-      case 'discard':
-        stop();
-        break;
-    }
+  if (behaviour.completionCondition) {
+    this.completionCondition = behaviour.completionCondition;
+  }
+
+  const collection = this.collection = this.getCollection();
+
+  if (collection) {
+    this.elementVariable = behaviour.elementVariable || 'item';
+  }
+
+  this.cardinality = this.getCardinality(collection);
+  this.onApiMessage = this.onApiMessage.bind(this);
+  const environment = activity.environment;
+  this.logger = environment.Logger(type.toLowerCase());
+  this.batchSize = environment.settings.batchSize || 50;
+}
+
+Characteristics.prototype.getContent = function getContent() {
+  return { ...(0, _messageHelper.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: (0, _messageHelper.cloneParent)(this.parent),
+    index
+  };
+
+  if (collection) {
+    content[this.elementVariable] = collection[index];
+  }
+
+  return content;
+};
+
+Characteristics.prototype.getCardinality = function getCardinality(collection) {
+  const collectionLen = this.collection && Array.isArray(collection) ? collection.length : undefined;
+
+  if (!this.loopCardinality) {
+    return collectionLen;
   }
 
-  function stop() {
-    broker.cancel(executeConsumerTag);
-    broker.cancel(apiConsumerTag);
+  const value = this.activity.environment.resolveExpression(this.loopCardinality, this.message);
+
+  if (value !== undefined && isNaN(value) || value < 0) {
+    throw new _Errors.RunError(`<${this.id}> invalid loop cardinality >${value}<`, this.message);
   }
 
-  function isConditionMet(condition, message, loopOutput) {
-    if (!condition) return false;
-    const testContext = (0, _messageHelper.cloneMessage)(message, {
-      loopOutput
-    });
-    return environment.resolveExpression(condition, testContext);
+  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, (0, _messageHelper.cloneMessage)(message));
+};
+
+Characteristics.prototype.isCompletionConditionMet = function isCompletionConditionMet(message) {
+  if (!this.completionCondition) return false;
+  return this.activity.environment.resolveExpression(this.completionCondition, (0, _messageHelper.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);
+    }
+  }
+};
+
+Characteristics.prototype.onApiMessage = function onApiMessage(_, message) {
+  switch (message.properties.type) {
+    case 'stop':
+    case 'discard':
+      this.stop();
+      break;
   }
-}
+};
+
+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}`);
+};