bpmn-elements 6.0.1 → 8.0.1

package/src/tasks/SignalTask.js

@@ -1,71 +1,96 @@
 import Activity from '../activity/Activity';
-import { ActivityError } from '../error/Errors';
+import {ActivityError} from '../error/Errors';
 import {cloneContent} from '../messageHelper';
 
 export default function SignalTask(activityDef, context) {
-  return Activity(SignalTaskBehaviour, activityDef, context);
+  return new Activity(SignalTaskBehaviour, activityDef, context);
 }
 
 export function SignalTaskBehaviour(activity) {
-  const {id, type, behaviour, broker} = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  const {id, type, behaviour} = activity;
 
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute,
-  };
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.broker = activity.broker;
+}
 
-  return source;
+const proto = SignalTaskBehaviour.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 executionId = executeContent.executionId;
 
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {noAck: true, consumerTag: `_api-${executionId}`});
-    broker.subscribeTmp('api', '#.signal.*', onDelegatedApiMessage, {noAck: true, consumerTag: `_api-delegated-${executionId}`});
-    broker.publish('event', 'activity.wait', cloneContent(content, {state: 'wait'}));
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(executeMessage, ...args), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+  });
+  broker.subscribeTmp('api', '#.signal.*', (...args) => this._onDelegatedApiMessage(executeMessage, ...args), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
+  });
+  broker.publish('event', 'activity.wait', cloneContent(executeContent, {state: 'wait'}));
+};
 
-    function onDelegatedApiMessage(routingKey, message) {
-      if (!message.properties.delegate) return;
-      const {content: delegateContent} = message;
-      if (!delegateContent || !delegateContent.message) return;
+proto._onDelegatedApiMessage = function onDelegatedApiMessage(executeMessage, routingKey, message) {
+  if (!message.properties.delegate) return;
 
-      const {id: signalId, executionId: signalExecutionId} = delegateContent.message;
-      if (loopCharacteristics && signalExecutionId !== executionId) return;
-      if (signalId !== id && signalExecutionId !== executionId) return;
+  const {content: delegateContent} = message;
+  if (!delegateContent || !delegateContent.message) 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 executeContent = executeMessage.content;
+  const {id: signalId, executionId: signalExecutionId} = delegateContent.message;
+  if (this.loopCharacteristics && signalExecutionId !== executeContent.executionId) return;
+  if (signalId !== this.id && signalExecutionId !== executeContent.executionId) return;
 
-    function onApiMessage(routingKey, message) {
-      const {type: messageType, correlationId} = message.properties;
+  const {type: messageType, correlationId} = message.properties;
+  this.broker.publish('event', 'activity.consumed', cloneContent(executeContent, {
+    message: { ...delegateContent.message},
+  }), {
+    correlationId,
+    type: messageType,
+  });
 
-      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 'error':
-          stop();
-          return broker.publish('execution', 'execute.error', cloneContent(content, {error: new ActivityError(message.content.message, executeMessage, message.content)}, {mandatory: true, correlationId}));
-        case 'discard':
-          stop();
-          return broker.publish('execution', 'execute.discard', cloneContent(content), {correlationId});
-      }
-    }
+  return this._onApiMessage(executeMessage, routingKey, message);
+};
 
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_api-delegated-${executionId}`);
-    }
+proto._onApiMessage = function onApiMessage(executeMessage, routingKey, message) {
+  const {type: messageType, correlationId} = message.properties;
+  const executeContent = executeMessage.content;
+  switch (messageType) {
+    case 'stop':
+      return this._stop(executeContent.executionId);
+    case 'signal':
+      this._stop(executeContent.executionId);
+      return this.broker.publish('execution', 'execute.completed', cloneContent(executeContent, {
+        output: message.content.message,
+        state: 'signal',
+      }), {
+        correlationId,
+      });
+    case 'error':
+      this._stop(executeContent.executionId);
+      return this.broker.publish('execution', 'execute.error', cloneContent(executeContent, {
+        error: new ActivityError(message.content.message, executeMessage, message.content),
+      }, {
+        mandatory: true,
+        correlationId,
+      }));
+    case 'discard':
+      this._stop(executeContent.executionId);
+      return this.broker.publish('execution', 'execute.discard', cloneContent(executeContent), {correlationId});
   }
-}
+};
+
+proto._stop = function stop(executionId) {
+  const broker = this.broker;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
+};

package/src/tasks/StandardLoopCharacteristics.js

@@ -3,6 +3,6 @@ import LoopCharacteristics from './LoopCharacteristics';
 export default function StandardLoopCharacteristics(activity, loopCharacteristics) {
   let {behaviour} = loopCharacteristics;
   behaviour = {...behaviour, isSequential: true};
-  return LoopCharacteristics(activity, {...loopCharacteristics, behaviour});
+  return new LoopCharacteristics(activity, {...loopCharacteristics, behaviour});
 }
 

package/src/tasks/SubProcess.js

@@ -2,9 +2,12 @@ import Activity from '../activity/Activity';
 import ProcessExecution from '../process/ProcessExecution';
 import {cloneContent} from '../messageHelper';
 
+const kExecutions = Symbol.for('executions');
+const kMessageHandlers = Symbol.for('messageHandlers');
+
 export default function SubProcess(activityDef, context) {
   const triggeredByEvent = activityDef.behaviour && activityDef.behaviour.triggeredByEvent;
-  const subProcess = Activity(SubProcessBehaviour, {...activityDef, isSubProcess: true, triggeredByEvent}, context);
+  const subProcess = new Activity(SubProcessBehaviour, {...activityDef, isSubProcess: true, triggeredByEvent}, context);
 
   subProcess.getStartActivities = function getStartActivities(filterOptions) {
     return context.getStartActivities(filterOptions, activityDef.id);
@@ -18,205 +21,229 @@ export default function SubProcess(activityDef, context) {
   function onShake(_, message) {
     const {startId} = message.content;
     const last = message.content.sequence.pop();
-    const sequence = ProcessExecution(subProcess, context).shake(startId);
+    const sequence = new ProcessExecution(subProcess, context).shake(startId);
     message.content.sequence.push({...last, isSubProcess: true, sequence});
   }
 }
 
 export function SubProcessBehaviour(activity, context) {
-  const {id, type, broker, behaviour, environment, logger} = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-
-  const processExecutions = [];
-  let rootExecutionId;
-
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    get execution() {
-      return processExecutions[0];
-    },
-    get executions() {
-      return processExecutions;
-    },
-    execute,
-    getApi,
-    getState,
-    getPostponed() {
-      return this.executions.reduce((result, pe) => {
-        result = result.concat(pe.getPostponed());
-        return result;
-      }, []);
-    },
-    recover,
+  const {id, type, behaviour} = activity;
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.context = context;
+  this.environment = activity.environment;
+  this.broker = activity.broker;
+  this.executionId = undefined;
+
+  this[kExecutions] = [];
+  this[kMessageHandlers] = {
+    onApiRootMessage: this._onApiRootMessage.bind(this),
+    onExecutionCompleted: this._onExecutionCompleted.bind(this),
   };
+}
 
-  return source;
+const proto = SubProcessBehaviour.prototype;
 
-  function execute(executeMessage) {
-    const content = executeMessage.content;
+Object.defineProperty(proto, 'execution', {
+  get() {
+    return this[kExecutions][0];
+  },
+});
 
-    if (content.isRootScope) {
-      rootExecutionId = content.executionId;
-    }
+Object.defineProperty(proto, 'executions', {
+  get() {
+    return this[kExecutions].slice();
+  },
+});
 
-    if (loopCharacteristics && content.isRootScope) {
-      broker.subscribeTmp('api', `activity.#.${rootExecutionId}`, onApiRootMessage, {noAck: true, consumerTag: `_api-${rootExecutionId}`, priority: 200});
-      return loopCharacteristics.execute(executeMessage);
-    }
+proto.execute = function execute(executeMessage) {
+  const content = executeMessage.content;
 
-    const processExecution = upsertExecution(executeMessage);
-    if (!processExecution) return;
+  let executionId = this.executionId;
+  if (content.isRootScope) {
+    executionId = this.executionId = content.executionId;
+  }
 
-    return processExecution.execute(executeMessage);
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && content.isRootScope) {
+    this.broker.subscribeTmp('api', `activity.#.${executionId}`, this[kMessageHandlers].onApiRootMessage, {
+      noAck: true,
+      consumerTag: `_api-${executionId}`,
+      priority: 200,
+    });
 
-    function onApiRootMessage(routingKey, message) {
-      const messageType = message.properties.type;
+    return loopCharacteristics.execute(executeMessage);
+  }
 
-      switch (messageType) {
-        case 'stop':
-          broker.cancel(`_api-${rootExecutionId}`);
-          stop();
-          break;
-        case 'discard':
-          broker.cancel(`_api-${rootExecutionId}`);
-          discard();
-          break;
-      }
-    }
+  const processExecution = this._upsertExecution(executeMessage);
+  if (!processExecution) return;
+
+  return processExecution.execute(executeMessage);
+};
+
+proto.stop = function stop() {
+  for (const execution of this[kExecutions]) {
+    this.broker.cancel(`_sub-process-execution-${execution.executionId}`);
+    this.broker.cancel(`_sub-process-api-${execution.executionId}`);
+    execution.stop();
   }
+};
 
-  function stop() {
-    return processExecutions.forEach((pe) => {
-      broker.cancel(`_sub-process-execution-${pe.executionId}`);
-      broker.cancel(`_sub-process-api-${pe.executionId}`);
-      pe.stop();
-    });
+proto.discard = function discard() {
+  for (const execution of this[kExecutions]) {
+    this.broker.cancel(`_sub-process-execution-${execution.executionId}`);
+    this.broker.cancel(`_sub-process-api-${execution.executionId}`);
+    execution.discard();
+  }
+};
+
+proto.getState = function getState() {
+  if (this.loopCharacteristics) {
+    return {
+      executions: this[kExecutions].map((pe) => {
+        const state = pe.getState();
+        state.environment = pe.environment.getState();
+        return state;
+      }),
+    };
   }
 
-  function discard() {
-    return processExecutions.forEach((pe) => {
-      broker.cancel(`_sub-process-execution-${pe.executionId}`);
-      broker.cancel(`_sub-process-api-${pe.executionId}`);
-      pe.discard();
-    });
+  const execution = this.execution;
+  if (execution) {
+    const state = execution.getState();
+    state.environment = execution.environment.getState();
+    return state;
   }
+};
 
-  function getState() {
-    if (loopCharacteristics) {
-      return {
-        executions: processExecutions.map(getExecutionState),
-      };
-    }
+proto.recover = function recover(state) {
+  if (!state) return;
 
-    if (processExecutions.length) {
-      return getExecutionState(processExecutions[0]);
-    }
+  const executions = this[kExecutions];
 
-    function getExecutionState(pe) {
-      const state = pe.getState();
-      state.environment = pe.environment.getState();
-      return state;
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && state.executions) {
+    executions.splice(0);
+    for (const se of state.executions) {
+      this.recover(se);
     }
+    return;
   }
 
-  function recover(state) {
-    if (!state) return;
-
-    if (loopCharacteristics && state.executions) {
-      processExecutions.splice(0);
-      return state.executions.forEach(recover);
-    } else if (!loopCharacteristics) {
-      processExecutions.splice(0);
-    }
+  if (!loopCharacteristics) {
+    executions.splice(0);
+  }
 
-    const subEnvironment = environment.clone().recover(state.environment);
-    const subContext = context.clone(subEnvironment);
+  const subEnvironment = this.environment.clone().recover(state.environment);
+  const subContext = this.context.clone(subEnvironment);
+
+  const execution = new ProcessExecution(this.activity, subContext).recover(state);
+
+  executions.push(execution);
+  return execution;
+};
+
+proto.getPostponed = function getPostponed() {
+  return this[kExecutions].reduce((result, pe) => {
+    result = result.concat(pe.getPostponed());
+    return result;
+  }, []);
+};
+
+proto._onApiRootMessage = function onApiRootMessage(_, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'stop':
+      this.broker.cancel(message.fields.consumerTag);
+      this.stop();
+      break;
+    case 'discard':
+      this.broker.cancel(message.fields.consumerTag);
+      this.discard();
+      break;
+  }
+};
 
-    const execution = ProcessExecution(activity, subContext).recover(state);
+proto._upsertExecution = function upsertExecution(executeMessage) {
+  const content = executeMessage.content;
+  const executionId = content.executionId;
 
-    processExecutions.push(execution);
+  let execution = this._getExecutionById(executionId);
+  if (execution) {
+    if (executeMessage.fields.redelivered) this._addListeners(execution, executionId);
     return execution;
   }
 
-  function upsertExecution(executeMessage) {
-    const content = executeMessage.content;
-    const executionId = content.executionId;
+  const subEnvironment = this.environment.clone();
+  const subContext = this.context.clone(subEnvironment);
 
-    let execution = getExecutionById(executionId);
-    if (execution) {
-      if (executeMessage.fields.redelivered) addListeners(execution, executionId);
-      return execution;
-    }
+  execution = new ProcessExecution(this.activity, subContext);
+  this[kExecutions].push(execution);
 
-    const subEnvironment = environment.clone({ output: {} });
-    const subContext = context.clone(subEnvironment);
+  this._addListeners(execution, executionId);
 
-    execution = ProcessExecution(activity, subContext);
-    processExecutions.push(execution);
+  return execution;
+};
 
-    addListeners(execution, executionId);
+proto._addListeners = function addListeners(processExecution, executionId) {
+  this.broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, this[kMessageHandlers].onExecutionCompleted, {
+    noAck: true,
+    consumerTag: `_sub-process-execution-${executionId}`,
+  });
+};
 
-    return execution;
-  }
+proto._onExecutionCompleted = function onExecutionCompleted(_, message) {
+  if (message.fields.redelivered && message.properties.persistent === false) return;
 
-  function addListeners(processExecution, executionId) {
-    const executionConsumerTag = `_sub-process-execution-${executionId}`;
-
-    broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, onExecutionCompleted, {noAck: true, consumerTag: executionConsumerTag});
-
-    function onExecutionCompleted(_, message) {
-      const content = message.content;
-      const messageType = message.properties.type;
-
-      if (message.fields.redelivered && message.properties.persistent === false) return;
-
-      switch (messageType) {
-        case 'stopped': {
-          broker.cancel(executionConsumerTag);
-          break;
-        }
-        case 'discard': {
-          broker.cancel(executionConsumerTag);
-          broker.publish('execution', 'execute.discard', cloneContent(content));
-          break;
-        }
-        case 'completed': {
-          broker.cancel(executionConsumerTag);
-          broker.publish('execution', 'execute.completed', cloneContent(content));
-          break;
-        }
-        case 'error': {
-          broker.cancel(executionConsumerTag);
-
-          const {error} = content;
-          logger.error(`<${id}>`, error);
-          broker.publish('execution', 'execute.error', cloneContent(content));
-          break;
-        }
-      }
+  const content = message.content;
+  const messageType = message.properties.type;
+  const broker = this.broker;
+
+  switch (messageType) {
+    case 'stopped': {
+      broker.cancel(message.fields.consumerTag);
+      break;
     }
-  }
+    case 'discard': {
+      broker.cancel(message.fields.consumerTag);
+      broker.publish('execution', 'execute.discard', cloneContent(content));
+      break;
+    }
+    case 'completed': {
+      broker.cancel(message.fields.consumerTag);
+      broker.publish('execution', 'execute.completed', cloneContent(content));
+      break;
+    }
+    case 'error': {
+      broker.cancel(message.fields.consumerTag);
 
-  function getApi(apiMessage) {
-    const content = apiMessage.content;
+      const {error} = content;
+      this.activity.logger.error(`<${this.id}>`, error);
+      broker.publish('execution', 'execute.error', cloneContent(content));
+      break;
+    }
+  }
+};
 
-    if (content.id === id) return;
+proto.getApi = function getApi(apiMessage) {
+  const content = apiMessage.content;
 
-    let execution;
-    if ((execution = getExecutionById(content.parent.executionId))) {
-      return execution.getApi(apiMessage);
-    }
+  if (content.id === this.id) return;
 
-    const parentPath = content.parent.path;
+  let execution;
 
-    for (let i = 0; i < parentPath.length; i++) {
-      if ((execution = getExecutionById(parentPath[i].executionId))) return execution.getApi(apiMessage);
-    }
+  if ((execution = this._getExecutionById(content.parent.executionId))) {
+    return execution.getApi(apiMessage);
   }
 
-  function getExecutionById(executionId) {
-    return processExecutions.find((pe) => pe.executionId === executionId);
+  for (const pp of content.parent.path) {
+    if ((execution = this._getExecutionById(pp.executionId))) return execution.getApi(apiMessage);
   }
-}
+};
+
+proto._getExecutionById = function getExecutionById(executionId) {
+  return this[kExecutions].find((pe) => pe.executionId === executionId);
+};

package/src/tasks/Task.js

@@ -1,28 +1,24 @@
 import Activity from '../activity/Activity';
+import {cloneContent} from '../messageHelper';
 
 export default function Task(activityDef, context) {
-  return Activity(TaskBehaviour, activityDef, context);
+  return new Activity(TaskBehaviour, activityDef, context);
 }
 
 export function TaskBehaviour(activity) {
   const {id, type, behaviour, broker} = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute,
-  };
-
-  return source;
-
-  function execute(executeMessage) {
-    const content = executeMessage.content;
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
-    }
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.broker = broker;
+}
 
-    return broker.publish('execution', 'execute.completed', {...content});
+TaskBehaviour.prototype.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && executeContent.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
   }
-}
+
+  return this.broker.publish('execution', 'execute.completed', cloneContent(executeContent));
+};