bpmn-elements 17.2.2 → 18.0.0

package/src/eventDefinitions/EscalationEventDefinition.js

@@ -1,66 +1,76 @@
-import getPropertyValue from '../getPropertyValue.js';
+import { getPropertyValue } from '../getPropertyValue.js';
 import { brokerSafeId } from '../shared.js';
 import { cloneContent, shiftParent } from '../messageHelper.js';
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_MESSAGE_Q, K_REFERENCE_ELEMENT } from '../constants.js';
 
-const kCompleted = Symbol.for('completed');
-const kMessageQ = Symbol.for('messageQ');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReference = Symbol.for('reference');
+const K_REFERENCE = Symbol.for('reference');
 
-export default function EscalationEventDefinition(activity, eventDefinition) {
+/**
+ * Escalation event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function EscalationEventDefinition(activity, eventDefinition) {
   const { id, broker, environment, isThrowing } = activity;
   const { type, behaviour = {} } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = (this.reference = {
+  /** @type {import('#types').EventReference} */
+  this.reference = {
     name: 'anonymous',
     ...behaviour.escalationRef,
     referenceType: 'escalate',
-  });
+  };
 
   this.isThrowing = isThrowing;
   this.activity = activity;
   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: 400 });
+    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: 400 });
   }
 }
 
 Object.defineProperty(EscalationEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 EscalationEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 EscalationEventDefinition.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 info = (this[kReference] = this._getReferenceInfo(executeMessage));
+  const info = (this[K_REFERENCE] = this._getReferenceInfo(executeMessage));
   const broker = this.broker;
-  this[kMessageQ].consume(this._onCatchMessage.bind(this), {
+  this[K_MESSAGE_Q].consume(this._onCatchMessage.bind(this), {
     noAck: true,
     consumerTag: `_onescalate-${executionId}`,
   });
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
 
   broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
     noAck: true,
@@ -79,6 +89,9 @@ EscalationEventDefinition.prototype.executeCatch = function executeCatch(execute
   broker.publish('event', 'activity.wait', waitContent);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 EscalationEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -100,17 +113,17 @@ EscalationEventDefinition.prototype.executeThrow = function executeThrow(execute
 };
 
 EscalationEventDefinition.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
-  const info = this[kReference];
+  const info = this[K_REFERENCE];
   if (getPropertyValue(message, 'content.message.id') !== info.message.id) return;
 
   const output = message.content.message;
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
 
   this._stop();
 
   this._debug(`caught ${info.description}`);
 
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[K_EXECUTE_MESSAGE].content;
   const { parent, ...content } = executeContent;
   const catchContent = cloneContent(content, {
     message: { ...output },
@@ -130,9 +143,9 @@ EscalationEventDefinition.prototype._onApiMessage = function onApiMessage(routin
       return this._onCatchMessage(routingKey, message);
     }
     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();
@@ -149,7 +162,7 @@ EscalationEventDefinition.prototype._stop = function stop() {
 };
 
 EscalationEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[kReferenceElement];
+  const referenceElement = this[K_REFERENCE_ELEMENT];
   if (!referenceElement) {
     return {
       message: { ...this.reference },

package/src/eventDefinitions/EventDefinitionExecution.js

@@ -1,33 +1,39 @@
 import { cloneContent, unshiftParent, shiftParent, cloneParent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kStopped = Symbol.for('stopped');
-
-export default function EventDefinitionExecution(activity, eventDefinitions, completedRoutingKey = 'execute.completed') {
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_STOPPED } from '../constants.js';
+
+/**
+ * Event definition execution orchestrator. Drives a sequence of event definitions for the
+ * activity and publishes the completed routing key when the last definition completes.
+ * @param {import('#types').Activity} activity
+ * @param {import('#types').EventDefinition[]} eventDefinitions
+ * @param {string} [completedRoutingKey] Routing key to publish on completion, defaults to `execute.completed`
+ */
+export function EventDefinitionExecution(activity, eventDefinitions, completedRoutingKey = 'execute.completed') {
   this.id = activity.id;
   this.activity = activity;
   this.broker = activity.broker;
   this.eventDefinitions = eventDefinitions;
   this.completedRoutingKey = completedRoutingKey;
-  this[kCompleted] = false;
-  this[kStopped] = false;
-  this[kExecuteMessage] = null;
+  this[K_COMPLETED] = false;
+  this[K_STOPPED] = false;
+  this[K_EXECUTE_MESSAGE] = null;
 }
 
-Object.defineProperties(EventDefinitionExecution.prototype, {
-  completed: {
-    get() {
-      return this[kCompleted];
-    },
+Object.defineProperty(EventDefinitionExecution.prototype, 'completed', {
+  get() {
+    return this[K_COMPLETED];
   },
-  stopped: {
-    get() {
-      return this[kStopped];
-    },
+});
+
+Object.defineProperty(EventDefinitionExecution.prototype, 'stopped', {
+  get() {
+    return this[K_STOPPED];
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 EventDefinitionExecution.prototype.execute = function execute(executeMessage) {
   const content = executeMessage.content;
 
@@ -36,7 +42,7 @@ EventDefinitionExecution.prototype.execute = function execute(executeMessage) {
 
   const broker = this.broker;
 
-  this[kExecuteMessage] = executeMessage;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
   const executionId = content.executionId;
 
   broker.subscribeTmp('execution', 'execute.#', this._onExecuteMessage.bind(this), {
@@ -58,8 +64,8 @@ EventDefinitionExecution.prototype.execute = function execute(executeMessage) {
   const eventDefinitions = this.eventDefinitions;
 
   for (let index = 0; index < eventDefinitions.length; ++index) {
-    if (this[kCompleted]) break;
-    if (this[kStopped]) break;
+    if (this[K_COMPLETED]) break;
+    if (this[K_STOPPED]) break;
 
     const ed = eventDefinitions[index];
     const edExecutionId = `${executionId}_${index}`;
@@ -110,12 +116,12 @@ EventDefinitionExecution.prototype._onExecuteMessage = function onExecuteMessage
 
 EventDefinitionExecution.prototype._complete = function complete(message) {
   const { executionId, type, index, parent } = message.content;
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
 
   this._debug(executionId, `event definition ${type} completed, index ${index}`);
 
   const completeContent = cloneContent(message.content, {
-    executionId: this[kExecuteMessage].content.executionId,
+    executionId: this[K_EXECUTE_MESSAGE].content.executionId,
     isRootScope: true,
     isDefinitionScope: undefined,
   });
@@ -133,7 +139,7 @@ EventDefinitionExecution.prototype._executeDefinition = function executeDefiniti
 };
 
 EventDefinitionExecution.prototype._stop = function stop() {
-  this[kStopped] = true;
+  this[K_STOPPED] = true;
   this.broker.cancel('_eventdefinition-execution-execute-tag');
   this.broker.cancel('_eventdefinition-execution-api-tag');
 };

package/src/eventDefinitions/LinkEventDefinition.js

@@ -1,88 +1,75 @@
-import getPropertyValue from '../getPropertyValue.js';
-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');
-
-export default function LinkEventDefinition(activity, eventDefinition) {
+import { K_EXECUTE_MESSAGE } from '../constants.js';
+
+/**
+ * Link event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function LinkEventDefinition(activity, eventDefinition) {
   const { id, broker, environment, isThrowing } = activity;
   const { type = 'LinkEventDefinition', behaviour } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = (this.reference = {
+  /** @type {import('#types').EventReference} */
+  this.reference = {
+    id: behaviour.name,
     linkName: behaviour.name,
     referenceType: 'link',
-  });
+  };
 
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
-  this[kCompleted] = false;
-
-  if (!isThrowing) {
-    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(reference.linkName)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, { durable: true });
-  } else {
-    broker.subscribeTmp('event', 'activity.discard', this._onDiscard.bind(this), {
-      noAck: true,
-      consumerTag: '_link-parent-discard',
-    });
-  }
 }
 
 Object.defineProperty(LinkEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 LinkEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 LinkEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
 
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
   const parentExecutionId = parent.executionId;
 
-  this[kMessageQ].consume(this._onCatchLink.bind(this), {
-    noAck: true,
-    consumerTag: `_api-link-${executionId}`,
-  });
+  const linkMessage = executeContent.message ?? executeContent.input ?? { ...this.reference };
 
-  if (this[kCompleted]) return;
+  this.logger.debug(`<${executionId} (${this.activity.id})> caught link ${this.reference.linkName}`);
 
   const broker = this.broker;
-  const onApiMessage = this._onApiMessage.bind(this);
-  broker.subscribeTmp('api', `activity.stop.${parentExecutionId}`, onApiMessage, {
-    noAck: true,
-    consumerTag: `_api-parent-${executionId}`,
-  });
-  broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
-    noAck: true,
-    consumerTag: `_api-${executionId}`,
-  });
-
-  this._debug(`expect link ${this.reference.linkName}`);
-
-  const waitContent = cloneContent(executeContent, {
-    executionId: parentExecutionId,
+  const catchContent = cloneContent(executeContent, {
     link: { ...this.reference },
+    message: { ...linkMessage },
+    executionId: parentExecutionId,
   });
-  waitContent.parent = shiftParent(parent);
+  catchContent.parent = shiftParent(parent);
 
-  broker.publish('event', 'activity.wait', waitContent);
+  broker.publish('event', 'activity.catch', catchContent, { type: 'catch' });
+
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output: linkMessage, state: 'catch' }));
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 LinkEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -98,80 +85,7 @@ LinkEventDefinition.prototype.executeThrow = function executeThrow(executeMessag
   });
   linkContent.parent = shiftParent(parent);
 
-  broker.publish('event', 'activity.link', linkContent, { type: 'link', delegate: true });
+  broker.publish('event', 'activity.link', linkContent, { type: 'link' });
 
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
-
-LinkEventDefinition.prototype._onCatchLink = function onCatchLink(routingKey, message) {
-  if (getPropertyValue(message, 'content.message.linkName') !== this.reference.linkName) return;
-  if (message.content.state === 'discard') return this._discard();
-  return this._complete('caught', message.content.message);
-};
-
-LinkEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const messageType = message.properties.type;
-
-  switch (messageType) {
-    case 'discard': {
-      return this._discard();
-    }
-    case 'stop': {
-      this._stop();
-      break;
-    }
-  }
-};
-
-LinkEventDefinition.prototype._complete = function complete(verb, output) {
-  this[kCompleted] = true;
-
-  this._stop();
-
-  this._debug(`${verb} link ${this.reference.linkName}`);
-
-  const executeContent = this[kExecuteMessage].content;
-  const parent = executeContent.parent;
-  const catchContent = cloneContent(executeContent, {
-    link: { ...this.reference },
-    message: { ...output },
-    executionId: parent.executionId,
-  });
-  catchContent.parent = shiftParent(parent);
-
-  const broker = this.broker;
-  broker.publish('event', 'activity.catch', catchContent, { type: 'catch' });
-
-  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output, state: 'catch' }));
-};
-
-LinkEventDefinition.prototype._discard = function discard() {
-  this[kCompleted] = true;
-  this._stop();
-  return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content));
-};
-
-LinkEventDefinition.prototype._stop = function stop() {
-  const broker = this.broker,
-    executionId = this.executionId;
-  broker.cancel(`_api-link-${executionId}`);
-  broker.cancel(`_api-parent-${executionId}`);
-  broker.cancel(`_api-${executionId}`);
-  this[kMessageQ].purge();
-};
-
-LinkEventDefinition.prototype._onDiscard = function onDiscard(_, message) {
-  this.broker.publish(
-    'event',
-    'activity.link.discard',
-    cloneContent(message.content, {
-      message: { ...this.reference },
-      state: 'discard',
-    }),
-    { type: 'link', delegate: true }
-  );
-};
-
-LinkEventDefinition.prototype._debug = function debug(msg) {
-  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
-};

package/src/eventDefinitions/MessageEventDefinition.js

@@ -1,70 +1,78 @@
-import getPropertyValue from '../getPropertyValue.js';
+import { getPropertyValue } from '../getPropertyValue.js';
 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 MessageEventDefinition(activity, eventDefinition) {
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_MESSAGE_Q, K_REFERENCE_ELEMENT, K_REFERENCE_INFO } from '../constants.js';
+
+/**
+ * Message event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function MessageEventDefinition(activity, eventDefinition) {
   const { id, broker, environment, isThrowing } = activity;
   const { type = 'MessageEventDefinition', behaviour = {} } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = (this.reference = {
+  /** @type {import('#types').EventReference} */
+  this.reference = {
     name: 'anonymous',
     ...behaviour.messageRef,
     referenceType: 'message',
-  });
+  };
 
   this.isThrowing = isThrowing;
   this.activity = activity;
   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 });
+    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 });
   }
 }
 
 Object.defineProperty(MessageEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 MessageEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 MessageEventDefinition.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._debug(`expect ${info.description}`);
 
   const broker = this.broker;
   const onCatchMessage = this._onCatchMessage.bind(this);
-  this[kMessageQ].consume(onCatchMessage, {
+  this[K_MESSAGE_Q].consume(onCatchMessage, {
     noAck: true,
     consumerTag: `_api-message-${executionId}`,
   });
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
 
   const onApiMessage = this._onApiMessage.bind(this);
   broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
@@ -91,6 +99,9 @@ MessageEventDefinition.prototype.executeCatch = function executeCatch(executeMes
   broker.publish('event', 'activity.wait', waitContent);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 MessageEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -112,13 +123,13 @@ MessageEventDefinition.prototype.executeThrow = function executeThrow(executeMes
 };
 
 MessageEventDefinition.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
-  if (getPropertyValue(message, 'content.message.id') !== this[kReferenceInfo].message.id) return;
+  if (getPropertyValue(message, 'content.message.id') !== this[K_REFERENCE_INFO].message.id) return;
 
   const { type, correlationId } = message.properties;
   this.broker.publish(
     'event',
     'activity.consumed',
-    cloneContent(this[kExecuteMessage].content, {
+    cloneContent(this[K_EXECUTE_MESSAGE].content, {
       message: { ...message.content.message },
     }),
     {
@@ -138,9 +149,9 @@ MessageEventDefinition.prototype._onApiMessage = function onApiMessage(routingKe
       return this._complete('got signal with', message.content.message, { correlationId });
     }
     case 'discard': {
-      this[kCompleted] = true;
+      this[K_COMPLETED] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), { correlationId });
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[K_EXECUTE_MESSAGE].content), { correlationId });
     }
     case 'stop': {
       return this._stop();
@@ -149,13 +160,13 @@ MessageEventDefinition.prototype._onApiMessage = function onApiMessage(routingKe
 };
 
 MessageEventDefinition.prototype._complete = function complete(verb, output, options) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
 
   this._stop();
-  this._debug(`${verb} ${this[kReferenceInfo].description}`);
+  this._debug(`${verb} ${this[K_REFERENCE_INFO].description}`);
 
   const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[K_EXECUTE_MESSAGE].content;
   const catchContent = cloneContent(executeContent, {
     message: { ...output },
     executionId: executeContent.parent.executionId,
@@ -182,11 +193,11 @@ MessageEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-parent-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);
-  this[kMessageQ].purge();
+  this[K_MESSAGE_Q].purge();
 };
 
 MessageEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[kReferenceElement];
+  const referenceElement = this[K_REFERENCE_ELEMENT];
   if (!referenceElement) {
     return {
       message: { ...this.reference },