bpmn-elements 6.0.1 → 8.0.1

package/src/tasks/ReceiveTask.js

@@ -1,8 +1,13 @@
 import Activity from '../activity/Activity';
 import {cloneContent} from '../messageHelper';
 
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kReferenceElement = Symbol.for('referenceElement');
+const kReferenceInfo = Symbol.for('referenceInfo');
+
 export default function ReceiveTask(activityDef, context) {
-  const task = Activity(ReceiveTaskBehaviour, activityDef, context);
+  const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
 
   task.broker.assertQueue('message', {autoDelete: false, durable: true});
   task.broker.bindQueue('message', 'api', '*.message.#', {durable: true});
@@ -11,140 +16,202 @@ export default function ReceiveTask(activityDef, context) {
 }
 
 export function ReceiveTaskBehaviour(activity) {
-  const {id, type, broker, logger, behaviour = {}, getActivityById} = activity;
-  const reference = behaviour.messageRef || {name: 'anonymous'};
+  const {id, type, behaviour} = activity;
 
-  const referenceElement = reference.id && getActivityById(reference.id);
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.id = id;
+  this.type = type;
 
-  const source = {
-    id,
-    type,
-    reference: {...reference, referenceType: 'message'},
-    execute,
+  const reference = this.reference = {
+    name: 'anonymous',
+    ...behaviour.messageRef,
+    referenceType: 'message',
   };
 
-  return source;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.broker = activity.broker;
 
-  function execute(executeMessage) {
-    const content = executeMessage.content;
-    const {executionId} = content;
+  this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+}
 
-    if (content.isRootScope) setupMessageHandling(executionId);
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
-    }
+ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
+  return new ReceiveTaskExecution(this).execute(executeMessage);
+};
 
-    let completed;
+function ReceiveTaskExecution(parent) {
+  const {activity, broker, loopCharacteristics, reference} = parent;
 
-    const {message: referenceMessage, description} = resolveReference(executeMessage);
-    broker.consume('message', onCatchMessage, {noAck: true, consumerTag: `_onmessage-${executionId}`});
+  this.id = activity.id;
+  this.logger = activity.logger;
+  this.reference = reference;
+  this.broker = broker;
+  this.loopCharacteristics = loopCharacteristics;
+  this.referenceElement = parent[kReferenceElement];
 
-    if (completed) return;
+  this[kCompleted] = false;
+}
 
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`, priority: 400});
+const proto = ReceiveTaskExecution.prototype;
 
-    logger.debug(`<${executionId} (${id})> expect ${description}`);
+proto.execute = function execute(executeMessage) {
+  this[kExecuteMessage] = executeMessage;
 
-    broker.publish('event', 'activity.wait', cloneContent(content, {message: {...referenceMessage}}));
+  const executeContent = executeMessage.content;
+  const {executionId, isRootScope} = executeContent;
+  this.executionId = executionId;
 
-    function onCatchMessage(routingKey, message) {
-      const {content: delegateContent} = message;
+  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
 
-      const {id: signalId, executionId: signalExecutionId} = delegateContent.message || {};
-      if (!referenceMessage.id && signalId || signalExecutionId) {
-        if (loopCharacteristics && signalExecutionId !== executionId) return;
-        if (signalId !== id && signalExecutionId !== executionId) return;
-        logger.debug(`<${executionId} (${id})> caught direct message`);
-      } else if (referenceMessage.id !== signalId) return;
-      else {
-        logger.debug(`<${executionId} (${id})> caught ${description}`);
-      }
+  if (isRootScope) {
+    this._setupMessageHandling(executionId);
+  }
 
-      const {type: messageType, correlationId} = message.properties;
-      broker.publish('event', 'activity.consumed', cloneContent(content, {message: {...message.content.message}}), {correlationId, type: messageType});
-      broker.publish('event', 'activity.catch', cloneContent(content, {message: message.content.message}), {type: 'catch', correlationId});
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && executeMessage.content.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
 
-      complete(message.content.message, {correlationId});
-    }
+  const broker = this.broker;
+  broker.consume('message', this._onCatchMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_onmessage-${executionId}`,
+  });
 
-    function onApiMessage(routingKey, message) {
-      const {type: messageType, correlationId} = message.properties;
-      switch (messageType) {
-        case 'message':
-        case 'signal': {
-          return complete(message.content.message, {correlationId});
-        }
-        case 'discard': {
-          completed = true;
-          stop();
-          return broker.publish('execution', 'execute.discard', cloneContent(content), {correlationId});
-        }
-        case 'stop': {
-          return stop();
-        }
-      }
-    }
+  if (this[kCompleted]) return;
 
-    function complete(output, options) {
-      completed = true;
-      stop();
-      return broker.publish('execution', 'execute.completed', cloneContent(content, {output}), options);
-    }
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 400,
+  });
 
-    function stop() {
-      broker.cancel(`_onmessage-${executionId}`);
-      broker.cancel(`_api-${executionId}`);
-    }
+  this._debug(`expect ${info.description}`);
+
+  broker.publish('event', 'activity.wait', cloneContent(executeContent, {message: {...info.message}}));
+};
+
+proto._onCatchMessage = function onCatchMessage(routingKey, message) {
+  const content = message.content;
+
+  const {id: signalId, executionId: signalExecutionId} = content.message || {};
+  const {message: referenceMessage, description} = this[kReferenceInfo];
+
+  if (!referenceMessage.id && signalId || signalExecutionId) {
+    if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
+    if (signalId !== this.id && signalExecutionId !== this.executionId) return;
+    this._debug('caught direct message');
+  } else if (referenceMessage.id !== signalId) return;
+  else {
+    this._debug(`caught ${description}`);
   }
 
-  function setupMessageHandling(executionId) {
-    broker.subscribeTmp('api', '#.signal.*', onDelegateMessage, {noAck: true, consumerTag: `_api-delegated-${executionId}`}, {noAck: true});
-    broker.subscribeTmp('api', `activity.stop.${executionId}`, onStopApiMessage, {noAck: true, consumerTag: `_api-stop-${executionId}`, priority: 400});
-    broker.subscribeTmp('execution', 'execute.#', onComplete, {noAck: true, consumerTag: `_execution-complete-${executionId}`}, {noAck: true});
+  const {type: messageType, correlationId} = message.properties;
+  const broker = this.broker;
+  const executeContent = this[kExecuteMessage].content;
 
-    function onDelegateMessage(_, message) {
-      if (!message.properties.delegate) return;
-      broker.sendToQueue('message', message.content, message.properties);
-    }
+  broker.publish('event', 'activity.consumed', cloneContent(executeContent, {message: {...message.content.message}}), {correlationId, type: messageType});
+  broker.publish('event', 'activity.catch', cloneContent(executeContent, {message: message.content.message}), {type: 'catch', correlationId});
 
-    function onStopApiMessage() {
-      stop(true);
-    }
+  this._complete(message.content.message, {correlationId});
+};
 
-    function onComplete(routingKey, {content}) {
-      if (!content.isRootScope) return;
-      switch (routingKey) {
-        case 'execute.completed':
-        case 'execute.error':
-        case 'execute.discard':
-          stop();
-          break;
-      }
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const {type: messageType, correlationId} = message.properties;
+  switch (messageType) {
+    case 'message':
+    case 'signal': {
+      return this._complete(message.content.message, {correlationId});
     }
-
-    function stop(keepMessageQ) {
-      broker.cancel(`_api-delegated-${executionId}`);
-      broker.cancel(`_api-stop-${executionId}`);
-      broker.cancel(`_execution-complete-${executionId}`);
-      if (!keepMessageQ) broker.purgeQueue('message');
+    case 'discard': {
+      this[kCompleted] = true;
+      this._stop();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
     }
+    case 'stop': {
+      return this._stop();
+    }
+  }
+};
+
+proto._complete = function complete(output, options) {
+  this[kCompleted] = true;
+  this._stop();
+  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {output}), options);
+};
+
+proto._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_onmessage-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+};
+
+proto._setupMessageHandling = function setupMessageHandling(executionId) {
+  const broker = this.broker;
+  broker.subscribeTmp('api', '#.signal.*', this._onDelegateMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
+  }, {
+    noAck: true,
+  });
+  broker.subscribeTmp('api', `activity.stop.${executionId}`, this._onStopApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-stop-${executionId}`,
+    priority: 400,
+  });
+  broker.subscribeTmp('execution', 'execute.#', this._onExecutionComplete.bind(this), {
+    noAck: true,
+    consumerTag: `_execution-complete-${executionId}`,
+  }, {
+    noAck: true,
+  });
+};
+
+proto._onDelegateMessage = function onDelegateMessage(_, message) {
+  if (!message.properties.delegate) return;
+  this.broker.sendToQueue('message', message.content, message.properties);
+};
+
+proto._onStopApiMessage = function onStopApiMessage() {
+  this._stopMessageHandling(true);
+};
+
+proto._onExecutionComplete = function onExecutionComplete(routingKey, {content}) {
+  if (!content.isRootScope) return;
+  switch (routingKey) {
+    case 'execute.completed':
+    case 'execute.error':
+    case 'execute.discard':
+      this._stopMessageHandling();
+      break;
+  }
+};
+
+proto._stopMessageHandling = function stop(keepMessageQ) {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-delegated-${executionId}`);
+  broker.cancel(`_api-stop-${executionId}`);
+  broker.cancel(`_execution-complete-${executionId}`);
+  if (!keepMessageQ) broker.purgeQueue('message');
+};
+
+proto._getReferenceInfo = function getReferenceInfo(message) {
+  const referenceElement = this.referenceElement;
+  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;
-  }
-}
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.id})> ${msg}`);
+};

package/src/tasks/ScriptTask.js

@@ -4,46 +4,43 @@ import { ActivityError } from '../error/Errors';
 import {cloneContent, cloneMessage} from '../messageHelper';
 
 export default function ScriptTask(activityDef, context) {
-  return Activity(ScriptTaskBehaviour, activityDef, context);
+  return new Activity(ScriptTaskBehaviour, activityDef, context);
 }
 
 export function ScriptTaskBehaviour(activity) {
-  const {id, type, behaviour, broker, logger, environment, emitFatal} = activity;
+  const {id, type, behaviour} = activity;
 
-  const {scriptFormat} = activity.behaviour;
+  this.id = id;
+  this.type = type;
+  this.scriptFormat = behaviour.scriptFormat;
 
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  const environment = this.environment = activity.environment;
 
   environment.registerScript(activity);
+}
 
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute,
-  };
-
-  return source;
-
-  function execute(executeMessage) {
-    const content = executeMessage.content;
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
-    }
+ScriptTaskBehaviour.prototype.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && executeContent.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
 
-    const script = environment.getScript(scriptFormat, activity, cloneMessage(executeMessage));
-    if (!script) {
-      return emitFatal(new ActivityError(`Script format ${scriptFormat} is unsupported or was not registered for <${activity.id}>`, executeMessage), content);
-    }
+  const activity = this.activity, scriptFormat = this.scriptFormat;
+  const script = this.environment.getScript(scriptFormat, activity, cloneMessage(executeMessage));
+  if (!script) {
+    return activity.emitFatal(new ActivityError(`Script format ${scriptFormat} is unsupported or was not registered for <${activity.id}>`, executeMessage), executeContent);
+  }
 
-    return script.execute(ExecutionScope(activity, executeMessage), scriptCallback);
+  return script.execute(ExecutionScope(activity, executeMessage), scriptCallback);
 
-    function scriptCallback(err, output) {
-      if (err) {
-        logger.error(`<${content.executionId} (${id})>`, err);
-        return broker.publish('execution', 'execute.error', cloneContent(content, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
-      }
-      return broker.publish('execution', 'execute.completed', cloneContent(content, {output}));
+  function scriptCallback(err, output) {
+    if (err) {
+      activity.logger.error(`<${executeContent.executionId} (${activity.id})>`, err);
+      return activity.broker.publish('execution', 'execute.error', cloneContent(executeContent, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
     }
+    return activity.broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output}));
   }
-}
+};

package/src/tasks/ServiceImplementation.js

@@ -1,24 +1,19 @@
 import ExecutionScope from '../activity/ExecutionScope';
 
 export default function ServiceImplementation(activity) {
-  const {type: atype, behaviour, environment} = activity;
-  const implementation = behaviour.implementation;
-
-  const type = `${atype}:implementation`;
-
-  return {
-    type,
-    implementation,
-    execute,
-  };
+  this.type = `${activity.type}:implementation`;
+  this.implementation = activity.behaviour.implementation;
+  this.activity = activity;
+}
 
-  function execute(executionMessage, callback) {
-    const serviceFn = environment.resolveExpression(implementation, executionMessage);
+ServiceImplementation.prototype.execute = function execute(executionMessage, callback) {
+  const activity = this.activity;
+  const implementation = this.implementation;
+  const serviceFn = activity.environment.resolveExpression(implementation, executionMessage);
 
-    if (typeof serviceFn !== 'function') return callback(new Error(`Implementation ${implementation} did not resolve to a function`));
+  if (typeof serviceFn !== 'function') return callback(new Error(`Implementation ${implementation} did not resolve to a function`));
 
-    serviceFn.call(activity, ExecutionScope(activity, executionMessage), (err, ...args) => {
-      callback(err, args);
-    });
-  }
-}
+  serviceFn.call(activity, ExecutionScope(activity, executionMessage), (err, ...args) => {
+    callback(err, args);
+  });
+};

package/src/tasks/ServiceTask.js

@@ -3,80 +3,87 @@ import {ActivityError} from '../error/Errors';
 import {cloneMessage, cloneContent} from '../messageHelper';
 
 export default function ServiceTask(activityDef, context) {
-  return Activity(ServiceTaskBehaviour, activityDef, context);
+  return new Activity(ServiceTaskBehaviour, activityDef, context);
 }
 
 export function ServiceTaskBehaviour(activity) {
-  const {id, type, broker, logger, behaviour, environment, emitFatal} = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  const {id, type, behaviour} = activity;
 
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute,
-    getService,
-  };
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.environment = activity.environment;
+  this.broker = activity.broker;
+}
 
-  return source;
+const proto = ServiceTaskBehaviour.prototype;
 
-  function execute(executeMessage) {
-    const content = executeMessage.content;
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
-    }
+proto.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && executeContent.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
 
-    const {executionId} = content;
-    const service = getService(executeMessage);
-    if (!service) return emitFatal(new ActivityError(`<${id}> service not defined`, executeMessage), content);
+  const executionId = executeContent.executionId;
+  const service = this.service = this.getService(executeMessage);
+  if (!service) return this.activity.emitFatal(new ActivityError(`<${this.id}> service not defined`, executeMessage), executeContent);
 
-    broker.subscribeTmp('api', `activity.#.${content.executionId}`, onApiMessage, {consumerTag: `_api-${executionId}`});
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(executeMessage, ...args), {consumerTag: `_api-${executionId}`});
 
-    return service.execute(executeMessage, (err, output) => {
-      broker.cancel(`_api-${executionId}`);
-      if (err) {
-        logger.error(`<${content.executionId} (${id})>`, err);
-        return broker.publish('execution', 'execute.error', cloneContent(content, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
-      }
+  return service.execute(executeMessage, (err, output) => {
+    broker.cancel(`_api-${executionId}`);
+    if (err) {
+      this.activity.logger.error(`<${executionId} (${this.id})>`, err);
+      return broker.publish('execution', 'execute.error', cloneContent(executeContent, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
+    }
 
-      return broker.publish('execution', 'execute.completed', cloneContent(content, {output, state: 'complete'}));
-    });
+    return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output, state: 'complete'}));
+  });
+};
 
-    function onApiMessage(_, message) {
-      if (message.properties.type === 'discard') {
-        broker.cancel(`_api-${executionId}`);
-        if (service && service.discard) service.discard(message);
-        logger.debug(`<${content.executionId} (${id})> discarded`);
-        return broker.publish('execution', 'execute.discard', cloneContent(content, {state: 'discard'}));
-      }
-      if (message.properties.type === 'stop') {
-        broker.cancel(`_api-${executionId}`);
-        if (service && service.stop) service.stop(message);
-        return logger.debug(`<${content.executionId} (${id})> stopped`);
-      }
-    }
+proto.getService = function getService(message) {
+  let Service = this.activity.behaviour.Service;
+  if (!Service) {
+    Service = this.environment.settings.enableDummyService ? DummyService : null;
   }
+  return Service && new Service(this.activity, cloneMessage(message));
+};
 
-  function getService(message) {
-    const Service = behaviour.Service;
-    if (!Service) {
-      return environment.settings.enableDummyService ? DummyService(activity) : null;
+proto._onApiMessage = function onApiMessage(executeMessage, _, message) {
+  const broker = this.broker;
+  switch (message.properties.type) {
+    case 'discard': {
+      const executionId = executeMessage.content.executionId;
+      broker.cancel(`_api-${executionId}`);
+      const service = this.service;
+      if (service) {
+        if (service.discard) service.discard(message);
+        else if (service.stop) service.stop(message);
+      }
+      this.activity.logger.debug(`<${executionId} (${this.id})> discarded`);
+      return broker.publish('execution', 'execute.discard', cloneContent(executeMessage.content, {state: 'discard'}));
     }
-    return Service(activity, cloneMessage(message));
-  }
-
-  function DummyService() {
-    logger.debug(`<${id}> returning dummy service`);
-
-    return {
-      type: 'dummyservice',
-      execute: executeDummyService,
-    };
-
-    function executeDummyService(...args) {
-      logger.debug(`<${id}> executing dummy service`);
-      const next = args.pop();
-      next();
+    case 'stop': {
+      const executionId = executeMessage.content.executionId;
+      broker.cancel(`_api-${executionId}`);
+      const service = this.service;
+      if (service && service.stop) service.stop(message);
+      return this.activity.logger.debug(`<${executionId} (${this.id})> stopped`);
     }
   }
+};
+
+function DummyService(activity) {
+  this.type = 'dummyservice';
+  this.activity = activity;
 }
+
+DummyService.prototype.execute = function executeDummyService(...args) {
+  const activity = this.activity;
+  activity.logger.debug(`<${activity.id}> executing dummy service`);
+  const next = args.pop();
+  next();
+};