bpmn-elements 16.1.0 → 16.2.1

package/src/Environment.js

@@ -59,7 +59,7 @@ Environment.prototype.recover = function recover(state) {
   return this;
 };
 
-Environment.prototype.clone = function clone(overrideOptions = {}) {
+Environment.prototype.clone = function clone(overrideOptions) {
   const services = this[kServices];
   const newOptions = {
     settings: { ...this.settings },
@@ -74,7 +74,7 @@ Environment.prototype.clone = function clone(overrideOptions = {}) {
     services,
   };
 
-  if (overrideOptions.services) newOptions.services = { ...services, ...overrideOptions.services };
+  if (overrideOptions?.services) newOptions.services = { ...services, ...overrideOptions.services };
 
   return new this.constructor(newOptions);
 };
@@ -109,7 +109,7 @@ Environment.prototype.getServiceByName = function getServiceByName(serviceName)
   return this[kServices][serviceName];
 };
 
-Environment.prototype.resolveExpression = function resolveExpression(expression, message = {}, expressionFnContext) {
+Environment.prototype.resolveExpression = function resolveExpression(expression, message, expressionFnContext) {
   const from = {
     environment: this,
     ...message,

package/src/EventBroker.js

@@ -78,7 +78,7 @@ EventBroker.prototype.on = function on(eventName, callback, eventOptions = { onc
   }
 };
 
-EventBroker.prototype.once = function once(eventName, callback, eventOptions = {}) {
+EventBroker.prototype.once = function once(eventName, callback, eventOptions) {
   return this.on(eventName, callback, { ...eventOptions, once: true });
 };
 

package/src/MessageFormatter.js

@@ -65,7 +65,7 @@ Formatter.prototype._onMessage = function onMessage(routingKey, message) {
     default: {
       message.ack();
 
-      const endRoutingKey = message.content && message.content.endRoutingKey;
+      const endRoutingKey = message.content?.endRoutingKey;
       if (endRoutingKey) {
         this._decorate(message.content);
         pending.push(message);
@@ -99,7 +99,7 @@ Formatter.prototype._complete = function complete(message, isError) {
   this.broker.cancel(message.fields.consumerTag);
 
   if (isError) {
-    const error = (message.content && message.content.error) || new Error('formatting failed');
+    const error = message.content?.error || new Error('formatting failed');
     const errMessage = error.message || 'formatting failed';
     this._debug(`formatting of ${formatKey} failed with ${message.fields.routingKey}: ${errMessage}`);
     return callback(new ActivityError(errMessage, cloneMessage(runMessage), error));

package/src/Tracker.js

@@ -30,6 +30,7 @@ ActivityTracker.prototype.track = function track(routingKey, message) {
       break;
     case 'activity.execution.outbound.take':
     case 'activity.detach':
+    case 'activity.call':
     case 'activity.wait': {
       if (content.isMultiInstance) this._waiting(content.parent.executionId);
       else this._waiting(executionId);

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,
@@ -88,7 +94,7 @@ function Activity(Behaviour, activityDef, context) {
     isTransaction: activityDef.isTransaction,
     isParallelJoin,
     isThrowing: activityDef.isThrowing,
-    lane: activityDef.lane && activityDef.lane.id,
+    lane: activityDef.lane?.id,
   };
   this[kExec] = new Map();
 
@@ -99,7 +105,7 @@ function Activity(Behaviour, activityDef, context) {
     onExecutionMessage: this._onExecutionMessage.bind(this),
   };
 
-  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
+  this[kEventDefinitions] = eventDefinitions?.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
   this[kExtensions] = context.loadExtensions(this);
   this[kConsuming] = false;
   this[kConsumingRunQ] = undefined;
@@ -129,7 +135,7 @@ Object.defineProperties(Activity.prototype, {
   bpmnIo: {
     get() {
       const extensions = this[kExtensions];
-      return extensions && extensions.extensions.find((e) => e.type === 'bpmnio');
+      return extensions?.extensions.find((e) => e.type === 'bpmnio');
     },
   },
   formatter: {
@@ -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`);
   }
@@ -649,7 +655,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       break;
     }
     case 'run.execute.passthrough': {
-      const execution = this.execution;
+      const execution = this[kExec].get('execution');
       if (!isRedelivered && execution) {
         if (execution.completed) return message.ack();
         this[kExecuteMessage] = message;
@@ -660,13 +666,19 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       this.status = 'executing';
       this[kExecuteMessage] = message;
 
-      const exec = this[kExec];
       if (isRedelivered && this.extensions) this.extensions.activate(cloneMessage(message));
-      if (!exec.has('execution')) exec.set('execution', new ActivityExecution(this, this.context));
+
+      const exec = this[kExec];
+      let execution = exec.get('execution');
+      if (!execution) {
+        execution = new ActivityExecution(this, this.context);
+        exec.set('execution', execution);
+      }
+
       this.broker
         .getQueue('execution-q')
         .assertConsumer(this[kMessageHandlers].onExecutionMessage, { exclusive: true, consumerTag: '_activity-execution' });
-      return exec.get('execution').execute(message);
+      return execution.execute(message);
     }
     case 'run.end': {
       this.logger.debug(`<${id}> end`, isRedelivered ? 'redelivered' : '');
@@ -821,14 +833,14 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   const fromContent = fromMessage.content;
 
   let discardSequence = fromContent.discardSequence;
-  if (isDiscarded && !discardSequence && this[kFlags].attachedTo && fromContent.inbound && fromContent.inbound[0]) {
+  if (isDiscarded && !discardSequence && this[kFlags].attachedTo && fromContent.inbound?.[0]) {
     discardSequence = [fromContent.inbound[0].id];
   }
 
   let outboundFlows;
   if (isDiscarded) {
     outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, { action: 'discard' }));
-  } else if (fromContent.outbound && fromContent.outbound.length) {
+  } else if (fromContent.outbound?.length) {
     outboundFlows = outboundSequenceFlows.map((flow) => formatFlowAction(flow, fromContent.outbound.filter((f) => f.id === flow.id).pop()));
   }
 
@@ -845,24 +857,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();
 
@@ -888,7 +920,7 @@ Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   return this.broker.publish('run', fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
 };
 
-Activity.prototype._publishEvent = function publishEvent(state, content, properties = {}) {
+Activity.prototype._publishEvent = function publishEvent(state, content, properties) {
   this.broker.publish('event', `activity.${state}`, cloneContent(content, { state }), {
     ...properties,
     type: state,
@@ -943,9 +975,8 @@ Activity.prototype._onApiMessage = function onApiMessage(routingKey, message) {
 };
 
 Activity.prototype._createMessage = function createMessage(override) {
-  const name = this.name,
-    status = this.status,
-    parent = this.parent;
+  const { name, status, parent } = this;
+
   const result = {
     ...override,
     id: this.id,
@@ -973,128 +1004,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/ActivityExecution.js

@@ -32,7 +32,7 @@ Object.defineProperty(ActivityExecution.prototype, 'completed', {
 
 ActivityExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Execution requires message');
-  const executionId = executeMessage.content && executeMessage.content.executionId;
+  const executionId = executeMessage.content?.executionId;
   if (!executionId) throw new Error('Execution requires execution id');
 
   this.executionId = executionId;
@@ -347,7 +347,7 @@ ActivityExecution.prototype._onParentApiMessage = function onParentApiMessage(ro
 };
 
 ActivityExecution.prototype._onStop = function onStop(message) {
-  const stoppedId = message && message.content && message.content.executionId;
+  const stoppedId = message?.content?.executionId;
   const running = this.getPostponed();
   for (const api of running) {
     if (stoppedId !== api.content.executionId) {

package/src/activity/outbound-evaluator.js

@@ -0,0 +1,127 @@
+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._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/definition/Definition.js

@@ -98,7 +98,7 @@ Object.defineProperties(Definition.prototype, {
   activityStatus: {
     get() {
       const execution = this[kExec].get('execution');
-      return (execution && execution.activityStatus) || 'idle';
+      return execution?.activityStatus || 'idle';
     },
   },
 });
@@ -160,7 +160,7 @@ Definition.prototype.getState = function getState() {
     stopped: this.stopped,
     counters: this.counters,
     environment: this.environment.getState(),
-    execution: this.execution && this.execution.getState(),
+    execution: this.execution?.getState(),
     broker: this.broker.getState(true),
   });
 };
@@ -289,8 +289,8 @@ Definition.prototype.cancelActivity = function cancelActivity(message) {
 Definition.prototype.sendMessage = function sendMessage(message) {
   const messageContent = { message };
   let messageType = 'message';
-  const reference = message && message.id && this.getElementById(message.id);
-  if (reference && reference.resolve) {
+  const reference = message?.id && this.getElementById(message.id);
+  if (reference?.resolve) {
     const resolvedReference = reference.resolve(this._createMessage({ message }));
     messageType = resolvedReference.messageType || messageType;
     messageContent.message = { ...message, ...resolvedReference };

package/src/definition/DefinitionExecution.js

@@ -408,7 +408,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       this[kStatus] = 'executing';
       break;
     case 'process.discarded': {
-      if (inbound && inbound.length) {
+      if (inbound?.length) {
         const calledFrom = inbound[0];
         this._getProcessApi({ content: calledFrom }).cancel({
           executionId: calledFrom.executionId,
@@ -417,7 +417,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       break;
     }
     case 'process.end': {
-      if (inbound && inbound.length) {
+      if (inbound?.length) {
         const calledFrom = inbound[0];
 
         this._getProcessApi({ content: calledFrom }).signal({
@@ -430,7 +430,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       break;
     }
     case 'process.error': {
-      if (inbound && inbound.length) {
+      if (inbound?.length) {
         const calledFrom = inbound[0];
 
         this._getProcessApi({ content: calledFrom }).sendApiMessage(
@@ -478,7 +478,7 @@ DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(
   message.ack();
   this._debug(`left <${executionId} (${id})> (${type}), pending runs ${this.postponedCount}`);
 
-  if (inbound && inbound.length) {
+  if (inbound?.length) {
     const bp = this._removeProcessByExecutionId(executionId);
     this._deactivateProcess(bp);
   }
@@ -651,7 +651,7 @@ DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(ro
   const delegateMessage = executeMessage.content.message;
 
   const reference = this.context.getActivityById(delegateMessage.id);
-  const message = reference && reference.resolve(executeMessage);
+  const message = reference?.resolve(executeMessage);
 
   this._debug(
     `<${reference ? `${messageType} ${delegateMessage.id}>` : `anonymous ${messageType}`} event received from <${content.parent.id}.${content.id}>. Delegating.`,
@@ -710,7 +710,7 @@ DefinitionExecution.prototype._complete = function complete(completionType, cont
   );
 };
 
-DefinitionExecution.prototype._createMessage = function createMessage(content = {}) {
+DefinitionExecution.prototype._createMessage = function createMessage(content) {
   return {
     id: this.id,
     type: this.type,

package/src/error/Errors.js

@@ -6,8 +6,7 @@ class ActivityError extends Error {
     this.type = 'ActivityError';
     this.name = this.constructor.name;
     this.description = description;
-    if (sourceMessage)
-      this.source = cloneMessage(sourceMessage, sourceMessage.content && sourceMessage.content.error && { error: undefined });
+    if (sourceMessage) this.source = cloneMessage(sourceMessage, sourceMessage.content?.error && { error: undefined });
     if (inner) {
       this.inner = inner;
       if (inner.name) this.name = inner.name;
@@ -24,17 +23,14 @@ class RunError extends ActivityError {
 }
 
 class BpmnError extends Error {
-  constructor(description, behaviour = {}, sourceMessage, inner) {
-    const { errorCode } = behaviour;
-
+  constructor(description, behaviour, sourceMessage, inner) {
     super(description);
     this.type = 'BpmnError';
-    this.name = behaviour.name || this.constructor.name;
+    this.name = behaviour?.name ?? this.constructor.name;
     this.description = description;
-    this.code = ('errorCode' in behaviour && errorCode && errorCode.toString()) || behaviour.code;
-    this.id = behaviour.id;
-    if (sourceMessage)
-      this.source = cloneMessage(sourceMessage, sourceMessage.content && sourceMessage.content.error && { error: undefined });
+    this.code = behaviour?.errorCode?.toString() ?? behaviour?.code;
+    this.id = behaviour?.id;
+    if (sourceMessage) this.source = cloneMessage(sourceMessage, sourceMessage.content?.error && { error: undefined });
     if (inner) this.inner = inner;
   }
 }
@@ -47,7 +43,7 @@ function makeErrorFromMessage(errorMessage) {
   if (isKnownError(content)) return content;
 
   const { error } = content;
-  if (!error) return new Error(`Malformatted error message with routing key ${errorMessage.fields && errorMessage.fields.routingKey}`);
+  if (!error) return new Error(`Malformatted error message with routing key ${errorMessage.fields?.routingKey}`);
 
   if (isKnownError(error)) return error;