bpmn-elements 6.0.1 → 7.0.0

package/dist/src/eventDefinitions/LinkEventDefinition.js

@@ -13,6 +13,10 @@ var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const completedSymbol = Symbol.for('completed');
+const messageQSymbol = Symbol.for('messageQ');
+const executeMessageSymbol = Symbol.for('executeMessage');
+
 function LinkEventDefinition(activity, eventDefinition) {
   const {
     id,
@@ -21,170 +25,191 @@ function LinkEventDefinition(activity, eventDefinition) {
     isThrowing
   } = activity;
   const {
-    type
+    type = 'LinkEventDefinition',
+    behaviour
   } = eventDefinition;
-  const {
-    debug
-  } = environment.Logger(type.toLowerCase());
-  const reference = {
-    linkName: eventDefinition.behaviour.name
-  };
-  const linkQueueName = `link-${(0, _shared.brokerSafeId)(id)}-${(0, _shared.brokerSafeId)(reference.linkName)}-q`;
-  if (!isThrowing) setupCatch();else setupThrow();
-  const source = {
-    id,
-    type,
-    reference: { ...reference,
-      referenceType: 'link'
-    },
-    execute: isThrowing ? executeThrow : executeCatch
+  this.id = id;
+  this.type = type;
+  const reference = this.reference = {
+    linkName: behaviour.name,
+    referenceType: 'link'
   };
-  return source;
-
-  function executeCatch(executeMessage) {
-    let completed;
-    const messageContent = (0, _messageHelper.cloneContent)(executeMessage.content);
-    const {
-      executionId,
-      parent
-    } = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-    const description = messageDescription();
-    broker.consume(linkQueueName, onCatchLink, {
-      noAck: true,
-      consumerTag: `_api-link-${executionId}`
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
+  this[completedSymbol] = false;
+
+  if (!isThrowing) {
+    const messageQueueName = `${reference.referenceType}-${(0, _shared.brokerSafeId)(id)}-${(0, _shared.brokerSafeId)(reference.linkName)}-q`;
+    this[messageQSymbol] = broker.assertQueue(messageQueueName, {
+      autoDelete: false,
+      durable: true
     });
-    if (completed) return;
-    broker.subscribeTmp('api', `activity.stop.${parentExecutionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: `_api-parent-${parentExecutionId}`
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {
+      durable: true
     });
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+  } else {
+    broker.subscribeTmp('event', 'activity.discard', this._onDiscard.bind(this), {
       noAck: true,
-      consumerTag: `_api-${executionId}`
-    });
-    debug(`<${executionId} (${id})> expect ${description}`);
-    broker.publish('event', 'activity.wait', { ...messageContent,
-      executionId: parentExecutionId,
-      parent: (0, _messageHelper.shiftParent)(parent),
-      link: { ...reference
-      }
+      consumerTag: '_link-parent-discard'
     });
+  }
+}
 
-    function onCatchLink(routingKey, message) {
-      if ((0, _getPropertyValue.default)(message, 'content.message.linkName') !== reference.linkName) return;
-      if (message.content.state === 'discard') return discard();
-      return complete('caught', message.content.message);
-    }
+const proto = LinkEventDefinition.prototype;
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  }
 
-    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: (0, _messageHelper.shiftParent)(executeMessage.content.parent)
-      }, {
-        type: 'catch'
-      });
-      return broker.publish('execution', 'execute.completed', { ...messageContent,
-        output,
-        state: 'catch'
-      });
-    }
+proto.execute = function execute(executeMessage) {
+  return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
+};
 
-    function discard() {
-      completed = true;
-      stop();
-      return broker.publish('execution', 'execute.discard', { ...messageContent
-      });
+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 = (0, _messageHelper.cloneContent)(executeContent, {
+    executionId: parentExecutionId,
+    link: { ...this.reference
     }
+  });
+  waitContent.parent = (0, _messageHelper.shiftParent)(parent);
+  broker.publish('event', 'activity.wait', waitContent);
+};
 
-    function stop() {
-      broker.cancel(`_api-link-${executionId}`);
-      broker.cancel(`_api-parent-${parentExecutionId}`);
-      broker.cancel(`_api-${executionId}`);
-      broker.purgeQueue(linkQueueName);
-    }
-  }
+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 = (0, _messageHelper.cloneContent)(executeContent, {
+    executionId: parentExecutionId,
+    message: { ...this.reference
+    },
+    state: 'throw'
+  });
+  linkContent.parent = (0, _messageHelper.shiftParent)(parent);
+  broker.publish('event', 'activity.link', linkContent, {
+    type: 'link',
+    delegate: true
+  });
+  return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent));
+};
+
+proto._onCatchLink = function onCatchLink(routingKey, message) {
+  if ((0, _getPropertyValue.default)(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();
+      }
 
-  function executeThrow(executeMessage) {
-    const messageContent = (0, _messageHelper.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', { ...(0, _messageHelper.cloneContent)(messageContent),
-      executionId: parentExecutionId,
-      parent: (0, _messageHelper.shiftParent)(parent),
-      message: { ...reference
-      },
-      state: 'throw'
-    }, {
-      type: 'link',
-      delegate: true
-    });
-    return broker.publish('execution', 'execute.completed', messageContent);
-  }
+    case 'stop':
+      {
+        this._stop();
 
-  function messageDescription() {
-    return `link ${reference.linkName}`;
+        break;
+      }
   }
+};
 
-  function setupCatch() {
-    broker.assertQueue(linkQueueName, {
-      autoDelete: false,
-      durable: true
-    });
-    broker.bindQueue(linkQueueName, 'api', '*.link.#', {
-      durable: true
-    });
-  }
+proto._complete = function complete(verb, output) {
+  this[completedSymbol] = true;
 
-  function setupThrow() {
-    broker.subscribeTmp('event', 'activity.discard', onDiscard, {
-      noAck: true,
-      consumerTag: '_link-parent-discard'
-    });
+  this._stop();
 
-    function onDiscard(_, message) {
-      broker.publish('event', 'activity.link.discard', { ...(0, _messageHelper.cloneContent)(message.content),
-        message: { ...reference
-        },
-        state: 'discard'
-      }, {
-        type: 'link',
-        delegate: true
-      });
-    }
-  }
-}
+  this._debug(`${verb} link ${this.reference.linkName}`);
+
+  const executeContent = this[executeMessageSymbol].content;
+  const parent = executeContent.parent;
+  const catchContent = (0, _messageHelper.cloneContent)(executeContent, {
+    link: { ...this.reference
+    },
+    message: { ...output
+    },
+    executionId: parent.executionId
+  });
+  catchContent.parent = (0, _messageHelper.shiftParent)(parent);
+  const broker = this.broker;
+  broker.publish('event', 'activity.catch', catchContent, {
+    type: 'catch'
+  });
+  return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
+    output,
+    state: 'catch'
+  }));
+};
+
+proto._discard = function discard() {
+  this[completedSymbol] = true;
+
+  this._stop();
+
+  return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.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', (0, _messageHelper.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}`);
+};