bpmn-elements 6.0.1 → 8.0.1

package/src/events/BoundaryEvent.js

@@ -3,132 +3,173 @@ import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecuti
 import {cloneContent, cloneMessage} from '../messageHelper';
 import {brokerSafeId} from '../shared';
 
+const kAttachedTags = Symbol.for('attachedConsumers');
+const kCompleteContent = Symbol.for('completeContent');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kExecution = Symbol.for('execution');
+const kShovels = Symbol.for('shovels');
+
 export default function BoundaryEvent(activityDef, context) {
-  return Activity(BoundaryEventBehaviour, activityDef, context);
+  return new Activity(BoundaryEventBehaviour, activityDef, context);
 }
 
 export function BoundaryEventBehaviour(activity) {
-  const {id, type = 'BoundaryEvent', broker, environment, attachedTo, behaviour = {}, eventDefinitions, logger} = activity;
-  const attachedToId = attachedTo.id;
-
-  const cancelActivity = 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
-  const eventDefinitionExecution = eventDefinitions && EventDefinitionExecution(activity, eventDefinitions, 'execute.bound.completed');
-
-  return {
-    id,
-    type,
-    attachedTo,
-    cancelActivity,
-    execute,
-  };
-
-  function execute(executeMessage) {
-    const executeContent = cloneContent(executeMessage.content);
-    const {isRootScope, executionId, inbound} = executeContent;
-
-    let parentExecutionId, completeContent;
-    const errorConsumerTags = [];
-    const shovels = [];
-    if (isRootScope) {
-      parentExecutionId = executionId;
-      if (eventDefinitionExecution && !environment.settings.strict) {
-        broker.subscribeTmp('execution', 'execute.expect', onExpectMessage, {noAck: true, consumerTag: '_expect-tag'});
-      }
-
-      attachedTo.broker.subscribeTmp('event', 'activity.leave', onAttachedLeave, {noAck: true, consumerTag: `_bound-listener-${parentExecutionId}`, priority: 300});
-
-      broker.subscribeOnce('execution', 'execute.detach', onDetachMessage, {consumerTag: '_detach-tag'});
-      broker.subscribeOnce('api', `activity.#.${parentExecutionId}`, onApiMessage, {consumerTag: `_api-${parentExecutionId}`});
-      broker.subscribeOnce('execution', 'execute.bound.completed', onCompleted, {consumerTag: `_execution-completed-${parentExecutionId}`});
-    }
-
-    if (eventDefinitionExecution) eventDefinitionExecution.execute(executeMessage);
-
-    function onCompleted(_, message) {
-      if (!cancelActivity && !message.content.cancelActivity) {
-        stop();
-        return broker.publish('execution', 'execute.completed', cloneContent(message.content));
-      }
-
-      completeContent = message.content;
-
-      const attachedToContent = inbound && inbound[0];
-      logger.debug(`<${executionId} (id)> cancel ${attachedTo.status} activity <${attachedToContent.executionId} (${attachedToContent.id})>`);
-
-      attachedTo.getApi({content: attachedToContent}).discard();
-    }
-
-    function onAttachedLeave(routingKey, message) {
-      if (message.content.id !== attachedToId) return;
-      stop();
-      if (!completeContent) return broker.publish('execution', 'execute.discard', executeContent);
-      return broker.publish('execution', 'execute.completed', completeContent);
-    }
-
-    function onExpectMessage(_, message) {
-      const errorConsumerTag = `_bound-error-listener-${message.content.executionId}`;
-      errorConsumerTags.push(errorConsumerTag);
-      attachedTo.broker.subscribeTmp('event', 'activity.error', attachedErrorHandler(message.content.expectRoutingKey), {noAck: true, consumerTag: errorConsumerTag, priority: 300});
-    }
+  this.id = activity.id;
+  this.type = activity.type;
+  this.attachedTo = activity.attachedTo;
+  this.activity = activity;
+  this.environment = activity.environment;
+  this.broker = activity.broker;
+  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions, 'execute.bound.completed');
+  this[kShovels] = [];
+  this[kAttachedTags] = [];
+}
 
-    function attachedErrorHandler(routingKey) {
-      return function onAttachedError(_, message) {
-        if (message.content.id !== attachedToId) return;
-        broker.publish('execution', routingKey, cloneContent(message.content));
-      };
+const proto = BoundaryEventBehaviour.prototype;
+
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[kExecuteMessage];
+    return message && message.content.executionId;
+  },
+});
+
+Object.defineProperty(proto, 'cancelActivity', {
+  enumerable: true,
+  get() {
+    const behaviour = this.activity.behaviour || {};
+    return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
+  },
+});
+
+proto.execute = function execute(executeMessage) {
+  const {isRootScope, executionId} = executeMessage.content;
+
+  const eventDefinitionExecution = this[kExecution];
+  if (isRootScope) {
+    this[kExecuteMessage] = executeMessage;
+
+    const broker = this.broker;
+    if (eventDefinitionExecution && !this.environment.settings.strict) {
+      broker.subscribeTmp('execution', 'execute.expect', this._onExpectMessage.bind(this), {
+        noAck: true,
+        consumerTag: '_expect-tag',
+      });
     }
 
-    function onDetachMessage(_, {content}) {
-      logger.debug(`<${parentExecutionId} (${id})> detach from activity <${attachedTo.id}>`);
-      stop(true);
-
-      const {executionId: detachId, bindExchange, sourceExchange = 'execution', sourcePattern} = content;
-
-      const shovelName = `_detached-${brokerSafeId(id)}_${detachId}`;
-      shovels.push(shovelName);
-      attachedTo.broker.createShovel(shovelName, {
-        exchange: sourceExchange,
-        pattern: sourcePattern,
-      }, {
-        broker,
-        exchange: bindExchange,
-      }, {
-        cloneMessage,
-      });
+    const consumerTag = `_bound-listener-${executionId}`;
+    this.attachedTo.broker.subscribeTmp('event', 'activity.leave', this._onAttachedLeave.bind(this), {
+      noAck: true,
+      consumerTag,
+      priority: 300,
+    });
+    this[kAttachedTags].push(consumerTag);
+
+    broker.subscribeOnce('execution', 'execute.detach', this._onDetachMessage.bind(this), {
+      consumerTag: '_detach-tag',
+    });
+    broker.subscribeOnce('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+      consumerTag: `_api-${executionId}`,
+    });
+    broker.subscribeOnce('execution', 'execute.bound.completed', this._onCompleted.bind(this), {
+      consumerTag: `_execution-completed-${executionId}`,
+    });
+  }
 
-      broker.subscribeOnce('execution', 'execute.bound.completed', onDetachedCompleted, {consumerTag: `_execution-completed-${parentExecutionId}`});
-    }
+  if (eventDefinitionExecution) {
+    return eventDefinitionExecution.execute(executeMessage);
+  }
+};
 
-    function onDetachedCompleted(_, message) {
-      stop();
-      return broker.publish('execution', 'execute.completed', cloneContent(message.content));
-    }
+proto._onCompleted = function onCompleted(_, {content}) {
+  if (!this.cancelActivity && !content.cancelActivity) {
+    this._stop();
+    return this.broker.publish('execution', 'execute.completed', cloneContent(content));
+  }
 
-    function onApiMessage(_, message) {
-      const messageType = message.properties.type;
-      switch (messageType) {
-        case 'discard':
-          stop();
-          break;
-        case 'stop':
-          stop();
-          break;
-      }
-    }
+  this[kCompleteContent] = content;
+
+  const {inbound} = this[kExecuteMessage].content;
+  const attachedToContent = inbound && inbound[0];
+  const attachedTo = this.attachedTo;
+  this.activity.logger.debug(`<${this.executionId} (${this.id})> cancel ${attachedTo.status} activity <${attachedToContent.executionId} (${attachedToContent.id})>`);
+
+  attachedTo.getApi({content: attachedToContent}).discard();
+};
+
+proto._onAttachedLeave = function onAttachedLeave(_, {content}) {
+  if (content.id !== this.attachedTo.id) return;
+  this._stop();
+  const completeContent = this[kCompleteContent];
+  if (!completeContent) return this.broker.publish('execution', 'execute.discard', this[kExecuteMessage].content);
+  return this.broker.publish('execution', 'execute.completed', cloneContent(completeContent));
+};
+
+proto._onExpectMessage = function onExpectMessage(_, {content}) {
+  const {executionId, expectRoutingKey} = content;
+  const attachedTo = this.attachedTo;
+
+  const errorConsumerTag = `_bound-error-listener-${executionId}`;
+  this[kAttachedTags].push(errorConsumerTag);
+
+  attachedTo.broker.subscribeTmp('event', 'activity.error', (__, errorMessage) => {
+    if (errorMessage.content.id !== attachedTo.id) return;
+    this.broker.publish('execution', expectRoutingKey, cloneContent(errorMessage.content));
+  }, {
+    noAck: true,
+    consumerTag: errorConsumerTag,
+    priority: 300,
+  });
+};
+
+proto._onDetachMessage = function onDetachMessage(_, {content}) {
+  const id = this.id, executionId = this.executionId, attachedTo = this.attachedTo;
+  this.activity.logger.debug(`<${executionId} (${id})> detach from activity <${attachedTo.id}>`);
+  this._stop(true);
+
+  const {executionId: detachId, bindExchange, sourceExchange, sourcePattern} = content;
+
+  const shovelName = `_detached-${brokerSafeId(id)}_${detachId}`;
+  this[kShovels].push(shovelName);
+
+  const broker = this.broker;
+  attachedTo.broker.createShovel(shovelName, {
+    exchange: sourceExchange,
+    pattern: sourcePattern,
+  }, {
+    broker,
+    exchange: bindExchange,
+  }, {
+    cloneMessage,
+  });
+
+  broker.subscribeOnce('execution', 'execute.bound.completed', (__, {content: completeContent}) => {
+    this._stop();
+    this.broker.publish('execution', 'execute.completed', cloneContent(completeContent));
+  }, {
+    consumerTag: `_execution-completed-${executionId}`,
+  });
+};
+
+proto._onApiMessage = function onApiMessage(_, message) {
+  switch (message.properties.type) {
+    case 'discard':
+    case 'stop':
+      this._stop();
+      break;
+  }
+};
 
-    function stop(detach) {
-      attachedTo.broker.cancel(`_bound-listener-${parentExecutionId}`);
-      attachedTo.broker.cancel(`_bound-error-listener-${parentExecutionId}`);
-      errorConsumerTags.splice(0).forEach((tag) => attachedTo.broker.cancel(tag));
-      shovels.splice(0).forEach((shovelName) => attachedTo.broker.closeShovel(shovelName));
+proto._stop = function stop(detach) {
+  const attachedTo = this.attachedTo, broker = this.broker, executionId = this.executionId;
+  for (const tag of this[kAttachedTags].splice(0)) attachedTo.broker.cancel(tag);
+  for (const shovelName of this[kShovels].splice(0)) attachedTo.broker.closeShovel(shovelName);
 
-      broker.cancel('_expect-tag');
-      broker.cancel('_detach-tag');
-      broker.cancel(`_execution-completed-${parentExecutionId}`);
+  broker.cancel('_expect-tag');
+  broker.cancel('_detach-tag');
+  broker.cancel(`_execution-completed-${executionId}`);
 
-      if (detach) return;
+  if (detach) return;
 
-      broker.cancel(`_api-${parentExecutionId}`);
-    }
-  }
-}
+  broker.cancel(`_api-${executionId}`);
+};

package/src/events/EndEvent.js

@@ -2,27 +2,24 @@ import Activity from '../activity/Activity';
 import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution';
 import {cloneContent} from '../messageHelper';
 
+const kExecution = Symbol.for('execution');
+
 export default function EndEvent(activityDef, context) {
-  return Activity(EndEventBehaviour, {...activityDef, isThrowing: true}, context);
+  return new Activity(EndEventBehaviour, {...activityDef, isThrowing: true}, context);
 }
 
 export function EndEventBehaviour(activity) {
-  const {id, type, broker, eventDefinitions} = activity;
-  const eventDefinitionExecution = eventDefinitions && EventDefinitionExecution(activity, eventDefinitions);
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute(executeMessage) {
-    if (eventDefinitionExecution) {
-      return eventDefinitionExecution.execute(executeMessage);
-    }
+  this.id = activity.id;
+  this.type = activity.type;
+  this.broker = activity.broker;
+  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+}
 
-    return broker.publish('execution', 'execute.completed', cloneContent(executeMessage.content));
+EndEventBehaviour.prototype.execute = function execute(executeMessage) {
+  const execution = this[kExecution];
+  if (execution) {
+    return execution.execute(executeMessage);
   }
-}
+
+  return this.broker.publish('execution', 'execute.completed', cloneContent(executeMessage.content));
+};

package/src/events/IntermediateCatchEvent.js

@@ -2,57 +2,53 @@ import Activity from '../activity/Activity';
 import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution';
 import {cloneContent} from '../messageHelper';
 
+const kExecution = Symbol.for('execution');
+
 export default function IntermediateCatchEvent(activityDef, context) {
-  return Activity(IntermediateCatchEventBehaviour, activityDef, context);
+  return new Activity(IntermediateCatchEventBehaviour, activityDef, context);
 }
 
 export function IntermediateCatchEventBehaviour(activity) {
-  const {id, type, broker, eventDefinitions} = activity;
-  const eventDefinitionExecution = eventDefinitions && EventDefinitionExecution(activity, eventDefinitions);
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute(executeMessage) {
-    if (eventDefinitionExecution) {
-      return eventDefinitionExecution.execute(executeMessage);
-    }
-
-    const content = cloneContent(executeMessage.content);
-    const {executionId} = content;
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
+  this.id = activity.id;
+  this.type = activity.type;
+  this.broker = activity.broker;
+  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+}
 
-    return broker.publish('event', 'activity.wait', cloneContent(content));
+IntermediateCatchEventBehaviour.prototype.execute = function execute(executeMessage) {
+  const execution = this[kExecution];
+  if (execution) {
+    return execution.execute(executeMessage);
+  }
 
-    function onApiMessage(routingKey, message) {
-      const messageType = message.properties.type;
-      switch (messageType) {
-        case 'message':
-        case 'signal': {
-          return complete(message.content.message);
-        }
-        case 'discard': {
-          stop();
-          return broker.publish('execution', 'execute.discard', cloneContent(content));
-        }
-        case 'stop': {
-          return stop();
-        }
-      }
+  const executeContent = executeMessage.content;
+  const executionId = executeContent.executionId;
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this, executeMessage), {
+    noAck: true,
+    consumerTag: '_api-behaviour-execution',
+  });
+
+  return broker.publish('event', 'activity.wait', cloneContent(executeContent));
+};
+
+IntermediateCatchEventBehaviour.prototype._onApiMessage = function onApiMessage(executeMessage, routingKey, message) {
+  switch (message.properties.type) {
+    case 'message':
+    case 'signal': {
+      const broker = this.broker;
+      broker.cancel('_api-behaviour-execution');
+      return broker.publish('execution', 'execute.completed', cloneContent(executeMessage.content, {
+        output: message.content.message,
+      }));
     }
-
-    function complete(output) {
-      stop();
-      return broker.publish('execution', 'execute.completed', cloneContent(content, {output}));
+    case 'discard': {
+      const broker = this.broker;
+      broker.cancel('_api-behaviour-execution');
+      return broker.publish('execution', 'execute.discard', cloneContent(executeMessage.content));
     }
-
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
+    case 'stop': {
+      return this.broker.cancel('_api-behaviour-execution');
     }
   }
-}
+};

package/src/events/IntermediateThrowEvent.js

@@ -2,27 +2,24 @@ import Activity from '../activity/Activity';
 import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution';
 import {cloneContent} from '../messageHelper';
 
+const kExecution = Symbol.for('execution');
+
 export default function IntermediateThrowEvent(activityDef, context) {
-  return Activity(IntermediateThrowEventBehaviour, {...activityDef, isThrowing: true}, context);
+  return new Activity(IntermediateThrowEventBehaviour, {...activityDef, isThrowing: true}, context);
 }
 
 export function IntermediateThrowEventBehaviour(activity) {
-  const {id, type, broker, eventDefinitions} = activity;
-  const eventDefinitionExecution = eventDefinitions && EventDefinitionExecution(activity, eventDefinitions);
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute(executeMessage) {
-    if (eventDefinitionExecution) {
-      return eventDefinitionExecution.execute(executeMessage);
-    }
+  this.id = activity.id;
+  this.type = activity.type;
+  this.broker = activity.broker;
+  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+}
 
-    return broker.publish('execution', 'execute.completed', cloneContent(executeMessage.content));
+IntermediateThrowEventBehaviour.prototype.execute = function execute(executeMessage) {
+  const execution = this[kExecution];
+  if (execution) {
+    return execution.execute(executeMessage);
   }
-}
+
+  return this.broker.publish('execution', 'execute.completed', cloneContent(executeMessage.content));
+};

package/src/events/StartEvent.js

@@ -2,68 +2,102 @@ import Activity from '../activity/Activity';
 import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution';
 import {cloneContent} from '../messageHelper';
 
+const kExecuteMessage = Symbol.for('executeMessage');
+const kExecution = Symbol.for('execution');
+
 export default function StartEvent(activityDef, context) {
-  return Activity(StartEventBehaviour, activityDef, context);
+  return new Activity(StartEventBehaviour, activityDef, context);
 }
 
 export function StartEventBehaviour(activity) {
-  const {id, type = 'startevent', broker, eventDefinitions} = activity;
-  const eventDefinitionExecution = eventDefinitions && EventDefinitionExecution(activity, eventDefinitions);
+  this.id = activity.id;
+  this.type = activity.type;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+}
 
-  const event = {
-    id,
-    type,
-    execute,
-  };
+const proto = StartEventBehaviour.prototype;
 
-  return event;
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[kExecuteMessage];
+    return message && message.content.executionId;
+  },
+});
 
-  function execute(executeMessage) {
-    if (eventDefinitionExecution) {
-      return eventDefinitionExecution.execute(executeMessage);
-    }
+proto.execute = function execute(executeMessage) {
+  const execution = this[kExecution];
+  if (execution) {
+    return execution.execute(executeMessage);
+  }
 
-    const content = cloneContent(executeMessage.content);
-    if (!content.form) {
-      return broker.publish('execution', 'execute.completed', content);
-    }
+  const content = cloneContent(executeMessage.content);
+  const broker = this.broker;
+  if (!content.form) {
+    return broker.publish('execution', 'execute.completed', content);
+  }
 
-    const {executionId} = content;
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`, priority: 300});
-    broker.subscribeTmp('api', '#.signal.*', onDelegatedApiMessage, {noAck: true, consumerTag: `_api-delegated-${executionId}`});
-    broker.publish('event', 'activity.wait', {...content, executionId, state: 'wait'});
+  const executionId = content.executionId;
+  this[kExecuteMessage] = executeMessage;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(...args), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 300,
+  });
+  broker.subscribeTmp('api', '#.signal.*', (...args) => this._onDelegatedApiMessage(...args), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
+  });
+  broker.publish('event', 'activity.wait', {...content, executionId, state: 'wait'});
+};
 
-    function onDelegatedApiMessage(routingKey, message) {
-      if (!message.properties.delegate) return;
-      const {content: delegateContent} = message;
-      if (!delegateContent || !delegateContent.message) return;
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const {type: messageType, correlationId} = message.properties;
+  switch (messageType) {
+    case 'stop':
+      return this._stop();
+    case 'signal': {
+      this._stop();
+      const content = this[kExecuteMessage].content;
+      return this.broker.publish('execution', 'execute.completed', cloneContent(content, {
+        output: message.content.message,
+        state: 'signal',
+      }), {correlationId});
+    }
+    case 'discard': {
+      this._stop();
+      const content = this[kExecuteMessage].content;
+      return this.broker.publish('execution', 'execute.discard', cloneContent(content), {correlationId});
+    }
+  }
+};
 
-      const {id: signalId, executionId: signalExecutionId} = delegateContent.message;
-      if (signalId !== id && signalExecutionId !== executionId) return;
+proto._onDelegatedApiMessage = function onDelegatedApiMessage(routingKey, message) {
+  if (!message.properties.delegate) return;
 
-      const {type: messageType, correlationId} = message.properties;
-      broker.publish('event', 'activity.consumed', cloneContent(content, {message: {...delegateContent.message}}), {correlationId, type: messageType});
-      return onApiMessage(routingKey, message);
-    }
+  const content = message.content;
+  if (!content.message) return;
 
-    function onApiMessage(routingKey, message) {
-      const {type: messageType, correlationId} = message.properties;
+  const {id: signalId, executionId: signalExecutionId} = content.message;
+  if (signalId !== this.id && signalExecutionId !== this.executionId) return;
 
-      switch (messageType) {
-        case 'stop':
-          return stop();
-        case 'signal':
-          stop();
-          return broker.publish('execution', 'execute.completed', cloneContent(content, {output: message.content.message, state: 'signal'}), {correlationId});
-        case 'discard':
-          stop();
-          return broker.publish('execution', 'execute.discard', cloneContent(content), {correlationId});
-      }
-    }
+  const {type, correlationId} = message.properties;
+  const executeContent = this[kExecuteMessage].content;
+  this.broker.publish('event', 'activity.consumed', cloneContent(executeContent, {
+    message: {
+      ...content.message,
+    },
+  }), {
+    correlationId,
+    type,
+  });
 
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_api-delegated-${executionId}`);
-    }
-  }
-}
+  return this._onApiMessage(routingKey, message);
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
+};