bpmn-elements 16.0.0 → 16.2.0

package/dist/Environment.js

@@ -95,7 +95,7 @@ Environment.prototype.assignVariables = function assignVariables(newVars) {
     ...newVars
   };
 };
-Environment.prototype.assignSettings = function assignVariables(newSettings) {
+Environment.prototype.assignSettings = function assignSettings(newSettings) {
   if (!newSettings || typeof newSettings !== 'object') return;
   this.settings = {
     ...this.settings,

package/dist/Scripts.js

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Scripts = Scripts;
 function Scripts() {}
-Scripts.prototype.getScript = function getScript( /*scriptType, activity*/) {};
-Scripts.prototype.register = function register( /*activity*/) {};
+Scripts.prototype.getScript = function getScript(/*scriptType, activity*/) {};
+Scripts.prototype.register = function register(/*activity*/) {};

package/dist/activity/Activity.js

@@ -11,6 +11,7 @@ var _EventBroker = require("../EventBroker.js");
 var _MessageFormatter = require("../MessageFormatter.js");
 var _messageHelper = require("../messageHelper.js");
 var _Errors = require("../error/Errors.js");
+var _outboundEvaluator = require("./outbound-evaluator.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const kActivityDef = Symbol.for('activityDefinition');
 const kConsuming = Symbol.for('consuming');
@@ -84,15 +85,20 @@ function Activity(Behaviour, activityDef, context) {
     inboundTriggers = inboundSequenceFlows.slice();
   }
   const outboundSequenceFlows = context.getOutboundSequenceFlows(id);
+  const isParallelJoin = activityDef.isParallelGateway && inboundSequenceFlows.length > 1;
   const flows = this[kFlows] = {
     inboundSequenceFlows,
     inboundAssociations,
-    inboundJoinFlows: new Set(),
     inboundTriggers,
     outboundSequenceFlows,
-    outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows)
+    outboundEvaluator: new _outboundEvaluator.OutboundEvaluator(this, outboundSequenceFlows),
+    ...(isParallelJoin && {
+      inboundJoinFlows: new Set(),
+      inboundSourceIds: new Set(inboundSequenceFlows.map(({
+        sourceId
+      }) => sourceId))
+    })
   };
-  const isParallelJoin = activityDef.isParallelGateway && flows.inboundSequenceFlows.length > 1;
   this[kFlags] = {
     isEnd: flows.outboundSequenceFlows.length === 0,
     isStart: flows.inboundSequenceFlows.length === 0 && !attachedTo && !behaviour.triggeredByEvent && !isForCompensation,
@@ -508,21 +514,21 @@ Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message)
   } = message;
   const {
     inboundJoinFlows,
-    inboundTriggers
+    inboundSourceIds
   } = this[kFlows];
   let alreadyTouched = false;
   const touched = new Set();
   let taken;
   for (const msg of inboundJoinFlows) {
-    const flowId = msg.content.id;
-    touched.add(flowId);
-    if (flowId === content.id) {
+    const sourceId = msg.content.sourceId;
+    touched.add(sourceId);
+    if (sourceId === content.sourceId) {
       alreadyTouched = true;
     }
   }
   inboundJoinFlows.add(message);
   if (alreadyTouched) return;
-  const remaining = inboundTriggers.length - touched.size - 1;
+  const remaining = inboundSourceIds.size - touched.size - 1;
   if (remaining) {
     return this.logger.debug(`<${this.id}> inbound ${message.content.action} from <${message.content.id}>, ${remaining} remaining`);
   }
@@ -851,11 +857,11 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   }
   let outboundFlows;
   if (isDiscarded) {
-    outboundFlows = outboundSequenceFlows.map(flow => formatFlowAction(flow, {
+    outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, {
       action: 'discard'
     }));
   } else if (fromContent.outbound && fromContent.outbound.length) {
-    outboundFlows = outboundSequenceFlows.map(flow => formatFlowAction(flow, fromContent.outbound.filter(f => f.id === flow.id).pop()));
+    outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, fromContent.outbound.filter(f => f.id === flow.id).pop()));
   }
   if (outboundFlows) {
     this._doRunOutbound(outboundFlows, fromContent, discardSequence);
@@ -868,25 +874,41 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   });
 };
 Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
-  for (const outboundFlow of outboundList) {
-    const {
-      id: flowId,
-      action,
-      result
-    } = outboundFlow;
-    this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
-      flow: {
-        ...(result && typeof result === 'object' && result),
-        ...outboundFlow,
-        sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
-        ...(discardSequence && {
-          discardSequence: discardSequence.slice()
-        })
+  if (outboundList.length === 1) {
+    this._publishRunOutbound(outboundList[0], content, discardSequence);
+  } else {
+    const targets = new Map();
+    for (const outboundFlow of outboundList) {
+      const prevTarget = targets.get(outboundFlow.targetId);
+      if (!prevTarget) {
+        targets.set(outboundFlow.targetId, outboundFlow);
+      } else if (outboundFlow.action === 'take' && outboundFlow.action !== prevTarget.action) {
+        targets.set(outboundFlow.targetId, outboundFlow);
       }
-    }));
+    }
+    for (const outboundFlow of targets.values()) {
+      this._publishRunOutbound(outboundFlow, content, discardSequence);
+    }
   }
   return outboundList;
 };
+Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content, discardSequence) {
+  const {
+    id: flowId,
+    action,
+    result
+  } = outboundFlow;
+  this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
+    flow: {
+      ...(result && typeof result === 'object' && result),
+      ...outboundFlow,
+      sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
+      ...(discardSequence && {
+        discardSequence: discardSequence.slice()
+      })
+    }
+  }));
+};
 Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
   const stateMessage = this[kStateMessage];
@@ -991,128 +1013,4 @@ Activity.prototype._deactivateRunConsumers = function _deactivateRunConsumers()
   this._pauseRunQ();
   broker.cancel('_activity-execution');
   this[kConsuming] = false;
-};
-function OutboundEvaluator(activity, outboundFlows) {
-  this.activity = activity;
-  this.broker = activity.broker;
-  const flows = this.outboundFlows = outboundFlows.slice();
-  const defaultFlowIdx = flows.findIndex(({
-    isDefault
-  }) => isDefault);
-  if (defaultFlowIdx > -1) {
-    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
-    flows.push(defaultFlow);
-  }
-  this.defaultFlowIdx = outboundFlows.findIndex(({
-    isDefault
-  }) => isDefault);
-  this._onEvaluated = this.onEvaluated.bind(this);
-  this.evaluateArgs = {};
-}
-OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
-  const outboundFlows = this.outboundFlows;
-  const args = this.evaluateArgs = {
-    fromMessage,
-    evaluationId: fromMessage.content.executionId,
-    discardRestAtTake,
-    callback,
-    conditionMet: false,
-    result: {},
-    takenCount: 0
-  };
-  if (!outboundFlows.length) return this.completed();
-  const flows = args.flows = outboundFlows.slice();
-  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
-    consumerTag: `_flow-evaluation-${args.evaluationId}`
-  });
-  return this.evaluateFlow(flows.shift());
-};
-OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
-  const content = message.content;
-  const {
-    id: flowId,
-    action,
-    evaluationId
-  } = message.content;
-  const args = this.evaluateArgs;
-  if (action === 'take') {
-    args.takenCount++;
-    args.conditionMet = true;
-  }
-  args.result[flowId] = content;
-  if ('result' in content) {
-    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
-  }
-  let nextFlow = args.flows.shift();
-  if (!nextFlow) return this.completed();
-  if (args.discardRestAtTake && args.conditionMet) {
-    do {
-      args.result[nextFlow.id] = formatFlowAction(nextFlow, {
-        action: 'discard'
-      });
-    } while (nextFlow = args.flows.shift());
-    return this.completed();
-  }
-  if (args.conditionMet && nextFlow.isDefault) {
-    args.result[nextFlow.id] = formatFlowAction(nextFlow, {
-      action: 'discard'
-    });
-    return this.completed();
-  }
-  message.ack();
-  this.evaluateFlow(nextFlow);
-};
-OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
-  const broker = this.broker;
-  const {
-    fromMessage,
-    evaluationId
-  } = this.evaluateArgs;
-  flow.evaluate((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
-    if (err) return this.completed(err);
-    const action = result ? 'take' : 'discard';
-    return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {
-      action,
-      result,
-      evaluationId
-    }), {
-      persistent: false
-    });
-  });
-};
-OutboundEvaluator.prototype.completed = function completed(err) {
-  const {
-    callback,
-    evaluationId,
-    fromMessage,
-    result,
-    takenCount
-  } = this.evaluateArgs;
-  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
-  if (err) return callback(err);
-  if (!takenCount && this.outboundFlows.length) {
-    const nonTakenError = new _Errors.ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
-    return callback(nonTakenError);
-  }
-  const message = fromMessage.content.message;
-  const evaluationResult = [];
-  for (const flow of Object.values(result)) {
-    evaluationResult.push({
-      ...flow,
-      ...(message !== undefined && {
-        message
-      })
-    });
-  }
-  return callback(null, evaluationResult);
-};
-function formatFlowAction(flow, options) {
-  return {
-    ...options,
-    id: flow.id,
-    action: options.action,
-    ...(flow.isDefault && {
-      isDefault: true
-    })
-  };
-}
+};

package/dist/activity/outbound-evaluator.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OutboundEvaluator = OutboundEvaluator;
+exports.formatFlowAction = formatFlowAction;
+var _Errors = require("../error/Errors.js");
+var _messageHelper = require("../messageHelper.js");
+function OutboundEvaluator(activity, outboundFlows) {
+  this.activity = activity;
+  this.broker = activity.broker;
+  const flows = this.outboundFlows = outboundFlows.slice();
+  const defaultFlowIdx = flows.findIndex(({
+    isDefault
+  }) => isDefault);
+  if (defaultFlowIdx > -1) {
+    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
+    flows.push(defaultFlow);
+  }
+  this.defaultFlowIdx = outboundFlows.findIndex(({
+    isDefault
+  }) => isDefault);
+  this._onEvaluated = this.onEvaluated.bind(this);
+  this.evaluateArgs = {};
+}
+OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
+  const outboundFlows = this.outboundFlows;
+  const args = this.evaluateArgs = {
+    fromMessage,
+    evaluationId: fromMessage.content.executionId,
+    discardRestAtTake,
+    callback,
+    conditionMet: false,
+    result: {},
+    takenCount: 0
+  };
+  if (!outboundFlows.length) return this.completed();
+  const flows = args.flows = outboundFlows.slice();
+  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
+    consumerTag: `_flow-evaluation-${args.evaluationId}`
+  });
+  return this.evaluateFlow(flows.shift());
+};
+OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
+  const content = message.content;
+  const {
+    id: flowId,
+    action,
+    evaluationId
+  } = message.content;
+  const args = this.evaluateArgs;
+  if (action === 'take') {
+    args.takenCount++;
+    args.conditionMet = true;
+  }
+  args.result[flowId] = content;
+  if ('result' in content) {
+    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
+  }
+  let nextFlow = args.flows.shift();
+  if (!nextFlow) return this.completed();
+  if (args.discardRestAtTake && args.conditionMet) {
+    do {
+      args.result[nextFlow.id] = formatFlowAction(nextFlow, {
+        action: 'discard'
+      });
+    } while (nextFlow = args.flows.shift());
+    return this.completed();
+  }
+  if (args.conditionMet && nextFlow.isDefault) {
+    args.result[nextFlow.id] = formatFlowAction(nextFlow, {
+      action: 'discard'
+    });
+    return this.completed();
+  }
+  message.ack();
+  this.evaluateFlow(nextFlow);
+};
+OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
+  const broker = this.broker;
+  const {
+    fromMessage,
+    evaluationId
+  } = this.evaluateArgs;
+  flow.evaluate((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
+    if (err) return this.completed(err);
+    const action = result ? 'take' : 'discard';
+    return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {
+      action,
+      result,
+      evaluationId
+    }), {
+      persistent: false
+    });
+  });
+};
+OutboundEvaluator.prototype.completed = function completed(err) {
+  const {
+    callback,
+    evaluationId,
+    fromMessage,
+    result,
+    takenCount
+  } = this.evaluateArgs;
+  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
+  if (err) return callback(err);
+  if (!takenCount && this.outboundFlows.length) {
+    const nonTakenError = new _Errors.ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
+    return callback(nonTakenError);
+  }
+  const message = fromMessage.content.message;
+  const evaluationResult = [];
+  for (const flow of Object.values(result)) {
+    evaluationResult.push({
+      ...flow,
+      ...(message !== undefined && {
+        message
+      })
+    });
+  }
+  return callback(null, evaluationResult);
+};
+function formatFlowAction(flow, options) {
+  return {
+    ...options,
+    id: flow.id,
+    action: options.action,
+    targetId: flow.targetId,
+    ...(flow.isDefault && {
+      isDefault: true
+    })
+  };
+}

package/dist/eventDefinitions/TimerEventDefinition.js

@@ -124,6 +124,8 @@ TimerEventDefinition.prototype._completed = function completed(completeContent,
       ...content,
       repeat
     }), options);
+  } else if (timerContent.repeat === -1) {
+    broker.publish('execution', 'execute.repeat', (0, _messageHelper.cloneContent)(timerContent, content), options);
   }
   broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(timerContent, content), options);
 };

package/dist/events/BoundaryEvent.js

@@ -72,7 +72,9 @@ BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
     });
     broker.bindQueue(execQ.name, 'execution', 'execute.detach');
     broker.bindQueue(execQ.name, 'execution', 'execute.bound.completed');
-    broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+    if (!this.cancelActivity) {
+      broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+    }
     if (eventDefinitionExecution && !this.environment.settings.strict) {
       broker.bindQueue(execQ.name, 'execution', 'execute.expect');
     }
@@ -218,7 +220,6 @@ BoundaryEventBehaviour.prototype._onApiMessage = function onApiMessage(_, messag
   }
 };
 BoundaryEventBehaviour.prototype._onRepeatMessage = function onRepeatMessage(_, message) {
-  if (this.cancelActivity) return;
   const executeMessage = this[kExecuteMessage];
   const repeat = message.content.repeat;
   this.broker.getQueue('inbound-q').queueMessage({

package/dist/gateways/EventBasedGateway.js

@@ -19,7 +19,7 @@ function EventBasedGatewayBehaviour(activity, context) {
   this.activity = activity;
   this.broker = activity.broker;
   this.context = context;
-  this[kTargets] = activity.outbound.map(flow => context.getActivityById(flow.targetId));
+  this[kTargets] = new Set(activity.outbound.map(flow => context.getActivityById(flow.targetId)));
 }
 EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
@@ -30,7 +30,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
   } = executeContent;
   const targets = this[kTargets];
   this[kCompleted] = false;
-  if (!targets.length) return this._complete(executeContent);
+  if (!targets.size) return this._complete(executeContent);
   for (const flow of this.activity.outbound) {
     outbound.push({
       id: flow.id,
@@ -50,9 +50,11 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
     consumerTag: '_api-stop-execution'
   });
   this[kCompleted] = false;
-  if (!executeMessage.fields.redelivered) return broker.publish('execution', 'execute.outbound.take', (0, _messageHelper.cloneContent)(executeContent, {
-    outboundTaken: true
-  }));
+  if (!executeMessage.fields.redelivered) {
+    return broker.publish('execution', 'execute.outbound.take', (0, _messageHelper.cloneContent)(executeContent, {
+      outboundTaken: true
+    }));
+  }
 };
 EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompleted(executeMessage, _, message, owner) {
   const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "16.0.0",
+  "version": "16.2.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -103,7 +103,7 @@
     "texample": "^0.0.6"
   },
   "dependencies": {
-    "@0dep/piso": "^2.0.0",
+    "@0dep/piso": "^2.0.2",
     "smqp": "^9.0.2"
   }
 }

package/src/Environment.js

@@ -88,7 +88,7 @@ Environment.prototype.assignVariables = function assignVariables(newVars) {
   };
 };
 
-Environment.prototype.assignSettings = function assignVariables(newSettings) {
+Environment.prototype.assignSettings = function assignSettings(newSettings) {
   if (!newSettings || typeof newSettings !== 'object') return;
 
   this.settings = {

package/src/activity/Activity.js

@@ -5,6 +5,7 @@ import { ActivityBroker } from '../EventBroker.js';
 import { Formatter } from '../MessageFormatter.js';
 import { cloneContent, cloneParent, cloneMessage } from '../messageHelper.js';
 import { makeErrorFromMessage, ActivityError } from '../error/Errors.js';
+import { OutboundEvaluator, formatFlowAction } from './outbound-evaluator.js';
 
 const kActivityDef = Symbol.for('activityDefinition');
 const kConsuming = Symbol.for('consuming');
@@ -68,16 +69,21 @@ function Activity(Behaviour, activityDef, context) {
     inboundTriggers = inboundSequenceFlows.slice();
   }
   const outboundSequenceFlows = context.getOutboundSequenceFlows(id);
+
+  const isParallelJoin = activityDef.isParallelGateway && inboundSequenceFlows.length > 1;
+
   const flows = (this[kFlows] = {
     inboundSequenceFlows,
     inboundAssociations,
-    inboundJoinFlows: new Set(),
     inboundTriggers,
     outboundSequenceFlows,
     outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows),
+    ...(isParallelJoin && {
+      inboundJoinFlows: new Set(),
+      inboundSourceIds: new Set(inboundSequenceFlows.map(({ sourceId }) => sourceId)),
+    }),
   });
 
-  const isParallelJoin = activityDef.isParallelGateway && flows.inboundSequenceFlows.length > 1;
   this[kFlags] = {
     isEnd: flows.outboundSequenceFlows.length === 0,
     isStart: flows.inboundSequenceFlows.length === 0 && !attachedTo && !behaviour.triggeredByEvent && !isForCompensation,
@@ -502,16 +508,16 @@ Activity.prototype._onInbound = function onInbound(routingKey, message) {
 
 Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message) {
   const { content } = message;
-  const { inboundJoinFlows, inboundTriggers } = this[kFlows];
+  const { inboundJoinFlows, inboundSourceIds } = this[kFlows];
   let alreadyTouched = false;
 
   const touched = new Set();
 
   let taken;
   for (const msg of inboundJoinFlows) {
-    const flowId = msg.content.id;
-    touched.add(flowId);
-    if (flowId === content.id) {
+    const sourceId = msg.content.sourceId;
+    touched.add(sourceId);
+    if (sourceId === content.sourceId) {
       alreadyTouched = true;
     }
   }
@@ -520,7 +526,7 @@ Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message)
 
   if (alreadyTouched) return;
 
-  const remaining = inboundTriggers.length - touched.size - 1;
+  const remaining = inboundSourceIds.size - touched.size - 1;
   if (remaining) {
     return this.logger.debug(`<${this.id}> inbound ${message.content.action} from <${message.content.id}>, ${remaining} remaining`);
   }
@@ -845,24 +851,44 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
 };
 
 Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
-  for (const outboundFlow of outboundList) {
-    const { id: flowId, action, result } = outboundFlow;
-    this.broker.publish(
-      'run',
-      'run.outbound.' + action,
-      cloneContent(content, {
-        flow: {
-          ...(result && typeof result === 'object' && result),
-          ...outboundFlow,
-          sequenceId: getUniqueId(`${flowId}_${action}`),
-          ...(discardSequence && { discardSequence: discardSequence.slice() }),
-        },
-      }),
-    );
+  if (outboundList.length === 1) {
+    this._publishRunOutbound(outboundList[0], content, discardSequence);
+  } else {
+    const targets = new Map();
+
+    for (const outboundFlow of outboundList) {
+      const prevTarget = targets.get(outboundFlow.targetId);
+      if (!prevTarget) {
+        targets.set(outboundFlow.targetId, outboundFlow);
+      } else if (outboundFlow.action === 'take' && outboundFlow.action !== prevTarget.action) {
+        targets.set(outboundFlow.targetId, outboundFlow);
+      }
+    }
+
+    for (const outboundFlow of targets.values()) {
+      this._publishRunOutbound(outboundFlow, content, discardSequence);
+    }
   }
+
   return outboundList;
 };
 
+Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content, discardSequence) {
+  const { id: flowId, action, result } = outboundFlow;
+  this.broker.publish(
+    'run',
+    'run.outbound.' + action,
+    cloneContent(content, {
+      flow: {
+        ...(result && typeof result === 'object' && result),
+        ...outboundFlow,
+        sequenceId: getUniqueId(`${flowId}_${action}`),
+        ...(discardSequence && { discardSequence: discardSequence.slice() }),
+      },
+    }),
+  );
+};
+
 Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
 
@@ -973,128 +999,3 @@ Activity.prototype._deactivateRunConsumers = function _deactivateRunConsumers()
   broker.cancel('_activity-execution');
   this[kConsuming] = false;
 };
-
-function OutboundEvaluator(activity, outboundFlows) {
-  this.activity = activity;
-  this.broker = activity.broker;
-  const flows = (this.outboundFlows = outboundFlows.slice());
-  const defaultFlowIdx = flows.findIndex(({ isDefault }) => isDefault);
-  if (defaultFlowIdx > -1) {
-    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
-    flows.push(defaultFlow);
-  }
-
-  this.defaultFlowIdx = outboundFlows.findIndex(({ isDefault }) => isDefault);
-  this._onEvaluated = this.onEvaluated.bind(this);
-  this.evaluateArgs = {};
-}
-
-OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
-  const outboundFlows = this.outboundFlows;
-
-  const args = (this.evaluateArgs = {
-    fromMessage,
-    evaluationId: fromMessage.content.executionId,
-    discardRestAtTake,
-    callback,
-    conditionMet: false,
-    result: {},
-    takenCount: 0,
-  });
-
-  if (!outboundFlows.length) return this.completed();
-
-  const flows = (args.flows = outboundFlows.slice());
-
-  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
-    consumerTag: `_flow-evaluation-${args.evaluationId}`,
-  });
-
-  return this.evaluateFlow(flows.shift());
-};
-
-OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
-  const content = message.content;
-  const { id: flowId, action, evaluationId } = message.content;
-  const args = this.evaluateArgs;
-
-  if (action === 'take') {
-    args.takenCount++;
-    args.conditionMet = true;
-  }
-
-  args.result[flowId] = content;
-
-  if ('result' in content) {
-    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
-  }
-
-  let nextFlow = args.flows.shift();
-  if (!nextFlow) return this.completed();
-
-  if (args.discardRestAtTake && args.conditionMet) {
-    do {
-      args.result[nextFlow.id] = formatFlowAction(nextFlow, { action: 'discard' });
-    } while ((nextFlow = args.flows.shift()));
-    return this.completed();
-  }
-
-  if (args.conditionMet && nextFlow.isDefault) {
-    args.result[nextFlow.id] = formatFlowAction(nextFlow, { action: 'discard' });
-    return this.completed();
-  }
-
-  message.ack();
-  this.evaluateFlow(nextFlow);
-};
-
-OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
-  const broker = this.broker;
-  const { fromMessage, evaluationId } = this.evaluateArgs;
-  flow.evaluate(cloneMessage(fromMessage), (err, result) => {
-    if (err) return this.completed(err);
-    const action = result ? 'take' : 'discard';
-    return broker.publish(
-      'execution',
-      'evaluate.flow.' + action,
-      formatFlowAction(flow, {
-        action,
-        result,
-        evaluationId,
-      }),
-      { persistent: false },
-    );
-  });
-};
-
-OutboundEvaluator.prototype.completed = function completed(err) {
-  const { callback, evaluationId, fromMessage, result, takenCount } = this.evaluateArgs;
-  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
-
-  if (err) return callback(err);
-
-  if (!takenCount && this.outboundFlows.length) {
-    const nonTakenError = new ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
-    return callback(nonTakenError);
-  }
-
-  const message = fromMessage.content.message;
-  const evaluationResult = [];
-  for (const flow of Object.values(result)) {
-    evaluationResult.push({
-      ...flow,
-      ...(message !== undefined && { message }),
-    });
-  }
-
-  return callback(null, evaluationResult);
-};
-
-function formatFlowAction(flow, options) {
-  return {
-    ...options,
-    id: flow.id,
-    action: options.action,
-    ...(flow.isDefault && { isDefault: true }),
-  };
-}

package/src/activity/outbound-evaluator.js

@@ -0,0 +1,128 @@
+import { ActivityError } from '../error/Errors.js';
+import { cloneMessage } from '../messageHelper.js';
+
+export function OutboundEvaluator(activity, outboundFlows) {
+  this.activity = activity;
+  this.broker = activity.broker;
+  const flows = (this.outboundFlows = outboundFlows.slice());
+  const defaultFlowIdx = flows.findIndex(({ isDefault }) => isDefault);
+  if (defaultFlowIdx > -1) {
+    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
+    flows.push(defaultFlow);
+  }
+
+  this.defaultFlowIdx = outboundFlows.findIndex(({ isDefault }) => isDefault);
+  this._onEvaluated = this.onEvaluated.bind(this);
+  this.evaluateArgs = {};
+}
+
+OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
+  const outboundFlows = this.outboundFlows;
+
+  const args = (this.evaluateArgs = {
+    fromMessage,
+    evaluationId: fromMessage.content.executionId,
+    discardRestAtTake,
+    callback,
+    conditionMet: false,
+    result: {},
+    takenCount: 0,
+  });
+
+  if (!outboundFlows.length) return this.completed();
+
+  const flows = (args.flows = outboundFlows.slice());
+
+  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
+    consumerTag: `_flow-evaluation-${args.evaluationId}`,
+  });
+
+  return this.evaluateFlow(flows.shift());
+};
+
+OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
+  const content = message.content;
+  const { id: flowId, action, evaluationId } = message.content;
+  const args = this.evaluateArgs;
+
+  if (action === 'take') {
+    args.takenCount++;
+    args.conditionMet = true;
+  }
+
+  args.result[flowId] = content;
+
+  if ('result' in content) {
+    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
+  }
+
+  let nextFlow = args.flows.shift();
+  if (!nextFlow) return this.completed();
+
+  if (args.discardRestAtTake && args.conditionMet) {
+    do {
+      args.result[nextFlow.id] = formatFlowAction(nextFlow, { action: 'discard' });
+    } while ((nextFlow = args.flows.shift()));
+    return this.completed();
+  }
+
+  if (args.conditionMet && nextFlow.isDefault) {
+    args.result[nextFlow.id] = formatFlowAction(nextFlow, { action: 'discard' });
+    return this.completed();
+  }
+
+  message.ack();
+  this.evaluateFlow(nextFlow);
+};
+
+OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
+  const broker = this.broker;
+  const { fromMessage, evaluationId } = this.evaluateArgs;
+  flow.evaluate(cloneMessage(fromMessage), (err, result) => {
+    if (err) return this.completed(err);
+    const action = result ? 'take' : 'discard';
+    return broker.publish(
+      'execution',
+      'evaluate.flow.' + action,
+      formatFlowAction(flow, {
+        action,
+        result,
+        evaluationId,
+      }),
+      { persistent: false },
+    );
+  });
+};
+
+OutboundEvaluator.prototype.completed = function completed(err) {
+  const { callback, evaluationId, fromMessage, result, takenCount } = this.evaluateArgs;
+  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
+
+  if (err) return callback(err);
+
+  if (!takenCount && this.outboundFlows.length) {
+    const nonTakenError = new ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
+    return callback(nonTakenError);
+  }
+
+  const message = fromMessage.content.message;
+  const evaluationResult = [];
+  for (const flow of Object.values(result)) {
+    evaluationResult.push({
+      ...flow,
+      ...(message !== undefined && { message }),
+    });
+  }
+
+  return callback(null, evaluationResult);
+};
+
+export function formatFlowAction(flow, options) {
+  return {
+    ...options,
+    id: flow.id,
+    action: options.action,
+    targetId: flow.targetId,
+    ...(flow.isDefault && { isDefault: true }),
+  };
+}

package/src/eventDefinitions/TimerEventDefinition.js

@@ -125,6 +125,8 @@ TimerEventDefinition.prototype._completed = function completed(completeContent,
   if (timerContent.repeat > 1) {
     const repeat = timerContent.repeat - 1;
     broker.publish('execution', 'execute.repeat', cloneContent(timerContent, { ...content, repeat }), options);
+  } else if (timerContent.repeat === -1) {
+    broker.publish('execution', 'execute.repeat', cloneContent(timerContent, content), options);
   }
 
   broker.publish('execution', 'execute.completed', cloneContent(timerContent, content), options);

package/src/events/BoundaryEvent.js

@@ -69,7 +69,11 @@ BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
     const execQ = broker.assertQueue(`_bound-execution-${executionId}`, { durable: false, autoDelete: true });
     broker.bindQueue(execQ.name, 'execution', 'execute.detach');
     broker.bindQueue(execQ.name, 'execution', 'execute.bound.completed');
-    broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+
+    if (!this.cancelActivity) {
+      broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+    }
+
     if (eventDefinitionExecution && !this.environment.settings.strict) {
       broker.bindQueue(execQ.name, 'execution', 'execute.expect');
     }
@@ -226,7 +230,6 @@ BoundaryEventBehaviour.prototype._onApiMessage = function onApiMessage(_, messag
 };
 
 BoundaryEventBehaviour.prototype._onRepeatMessage = function onRepeatMessage(_, message) {
-  if (this.cancelActivity) return;
   const executeMessage = this[kExecuteMessage];
   const repeat = message.content.repeat;
   this.broker

package/src/gateways/EventBasedGateway.js

@@ -14,7 +14,7 @@ export function EventBasedGatewayBehaviour(activity, context) {
   this.activity = activity;
   this.broker = activity.broker;
   this.context = context;
-  this[kTargets] = activity.outbound.map((flow) => context.getActivityById(flow.targetId));
+  this[kTargets] = new Set(activity.outbound.map((flow) => context.getActivityById(flow.targetId)));
 }
 
 EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage) {
@@ -23,7 +23,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
 
   const targets = this[kTargets];
   this[kCompleted] = false;
-  if (!targets.length) return this._complete(executeContent);
+  if (!targets.size) return this._complete(executeContent);
 
   for (const flow of this.activity.outbound) {
     outbound.push({ id: flow.id, action: 'take' });
@@ -44,8 +44,10 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
   });
 
   this[kCompleted] = false;
-  if (!executeMessage.fields.redelivered)
+
+  if (!executeMessage.fields.redelivered) {
     return broker.publish('execution', 'execute.outbound.take', cloneContent(executeContent, { outboundTaken: true }));
+  }
 };
 
 EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompleted(executeMessage, _, message, owner) {