bpmn-elements 6.0.1 → 7.0.0

package/src/eventDefinitions/ConditionalEventDefinition.js

@@ -1,127 +1,170 @@
 import {cloneContent, shiftParent} from '../messageHelper';
+import {ActivityError} from '../error/Errors';
+
+const executeMessageSymbol = Symbol.for('executeMessage');
 
 export default function ConditionalEventDefinition(activity, eventDefinition) {
   const {id, broker, environment, attachedTo} = activity;
-  const {type = 'ConditionalEventDefinition', behaviour = {}} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const condition = behaviour.expression;
-  const isWaiting = !attachedTo;
 
-  const source = {
-    type,
-    condition,
-    execute,
-  };
+  const {type = 'ConditionalEventDefinition', behaviour = {}} = eventDefinition;
 
-  return source;
+  this.id = id;
+  this.type = type;
+  this.isWaiting = !attachedTo;
+  this.condition = behaviour.expression;
+  this.activity = activity;
+  this.environment = environment;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
+}
 
-  function execute(executeMessage) {
-    return isWaiting ? executeWait(executeMessage) : executeCatch(executeMessage);
+const proto = ConditionalEventDefinition.prototype;
+
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  },
+});
+
+proto.execute = function execute(executeMessage) {
+  this[executeMessageSymbol] = executeMessage;
+  return this.isWaiting ? this.executeWait(executeMessage) : this.executeCatch(executeMessage);
+};
+
+proto.executeWait = function executeWait(executeMessage) {
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+  const parentExecutionId = parent.executionId;
+
+  if (this._evaluateWait(executeMessage)) return;
+
+  const broker = this.broker;
+  const onApiMessage = this._onWaitApiMessage.bind(this);
+  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+  });
+  broker.subscribeTmp('api', `activity.signal.${parentExecutionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_parent-signal-${executionId}`,
+  });
+
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    condition: this.condition,
+  });
+  waitContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.wait', waitContent);
+};
+
+proto.executeCatch = function executeCatch(executeMessage) {
+  const executeContent = executeMessage.content;
+  const {executionId, index} = executeContent;
+
+  this.broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}_${index}`,
+  });
+
+  const {id: attachedToId, broker: attachedToBroker} = this.activity.attachedTo;
+
+  this._debug(`listen for execute completed from <${attachedToId}>`);
+
+  attachedToBroker.subscribeOnce('execution', 'execute.completed', this._onAttachedCompleted.bind(this), {
+    priority: 300,
+    consumerTag: `_onend-${executionId}_${index}`,
+  });
+};
+
+proto._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'signal': {
+      return this._evaluateWait(message);
+    }
+    case 'discard': {
+      this._stopWait();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content, {state: 'discard'}));
+    }
+    case 'stop': {
+      return this._stopWait();
+    }
   }
+};
 
-  function executeCatch(executeMessage) {
-    const attachedToBroker = attachedTo.broker;
-    const messageContent = cloneContent(executeMessage.content);
-
-    const {executionId, index} = messageContent;
-    messageContent.condition = condition;
-
-    const apiConsumerTag = `_api-${executionId}_${index}`;
-    const endConsumerTag = `_onend-${executionId}_${index}`;
+proto._evaluateWait = function evaluate(message) {
+  const executeMessage = this[executeMessageSymbol];
+  const broker = this.broker, executeContent = executeMessage.content;
 
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: apiConsumerTag});
+  try {
+    var output = this.environment.resolveExpression(this.condition, message); // eslint-disable-line no-var
+  } catch (err) {
+    return broker.publish('execution', 'execute.error', cloneContent(executeContent, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
+  }
 
-    debug(`<${executionId} (${id})> listen for execute completed from <${attachedTo.id}>`);
-    attachedToBroker.subscribeOnce('execution', 'execute.completed', onAttachedCompleted, {priority: 300, consumerTag: endConsumerTag});
+  this._debug(`condition evaluated to ${!!output}`);
 
-    function onAttachedCompleted(routingKey, endMessage) {
-      stop();
+  broker.publish('event', 'activity.condition', cloneContent(executeContent, {
+    conditionResult: output,
+  }));
 
-      const output = environment.resolveExpression(condition, endMessage);
-      debug(`<${executionId} (${id})> condition from <${endMessage.content.executionId}> evaluated to`, !!output);
+  if (!output) return;
+  this._stopWait();
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output}));
+};
 
-      broker.publish('event', 'activity.condition', {
-        ...cloneContent(messageContent),
-        conditionResult: output,
-      });
+proto._stopWait = function stopWait() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_parent-signal-${executionId}`);
+};
 
-      if (output) {
-        broker.publish('execution', 'execute.completed', {
-          ...messageContent,
-          output,
-        });
-      }
-    }
+proto._onAttachedCompleted = function onAttachedCompleted(routingKey, message) {
+  this._stopCatch();
 
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-      switch (messageType) {
-        case 'discard': {
-          stop();
-          debug(`<${executionId} (${id})> discarded`);
-          return broker.publish('execution', 'execute.discard', {...messageContent, state: 'discard'});
-        }
-        case 'stop': {
-          stop();
-          return debug(`<${executionId} (${id})> stopped`);
-        }
-      }
-    }
-
-    function stop() {
-      attachedToBroker.cancel(endConsumerTag);
-      broker.cancel(apiConsumerTag);
-    }
+  const executeMessage = this[executeMessageSymbol];
+  const broker = this.broker, executeContent = executeMessage.content;
+  try {
+    var output = this.environment.resolveExpression(this.condition, message); // eslint-disable-line no-var
+  } catch (err) {
+    return broker.publish('execution', 'execute.error', cloneContent(executeContent, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
   }
 
-  function executeWait(executeMessage) {
-    const messageContent = cloneContent(executeMessage.content);
-    messageContent.condition = condition;
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    if (evaluate(executeMessage)) return;
-
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
-    broker.subscribeTmp('api', `activity.signal.${parentExecutionId}`, onApiMessage, {noAck: true, consumerTag: `_parent-signal-${executionId}`});
-
-    broker.publish('event', 'activity.wait', {...cloneContent(messageContent), executionId: parentExecutionId, parent: shiftParent(parent)});
-
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-
-      switch (messageType) {
-        case 'signal': {
-          return evaluate(message);
-        }
-        case 'discard': {
-          stop();
-          return broker.publish('execution', 'execute.discard', {...messageContent, state: 'discard'});
-        }
-        case 'stop': {
-          stop();
-          break;
-        }
-      }
-    }
-
-    function evaluate(message) {
-      const output = environment.resolveExpression(condition, message);
-      debug(`<${executionId} (${id})> condition evaluated to`, !!output);
+  this._debug(`condition from <${message.content.executionId}> evaluated to ${!!output}`);
 
-      broker.publish('event', 'activity.condition', {
-        ...cloneContent(messageContent),
-        conditionResult: output,
-      });
+  broker.publish('event', 'activity.condition', cloneContent(executeContent, {
+    conditionResult: output,
+  }));
 
-      if (!output) return;
-      stop();
-      return broker.publish('execution', 'execute.completed', {...messageContent, output});
+  if (output) {
+    broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output}));
+  }
+};
+
+proto._onCatchApiMessage = function onCatchApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+  switch (messageType) {
+    case 'discard': {
+      this._stopCatch();
+      this._debug('discarded');
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content, {state: 'discard'}));
     }
-
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_parent-signal-${executionId}`);
+    case 'stop': {
+      this._stopCatch();
+      return this._debug('stopped');
     }
   }
-}
+};
+
+proto._stopCatch = function stopCatch() {
+  const {executionId, index} = this[executeMessageSymbol].content;
+  this.activity.attachedTo.broker.cancel(`_onend-${executionId}_${index}`);
+  this.broker.cancel(`_api-${executionId}_${index}`);
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};

package/src/eventDefinitions/ErrorEventDefinition.js

@@ -1,160 +1,219 @@
 import {brokerSafeId} from '../shared';
 import {cloneContent, shiftParent} from '../messageHelper';
 
+const completedSymbol = Symbol.for('completed');
+const messageQSymbol = Symbol.for('messageQ');
+const executeMessageSymbol = Symbol.for('executeMessage');
+const referenceElementSymbol = Symbol.for('referenceElement');
+const referenceInfoSymbol = Symbol.for('referenceInfo');
+
 export default function ErrorEventDefinition(activity, eventDefinition) {
-  const {id, broker, environment, getActivityById, isThrowing} = activity;
+  const {id, broker, environment, isThrowing} = activity;
   const {type = 'ErrorEventDefinition', behaviour = {}} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const reference = behaviour.errorRef || {name: 'anonymous'};
-  const referenceElement = reference.id && getActivityById(reference.id);
-  const errorId = referenceElement ? referenceElement.id : 'anonymous';
-  const errorQueueName = `error-${brokerSafeId(id)}-${brokerSafeId(errorId)}-q`;
-
-  if (!isThrowing) setupCatch();
-
-  const source = {
-    type,
-    reference: {...reference, referenceType: 'throw'},
-    execute: isThrowing ? executeThrow : executeCatch,
-  };
-
-  return source;
-
-  function executeCatch(executeMessage) {
-    let completed;
 
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
+  this.id = id;
+  this.type = type;
 
-    const {message: referenceMessage, description} = resolveMessage(executeMessage);
-    broker.consume(errorQueueName, onThrowApiMessage, {noAck: true, consumerTag: `_onthrow-${executionId}`});
+  const reference = this.reference = {
+    name: 'anonymous',
+    ...behaviour.errorRef,
+    referenceType: 'throw',
+  };
 
-    if (completed) return;
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  this.environment = environment;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
+
+  const referenceElement = this[referenceElementSymbol] = reference.id && activity.getActivityById(reference.id);
+  if (!isThrowing) {
+    this[completedSymbol] = false;
+    const referenceId = referenceElement ? referenceElement.id : 'anonymous';
+    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
+    this[messageQSymbol] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 300});
+  }
+}
 
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
+const proto = ErrorEventDefinition.prototype;
 
-    if (!environment.settings.strict) {
-      const expectRoutingKey = `execute.throw.${executionId}`;
-      broker.publish('execution', 'execute.expect', {...cloneContent(messageContent), expectRoutingKey, expect: {...referenceMessage}});
-      broker.subscribeOnce('execution', expectRoutingKey, onErrorMessage, {consumerTag: `_onerror-${executionId}`});
-    }
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  },
+});
 
-    if (completed) return stop();
+proto.execute = function execute(executeMessage) {
+  return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
+};
 
-    debug(`<${executionId} (${id})> expect ${description}`);
+proto.executeCatch = function executeCatch(executeMessage) {
+  this[executeMessageSymbol] = executeMessage;
+  this[completedSymbol] = false;
 
-    broker.publish('event', 'activity.wait', {
-      ...messageContent,
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      expect: {...referenceMessage},
-    });
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+  const parentExecutionId = parent && parent.executionId;
 
-    function onErrorMessage(routingKey, message) {
-      const error = message.content.error;
-      if (!referenceElement) return catchError(routingKey, message, error);
+  const info = this[referenceInfoSymbol] = this._getReferenceInfo(executeMessage);
 
-      if (!error) return;
+  this[messageQSymbol].consume(this._onThrowApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_onthrow-${executionId}`,
+  });
 
-      if (('' + error.code) !== ('' + referenceMessage.code)) return;
+  if (this[completedSymbol]) return;
 
-      return catchError(routingKey, message, error);
-    }
+  this._debug(`expect ${info.description}`);
 
-    function onThrowApiMessage(routingKey, message) {
-      const error = message.content.message;
-      if (!referenceElement) return catchError(routingKey, message, error);
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+  });
 
-      if (referenceMessage.id !== (error && error.id)) return;
-      return catchError(routingKey, message, error);
-    }
+  if (!this.environment.settings.strict) {
+    const expectRoutingKey = `execute.throw.${executionId}`;
+    broker.subscribeTmp('execution', expectRoutingKey, this._onErrorMessage.bind(this), {
+      noAck: true,
+      consumerTag: `_onerror-${executionId}`,
+    });
+    broker.publish('execution', 'execute.expect', cloneContent(executeContent, {
+      expectRoutingKey,
+      expect: {...info.message},
+    }));
 
-    function catchError(routingKey, message, error) {
-      completed = true;
-
-      stop();
-
-      debug(`<${executionId} (${id})> caught ${description}`);
-      broker.publish('event', 'activity.catch', {
-        ...messageContent,
-        source: {
-          id: message.content.id,
-          type: message.content.type,
-          executionId: message.content.executionId,
-        },
-        error,
-        executionId: parentExecutionId,
-        parent: shiftParent(executeMessage.content.parent),
-      }, {type: 'catch'});
-
-      return broker.publish('execution', 'execute.completed', {...messageContent, output: error, cancelActivity: true, state: 'catch'});
-    }
+    if (this[completedSymbol]) return this._stop();
+  }
 
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-
-      switch (messageType) {
-        case 'discard': {
-          completed = true;
-          stop();
-          return broker.publish('execution', 'execute.discard', cloneContent(messageContent));
-        }
-        case 'stop': {
-          stop();
-          break;
-        }
-      }
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    expect: {...info.message},
+  });
+  waitContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.wait', waitContent);
+};
+
+proto.executeThrow = function executeThrow(executeMessage) {
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+
+  const info = this._getReferenceInfo(executeMessage);
+
+  this.logger.debug(`<${executionId} (${this.activity.id})> throw ${info.description}`);
+
+  const broker = this.broker;
+  const throwContent = cloneContent(executeContent, {
+    executionId: parent.executionId,
+    message: {...info.message},
+    state: 'throw',
+  });
+  throwContent.parent = shiftParent(parent);
+
+  this.broker.publish('event', 'activity.throw', throwContent, {type: 'throw', delegate: true});
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {
+    message: {...info.message},
+  }));
+};
+
+proto._onErrorMessage = function onErrorMessage(routingKey, message) {
+  const error = message.content.error;
+  if (!this[referenceElementSymbol]) return this._catchError(routingKey, message, error);
+
+  if (!error) return;
+
+  const info = this[referenceInfoSymbol];
+  if (('' + error.code) !== ('' + info.message.code)) return;
+
+  return this._catchError(routingKey, message, error);
+};
+
+proto._onThrowApiMessage = function onThrowApiMessage(routingKey, message) {
+  const error = message.content.message;
+  if (!this[referenceElementSymbol]) return this._catchError(routingKey, message, error);
+
+  const info = this[referenceInfoSymbol];
+  if (info.message.id !== (error && error.id)) return;
+  return this._catchError(routingKey, message, error);
+};
+
+proto._catchError = function catchError(routingKey, message, error) {
+  this[completedSymbol] = true;
+
+  this._stop();
+
+  this._debug(`caught ${this[referenceInfoSymbol].description}`);
+
+  const executeContent = this[executeMessageSymbol].content;
+  const parent = executeContent.parent;
+  const catchContent = cloneContent(executeContent, {
+    source: {
+      id: message.content.id,
+      type: message.content.type,
+      executionId: message.content.executionId,
+    },
+    error,
+    executionId: parent.executionId,
+  });
+  catchContent.parent = shiftParent(parent);
+
+  const broker = this.broker;
+  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {
+    output: error,
+    cancelActivity: true,
+    state: 'catch',
+  }));
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'discard': {
+      this[completedSymbol] = true;
+      this._stop();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content));
     }
-
-    function stop() {
-      broker.cancel(`_onthrow-${executionId}`);
-      broker.cancel(`_onerror-${executionId}`);
-      broker.cancel(`_api-${executionId}`);
-      broker.purgeQueue(errorQueueName);
+    case 'stop': {
+      this._stop();
+      break;
     }
   }
-
-  function executeThrow(executeMessage) {
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    const {message: referenceMessage, description} = resolveMessage(executeMessage);
-
-    debug(`<${executionId} (${id})> throw ${description}`);
-
-    broker.publish('event', 'activity.throw', {
-      ...cloneContent(messageContent),
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      message: {...referenceMessage},
-      state: 'throw',
-    }, {type: 'throw', delegate: true});
-
-    return broker.publish('execution', 'execute.completed', {...messageContent, message: referenceMessage});
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_onthrow-${executionId}`);
+  broker.cancel(`_onerror-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+  this[messageQSymbol].purge();
+};
+
+proto._getReferenceInfo = function getReferenceInfo(message) {
+  const referenceElement = this[referenceElementSymbol];
+  if (!referenceElement) {
+    return {
+      message: {...this.reference},
+      description: 'anonymous error',
+    };
   }
 
-  function resolveMessage(message) {
-    if (!referenceElement) {
-      return {
-        message: {...reference},
-        description: 'anonymous error',
-      };
-    }
+  const result = {
+    message: referenceElement.resolve(message),
+  };
 
-    const result = {
-      message: referenceElement.resolve(message),
-    };
+  result.description = `${result.message.name} <${result.message.id}>`;
+  if (result.message.code) result.description += ` code ${result.message.code}`;
 
-    result.description = `${result.message.name} <${result.message.id}>`;
-    if (result.message.code) result.description += ` code ${result.message.code}`;
+  return result;
+};
 
-    return result;
-  }
-
-  function setupCatch() {
-    broker.assertQueue(errorQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(errorQueueName, 'api', '*.throw.#', {durable: true, priority: 300});
-  }
-}
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};