bpmn-elements 17.2.2 → 18.0.0

package/src/gateways/EventBasedGateway.js

@@ -1,40 +1,52 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { cloneContent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kTargets = Symbol.for('targets');
-
-export default function EventBasedGateway(activityDef, context) {
+import { K_COMPLETED, K_TARGETS } from '../constants.js';
+
+/**
+ * Event based gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function EventBasedGateway(activityDef, context) {
   return new Activity(EventBasedGatewayBehaviour, activityDef, context);
 }
 
+/**
+ * Event based gateway behaviour
+ * @param {import('#types').Activity} activity
+ * @param {import('#types').ContextInstance} context
+ */
 export function EventBasedGatewayBehaviour(activity, context) {
   this.id = activity.id;
   this.type = activity.type;
   this.activity = activity;
   this.broker = activity.broker;
   this.context = context;
-  this[kTargets] = new Set(activity.outbound.map((flow) => context.getActivityById(flow.targetId)));
+  this[K_TARGETS] = new Set(activity.outbound.map((flow) => context.getActivityById(flow.targetId)));
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, outbound = [], outboundTaken } = executeContent;
 
-  const targets = this[kTargets];
-  this[kCompleted] = false;
+  const targets = this[K_TARGETS];
+  this[K_COMPLETED] = false;
   if (!targets.size) return this._complete(executeContent);
 
   for (const flow of this.activity.outbound) {
     outbound.push({ id: flow.id, action: 'take' });
   }
 
-  if (!this[kCompleted] && outboundTaken) return;
+  if (!this[K_COMPLETED] && outboundTaken) return;
 
   const targetConsumerTag = `_gateway-listener-${this.id}`;
 
   const onTargetCompleted = this._onTargetCompleted.bind(this, executeMessage);
-  for (const target of this[kTargets]) {
+  for (const target of this[K_TARGETS]) {
     target.broker.subscribeOnce('event', 'activity.end', onTargetCompleted, { consumerTag: targetConsumerTag });
   }
 
@@ -43,7 +55,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
     consumerTag: '_api-stop-execution',
   });
 
-  this[kCompleted] = false;
+  this[K_COMPLETED] = false;
 
   if (!executeMessage.fields.redelivered) {
     return broker.publish('execution', 'execute.outbound.take', cloneContent(executeContent, { outboundTaken: true }));
@@ -57,7 +69,7 @@ EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompl
   this.activity.logger.debug(`<${executionId} (${this.id})> <${targetExecutionId}> completed run, discarding the rest`);
 
   this._stop();
-  for (const target of this[kTargets]) {
+  for (const target of this[K_TARGETS]) {
     if (target === owner) continue;
     target.discard();
   }
@@ -74,12 +86,12 @@ EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompl
 };
 
 EventBasedGatewayBehaviour.prototype._complete = function complete(completedContent) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   this.broker.publish('execution', 'execute.completed', cloneContent(completedContent));
 };
 
 EventBasedGatewayBehaviour.prototype._stop = function stop() {
   const targetConsumerTag = `_gateway-listener-${this.id}`;
-  for (const target of this[kTargets]) target.broker.cancel(targetConsumerTag);
+  for (const target of this[K_TARGETS]) target.broker.cancel(targetConsumerTag);
   this.broker.cancel('_api-stop-execution');
 };

package/src/gateways/ExclusiveGateway.js

@@ -1,10 +1,19 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { cloneContent } from '../messageHelper.js';
 
-export default function ExclusiveGateway(activityDef, context) {
+/**
+ * Exclusive gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function ExclusiveGateway(activityDef, context) {
   return new Activity(ExclusiveGatewayBehaviour, activityDef, context);
 }
 
+/**
+ * Exclusive gateway behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function ExclusiveGatewayBehaviour(activity) {
   const { id, type, broker } = activity;
   this.id = id;
@@ -12,6 +21,10 @@ export function ExclusiveGatewayBehaviour(activity) {
   this.broker = broker;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 ExclusiveGatewayBehaviour.prototype.execute = function execute({ content }) {
-  this.broker.publish('execution', 'execute.completed', cloneContent(content, { outboundTakeOne: true }));
+  this.broker.publish('execution', 'execute.completed', cloneContent(content, { outboundTakeOne: true, requireOutbound: true }));
 };

package/src/gateways/InclusiveGateway.js

@@ -1,10 +1,19 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { cloneContent } from '../messageHelper.js';
 
-export default function InclusiveGateway(activityDef, context) {
+/**
+ * Inclusive gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function InclusiveGateway(activityDef, context) {
   return new Activity(InclusiveGatewayBehaviour, activityDef, context);
 }
 
+/**
+ * Inclusive gateway behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function InclusiveGatewayBehaviour(activity) {
   const { id, type, broker } = activity;
   this.id = id;
@@ -12,6 +21,10 @@ export function InclusiveGatewayBehaviour(activity) {
   this.broker = broker;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 InclusiveGatewayBehaviour.prototype.execute = function execute({ content }) {
-  this.broker.publish('execution', 'execute.completed', cloneContent(content));
+  this.broker.publish('execution', 'execute.completed', cloneContent(content, { requireOutbound: true }));
 };

package/src/gateways/ParallelGateway.js

@@ -1,17 +1,308 @@
-import Activity from '../activity/Activity.js';
-import { cloneContent } from '../messageHelper.js';
+import { Activity } from '../activity/Activity.js';
+import { cloneContent, cloneMessage } from '../messageHelper.js';
+import { K_EXECUTE_MESSAGE, K_TARGETS } from '../constants.js';
 
-export default function ParallelGateway(activityDef, context) {
-  return new Activity(ParallelGatewayBehaviour, { ...activityDef, isParallelGateway: true }, context);
+const STATE_MONTITORING = 'monitoring';
+const STATE_SETUP = 'setup';
+
+const K_PEERS = Symbol.for('peers');
+const K_PEERS_DISCOVERED = Symbol.for('peers discovered');
+
+/**
+ * Parallel gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function ParallelGateway(activityDef, context) {
+  const activity = new Activity(ParallelGatewayBehaviour, { ...activityDef, isParallelGateway: true }, context);
+
+  const id = (this.id = activity.id);
+
+  activity.broker.cancel('_api-shake');
+  activity.broker.subscribeTmp('api', 'activity.shake.continue', onApiShake, { noAck: true, consumerTag: '_api-shake', priority: 1000 });
+
+  const peers = (activity[K_PEERS] = new Map(activity.inbound.map(({ id: flowId, sourceId }) => [flowId, new Set([sourceId])])));
+
+  const cachedPeers = context.getShakenPeers(id);
+  if (cachedPeers) {
+    for (const [flowId, sourceIds] of cachedPeers) {
+      let peer = peers.get(flowId);
+      if (!peer) peers.set(flowId, (peer = new Set()));
+      for (const sourceId of sourceIds) peer.add(sourceId);
+    }
+    activity[K_PEERS_DISCOVERED] = true;
+  }
+
+  return activity;
+
+  function onApiShake(_, message) {
+    const collect = new Set();
+
+    let sequenceFlow;
+    for (const s of message.content.sequence) {
+      if (s.isSequenceFlow) {
+        sequenceFlow = s;
+      } else if (s.id === id) {
+        const peer = peers.get(sequenceFlow.id);
+        for (const c of collect) {
+          peer.add(c);
+        }
+        collect.clear();
+      } else {
+        collect.add(s.id);
+      }
+    }
+
+    activity.logger.debug(`<${activity.id}> collected parallel gateway peers`);
+
+    activity[K_PEERS_DISCOVERED] = true;
+    context.setShakenPeers(
+      id,
+      [...peers].map(([flowId, sourceIds]) => [flowId, [...sourceIds]])
+    );
+
+    activity.shake(message);
+  }
 }
 
+/**
+ * Parallel gateway behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function ParallelGatewayBehaviour(activity) {
-  const { id, type, broker } = activity;
-  this.id = id;
-  this.type = type;
-  this.broker = broker;
+  this.id = activity.id;
+  this.type = activity.type;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this.inbound = new Set();
+
+  this.isConverging = true;
+  this[K_EXECUTE_MESSAGE] = undefined;
+}
+
+Object.defineProperty(ParallelGatewayBehaviour.prototype, 'executionId', {
+  get() {
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
+  },
+});
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
+ParallelGatewayBehaviour.prototype.execute = function execute(executeMessage) {
+  const routingKey = executeMessage.fields.routingKey;
+  const isRedelivered = executeMessage.fields.redelivered;
+  const executeContent = executeMessage.content;
+
+  if (executeContent.isRootScope) {
+    this[K_EXECUTE_MESSAGE] = executeMessage;
+
+    switch (routingKey) {
+      case 'execute.start': {
+        if (!isRedelivered && executeContent.state === STATE_SETUP && !this.peerMonitor.isRunning) {
+          return this._complete();
+        }
+        if (executeContent.state !== 'start' && !isRedelivered) {
+          return;
+        }
+        return this.setup(executeMessage);
+      }
+    }
+  }
+};
+
+ParallelGatewayBehaviour.prototype.setup = function setup(executeMessage) {
+  const peerIds = new Set([...this.activity[K_PEERS].values()].map((v) => [...v]).flat());
+  this[K_TARGETS] = new Map([...peerIds].map((pid) => [pid, this.activity.getActivityById(pid)]));
+
+  this.peerMonitor = new PeerMonitor(this.activity, this[K_TARGETS]);
+
+  const message = (this[K_EXECUTE_MESSAGE] = cloneMessage(executeMessage));
+  const executeContent = message.content;
+  const { executionId } = executeContent;
+
+  this.inbound.add(cloneContent(executeMessage.content.inbound[0]));
+
+  this.broker.subscribeOnce('api', `activity.stop.${executionId}`, () => this._stop(), {
+    consumerTag: '_api-stop-execution',
+  });
+
+  this.broker.subscribeTmp('execution', 'execute.completed', this._onExecuteMessage.bind(this), {
+    noAck: true,
+    consumerTag: '_parallel-execution-execute-tag',
+  });
+
+  this.broker.subscribeTmp('execution', 'execute.start', this._onPeerEnterMessage.bind(this), {
+    noAck: true,
+    consumerTag: '_parallel-execution-peer-enter-tag',
+  });
+
+  this.peerMonitor.execute(message);
+
+  const inboundQ = this.broker.getQueue('inbound-q');
+  inboundQ.consume(
+    (_, inboundMessage) => {
+      this.inbound.add(inboundMessage);
+
+      message.content.inbound.push(cloneContent(inboundMessage.content));
+
+      this.peerMonitor.execute(message);
+    },
+    { consumerTag: '_converging-inbound', exclusive: true, prefetch: 10000 }
+  );
+
+  if (this.isConverging) {
+    this.broker.publish('event', 'activity.converge', cloneContent(executeContent));
+  }
+
+  return this.broker.publish(
+    'execution',
+    'execute.start',
+    cloneContent(executeMessage.content, { preventComplete: true, state: STATE_SETUP })
+  );
+};
+
+ParallelGatewayBehaviour.prototype._onExecuteMessage = function onExecuteMessage(routingKey, message) {
+  this.activity.logger.debug(`<${this.executionId} (${this.id})> received completed from <${message.content.id}>`);
+  if (this.peerMonitor._onCompleteMessage(routingKey, message)) {
+    return this._complete();
+  }
+};
+
+ParallelGatewayBehaviour.prototype._onPeerEnterMessage = function onPeerEnterMessage(_, message) {
+  if (!message.properties.monitor) return;
+  const peer = this.peerMonitor.watching.get(message.content.id);
+  if (peer) this.peerMonitor.running.set(message.content.id, peer);
+};
+
+ParallelGatewayBehaviour.prototype._complete = function complete() {
+  this.broker.cancel('_converging-inbound', false);
+
+  this._stop();
+
+  this.activity.logger.debug(`<${this.executionId} (${this.id})> completed monitoring`);
+
+  const content = cloneContent(this[K_EXECUTE_MESSAGE].content, { isRootScope: true, state: 'completed' });
+  content.inbound = this.peerMonitor.inbound;
+
+  return this.broker.publish('execution', 'execute.completed', content);
+};
+
+ParallelGatewayBehaviour.prototype._stop = function stop() {
+  this.broker.cancel('_converging-inbound');
+  this.broker.cancel('_api-stop-execution');
+  this.broker.cancel('_parallel-execution-execute-tag');
+  this.broker.cancel('_parallel-execution-peer-enter-tag');
+  this.peerMonitor.stop();
+};
+
+function PeerMonitor(activity, targets) {
+  this.activity = activity;
+  this.id = activity.id;
+  this.broker = activity.broker;
+  this.running = 0;
+  this.index = 0;
+  this.discarded = 0;
+  this.running = new Map();
+  this.watching = new Map();
+  this.targets = targets;
+  this.touched = new Set();
+  this.inbound = [];
 }
 
-ParallelGatewayBehaviour.prototype.execute = function execute({ content }) {
-  this.broker.publish('execution', 'execute.completed', cloneContent(content));
+Object.defineProperty(PeerMonitor.prototype, 'isRunning', {
+  get() {
+    return this.running.size > 0;
+  },
+});
+
+PeerMonitor.prototype.execute = function execute(executeMessage) {
+  const message = cloneMessage(executeMessage);
+  const inbound = message.content.inbound.pop();
+  this.inbound.push(cloneContent(inbound));
+
+  this.activity.logger.debug(`<${executeMessage.content.executionId} (${this.id})> start monitoring inbound <${inbound.id}> peers`);
+
+  this.activity.broker.publish('execution', 'execute.start', {
+    ...cloneContent(executeMessage.content),
+    inbound: this.inbound.slice(),
+    state: STATE_MONTITORING,
+    preventComplete: true,
+  });
+
+  this.touched.add(inbound.sourceId);
+
+  for (const target of this.targets.values()) {
+    this.monitor(target);
+  }
+
+  return this.running.size;
+};
+
+PeerMonitor.prototype.monitor = function monitor(peerActivity) {
+  if (this.watching.has(peerActivity.id)) return;
+
+  this.activity.logger.debug(`<${this.id}> monitor <${peerActivity.id}> with status: ${peerActivity.status}`);
+
+  this.watching.set(peerActivity.id, peerActivity);
+
+  if (peerActivity.status || peerActivity.initialized) {
+    this.running.set(peerActivity.id, peerActivity);
+  }
+
+  peerActivity.broker.createShovel(
+    `_on-enter-${this.id}`,
+    {
+      exchange: 'event',
+      pattern: 'activity.enter',
+    },
+    {
+      broker: this.broker,
+      exchange: 'execution',
+      exchangeKey: 'execute.start',
+      publishProperties: {
+        monitor: true,
+      },
+    },
+    {
+      cloneMessage(sourceMessage) {
+        return cloneMessage(sourceMessage, { isRootScope: false });
+      },
+    }
+  );
+
+  peerActivity.broker.createShovel(
+    `_on-leave-${this.id}`,
+    {
+      exchange: 'event',
+      pattern: 'activity.leave',
+    },
+    {
+      broker: this.broker,
+      exchange: 'execution',
+      exchangeKey: 'execute.completed',
+      publishProperties: {
+        monitor: true,
+      },
+    },
+    {
+      cloneMessage(sourceMessage) {
+        return cloneMessage(sourceMessage, { isRootScope: false, preventComplete: true });
+      },
+    }
+  );
+};
+
+PeerMonitor.prototype._onCompleteMessage = function onCompleteMessage(_routingKey, message) {
+  this.running.delete(message.content.id);
+
+  return !this.running.size;
+};
+
+PeerMonitor.prototype.stop = function stop() {
+  for (const peerActivity of this.watching.values()) {
+    peerActivity.broker.closeShovel(`_on-leave-${this.id}`);
+    peerActivity.broker.closeShovel(`_on-enter-${this.id}`);
+  }
 };

package/src/gateways/index.js

@@ -1,7 +1,7 @@
-import EventBasedGateway, { EventBasedGatewayBehaviour } from './EventBasedGateway.js';
-import ExclusiveGateway, { ExclusiveGatewayBehaviour } from './ExclusiveGateway.js';
-import InclusiveGateway, { InclusiveGatewayBehaviour } from './InclusiveGateway.js';
-import ParallelGateway, { ParallelGatewayBehaviour } from './ParallelGateway.js';
+import { EventBasedGateway, EventBasedGatewayBehaviour } from './EventBasedGateway.js';
+import { ExclusiveGateway, ExclusiveGatewayBehaviour } from './ExclusiveGateway.js';
+import { InclusiveGateway, InclusiveGatewayBehaviour } from './InclusiveGateway.js';
+import { ParallelGateway, ParallelGatewayBehaviour } from './ParallelGateway.js';
 
 export {
   EventBasedGateway,

package/src/getPropertyValue.js

@@ -3,7 +3,7 @@ const stringConstantPattern = /^(['"])(.*)\1$/;
 const numberConstantPattern = /^\W*-?\d+(.\d+)?\W*$/;
 const negativeIndexPattern = /^-\d+$/;
 
-export default function getPropertyValue(inputContext, propertyPath, fnScope) {
+export function getPropertyValue(inputContext, propertyPath, fnScope) {
   if (!inputContext) return;
 
   let resultValue;
@@ -86,7 +86,7 @@ function splitArguments(args, base, fnScope) {
     }
 
     if (argCompleted) {
-      if (arg.length > 0) {
+      if (arg.length) {
         callArguments.push(getFunctionArgument(base, arg.trim(), fnScope));
       }
       arg = '';

package/src/index.js

@@ -1,22 +1,22 @@
-import Activity from './activity/Activity.js';
-import BpmnError from './error/BpmnError.js';
-import Context from './Context.js';
-import DataObject from './io/EnvironmentDataObject.js';
-import DataStore from './io/EnvironmentDataStore.js';
-import DataStoreReference from './io/EnvironmentDataStoreReference.js';
-import Definition from './definition/Definition.js';
-import Dummy from './activity/Dummy.js';
-import Environment from './Environment.js';
-import Escalation from './activity/Escalation.js';
-import InputOutputSpecification from './io/InputOutputSpecification.js';
-import Lane from './process/Lane.js';
-import LoopCharacteristics from './tasks/LoopCharacteristics.js';
-import Message from './activity/Message.js';
-import Process from './process/Process.js';
-import Properties from './io/Properties.js';
-import ServiceImplementation from './tasks/ServiceImplementation.js';
-import Signal from './activity/Signal.js';
-import StandardLoopCharacteristics from './tasks/StandardLoopCharacteristics.js';
+import { Activity } from './activity/Activity.js';
+import { BpmnErrorActivity as BpmnError } from './error/BpmnError.js';
+import { Context } from './Context.js';
+import { EnvironmentDataObject as DataObject } from './io/EnvironmentDataObject.js';
+import { EnvironmentDataStore as DataStore } from './io/EnvironmentDataStore.js';
+import { EnvironmentDataStoreReference as DataStoreReference } from './io/EnvironmentDataStoreReference.js';
+import { Definition } from './definition/Definition.js';
+import { DummyActivity as Dummy } from './activity/Dummy.js';
+import { Environment } from './Environment.js';
+import { Escalation } from './activity/Escalation.js';
+import { IoSpecification as InputOutputSpecification } from './io/InputOutputSpecification.js';
+import { Lane } from './process/Lane.js';
+import { LoopCharacteristics } from './tasks/LoopCharacteristics.js';
+import { Message } from './activity/Message.js';
+import { Process } from './process/Process.js';
+import { Properties } from './io/Properties.js';
+import { ServiceImplementation } from './tasks/ServiceImplementation.js';
+import { Signal } from './activity/Signal.js';
+import { StandardLoopCharacteristics } from './tasks/StandardLoopCharacteristics.js';
 import { Association, MessageFlow, SequenceFlow } from './flows/index.js';
 import { BoundaryEvent, EndEvent, IntermediateCatchEvent, IntermediateThrowEvent, StartEvent } from './events/index.js';
 import { EventBasedGateway, ExclusiveGateway, InclusiveGateway, ParallelGateway } from './gateways/index.js';

package/src/io/BpmnIO.js

@@ -1,4 +1,10 @@
-export default function BpmnIO(activity, context) {
+/**
+ * Built-in IO extension. Composes the activity's ioSpecification and properties behaviours.
+ * @param {import('#types').Activity} activity
+ * @param {import('#types').ContextInstance} context
+ * @satisfies {import('#types').IExtension}
+ */
+export function BpmnIO(activity, context) {
   this.activity = activity;
   this.context = context;
   this.type = 'bpmnio';
@@ -15,6 +21,9 @@ Object.defineProperty(BpmnIO.prototype, 'hasIo', {
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} message
+ */
 BpmnIO.prototype.activate = function activate(message) {
   const properties = this.properties,
     specification = this.specification;
@@ -22,6 +31,9 @@ BpmnIO.prototype.activate = function activate(message) {
   if (specification) specification.activate(message);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} message
+ */
 BpmnIO.prototype.deactivate = function deactivate(message) {
   const properties = this.properties,
     specification = this.specification;

package/src/io/EnvironmentDataObject.js

@@ -1,13 +1,27 @@
-export default function EnvironmentDataObject(dataObjectDef, { environment }) {
+/**
+ * Builtin data object. Reads from / writes to `environment.variables._data`.
+ * @param {import('moddle-context-serializer').DataObject} dataObjectDef
+ * @param {import('#types').ContextInstance} context
+ * @satisfies {import('#types').IIOData}
+ */
+export function EnvironmentDataObject(dataObjectDef, { environment }) {
   const { id, type, name, behaviour, parent } = dataObjectDef;
   this.id = id;
   this.type = type;
   this.name = name;
+  /** @type {Record<string, any>} */
   this.behaviour = behaviour;
+  /** @type {import('moddle-context-serializer').Parent | undefined} */
   this.parent = parent;
   this.environment = environment;
 }
 
+/**
+ * @param {import('smqp').Broker} broker
+ * @param {string} exchange
+ * @param {string} routingKeyPrefix
+ * @param {Record<string, any>} [messageProperties]
+ */
 EnvironmentDataObject.prototype.read = function read(broker, exchange, routingKeyPrefix, messageProperties) {
   const environment = this.environment;
   const value = environment.variables._data?.[this.id];
@@ -15,6 +29,13 @@ EnvironmentDataObject.prototype.read = function read(broker, exchange, routingKe
   return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
 };
 
+/**
+ * @param {import('smqp').Broker} broker
+ * @param {string} exchange
+ * @param {string} routingKeyPrefix
+ * @param {any} value
+ * @param {Record<string, any>} [messageProperties]
+ */
 EnvironmentDataObject.prototype.write = function write(broker, exchange, routingKeyPrefix, value, messageProperties) {
   const environment = this.environment;
   environment.variables._data = environment.variables._data || {};
@@ -23,6 +44,10 @@ EnvironmentDataObject.prototype.write = function write(broker, exchange, routing
   return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
 };
 
+/**
+ * @private
+ * Create content
+ */
 EnvironmentDataObject.prototype._createContent = function createContent(value) {
   return {
     id: this.id,