bpmn-elements 17.2.2 → 18.0.0

package/src/error/Errors.js

@@ -1,21 +1,39 @@
 import { cloneMessage } from '../messageHelper.js';
 
 export class ActivityError extends Error {
+  /**
+   * @param {string} description
+   * @param {import('#types').ElementBrokerMessage} [sourceMessage]
+   * @param {Error | { name?: string; code?: string | number }} [inner]
+   */
   constructor(description, sourceMessage, inner) {
     super(description);
+    /** @type {string} */
     this.type = 'ActivityError';
+    /** @type {string} */
     this.name = this.constructor.name;
+    /** @type {string} */
     this.description = description;
-    if (sourceMessage) this.source = cloneMessage(sourceMessage, sourceMessage.content?.error && { error: undefined });
+    if (sourceMessage) {
+      /** @type {Pick<import('#types').ElementBrokerMessage, 'fields' | 'content' | 'properties'> | undefined} */
+      this.source = cloneMessage(sourceMessage, sourceMessage.content?.error && { error: undefined });
+    }
     if (inner) {
+      /** @type {Error | { name?: string; code?: string | number } | undefined} */
       this.inner = inner;
       if (inner.name) this.name = inner.name;
-      if (inner.code) this.code = inner.code;
+      if ('code' in inner && inner.code) {
+        /** @type {string | number | undefined} */
+        this.code = inner.code;
+      }
     }
   }
 }
 
 export class RunError extends ActivityError {
+  /**
+   * @param {ConstructorParameters<typeof ActivityError>} args
+   */
   constructor(...args) {
     super(...args);
     this.type = 'RunError';
@@ -23,18 +41,35 @@ export class RunError extends ActivityError {
 }
 
 export class BpmnError extends Error {
-  constructor(description, behaviour, sourceMessage, inner) {
+  /**
+   * @param {string} description
+   * @param {{ id?: string; name?: string; errorCode?: string | number; code?: string }} [behaviour]
+   * @param {import('#types').ElementBrokerMessage} [sourceMessage]
+   */
+  constructor(description, behaviour, sourceMessage) {
     super(description);
+    /** @type {string} */
     this.type = 'BpmnError';
+    /** @type {string} */
     this.name = behaviour?.name ?? this.constructor.name;
+    /** @type {string} */
     this.description = description;
+    /** @type {string | undefined} */
     this.code = behaviour?.errorCode?.toString() ?? behaviour?.code;
+    /** @type {string | undefined} */
     this.id = behaviour?.id;
-    if (sourceMessage) this.source = cloneMessage(sourceMessage, sourceMessage.content?.error && { error: undefined });
-    if (inner) this.inner = inner;
+    if (sourceMessage) {
+      /** @type {Pick<import('#types').ElementBrokerMessage, 'fields' | 'content' | 'properties'> | undefined} */
+      this.source = cloneMessage(sourceMessage, sourceMessage.content?.error && { error: undefined });
+    }
   }
 }
 
+/**
+ * Get an Error from an error message.
+ * @param {import('#types').ElementBrokerMessage} errorMessage
+ * @returns {Error | ActivityError | RunError | BpmnError}
+ */
 export function makeErrorFromMessage(errorMessage) {
   const { content } = errorMessage;
 
@@ -65,6 +100,10 @@ export function makeErrorFromMessage(errorMessage) {
   return error;
 }
 
+/**
+ * @param {any} test
+ * @returns {Error | undefined}
+ */
 function isKnownError(test) {
   if (test instanceof ActivityError) return test;
   if (test instanceof BpmnError) return test;

package/src/eventDefinitions/CancelEventDefinition.js

@@ -1,14 +1,18 @@
 import { cloneContent, shiftParent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-
-export default function CancelEventDefinition(activity, eventDefinition) {
+import { K_COMPLETED, K_EXECUTE_MESSAGE } from '../constants.js';
+
+/**
+ * Cancel event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function CancelEventDefinition(activity, eventDefinition) {
   const { id, broker, environment, isThrowing } = activity;
   const type = eventDefinition.type;
 
   this.id = id;
   this.type = type;
+  /** @type {import('#types').EventReference} */
   this.reference = { referenceType: 'cancel' };
   this.isThrowing = isThrowing;
   this.activity = activity;
@@ -18,18 +22,25 @@ export default function CancelEventDefinition(activity, eventDefinition) {
 }
 
 Object.defineProperty(CancelEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CancelEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
+  this[K_COMPLETED] = false;
 
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -69,6 +80,9 @@ CancelEventDefinition.prototype.executeCatch = function executeCatch(executeMess
   broker.publish('event', 'activity.wait', waitContent);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CancelEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -84,7 +98,7 @@ CancelEventDefinition.prototype.executeThrow = function executeThrow(executeMess
 
   broker.publish('event', 'activity.cancel', cancelContent, { type: 'cancel' });
 
-  return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
+  broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
 
 CancelEventDefinition.prototype._onCatchMessage = function onCatchMessage(_, message) {
@@ -94,10 +108,10 @@ CancelEventDefinition.prototype._onCatchMessage = function onCatchMessage(_, mes
 };
 
 CancelEventDefinition.prototype._complete = function complete(output) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   this._stop();
   this._debug('completed');
-  const content = cloneContent(this[kExecuteMessage].content, {
+  const content = cloneContent(this[K_EXECUTE_MESSAGE].content, {
     output,
     state: 'cancel',
   });
@@ -107,9 +121,9 @@ CancelEventDefinition.prototype._complete = function complete(output) {
 CancelEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'discard': {
-      this[kCompleted] = true;
+      this[K_COMPLETED] = true;
       this._stop();
-      const content = cloneContent(this[kExecuteMessage].content);
+      const content = cloneContent(this[K_EXECUTE_MESSAGE].content);
       return this.broker.publish('execution', 'execute.discard', content);
     }
     case 'stop': {

package/src/eventDefinitions/CompensateEventDefinition.js

@@ -1,49 +1,62 @@
 import { brokerSafeId } from '../shared.js';
 import { cloneContent, cloneMessage, shiftParent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kMessageQ = Symbol.for('messageQ');
-const kCompensateQ = Symbol.for('compensateQ');
-const kAssociations = Symbol.for('associations');
-
-export default function CompensateEventDefinition(activity, eventDefinition, context) {
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_MESSAGE_Q } from '../constants.js';
+
+const K_COMPENSATE_Q = Symbol.for('compensateQ');
+const K_ASSOCIATIONS = Symbol.for('associations');
+
+/**
+ * Compensate event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ * @param {import('#types').ContextInstance} context
+ */
+export function CompensateEventDefinition(activity, eventDefinition, context) {
   const { id, broker, environment, isThrowing } = activity;
 
   this.id = id;
   const type = (this.type = eventDefinition.type);
-  const reference = (this.reference = { referenceType: 'compensate' });
+  const referenceType = 'compensate';
+  /** @type {import('#types').EventReference} */
+  this.reference = { referenceType };
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
   if (!isThrowing) {
-    this[kCompleted] = false;
-    this[kAssociations] = context.getOutboundAssociations(id);
-    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
-    this[kCompensateQ] = broker.assertQueue('compensate-q', { autoDelete: false, durable: true });
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, { durable: true, priority: 400 });
+    this[K_COMPLETED] = false;
+    this[K_ASSOCIATIONS] = context.getOutboundAssociations(id);
+    const messageQueueName = `${referenceType}-${brokerSafeId(id)}-q`;
+    this[K_MESSAGE_Q] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
+    this[K_COMPENSATE_Q] = broker.assertQueue('compensate-q', { autoDelete: false, durable: true });
+    broker.bindQueue(messageQueueName, 'api', `*.${referenceType}.#`, { durable: true, priority: 400 });
   }
 }
 
 Object.defineProperty(CompensateEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CompensateEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CompensateEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
+  this[K_COMPLETED] = false;
   if (executeMessage.fields.routingKey === 'execute.compensating') {
     this._debug('resumed at compensating');
-    this[kCompleted] = true;
+    this[K_COMPLETED] = true;
     return this._compensate();
   }
 
@@ -60,12 +73,12 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
     consumerTag: '_oncollect-messages',
   });
 
-  this[kMessageQ].consume(this._onCompensateApiMessage.bind(this), {
+  this[K_MESSAGE_Q].consume(this._onCompensateApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_oncompensate-${executionId}`,
   });
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
 
   broker.subscribeTmp('api', `activity.#.${parent.executionId}#`, this._onApiMessage.bind(this), {
     noAck: true,
@@ -83,6 +96,9 @@ CompensateEventDefinition.prototype.executeCatch = function executeCatch(execute
   );
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 CompensateEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { parent } = executeContent;
@@ -105,16 +121,16 @@ CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey,
   switch (routingKey) {
     case 'execute.error':
     case 'execute.completed': {
-      return this[kCompensateQ].queueMessage(message.fields, cloneContent(message.content), message.properties);
+      return this[K_COMPENSATE_Q].queueMessage(message.fields, cloneContent(message.content), message.properties);
     }
   }
 };
 
 CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   const output = message.content.message;
   const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[K_EXECUTE_MESSAGE].content;
 
   this._stopCollect();
 
@@ -126,7 +142,7 @@ CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompens
   });
   catchContent.parent = shiftParent(catchContent.parent);
 
-  this[kCompensateQ].queueMessage({ routingKey: 'execute.compensated' }, cloneContent(executeContent));
+  this[K_COMPENSATE_Q].queueMessage({ routingKey: 'execute.compensated' }, cloneContent(executeContent));
 
   broker.publish('execution', 'execute.compensating', cloneContent(executeContent, { message: { ...output } }));
   broker.publish('event', 'activity.catch', catchContent, { type: 'catch' });
@@ -135,7 +151,7 @@ CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompens
 };
 
 CompensateEventDefinition.prototype._compensate = function compensate() {
-  return this[kCompensateQ].consume(this._onCollected.bind(this), { noAck: true, consumerTag: '_convey-messages' });
+  return this[K_COMPENSATE_Q].consume(this._onCollected.bind(this), { noAck: true, consumerTag: '_convey-messages' });
 };
 
 CompensateEventDefinition.prototype._onCollected = function onCollected(routingKey, message) {
@@ -144,15 +160,15 @@ CompensateEventDefinition.prototype._onCollected = function onCollected(routingK
     broker.cancel('_convey-messages');
     return this.broker.publish('execution', 'execute.completed', cloneContent(message.content, { cancelActivity: false }));
   }
-  for (const association of this[kAssociations]) association.take(cloneMessage(message));
+  for (const association of this[K_ASSOCIATIONS]) association.take(cloneMessage(message));
 };
 
 CompensateEventDefinition.prototype._onDiscardApiMessage = function onDiscardApiMessage(routingKey, message) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   this._stop();
-  this[kCompensateQ].purge();
-  for (const association of this[kAssociations]) association.discard(cloneMessage(message));
-  return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content));
+  this[K_COMPENSATE_Q].purge();
+  for (const association of this[K_ASSOCIATIONS]) association.discard(cloneMessage(message));
+  return this.broker.publish('execution', 'execute.discard', cloneContent(this[K_EXECUTE_MESSAGE].content));
 };
 
 CompensateEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
@@ -176,7 +192,7 @@ CompensateEventDefinition.prototype._stopCollect = function stopCollect() {
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_oncompensate-${executionId}`);
   broker.cancel('_oncollect-messages');
-  this[kMessageQ].purge();
+  this[K_MESSAGE_Q].purge();
 };
 
 CompensateEventDefinition.prototype._stop = function stop() {

package/src/eventDefinitions/ConditionalEventDefinition.js

@@ -1,10 +1,16 @@
 import { cloneContent, shiftParent } from '../messageHelper.js';
 import { ActivityError } from '../error/Errors.js';
 import { ScriptCondition, ExpressionCondition } from '../condition.js';
+import { K_EXECUTE_MESSAGE } from '../constants.js';
 
-const kExecuteMessage = Symbol.for('executeMessage');
-
-export default function ConditionalEventDefinition(activity, eventDefinition, _context, index) {
+/**
+ * Conditional event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ * @param {import('#types').ContextInstance} _context
+ * @param {number} index event definition index
+ */
+export function ConditionalEventDefinition(activity, eventDefinition, _context, index) {
   const { id, broker, environment } = activity;
 
   const { type = 'ConditionalEventDefinition', behaviour = {} } = eventDefinition;
@@ -19,13 +25,17 @@ export default function ConditionalEventDefinition(activity, eventDefinition, _c
 }
 
 Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ConditionalEventDefinition.prototype.execute = function execute(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
 
   if (!this.condition) return this._setup(executeMessage);
 
@@ -68,7 +78,7 @@ ConditionalEventDefinition.prototype._setup = function setup(executeMessage) {
 
 /**
  * Evaluate condition
- * @param {import('types').ElementBrokerMessage} message
+ * @param {import('#types').ElementBrokerMessage} message
  * @param {CallableFunction} callback
  */
 ConditionalEventDefinition.prototype.evaluate = function evaluate(message, callback) {
@@ -88,7 +98,7 @@ ConditionalEventDefinition.prototype.evaluate = function evaluate(message, callb
  */
 ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallback(err, result) {
   const broker = this.broker;
-  const executeMessage = this[kExecuteMessage];
+  const executeMessage = this[K_EXECUTE_MESSAGE];
   const executeContent = executeMessage.content;
 
   if (err) {
@@ -104,7 +114,7 @@ ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallbac
   this.broker.publish(
     'event',
     'activity.condition',
-    cloneContent(this[kExecuteMessage].content, {
+    cloneContent(this[K_EXECUTE_MESSAGE].content, {
       conditionResult: result,
     })
   );
@@ -118,7 +128,7 @@ ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallbac
 /**
  * Get condition
  * @param {number} index Eventdefinition sequence number, used to name registered script
- * @returns {ExpressionCondition|ScriptCondition|null}
+ * @returns {import('#types').ICondition | null}
  */
 ConditionalEventDefinition.prototype.getCondition = function getCondition(index) {
   const behaviour = this.behaviour;
@@ -164,7 +174,7 @@ ConditionalEventDefinition.prototype._onApiMessage = function onApiMessage(routi
     case 'discard': {
       this._stop();
       this._debug('discarded');
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content, { state: 'discard' }));
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[K_EXECUTE_MESSAGE].content, { state: 'discard' }));
     }
     case 'stop': {
       this._stop();

package/src/eventDefinitions/ErrorEventDefinition.js

@@ -1,24 +1,25 @@
 import { brokerSafeId } from '../shared.js';
 import { cloneContent, shiftParent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kMessageQ = Symbol.for('messageQ');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReferenceInfo = Symbol.for('referenceInfo');
-
-export default function ErrorEventDefinition(activity, eventDefinition) {
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_MESSAGE_Q, K_REFERENCE_ELEMENT, K_REFERENCE_INFO } from '../constants.js';
+
+/**
+ * Error event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function ErrorEventDefinition(activity, eventDefinition) {
   const { id, broker, environment, isThrowing } = activity;
   const { type = 'ErrorEventDefinition', behaviour = {} } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = (this.reference = {
+  /** @type {import('#types').EventReference} */
+  this.reference = {
     name: 'anonymous',
     ...behaviour.errorRef,
     referenceType: 'throw',
-  });
+  };
 
   this.isThrowing = isThrowing;
   this.activity = activity;
@@ -26,42 +27,49 @@ export default function ErrorEventDefinition(activity, eventDefinition) {
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  const referenceElement = (this[kReferenceElement] = reference.id && activity.getActivityById(reference.id));
+  const referenceElement = (this[K_REFERENCE_ELEMENT] = this.reference.id && activity.getActivityById(this.reference.id));
   if (!isThrowing) {
-    this[kCompleted] = false;
+    this[K_COMPLETED] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
-    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, { durable: true, priority: 300 });
+    const messageQueueName = `${this.reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
+    this[K_MESSAGE_Q] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
+    broker.bindQueue(messageQueueName, 'api', `*.${this.reference.referenceType}.#`, { durable: true, priority: 300 });
   }
 }
 
 Object.defineProperty(ErrorEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ErrorEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
+  this[K_COMPLETED] = false;
 
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
   const parentExecutionId = parent?.executionId;
 
-  const info = (this[kReferenceInfo] = this._getReferenceInfo(executeMessage));
+  const info = (this[K_REFERENCE_INFO] = this._getReferenceInfo(executeMessage));
 
-  this[kMessageQ].consume(this._onThrowApiMessage.bind(this), {
+  this[K_MESSAGE_Q].consume(this._onThrowApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_onthrow-${executionId}`,
   });
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
 
   this._debug(`expect ${info.description}`);
 
@@ -88,7 +96,7 @@ ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessa
       })
     );
 
-    if (this[kCompleted]) return this._stop();
+    if (this[K_COMPLETED]) return this._stop();
   }
 
   const waitContent = cloneContent(executeContent, {
@@ -100,6 +108,9 @@ ErrorEventDefinition.prototype.executeCatch = function executeCatch(executeMessa
   broker.publish('event', 'activity.wait', waitContent);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 ErrorEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -129,11 +140,11 @@ ErrorEventDefinition.prototype.executeThrow = function executeThrow(executeMessa
 
 ErrorEventDefinition.prototype._onErrorMessage = function onErrorMessage(routingKey, message) {
   const error = message.content.error;
-  if (!this[kReferenceElement]) return this._catchError(routingKey, message, error);
+  if (!this[K_REFERENCE_ELEMENT]) return this._catchError(routingKey, message, error);
 
   if (!error) return;
 
-  const info = this[kReferenceInfo];
+  const info = this[K_REFERENCE_INFO];
   if ('' + error.code !== '' + info.message.code) return;
 
   return this._catchError(routingKey, message, error);
@@ -141,21 +152,21 @@ ErrorEventDefinition.prototype._onErrorMessage = function onErrorMessage(routing
 
 ErrorEventDefinition.prototype._onThrowApiMessage = function onThrowApiMessage(routingKey, message) {
   const error = message.content.message;
-  if (!this[kReferenceElement]) return this._catchError(routingKey, message, error);
+  if (!this[K_REFERENCE_ELEMENT]) return this._catchError(routingKey, message, error);
 
-  const info = this[kReferenceInfo];
+  const info = this[K_REFERENCE_INFO];
   if (info.message.id !== error?.id) return;
   return this._catchError(routingKey, message, error);
 };
 
 ErrorEventDefinition.prototype._catchError = function catchError(routingKey, message, error) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
 
   this._stop();
 
-  this._debug(`caught ${this[kReferenceInfo].description}`);
+  this._debug(`caught ${this[K_REFERENCE_INFO].description}`);
 
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[K_EXECUTE_MESSAGE].content;
   const parent = executeContent.parent;
   const catchContent = cloneContent(executeContent, {
     source: {
@@ -187,9 +198,9 @@ ErrorEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey,
 
   switch (messageType) {
     case 'discard': {
-      this[kCompleted] = true;
+      this[K_COMPLETED] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content));
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[K_EXECUTE_MESSAGE].content));
     }
     case 'stop': {
       this._stop();
@@ -204,11 +215,11 @@ ErrorEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_onthrow-${executionId}`);
   broker.cancel(`_onerror-${executionId}`);
   broker.cancel(`_api-${executionId}`);
-  this[kMessageQ].purge();
+  this[K_MESSAGE_Q].purge();
 };
 
 ErrorEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[kReferenceElement];
+  const referenceElement = this[K_REFERENCE_ELEMENT];
   if (!referenceElement) {
     return {
       message: { ...this.reference },