bpmn-elements 5.1.3 → 7.0.0

package/src/eventDefinitions/LinkEventDefinition.js

@@ -2,142 +2,173 @@ 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');
+
 export default function LinkEventDefinition(activity, eventDefinition) {
   const {id, broker, environment, isThrowing} = activity;
-  const {type} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const reference = {linkName: eventDefinition.behaviour.name};
-  const linkQueueName = `link-${brokerSafeId(id)}-${brokerSafeId(reference.linkName)}-q`;
-
-  if (!isThrowing) setupCatch();
-  else setupThrow();
-
-  const source = {
-    id,
-    type,
-    reference: {...reference, referenceType: 'link'},
-    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;
+  const {type = 'LinkEventDefinition', behaviour} = eventDefinition;
 
-    const description = messageDescription();
-    broker.consume(linkQueueName, onCatchLink, {noAck: true, consumerTag: `_api-link-${executionId}`});
+  this.id = id;
+  this.type = type;
 
-    if (completed) return;
-
-    broker.subscribeTmp('api', `activity.stop.${parentExecutionId}`, onApiMessage, {noAck: true, consumerTag: `_api-parent-${parentExecutionId}`});
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
-
-    debug(`<${executionId} (${id})> expect ${description}`);
+  const reference = this.reference = {
+    linkName: behaviour.name,
+    referenceType: 'link',
+  };
 
-    broker.publish('event', 'activity.wait', {
-      ...messageContent,
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      link: {...reference},
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
+  this[completedSymbol] = false;
+
+  if (!isThrowing) {
+    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(reference.linkName)}-q`;
+    this[messageQSymbol] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true});
+  } else {
+    broker.subscribeTmp('event', 'activity.discard', this._onDiscard.bind(this), {
+      noAck: true,
+      consumerTag: '_link-parent-discard',
     });
-
-    function onCatchLink(routingKey, message) {
-      if (getPropertyValue(message, 'content.message.linkName') !== reference.linkName) return;
-      if (message.content.state === 'discard') return discard();
-      return complete('caught', message.content.message);
-    }
-
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-
-      switch (messageType) {
-        case 'link': {
-          return complete('got link with', message.content.message);
-        }
-        case 'discard': {
-          return discard();
-        }
-        case 'stop': {
-          stop();
-          break;
-        }
-      }
-    }
-
-    function complete(verb, output) {
-      completed = true;
-
-      stop();
-
-      debug(`<${executionId} (${id})> ${verb} ${description}`);
-
-      broker.publish('event', 'activity.catch', {
-        ...messageContent,
-        link: {...reference},
-        message: {...output},
-        executionId: parentExecutionId || executionId,
-        parent: shiftParent(executeMessage.content.parent),
-      }, {type: 'catch'});
-
-      return broker.publish('execution', 'execute.completed', {...messageContent, output, state: 'catch'});
-    }
-
-    function discard() {
-      completed = true;
-      stop();
-      return broker.publish('execution', 'execute.discard', {...messageContent});
-    }
-
-    function stop() {
-      broker.cancel(`_api-link-${executionId}`);
-      broker.cancel(`_api-parent-${parentExecutionId}`);
-      broker.cancel(`_api-${executionId}`);
-      broker.purgeQueue(linkQueueName);
-    }
-  }
-
-  function executeThrow(executeMessage) {
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    const description = messageDescription();
-
-    debug(`<${executionId} (${id})> throw ${description}`);
-
-    broker.publish('event', 'activity.link', {
-      ...cloneContent(messageContent),
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      message: {...reference},
-      state: 'throw',
-    }, {type: 'link', delegate: true});
-
-    return broker.publish('execution', 'execute.completed', messageContent);
-  }
-
-  function messageDescription() {
-    return `link ${reference.linkName}`;
-  }
-
-  function setupCatch() {
-    broker.assertQueue(linkQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(linkQueueName, 'api', '*.link.#', {durable: true});
   }
+}
 
-  function setupThrow() {
-    broker.subscribeTmp('event', 'activity.discard', onDiscard, {noAck: true, consumerTag: '_link-parent-discard'});
-
-    function onDiscard(_, message) {
-      broker.publish('event', 'activity.link.discard', {
-        ...cloneContent(message.content),
-        message: {...reference},
-        state: 'discard',
-      }, {type: 'link', delegate: true});
+const proto = LinkEventDefinition.prototype;
+
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  },
+});
+
+proto.execute = function execute(executeMessage) {
+  return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
+};
+
+proto.executeCatch = function executeCatch(executeMessage) {
+  this[executeMessageSymbol] = executeMessage;
+  this[completedSymbol] = false;
+
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+  const parentExecutionId = parent.executionId;
+
+  this[messageQSymbol].consume(this._onCatchLink.bind(this), {
+    noAck: true,
+    consumerTag: `_api-link-${executionId}`,
+  });
+
+  if (this[completedSymbol]) return;
+
+  const broker = this.broker;
+  const onApiMessage = this._onApiMessage.bind(this);
+  broker.subscribeTmp('api', `activity.stop.${parentExecutionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-parent-${executionId}`,
+  });
+  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+  });
+
+  this._debug(`expect link ${this.reference.linkName}`);
+
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    link: {...this.reference},
+  });
+  waitContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.wait', waitContent);
+};
+
+proto.executeThrow = function executeThrow(executeMessage) {
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+  const parentExecutionId = parent && parent.executionId;
+
+  this.logger.debug(`<${executionId} (${this.activity.id})> throw link ${this.reference.linkName}`);
+
+  const broker = this.broker;
+  const linkContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    message: {...this.reference},
+    state: 'throw',
+  });
+  linkContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.link', linkContent, {type: 'link', delegate: true});
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
+};
+
+proto._onCatchLink = function onCatchLink(routingKey, message) {
+  if (getPropertyValue(message, 'content.message.linkName') !== this.reference.linkName) return;
+  if (message.content.state === 'discard') return this._discard();
+  return this._complete('caught', message.content.message);
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'discard': {
+      return this._discard();
+    }
+    case 'stop': {
+      this._stop();
+      break;
     }
   }
-}
+};
+
+proto._complete = function complete(verb, output) {
+  this[completedSymbol] = true;
+
+  this._stop();
+
+  this._debug(`${verb} link ${this.reference.linkName}`);
+
+  const executeContent = this[executeMessageSymbol].content;
+  const parent = executeContent.parent;
+  const catchContent = cloneContent(executeContent, {
+    link: {...this.reference},
+    message: {...output},
+    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, state: 'catch'}));
+};
+
+proto._discard = function discard() {
+  this[completedSymbol] = true;
+  this._stop();
+  return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content));
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-link-${executionId}`);
+  broker.cancel(`_api-parent-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+  this[messageQSymbol].purge();
+};
+
+proto._onDiscard = function onDiscard(_, message) {
+  this.broker.publish('event', 'activity.link.discard', cloneContent(message.content, {
+    message: {...this.reference},
+    state: 'discard',
+  }), {type: 'link', delegate: true});
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};

package/src/eventDefinitions/MessageEventDefinition.js

@@ -2,142 +2,199 @@ 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('referenceInfo');
+
 export default function MessageEventDefinition(activity, eventDefinition) {
-  const {id, broker, environment, isStart, isThrowing, getActivityById} = activity;
+  const {id, broker, environment, isThrowing} = activity;
   const {type = 'MessageEventDefinition', behaviour = {}} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const reference = behaviour.messageRef || {name: 'anonymous'};
-  const referenceElement = reference.id && getActivityById(reference.id);
-  const messageId = referenceElement ? referenceElement.id : 'anonymous';
-  const messageQueueName = `message-${brokerSafeId(id)}-${brokerSafeId(messageId)}-q`;
 
-  if (!isThrowing || isStart) setupCatch();
+  this.id = id;
+  this.type = type;
 
-  const source = {
-    id,
-    type,
-    reference: {...reference, referenceType: 'message'},
-    execute: isThrowing ? executeThrow : executeCatch,
+  const reference = this.reference = {
+    name: 'anonymous',
+    ...behaviour.messageRef,
+    referenceType: 'message',
   };
 
-  return source;
-
-  function executeCatch(executeMessage) {
-    let completed;
-
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    const {message: referenceMessage, description} = resolveReference(executeMessage);
-    broker.consume(messageQueueName, onCatchMessage, {noAck: true, consumerTag: `_onmessage-${executionId}`});
-
-    if (completed) return;
-
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`, priority: 400});
-    if (parentExecutionId) broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {noAck: true, consumerTag: `_api-parent-${executionId}`, priority: 400});
-    broker.subscribeTmp('api', '#.signal.*', onCatchMessage, {noAck: true, consumerTag: `_api-delegated-${executionId}`});
-
-    debug(`<${executionId} (${id})> expect ${description}`);
-
-    broker.publish('event', 'activity.wait', {
-      ...messageContent,
-      executionId: parentExecutionId || executionId,
-      parent: shiftParent(parent),
-      message: {...referenceMessage},
-    });
-
-    function onCatchMessage(routingKey, message) {
-      if (getPropertyValue(message, 'content.message.id') !== referenceMessage.id) return;
+  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});
+  }
+}
 
-      const {type: messageType, correlationId} = message.properties;
-      broker.publish('event', 'activity.consumed', cloneContent(messageContent, {message: {...message.content.message}}), {correlationId, type: messageType});
+const proto = MessageEventDefinition.prototype;
+
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  },
+});
+
+proto.execute = function execute(executeMessage) {
+  return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
+};
+
+proto.executeCatch = function executeCatch(executeMessage) {
+  this[executeMessageSymbol] = executeMessage;
+  this[completedSymbol] = false;
+
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+  const parentExecutionId = parent && parent.executionId;
+
+  const info = this[referenceInfoSymbol] = this._getReferenceInfo(executeMessage);
+  this._debug(`expect ${info.description}`);
+
+  const broker = this.broker;
+  const onCatchMessage = this._onCatchMessage.bind(this);
+  this[messageQSymbol].consume(onCatchMessage, {
+    noAck: true,
+    consumerTag: `_api-message-${executionId}`,
+  });
+
+  if (this[completedSymbol]) return;
+
+  const onApiMessage = this._onApiMessage.bind(this);
+  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 400,
+  });
+  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-parent-${executionId}`,
+    priority: 400,
+  });
+  broker.subscribeTmp('api', '#.signal.*', onCatchMessage, {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
+  });
+
+  const waitContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    message: {...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})> message ${info.description}`);
+
+  const broker = this.broker;
+  const throwContent = cloneContent(executeContent, {
+    executionId: parent.executionId,
+    message: {...executeContent.input, ...info.message},
+    state: 'throw',
+  });
+  throwContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.message', throwContent, {type: 'message', delegate: true});
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
+};
+
+proto._onCatchMessage = function onCatchMessage(routingKey, message) {
+  if (getPropertyValue(message, 'content.message.id') !== this[referenceInfoSymbol].message.id) return;
+
+  const {type, correlationId} = message.properties;
+  this.broker.publish('event', 'activity.consumed', cloneContent(this[executeMessageSymbol].content, {
+    message: {...message.content.message},
+  }), {
+    correlationId,
+    type,
+  });
 
-      complete('caught', message.content.message, {correlationId});
-    }
+  this._complete('caught', message.content.message, {correlationId});
+};
 
-    function onApiMessage(routingKey, message) {
-      const {type: messageType, correlationId} = message.properties;
-      switch (messageType) {
-        case 'message':
-        case 'signal': {
-          return complete('got signal with', message.content.message, {correlationId});
-        }
-        case 'discard': {
-          completed = true;
-          stop();
-          return broker.publish('execution', 'execute.discard', {...messageContent}, {correlationId});
-        }
-        case 'stop': {
-          return stop();
-        }
-      }
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const {type, correlationId} = message.properties;
+  switch (type) {
+    case 'message':
+    case 'signal': {
+      return this._complete('got signal with', message.content.message, {correlationId});
     }
-
-    function complete(verb, output, options) {
-      completed = true;
-
-      stop();
-
-      debug(`<${executionId} (${id})> ${verb} ${description}`);
-      broker.publish('event', 'activity.catch', {
-        ...messageContent,
-        message: {...output},
-        executionId: parentExecutionId || executionId,
-        parent: shiftParent(executeMessage.content.parent),
-      }, {type: 'catch'});
-
-      return broker.publish('execution', 'execute.completed', {...messageContent, output, state: 'catch'}, options);
+    case 'discard': {
+      this[completedSymbol] = true;
+      this._stop();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[executeMessageSymbol].content), {correlationId});
     }
-
-    function stop() {
-      broker.cancel(`_onmessage-${executionId}`);
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_api-parent-${executionId}`);
-      broker.cancel(`_api-delegated-${executionId}`);
-      broker.purgeQueue(messageQueueName);
+    case 'stop': {
+      return this._stop();
     }
   }
-
-  function executeThrow(executeMessage) {
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    const {message: referenceMessage, description} = resolveReference(executeMessage);
-
-    debug(`<${executionId} (${id})> message ${description}`);
-
-    broker.publish('event', 'activity.message', {
-      ...cloneContent(messageContent),
-      executionId: parentExecutionId || executionId,
-      parent: shiftParent(parent),
-      message: {...messageContent.input, ...referenceMessage},
-      state: 'throw',
-    }, {type: 'message', delegate: true});
-
-    return broker.publish('execution', 'execute.completed', {...messageContent});
+};
+
+proto._complete = function complete(verb, output, options) {
+  this[completedSymbol] = true;
+
+  this._stop();
+  this._debug(`${verb} ${this[referenceInfoSymbol].description}`);
+
+  const broker = this.broker;
+  const executeContent = this[executeMessageSymbol].content;
+  const catchContent = cloneContent(executeContent, {
+    message: {...output},
+    executionId: executeContent.parent.executionId,
+  });
+  catchContent.parent = shiftParent(executeContent.parent);
+
+  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {
+    output,
+    state: 'catch',
+  }), options);
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-message-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_api-parent-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
+  this[messageQSymbol].purge();
+};
+
+proto._getReferenceInfo = function getReferenceInfo(message) {
+  const referenceElement = this[referenceElementSymbol];
+  if (!referenceElement) {
+    return {
+      message: {...this.reference},
+      description: 'anonymous message',
+    };
   }
 
-  function resolveReference(message) {
-    if (!referenceElement) {
-      return {
-        message: {...reference},
-        description: 'anonymous message',
-      };
-    }
-
-    const result = {
-      message: referenceElement.resolve(message),
-    };
+  const result = {
+    message: referenceElement.resolve(message),
+  };
 
-    result.description = `${result.message.name} <${result.message.id}>`;
+  result.description = `${result.message.name} <${result.message.id}>`;
 
-    return result;
-  }
+  return result;
+};
 
-  function setupCatch() {
-    broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(messageQueueName, 'api', '*.message.#', {durable: true});
-  }
-}
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};