bpmn-elements 6.0.0 → 8.0.0

package/src/error/Errors.js

@@ -15,6 +15,8 @@ class ActivityError extends Error {
   }
 }
 
+class RunError extends ActivityError {}
+
 class BpmnError extends Error {
   constructor(description, behaviour = {}, sourceMessage, inner) {
     const {errorCode} = behaviour;
@@ -33,6 +35,7 @@ class BpmnError extends Error {
 export {
   ActivityError,
   BpmnError,
+  RunError,
   makeErrorFromMessage
 };
 
@@ -41,21 +44,23 @@ function makeErrorFromMessage(errorMessage) {
   if (isKnownError(content)) return content;
 
   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) {
     case 'ActivityError':
       return new ActivityError(error.message || error.description, error.source, error.inner ? error.inner : {code: error.code, 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/src/eventDefinitions/CancelEventDefinition.js

@@ -1,130 +1,173 @@
 import {brokerSafeId} from '../shared';
 import {cloneContent, shiftParent} from '../messageHelper';
 
+const kMessageQ = Symbol.for('cancelQ');
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+
 export default function CancelEventDefinition(activity, eventDefinition) {
   const {id, broker, environment, isThrowing} = activity;
-  const {type} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const cancelQueueName = `cancel-${brokerSafeId(id)}-q`;
-
-  if (!isThrowing) setupCatch();
-
-  const source = {
-    id,
-    type,
-    reference: {referenceType: 'cancel'},
-    execute: isThrowing ? executeThrow : executeCatch,
-  };
-
-  return source;
-
-  function executeCatch(executeMessage) {
-    let completed;
-
-    const messageContent = 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', 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', cloneContent(messageContent, {
-        pattern: '#',
-        bindExchange: 'cancel',
-        sourceExchange: 'event',
-        sourcePattern: '#',
-      }));
-
-      broker.publish('event', 'activity.compensate', 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'});
-    }
+  const type = eventDefinition.type;
+
+  this.id = id;
+  this.type = type;
+  const reference = this.reference = {referenceType: 'cancel'};
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  this.environment = environment;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
+
+  if (!isThrowing) {
+    this[kCompleted] = false;
+    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
+    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 400});
+  }
+}
 
-    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;
-        }
-      }
+const proto = CancelEventDefinition.prototype;
+
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[kExecuteMessage];
+    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[kExecuteMessage] = executeMessage;
+  this[kCompleted] = false;
+
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+  const parentExecutionId = parent.executionId;
+
+  const broker = this.broker;
+  const onCatchMessage = this._onCatchMessage.bind(this);
+  this[kMessageQ].consume(onCatchMessage, {
+    noAck: true,
+    consumerTag: `_oncancel-${executionId}`,
+  });
+
+  if (this[kCompleted]) 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', 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 = cloneContent(executeContent, {
+    isTransaction,
+    executionId: parent.executionId,
+    state: 'throw',
+  });
+  cancelContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.cancel', cancelContent, {type: 'cancel', delegate: isTransaction});
+
+  return broker.publish('execution', 'execute.completed', 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[kExecuteMessage].content;
+  broker.cancel(`_oncancel-${executionId}`);
+
+  this._debug(`cancel transaction thrown by <${message.content.id}>`);
+
+  broker.assertExchange('cancel', 'topic');
+  broker.publish('execution', 'execute.detach', cloneContent(executeContent, {
+    pattern: '#',
+    bindExchange: 'cancel',
+    sourceExchange: 'event',
+    sourcePattern: '#',
+  }));
+
+  broker.publish('event', 'activity.compensate', 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[kCompleted] = true;
+  this._stop();
+  this._debug('completed');
+  const content = cloneContent(this[kExecuteMessage].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[kCompleted] = true;
+      this._stop();
+      const content = cloneContent(this[kExecuteMessage].content);
+      return this.broker.publish('execution', 'execute.discard', content);
     }
-
-    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);
+    case 'stop': {
+      this._stop();
+      break;
     }
   }
-
-  function executeThrow(executeMessage) {
-    const {isTransaction} = environment.variables.content || {};
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    debug(`<${executionId} (${id})> throw cancel${isTransaction ? ' transaction' : ''}`);
-
-    broker.publish('event', 'activity.cancel', {
-      ...cloneContent(messageContent),
-      isTransaction,
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      state: 'throw',
-    }, {type: 'cancel', delegate: isTransaction});
-
-    return broker.publish('execution', 'execute.completed', {...messageContent});
-  }
-
-  function setupCatch() {
-    broker.assertQueue(cancelQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(cancelQueueName, 'api', '*.cancel.#', {durable: true, priority: 400});
-  }
-}
+};
+
+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[kMessageQ].purge();
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};

package/src/eventDefinitions/CompensateEventDefinition.js

@@ -1,144 +1,179 @@
 import {brokerSafeId} from '../shared';
 import {cloneContent, cloneMessage, shiftParent} from '../messageHelper';
 
-export default function CompensationEventDefinition(activity, eventDefinition, context) {
-  const {id, broker, environment, isThrowing} = activity;
-  const {type} = eventDefinition;
-  const {debug} = environment.Logger(type.toLowerCase());
-  const compensationQueueName = `compensate-${brokerSafeId(id)}-q`;
-  const associations = context.getOutboundAssociations(id) || [];
-
-  if (!isThrowing) setupCatch();
-
-  const source = {
-    id,
-    type,
-    reference: {referenceType: 'compensate'},
-    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;
-
-    broker.consume(compensationQueueName, onCompensateApiMessage, {noAck: true, consumerTag: `_oncompensate-${executionId}`});
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageQ = Symbol.for('messageQ');
+const kCompensateQ = Symbol.for('compensateQ');
+const kAssociations = Symbol.for('associations');
 
-    if (completed) return;
-
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
+export default function CompensateEventDefinition(activity, eventDefinition, context) {
+  const {id, broker, environment, isThrowing} = activity;
 
-    if (completed) return stop();
+  this.id = id;
+  const type = this.type = eventDefinition.type;
+  const reference = this.reference = {referenceType: 'compensate'};
+  this.isThrowing = isThrowing;
+  this.activity = activity;
+  this.broker = broker;
+  this.logger = environment.Logger(type.toLowerCase());
+
+  if (!isThrowing) {
+    this[kCompleted] = false;
+    this[kAssociations] = context.getOutboundAssociations(id) || [];
+    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
+    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 400});
+  }
+}
 
-    debug(`<${executionId} (${id})> expect compensate`);
+const proto = CompensateEventDefinition.prototype;
+
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[kExecuteMessage];
+    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[kExecuteMessage] = executeMessage;
+  this[kCompleted] = false;
+
+  const executeContent = executeMessage.content;
+  const {executionId, parent} = executeContent;
+
+  this._debug('expect compensate');
+
+  const broker = this.broker;
+  broker.assertExchange('compensate', 'topic');
+  this[kCompensateQ] = broker.assertQueue('compensate-q', {durable: true, autoDelete: false});
+  broker.subscribeTmp('compensate', 'execute.#', this._onCollect.bind(this), {
+    noAck: true,
+    consumerTag: '_oncollect-messages',
+  });
+
+  broker.publish('execution', 'execute.detach', cloneContent(executeContent, {
+    sourceExchange: 'execution',
+    bindExchange: 'compensate',
+  }));
+
+  this[kMessageQ].consume(this._onCompensateApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_oncompensate-${executionId}`,
+  });
+
+  if (this[kCompleted]) return;
+
+  const onApiMessage = this._onApiMessage.bind(this);
+  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+  });
+
+  const detachContent = cloneContent(executeContent, {
+    executionId: parent.executionId,
+    bindExchange: 'compensate',
+  });
+  detachContent.parent = shiftParent(parent);
+
+  broker.publish('event', 'activity.detach', detachContent);
+};
+
+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 compensate`);
+
+  const broker = this.broker;
+  const throwContent = cloneContent(executeContent, {
+    executionId: parentExecutionId,
+    state: 'throw',
+  });
+  throwContent.parent = shiftParent(parent);
+  broker.publish('event', 'activity.compensate', throwContent, {type: 'compensate', delegate: true});
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
+};
+
+proto._onCollect = function onCollect(routingKey, message) {
+
+  switch (routingKey) {
+    case 'execute.error':
+    case 'execute.completed': {
+      return this[kCompensateQ].queueMessage(message.fields, cloneContent(message.content), message.properties);
+    }
+  }
+};
 
-    broker.assertExchange('compensate', 'topic');
-    const compensateQ = broker.assertQueue('compensate-q', {durable: true, autoDelete: false});
-    broker.subscribeTmp('compensate', 'execute.#', onCollect, {noAck: true, consumerTag: '_oncollect-messages'});
-    broker.publish('execution', 'execute.detach', cloneContent(messageContent, {bindExchange: 'compensate'}));
+proto._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
+  const output = message.content.message;
+  this[kCompleted] = true;
 
-    broker.publish('event', 'activity.detach', {
-      ...messageContent,
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      bindExchange: 'compensate',
-    });
+  this._stop();
 
-    function onCollect(routingKey, message) {
-      switch (routingKey) {
-        case 'execute.error':
-        case 'execute.completed': {
-          return compensateQ.queueMessage(message.fields, cloneContent(message.content), message.properties);
-        }
-      }
-    }
+  this._debug('caught compensate event');
+  const broker = this.broker;
+  const executeContent = this[kExecuteMessage].content;
+  const catchContent = cloneContent(executeContent, {
+    message: {...output},
+    executionId: executeContent.parent.executionId,
+  });
+  catchContent.parent = shiftParent(catchContent.parent);
 
-    function onCompensateApiMessage(routingKey, message) {
-      const output = message.content.message;
-      completed = true;
+  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
 
-      stop();
+  const compensateQ = this[kCompensateQ];
+  compensateQ.on('depleted', onDepleted);
+  compensateQ.consume(this._onCollected.bind(this), {noAck: true, consumerTag: '_convey-messages'});
 
-      debug(`<${executionId} (${id})> caught compensate event`);
-      broker.publish('event', 'activity.catch', {
-        ...messageContent,
-        message: {...output},
-        executionId: parentExecutionId,
-        parent: shiftParent(executeMessage.content.parent),
-      }, {type: 'catch'});
+  for (const association of this[kAssociations]) association.complete(cloneMessage(message));
 
-      compensateQ.on('depleted', onDepleted);
-      compensateQ.consume(onCollected, {noAck: true, consumerTag: '_convey-messages'});
+  function onDepleted() {
+    compensateQ.off('depleted', onDepleted);
+    return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output, state: 'catch'}));
+  }
+};
 
-      associations.forEach((association) => {
-        association.complete(cloneMessage(message));
-      });
+proto._onCollected = function onCollected(routingKey, message) {
+  for (const association of this[kAssociations]) association.take(cloneMessage(message));
+};
 
-      function onDepleted() {
-        compensateQ.off('depleted', onDepleted);
-        return broker.publish('execution', 'execute.completed', {...messageContent, output, state: 'catch'});
-      }
-    }
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
 
-    function onCollected(routingKey, message) {
-      associations.forEach((association) => {
-        association.take(cloneMessage(message));
-      });
+  switch (messageType) {
+    case 'compensate': {
+      return this._onCompensateApiMessage(routingKey, message);
     }
-
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-
-      switch (messageType) {
-        case 'compensate': {
-          return onCompensateApiMessage(routingKey, message);
-        }
-        case 'discard': {
-          completed = true;
-          stop();
-          associations.forEach((association) => {
-            association.discard(cloneMessage(message));
-          });
-          return broker.publish('execution', 'execute.discard', {...messageContent});
-        }
-        case 'stop': {
-          stop();
-          break;
-        }
-      }
+    case 'discard': {
+      this[kCompleted] = true;
+      this._stop();
+      for (const association of this[kAssociations]) association.discard(cloneMessage(message));
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content));
     }
-
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_oncompensate-${executionId}`);
-      broker.cancel('_oncollect-messages');
-      broker.cancel('_convey-messages');
+    case 'stop': {
+      this._stop();
+      break;
     }
   }
-
-  function executeThrow(executeMessage) {
-    const messageContent = cloneContent(executeMessage.content);
-    const {executionId, parent} = messageContent;
-    const parentExecutionId = parent && parent.executionId;
-
-    debug(`<${executionId} (${id})> throw compensate`);
-
-    broker.publish('event', 'activity.compensate', {
-      ...cloneContent(messageContent),
-      executionId: parentExecutionId,
-      parent: shiftParent(parent),
-      state: 'throw',
-    }, {type: 'compensate', delegate: true});
-
-    return broker.publish('execution', 'execute.completed', {...messageContent});
-  }
-
-  function setupCatch() {
-    broker.assertQueue(compensationQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(compensationQueueName, 'api', '*.compensate.#', {durable: true, priority: 400});
-  }
-}
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_oncompensate-${executionId}`);
+  broker.cancel('_oncollect-messages');
+  broker.cancel('_convey-messages');
+  this[kMessageQ].purge();
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};