bpmn-elements 5.1.3 → 7.0.0

package/dist/src/error/Errors.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.RunError = exports.BpmnError = exports.ActivityError = void 0;
 exports.makeErrorFromMessage = makeErrorFromMessage;
-exports.BpmnError = exports.ActivityError = void 0;
 
 var _messageHelper = require("../messageHelper");
 
@@ -29,6 +29,10 @@ class ActivityError extends Error {
 
 exports.ActivityError = ActivityError;
 
+class RunError extends ActivityError {}
+
+exports.RunError = RunError;
+
 class BpmnError extends Error {
   constructor(description, behaviour = {}, sourceMessage, inner) {
     const {
@@ -58,7 +62,7 @@ function makeErrorFromMessage(errorMessage) {
   const {
     error
   } = content;
-  if (!error) return;
+  if (!error) return new Error(`Malformatted error message with routing key ${errorMessage.fields && errorMessage.fields.routingKey}`);
   if (isKnownError(error)) return error;
 
   switch (error.type) {
@@ -68,15 +72,21 @@ function makeErrorFromMessage(errorMessage) {
         name: error.name
       });
 
+    case 'RunError':
+      return new RunError(error.message || error.description, error.source, error.inner ? error.inner : {
+        code: error.code,
+        name: error.name
+      });
+
     case 'BpmnError':
       return new BpmnError(error.message || error.description, error, error.source);
   }
 
   return error;
+}
 
-  function isKnownError(test) {
-    if (test instanceof Error) return test;
-    if (test instanceof ActivityError) return test;
-    if (test instanceof BpmnError) return test;
-  }
+function isKnownError(test) {
+  if (test instanceof ActivityError) return test;
+  if (test instanceof BpmnError) return test;
+  if (test instanceof Error) return test;
 }

package/dist/src/eventDefinitions/CancelEventDefinition.js

@@ -9,6 +9,10 @@ var _shared = require("../shared");
 
 var _messageHelper = require("../messageHelper");
 
+const messageQSymbol = Symbol.for('cancelQ');
+const completedSymbol = Symbol.for('completed');
+const executeMessageSymbol = Symbol.for('executeMessage');
+
 function CancelEventDefinition(activity, eventDefinition) {
   const {
     id,
@@ -16,162 +20,198 @@ function CancelEventDefinition(activity, eventDefinition) {
     environment,
     isThrowing
   } = activity;
-  const {
-    type
-  } = eventDefinition;
-  const {
-    debug
-  } = environment.Logger(type.toLowerCase());
-  const cancelQueueName = `cancel-${(0, _shared.brokerSafeId)(id)}-q`;
-  if (!isThrowing) setupCatch();
-  const source = {
-    id,
-    type,
-    reference: {
-      referenceType: 'cancel'
-    },
-    execute: isThrowing ? executeThrow : executeCatch
+  const type = eventDefinition.type;
+  this.id = id;
+  this.type = type;
+  const reference = this.reference = {
+    referenceType: 'cancel'
   };
-  return source;
-
-  function executeCatch(executeMessage) {
-    let completed;
-    const messageContent = (0, _messageHelper.cloneContent)(executeMessage.content);
-    const {
-      executionId,
-      parent,
-      attachedTo
-    } = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-    broker.consume(cancelQueueName, onCatchMessage, {
-      noAck: true,
-      consumerTag: `_oncancel-${executionId}`
-    });
-    if (completed) return;
-    broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: `_api-parent-${parentExecutionId}`
-    });
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: `_api-${executionId}`
-    });
-    debug(`<${executionId} (${id})> expect cancel`);
-    const exchangeKey = `execute.canceled.${executionId}`;
-    broker.subscribeOnce('execution', exchangeKey, onCatchMessage, {
-      consumerTag: `_onattached-cancel-${executionId}`
-    });
-    broker.publish('execution', 'execute.expect', (0, _messageHelper.cloneContent)(messageContent, {
-      pattern: '#.cancel',
-      exchange: 'execution',
-      exchangeKey
-    }));
-
-    function onCatchMessage(_, message) {
-      if (message.content && message.content.isTransaction) return onCancelTransaction(_, message);
-      debug(`<${executionId} (${id})> cancel caught from <${message.content.id}>`);
-      return complete(message.content.message);
-    }
-
-    function onCancelTransaction(_, message) {
-      broker.cancel(`_oncancel-${executionId}`);
-      debug(`<${executionId} (${id})> cancel transaction thrown by <${message.content.id}>`);
-      broker.assertExchange('cancel', 'topic');
-      broker.publish('execution', 'execute.detach', (0, _messageHelper.cloneContent)(messageContent, {
-        pattern: '#',
-        bindExchange: 'cancel',
-        sourceExchange: 'event',
-        sourcePattern: '#'
-      }));
-      broker.publish('event', 'activity.compensate', (0, _messageHelper.cloneContent)(message.content, {
-        state: 'throw'
-      }), {
-        type: 'compensate',
-        delegate: true
-      });
-      broker.subscribeTmp('cancel', 'activity.leave', (__, {
-        content: msg
-      }) => {
-        if (msg.id !== attachedTo) return;
-        return complete(message.content.message);
-      }, {
-        noAck: true,
-        consumerTag: `_oncancelend-${executionId}`
-      });
-    }
-
-    function complete(output) {
-      completed = true;
-      stop();
-      debug(`<${executionId} (${id})> completed`);
-      return broker.publish('execution', 'execute.completed', { ...messageContent,
-        output,
-        state: 'cancel'
-      });
-    }
-
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-
-      switch (messageType) {
-        case 'discard':
-          {
-            completed = true;
-            stop();
-            return broker.publish('execution', 'execute.discard', { ...messageContent
-            });
-          }
-
-        case 'stop':
-          {
-            stop();
-            break;
-          }
-      }
-    }
-
-    function stop() {
-      broker.cancel(`_api-parent-${parentExecutionId}`);
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_oncancel-${executionId}`);
-      broker.cancel(`_oncancelend-${executionId}`);
-      broker.cancel(`_onattached-cancel-${executionId}`);
-      broker.purgeQueue(cancelQueueName);
-    }
-  }
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  this.environment = environment;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
 
-  function executeThrow(executeMessage) {
-    const {
-      isTransaction
-    } = environment.variables.content || {};
-    const messageContent = (0, _messageHelper.cloneContent)(executeMessage.content);
-    const {
-      executionId,
-      parent
-    } = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-    debug(`<${executionId} (${id})> throw cancel${isTransaction ? ' transaction' : ''}`);
-    broker.publish('event', 'activity.cancel', { ...(0, _messageHelper.cloneContent)(messageContent),
-      isTransaction,
-      executionId: parentExecutionId,
-      parent: (0, _messageHelper.shiftParent)(parent),
-      state: 'throw'
-    }, {
-      type: 'cancel',
-      delegate: isTransaction
-    });
-    return broker.publish('execution', 'execute.completed', { ...messageContent
-    });
-  }
-
-  function setupCatch() {
-    broker.assertQueue(cancelQueueName, {
+  if (!isThrowing) {
+    this[completedSymbol] = false;
+    const messageQueueName = `${reference.referenceType}-${(0, _shared.brokerSafeId)(id)}-q`;
+    this[messageQSymbol] = broker.assertQueue(messageQueueName, {
       autoDelete: false,
       durable: true
     });
-    broker.bindQueue(cancelQueueName, 'api', '*.cancel.#', {
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {
       durable: true,
       priority: 400
     });
   }
-}
+}
+
+const proto = CancelEventDefinition.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;
+  const broker = this.broker;
+
+  const onCatchMessage = this._onCatchMessage.bind(this);
+
+  this[messageQSymbol].consume(onCatchMessage, {
+    noAck: true,
+    consumerTag: `_oncancel-${executionId}`
+  });
+  if (this[completedSymbol]) return;
+
+  const onApiMessage = this._onApiMessage.bind(this);
+
+  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-parent-${executionId}`
+  });
+  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-${executionId}`
+  });
+
+  this._debug('expect cancel');
+
+  const exchangeKey = `execute.canceled.${executionId}`;
+  broker.subscribeOnce('execution', exchangeKey, onCatchMessage, {
+    consumerTag: `_onattached-cancel-${executionId}`
+  });
+  broker.publish('execution', 'execute.expect', (0, _messageHelper.cloneContent)(executeContent, {
+    pattern: '#.cancel',
+    exchange: 'execution',
+    exchangeKey
+  }));
+};
+
+proto.executeThrow = function executeThrow(executeMessage) {
+  const {
+    isTransaction
+  } = this.environment.variables.content || {};
+  const executeContent = executeMessage.content;
+  const {
+    executionId,
+    parent
+  } = executeContent;
+  this.logger.debug(`<${executionId} (${this.activity.id})> throw cancel${isTransaction ? ' transaction' : ''}`);
+  const broker = this.broker;
+  const cancelContent = (0, _messageHelper.cloneContent)(executeContent, {
+    isTransaction,
+    executionId: parent.executionId,
+    state: 'throw'
+  });
+  cancelContent.parent = (0, _messageHelper.shiftParent)(parent);
+  broker.publish('event', 'activity.cancel', cancelContent, {
+    type: 'cancel',
+    delegate: isTransaction
+  });
+  return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent));
+};
+
+proto._onCatchMessage = function onCatchMessage(_, message) {
+  if (message.content && message.content.isTransaction) return this._onCancelTransaction(_, message);
+
+  this._debug(`cancel caught from <${message.content.id}>`);
+
+  return this._complete(message.content.message);
+};
+
+proto._onCancelTransaction = function onCancelTransaction(_, message) {
+  const broker = this.broker,
+        executionId = this.executionId;
+  const executeContent = this[executeMessageSymbol].content;
+  broker.cancel(`_oncancel-${executionId}`);
+
+  this._debug(`cancel transaction thrown by <${message.content.id}>`);
+
+  broker.assertExchange('cancel', 'topic');
+  broker.publish('execution', 'execute.detach', (0, _messageHelper.cloneContent)(executeContent, {
+    pattern: '#',
+    bindExchange: 'cancel',
+    sourceExchange: 'event',
+    sourcePattern: '#'
+  }));
+  broker.publish('event', 'activity.compensate', (0, _messageHelper.cloneContent)(message.content, {
+    state: 'throw'
+  }), {
+    type: 'compensate',
+    delegate: true
+  });
+  broker.subscribeTmp('cancel', 'activity.leave', (__, {
+    content: msg
+  }) => {
+    if (msg.id !== executeContent.attachedTo) return;
+    return this._complete(message.content.message);
+  }, {
+    noAck: true,
+    consumerTag: `_oncancelend-${executionId}`
+  });
+};
+
+proto._complete = function complete(output) {
+  this[completedSymbol] = true;
+
+  this._stop();
+
+  this._debug('completed');
+
+  const content = (0, _messageHelper.cloneContent)(this[executeMessageSymbol].content, {
+    output,
+    state: 'cancel'
+  });
+  return this.broker.publish('execution', 'execute.completed', content);
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  switch (message.properties.type) {
+    case 'discard':
+      {
+        this[completedSymbol] = true;
+
+        this._stop();
+
+        const content = (0, _messageHelper.cloneContent)(this[executeMessageSymbol].content);
+        return this.broker.publish('execution', 'execute.discard', content);
+      }
+
+    case 'stop':
+      {
+        this._stop();
+
+        break;
+      }
+  }
+};
+
+proto._stop = function stop() {
+  const broker = this.broker,
+        executionId = this.executionId;
+  broker.cancel(`_api-parent-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_oncancel-${executionId}`);
+  broker.cancel(`_oncancelend-${executionId}`);
+  broker.cancel(`_onattached-cancel-${executionId}`);
+  this[messageQSymbol].purge();
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};