bpmn-elements 5.1.3 → 7.0.0

package/src/eventDefinitions/EscalationEventDefinition.js

@@ -2,134 +2,172 @@ import getPropertyValue from '../getPropertyValue';
 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('reference');
+
 export default function EscalationEventDefinition(activity, eventDefinition) {
-  const {id, broker, environment, isThrowing, getActivityById} = activity;
+  const {id, broker, environment, isThrowing} = activity;
   const {type, behaviour = {}} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const reference = behaviour.escalationRef || {name: 'anonymous'};
-  const referenceElement = reference.id && getActivityById(reference.id);
-  const escalationId = referenceElement ? referenceElement.id : 'anonymous';
-  const escalationQueueName = `escalate-${brokerSafeId(id)}-${brokerSafeId(escalationId)}-q`;
-
-  if (!isThrowing) setupCatch();
-
-  const source = {
-    id,
-    type,
-    reference: {...reference, referenceType: 'escalate'},
-    execute: isThrowing ? executeThrow : executeCatch,
+
+  this.id = id;
+  this.type = type;
+
+  const reference = this.reference = {
+    name: 'anonymous',
+    ...behaviour.escalationRef,
+    referenceType: 'escalate',
   };
 
-  return source;
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  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: 400});
+  }
+}
 
-  function executeCatch(executeMessage) {
-    let completed;
+const proto = EscalationEventDefinition.prototype;
 
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  },
+});
 
-    const {message: referenceMessage, description} = resolveMessage(executeMessage);
-    broker.consume(escalationQueueName, onEscalationApiMessage, {noAck: true, consumerTag: `_onescalate-${executionId}`});
+proto.execute = function execute(executeMessage) {
+  return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
+};
 
-    if (completed) return;
+proto.executeCatch = function executeCatch(executeMessage) {
+  this[executeMessageSymbol] = executeMessage;
+  this[completedSymbol] = false;
 
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
 
-    if (completed) return stop();
+  const info = this[referenceInfoSymbol] = this._getReferenceInfo(executeMessage);
+  const broker = this.broker;
+  this[messageQSymbol].consume(this._onCatchMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_onescalate-${executionId}`,
+  });
 
-    debug(`<${executionId} (${id})> expect ${description}`);
+  if (this[completedSymbol]) return;
 
-    broker.publish('event', 'activity.wait', {
-      ...messageContent,
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      escalation: {...referenceMessage},
-    });
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+  });
 
-    function onEscalationApiMessage(routingKey, message) {
-      if (getPropertyValue(message, 'content.message.id') !== referenceMessage.id) return;
+  this._debug(`expect ${info.description}`);
 
-      const output = message.content.message;
-      completed = true;
+  const waitContent = cloneContent(executeContent, {
+    executionId: parent.executionId,
+    parent: shiftParent(parent),
+    escalation: {...info.message},
+  });
+  waitContent.parent = shiftParent(parent);
 
-      stop();
+  broker.publish('event', 'activity.wait', waitContent);
+};
 
-      debug(`<${executionId} (${id})> caught ${description}`);
-      broker.publish('event', 'activity.catch', {
-        ...messageContent,
-        message: {...output},
-        executionId: parentExecutionId,
-        parent: shiftParent(executeMessage.content.parent),
-      }, {type: 'catch'});
+proto.executeThrow = function executeThrow(executeMessage) {
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
 
-      return broker.publish('execution', 'execute.completed', {...messageContent, output, state: 'catch'});
-    }
+  const info = this._getReferenceInfo(executeMessage);
+  this.logger.debug(`<${executionId} (${this.activity.id})> escalate ${info.description}`);
 
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-
-      switch (messageType) {
-        case 'escalate': {
-          return onEscalationApiMessage(routingKey, message);
-        }
-        case 'discard': {
-          completed = true;
-          stop();
-          return broker.publish('execution', 'execute.discard', {...messageContent});
-        }
-        case 'stop': {
-          stop();
-          break;
-        }
-      }
-    }
+  const broker = this.broker;
+  const throwContent = cloneContent(executeContent, {
+    executionId: parent.executionId,
+    message: info.message,
+    state: 'throw',
+  });
+  throwContent.parent = shiftParent(parent);
 
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_onescalate-${executionId}`);
-    }
-  }
+  broker.publish('event', 'activity.escalate', throwContent, {type: 'escalate', delegate: true});
 
-  function executeThrow(executeMessage) {
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
+};
 
-    const {message: referenceMessage, description} = resolveMessage(executeMessage);
+proto._onCatchMessage = function onCatchMessage(routingKey, message) {
+  const info = this[referenceInfoSymbol];
+  if (getPropertyValue(message, 'content.message.id') !== info.message.id) return;
 
-    debug(`<${executionId} (${id})> escalate ${description}`);
+  const output = message.content.message;
+  this[completedSymbol] = true;
 
-    broker.publish('event', 'activity.escalate', {
-      ...cloneContent(messageContent),
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      message: {...referenceMessage},
-      state: 'throw',
-    }, {type: 'escalate', delegate: true});
+  this._stop();
 
-    return broker.publish('execution', 'execute.completed', {...messageContent});
-  }
+  this._debug(`caught ${info.description}`);
 
-  function resolveMessage(message) {
-    if (!referenceElement) {
-      return {
-        message: {...reference},
-        description: 'anonymous escalation',
-      };
-    }
+  const executeContent = this[executeMessageSymbol].content;
+  const {parent, ...content} = executeContent;
+  const catchContent = cloneContent(content, {
+    message: {...output},
+    executionId: parent.executionId,
+  });
+  catchContent.parent = shiftParent(parent);
 
-    const result = {
-      message: referenceElement.resolve(message),
-    };
+  const broker = this.broker;
+  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
 
-    result.description = `${result.message.name} <${result.message.id}>`;
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output, state: 'catch'}));
+};
 
-    return result;
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  switch (message.properties.type) {
+    case 'escalate': {
+      return this._onCatchMessage(routingKey, message);
+    }
+    case 'discard': {
+      this[completedSymbol] = true;
+      this._stop();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content));
+    }
+    case 'stop': {
+      this._stop();
+      break;
+    }
   }
-
-  function setupCatch() {
-    broker.assertQueue(escalationQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(escalationQueueName, 'api', '*.escalate.#', {durable: true, priority: 400});
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_onescalate-${executionId}`);
+};
+
+proto._getReferenceInfo = function getReferenceInfo(message) {
+  const referenceElement = this[referenceElementSymbol];
+  if (!referenceElement) {
+    return {
+      message: {...this.reference},
+      description: 'anonymous escalation',
+    };
   }
-}
+
+  const result = {
+    message: referenceElement.resolve(message),
+  };
+
+  result.description = `${result.message.name} <${result.message.id}>`;
+
+  return result;
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};

package/src/eventDefinitions/EventDefinitionExecution.js

@@ -1,113 +1,145 @@
-import {cloneContent, unshiftParent, shiftParent} from '../messageHelper';
+import {cloneContent, unshiftParent, shiftParent, cloneParent} from '../messageHelper';
+
+const completedSymbol = Symbol.for('completed');
+const executeMessageSymbol = Symbol.for('executeMessage');
+const stoppedSymbol = Symbol.for('stopped');
 
 export default function EventDefinitionExecution(activity, eventDefinitions, completedRoutingKey = 'execute.completed') {
-  const {id, broker, logger} = activity;
-  const executeConsumerTag = '_eventdefinition-execution-execute-tag';
-  const apiConsumerTag = '_eventdefinition-execution-api-tag';
+  this.id = activity.id;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this.eventDefinitions = eventDefinitions;
+  this.completedRoutingKey = completedRoutingKey;
+  this[completedSymbol] = false;
+  this[stoppedSymbol] = false;
+  this[executeMessageSymbol] = null;
+}
 
-  let parentExecutionContent, parent, completed = false, stopped = false;
+const proto = EventDefinitionExecution.prototype;
 
-  return {
-    execute,
-    get completed() {
-      return completed;
-    },
-  };
+Object.defineProperty(proto, 'completed', {
+  enumerable: true,
+  get() {
+    return this[completedSymbol];
+  },
+});
 
-  function execute(executeMessage) {
-    const executeContent = executeMessage.content;
-    const isRedelivered = executeMessage.fields.redelivered;
-    const {isRootScope, isDefinitionScope, executionId: messageExecutionId} = executeContent;
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
+  get() {
+    return this[stoppedSymbol];
+  },
+});
 
-    if (isDefinitionScope) return executeDefinition();
+proto.execute = function execute(executeMessage) {
+  const content = executeMessage.content;
 
-    let parentExecutionId;
-    if (isRootScope) {
-      parentExecutionId = messageExecutionId;
-      parentExecutionContent = executeContent;
+  if (content.isDefinitionScope) return this._executeDefinition(executeMessage);
+  if (!content.isRootScope) return;
 
-      broker.subscribeTmp('execution', 'execute.#', onExecuteMessage, {noAck: true, consumerTag: executeConsumerTag, priority: 300});
-      broker.subscribeTmp('api', `activity.*.${parentExecutionId}`, onApiMessage, {noAck: true, consumerTag: apiConsumerTag, priority: 300});
+  const broker = this.broker;
 
-      parent = unshiftParent(parentExecutionContent.parent, parentExecutionContent);
-      broker.publish('execution', 'execute.update', {...cloneContent(parentExecutionContent), preventComplete: true});
-    }
-    if (isRedelivered) return;
-
-    for (let index = 0; index < eventDefinitions.length; ++index) {
-      if (completed) break;
-      if (stopped) break;
-
-      const ed = eventDefinitions[index];
-      const executionId = `${messageExecutionId}_${index}`;
-
-      logger.debug(`<${messageExecutionId} (${id})> start event definition ${ed.type}, index ${index}`);
-
-      broker.publish('execution', 'execute.start', {
-        ...cloneContent(parentExecutionContent),
-        isRootScope: undefined,
-        type: ed.type,
-        executionId,
-        isDefinitionScope: true,
-        index,
-        parent,
-      });
-    }
+  this[executeMessageSymbol] = executeMessage;
+  const executionId = content.executionId;
 
-    function onApiMessage(_, message) {
-      const messageType = message.properties.type;
-      switch (messageType) {
-        case 'stop':
-          stopped = true;
-        case 'discard':
-          return stop();
-      }
-    }
+  broker.subscribeTmp('execution', 'execute.#', this._onExecuteMessage.bind(this), {
+    noAck: true,
+    consumerTag: '_eventdefinition-execution-execute-tag',
+    priority: 300,
+  });
+  broker.subscribeTmp('api', `activity.*.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: '_eventdefinition-execution-api-tag',
+    priority: 300,
+  });
 
-    function onExecuteMessage(routingKey, message) {
-      const {correlationId} = message.properties;
-      switch (routingKey) {
-        case 'execute.completed': {
-          stop();
-          if (message.content.isDefinitionScope) return complete();
-          break;
-        }
-        case 'execute.discard': {
-          if (message.content.isDefinitionScope) {
-            logger.debug(`<${message.content.executionId} (${id})> event definition ${message.content.type} discarded, index ${message.content.index}`);
-            break;
-          }
-          stop();
-          logger.debug(`<${message.content.executionId} (${id})> event definition parent execution discarded`);
-          break;
-        }
-      }
+  broker.publish('execution', 'execute.update', cloneContent(content, {preventComplete: true}));
 
-      function complete() {
-        const content = cloneContent(message.content);
-        completed = true;
+  if (executeMessage.fields.redelivered) return;
 
-        logger.debug(`<${content.executionId} (${id})> event definition ${content.type} completed, index ${content.index}`);
+  const parent = unshiftParent(content.parent, content);
+  const eventDefinitions = this.eventDefinitions;
 
-        broker.publish('execution', completedRoutingKey, {
-          ...cloneContent(content),
-          executionId: parentExecutionId,
-          isRootScope: true,
-          parent: shiftParent(content.parent),
-        }, {correlationId});
-      }
-    }
+  for (let index = 0; index < eventDefinitions.length; ++index) {
+    if (this[completedSymbol]) break;
+    if (this[stoppedSymbol]) break;
 
-    function executeDefinition() {
-      const ed = eventDefinitions[executeContent.index];
-      if (!ed) return logger.warn(`<${messageExecutionId} (${id})> found no event definition on index ${executeContent.index}`);
-      logger.debug(`<${messageExecutionId} (${id})> execute event definition ${ed.type}, index ${executeContent.index}`);
-      ed.execute(executeMessage);
-    }
+    const ed = eventDefinitions[index];
+    const edExecutionId = `${executionId}_${index}`;
+
+    this._debug(executionId, `start event definition ${ed.type}, index ${index}`);
 
-    function stop() {
-      broker.cancel(executeConsumerTag);
-      broker.cancel(apiConsumerTag);
+    const edContent = cloneContent(content, {
+      isRootScope: undefined,
+      type: ed.type,
+      executionId: edExecutionId,
+      isDefinitionScope: true,
+      index,
+    });
+    edContent.parent = cloneParent(parent);
+
+    broker.publish('execution', 'execute.start', edContent);
+  }
+};
+
+proto._onApiMessage = function onApiMessage(_, message) {
+  const messageType = message.properties.type;
+  switch (messageType) {
+    case 'stop':
+    case 'discard':
+      return this._stop();
+  }
+};
+
+proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
+  switch (routingKey) {
+    case 'execute.completed': {
+      this._stop();
+      if (message.content.isDefinitionScope) return this._complete(message);
+      break;
+    }
+    case 'execute.discard': {
+      const {executionId, isDefinitionScope} = message.content;
+      if (isDefinitionScope) {
+        this._debug(executionId, `event definition ${message.content.type} discarded, index ${message.content.index}`);
+        break;
+      }
+      this._stop();
+      this._debug(executionId, 'event definition parent execution discarded');
+      break;
     }
   }
-}
+};
+
+proto._complete = function complete(message) {
+  const {executionId, type, index, parent} = message.content;
+  this[completedSymbol] = true;
+
+  this._debug(executionId, `event definition ${type} completed, index ${index}`);
+
+  const completeContent = cloneContent(message.content, {
+    executionId: this[executeMessageSymbol].content.executionId,
+    isRootScope: true,
+  });
+  completeContent.parent = shiftParent(parent);
+
+  this.broker.publish('execution', this.completedRoutingKey, completeContent, {correlationId: message.properties.correlationId});
+};
+
+proto._executeDefinition = function executeDefinition(message) {
+  const {executionId, index} = message.content;
+  const ed = this.eventDefinitions[index];
+  if (!ed) return this.activity.logger.warn(`<${executionId} (${this.id})> found no event definition on index ${index}`);
+  this._debug(executionId, `execute event definition ${ed.type}, index ${index}`);
+  ed.execute(message);
+};
+
+proto._stop = function stop() {
+  this[stoppedSymbol] = true;
+  this.broker.cancel('_eventdefinition-execution-execute-tag');
+  this.broker.cancel('_eventdefinition-execution-api-tag');
+};
+
+proto._debug = function debug(executionId, msg) {
+  this.activity.logger.debug(`<${executionId} (${this.id})> ${msg}`);
+};