bpmn-elements 8.2.4 → 9.1.0

package/src/tasks/ReceiveTask.js

@@ -1,217 +1,215 @@
-import Activity from '../activity/Activity';
-import {cloneContent} from '../messageHelper';
-
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReferenceInfo = Symbol.for('referenceInfo');
-
-export default function ReceiveTask(activityDef, context) {
-  const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
-
-  task.broker.assertQueue('message', {autoDelete: false, durable: true});
-  task.broker.bindQueue('message', 'api', '*.message.#', {durable: true});
-
-  return task;
-}
-
-export function ReceiveTaskBehaviour(activity) {
-  const {id, type, behaviour} = activity;
-
-  this.id = id;
-  this.type = type;
-
-  const reference = this.reference = {
-    name: 'anonymous',
-    ...behaviour.messageRef,
-    referenceType: 'message',
-  };
-
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-  this.activity = activity;
-  this.broker = activity.broker;
-
-  this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
-}
-
-ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
-  return new ReceiveTaskExecution(this).execute(executeMessage);
-};
-
-function ReceiveTaskExecution(parent) {
-  const {activity, broker, loopCharacteristics, reference} = parent;
-
-  this.id = activity.id;
-  this.logger = activity.logger;
-  this.reference = reference;
-  this.broker = broker;
-  this.loopCharacteristics = loopCharacteristics;
-  this.referenceElement = parent[kReferenceElement];
-
-  this[kCompleted] = false;
-}
-
-const proto = ReceiveTaskExecution.prototype;
-
-proto.execute = function execute(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-
-  const executeContent = executeMessage.content;
-  const {executionId, isRootScope} = executeContent;
-  this.executionId = executionId;
-
-  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
-
-  if (isRootScope) {
-    this._setupMessageHandling(executionId);
-  }
-
-  const loopCharacteristics = this.loopCharacteristics;
-  if (loopCharacteristics && executeMessage.content.isRootScope) {
-    return loopCharacteristics.execute(executeMessage);
-  }
-
-  const broker = this.broker;
-  broker.consume('message', this._onCatchMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_onmessage-${executionId}`,
-  });
-
-  if (this[kCompleted]) return;
-
-  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-${executionId}`,
-    priority: 400,
-  });
-
-  this._debug(`expect ${info.description}`);
-
-  broker.publish('event', 'activity.wait', cloneContent(executeContent, {message: {...info.message}}));
-};
-
-proto._onCatchMessage = function onCatchMessage(routingKey, message) {
-  const content = message.content;
-
-  const {id: signalId, executionId: signalExecutionId} = content.message || {};
-  const {message: referenceMessage, description} = this[kReferenceInfo];
-
-  if (!referenceMessage.id && signalId || signalExecutionId) {
-    if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
-    if (signalId !== this.id && signalExecutionId !== this.executionId) return;
-    this._debug('caught direct message');
-  } else if (referenceMessage.id !== signalId) return;
-  else {
-    this._debug(`caught ${description}`);
-  }
-
-  const {type: messageType, correlationId} = message.properties;
-  const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
-
-  broker.publish('event', 'activity.consumed', cloneContent(executeContent, {message: {...message.content.message}}), {correlationId, type: messageType});
-  broker.publish('event', 'activity.catch', cloneContent(executeContent, {message: message.content.message}), {type: 'catch', correlationId});
-
-  this._complete(message.content.message, {correlationId});
-};
-
-proto._onApiMessage = function onApiMessage(routingKey, message) {
-  const {type: messageType, correlationId} = message.properties;
-  switch (messageType) {
-    case 'message':
-    case 'signal': {
-      return this._complete(message.content.message, {correlationId});
-    }
-    case 'discard': {
-      this[kCompleted] = true;
-      this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
-    }
-    case 'stop': {
-      return this._stop();
-    }
-  }
-};
-
-proto._complete = function complete(output, options) {
-  this[kCompleted] = true;
-  this._stop();
-  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {output}), options);
-};
-
-proto._stop = function stop() {
-  const broker = this.broker, executionId = this.executionId;
-  broker.cancel(`_onmessage-${executionId}`);
-  broker.cancel(`_api-${executionId}`);
-};
-
-proto._setupMessageHandling = function setupMessageHandling(executionId) {
-  const broker = this.broker;
-  broker.subscribeTmp('api', '#.signal.*', this._onDelegateMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-delegated-${executionId}`,
-  }, {
-    noAck: true,
-  });
-  broker.subscribeTmp('api', `activity.stop.${executionId}`, this._onStopApiMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-stop-${executionId}`,
-    priority: 400,
-  });
-  broker.subscribeTmp('execution', 'execute.#', this._onExecutionComplete.bind(this), {
-    noAck: true,
-    consumerTag: `_execution-complete-${executionId}`,
-  }, {
-    noAck: true,
-  });
-};
-
-proto._onDelegateMessage = function onDelegateMessage(_, message) {
-  if (!message.properties.delegate) return;
-  this.broker.sendToQueue('message', message.content, message.properties);
-};
-
-proto._onStopApiMessage = function onStopApiMessage() {
-  this._stopMessageHandling(true);
-};
-
-proto._onExecutionComplete = function onExecutionComplete(routingKey, {content}) {
-  if (!content.isRootScope) return;
-  switch (routingKey) {
-    case 'execute.completed':
-    case 'execute.error':
-    case 'execute.discard':
-      this._stopMessageHandling();
-      break;
-  }
-};
-
-proto._stopMessageHandling = function stop(keepMessageQ) {
-  const broker = this.broker, executionId = this.executionId;
-  broker.cancel(`_api-delegated-${executionId}`);
-  broker.cancel(`_api-stop-${executionId}`);
-  broker.cancel(`_execution-complete-${executionId}`);
-  if (!keepMessageQ) broker.purgeQueue('message');
-};
-
-proto._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this.referenceElement;
-  if (!referenceElement) {
-    return {
-      message: {...this.reference},
-      description: 'anonymous message',
-    };
-  }
-
-  const result = {
-    message: referenceElement.resolve(message),
-  };
-
-  result.description = `${result.message.name} <${result.message.id}>`;
-
-  return result;
-};
-
-proto._debug = function debug(msg) {
-  this.logger.debug(`<${this.executionId} (${this.id})> ${msg}`);
-};
+import Activity from '../activity/Activity.js';
+import {cloneContent} from '../messageHelper.js';
+
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kReferenceElement = Symbol.for('referenceElement');
+const kReferenceInfo = Symbol.for('referenceInfo');
+
+export default function ReceiveTask(activityDef, context) {
+  const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
+
+  task.broker.assertQueue('message', {autoDelete: false, durable: true});
+  task.broker.bindQueue('message', 'api', '*.message.#', {durable: true});
+
+  return task;
+}
+
+export function ReceiveTaskBehaviour(activity) {
+  const {id, type, behaviour} = activity;
+
+  this.id = id;
+  this.type = type;
+
+  const reference = this.reference = {
+    name: 'anonymous',
+    ...behaviour.messageRef,
+    referenceType: 'message',
+  };
+
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.broker = activity.broker;
+
+  this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+}
+
+ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
+  return new ReceiveTaskExecution(this).execute(executeMessage);
+};
+
+function ReceiveTaskExecution(parent) {
+  const {activity, broker, loopCharacteristics, reference} = parent;
+
+  this.id = activity.id;
+  this.logger = activity.logger;
+  this.reference = reference;
+  this.broker = broker;
+  this.loopCharacteristics = loopCharacteristics;
+  this.referenceElement = parent[kReferenceElement];
+
+  this[kCompleted] = false;
+}
+
+ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
+  this[kExecuteMessage] = executeMessage;
+
+  const executeContent = executeMessage.content;
+  const {executionId, isRootScope} = executeContent;
+  this.executionId = executionId;
+
+  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
+
+  if (isRootScope) {
+    this._setupMessageHandling(executionId);
+  }
+
+  const loopCharacteristics = this.loopCharacteristics;
+  if (loopCharacteristics && executeMessage.content.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
+
+  const broker = this.broker;
+  broker.consume('message', this._onCatchMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_onmessage-${executionId}`,
+  });
+
+  if (this[kCompleted]) return;
+
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 400,
+  });
+
+  this._debug(`expect ${info.description}`);
+
+  broker.publish('event', 'activity.wait', cloneContent(executeContent, {message: {...info.message}}));
+};
+
+ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
+  const content = message.content;
+
+  const {id: signalId, executionId: signalExecutionId} = content.message || {};
+  const {message: referenceMessage, description} = this[kReferenceInfo];
+
+  if (!referenceMessage.id && signalId || signalExecutionId) {
+    if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
+    if (signalId !== this.id && signalExecutionId !== this.executionId) return;
+    this._debug('caught direct message');
+  } else if (referenceMessage.id !== signalId) return;
+  else {
+    this._debug(`caught ${description}`);
+  }
+
+  const {type: messageType, correlationId} = message.properties;
+  const broker = this.broker;
+  const executeContent = this[kExecuteMessage].content;
+
+  broker.publish('event', 'activity.consumed', cloneContent(executeContent, {message: {...message.content.message}}), {correlationId, type: messageType});
+  broker.publish('event', 'activity.catch', cloneContent(executeContent, {message: message.content.message}), {type: 'catch', correlationId});
+
+  this._complete(message.content.message, {correlationId});
+};
+
+ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
+  const {type: messageType, correlationId} = message.properties;
+  switch (messageType) {
+    case 'message':
+    case 'signal': {
+      return this._complete(message.content.message, {correlationId});
+    }
+    case 'discard': {
+      this[kCompleted] = true;
+      this._stop();
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
+    }
+    case 'stop': {
+      return this._stop();
+    }
+  }
+};
+
+ReceiveTaskExecution.prototype._complete = function complete(output, options) {
+  this[kCompleted] = true;
+  this._stop();
+  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {output}), options);
+};
+
+ReceiveTaskExecution.prototype._stop = function stop() {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_onmessage-${executionId}`);
+  broker.cancel(`_api-${executionId}`);
+};
+
+ReceiveTaskExecution.prototype._setupMessageHandling = function setupMessageHandling(executionId) {
+  const broker = this.broker;
+  broker.subscribeTmp('api', '#.signal.*', this._onDelegateMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
+  }, {
+    noAck: true,
+  });
+  broker.subscribeTmp('api', `activity.stop.${executionId}`, this._onStopApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-stop-${executionId}`,
+    priority: 400,
+  });
+  broker.subscribeTmp('execution', 'execute.#', this._onExecutionComplete.bind(this), {
+    noAck: true,
+    consumerTag: `_execution-complete-${executionId}`,
+  }, {
+    noAck: true,
+  });
+};
+
+ReceiveTaskExecution.prototype._onDelegateMessage = function onDelegateMessage(_, message) {
+  if (!message.properties.delegate) return;
+  this.broker.sendToQueue('message', message.content, message.properties);
+};
+
+ReceiveTaskExecution.prototype._onStopApiMessage = function onStopApiMessage() {
+  this._stopMessageHandling(true);
+};
+
+ReceiveTaskExecution.prototype._onExecutionComplete = function onExecutionComplete(routingKey, {content}) {
+  if (!content.isRootScope) return;
+  switch (routingKey) {
+    case 'execute.completed':
+    case 'execute.error':
+    case 'execute.discard':
+      this._stopMessageHandling();
+      break;
+  }
+};
+
+ReceiveTaskExecution.prototype._stopMessageHandling = function stop(keepMessageQ) {
+  const broker = this.broker, executionId = this.executionId;
+  broker.cancel(`_api-delegated-${executionId}`);
+  broker.cancel(`_api-stop-${executionId}`);
+  broker.cancel(`_execution-complete-${executionId}`);
+  if (!keepMessageQ) broker.purgeQueue('message');
+};
+
+ReceiveTaskExecution.prototype._getReferenceInfo = function getReferenceInfo(message) {
+  const referenceElement = this.referenceElement;
+  if (!referenceElement) {
+    return {
+      message: {...this.reference},
+      description: 'anonymous message',
+    };
+  }
+
+  const result = {
+    message: referenceElement.resolve(message),
+  };
+
+  result.description = `${result.message.name} <${result.message.id}>`;
+
+  return result;
+};
+
+ReceiveTaskExecution.prototype._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.id})> ${msg}`);
+};

package/src/tasks/ScriptTask.js

@@ -1,7 +1,7 @@
-import Activity from '../activity/Activity';
-import ExecutionScope from '../activity/ExecutionScope';
-import { ActivityError } from '../error/Errors';
-import {cloneContent, cloneMessage} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import ExecutionScope from '../activity/ExecutionScope.js';
+import { ActivityError } from '../error/Errors.js';
+import {cloneContent, cloneMessage} from '../messageHelper.js';
 
 export default function ScriptTask(activityDef, context) {
   return new Activity(ScriptTaskBehaviour, activityDef, context);

package/src/tasks/ServiceImplementation.js

@@ -1,4 +1,4 @@
-import ExecutionScope from '../activity/ExecutionScope';
+import ExecutionScope from '../activity/ExecutionScope.js';
 
 export default function ServiceImplementation(activity) {
   this.type = `${activity.type}:implementation`;

package/src/tasks/ServiceTask.js

@@ -1,6 +1,6 @@
-import Activity from '../activity/Activity';
-import {ActivityError} from '../error/Errors';
-import {cloneMessage, cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {ActivityError} from '../error/Errors.js';
+import {cloneMessage, cloneContent} from '../messageHelper.js';
 
 export default function ServiceTask(activityDef, context) {
   return new Activity(ServiceTaskBehaviour, activityDef, context);
@@ -17,9 +17,7 @@ export function ServiceTaskBehaviour(activity) {
   this.broker = activity.broker;
 }
 
-const proto = ServiceTaskBehaviour.prototype;
-
-proto.execute = function execute(executeMessage) {
+ServiceTaskBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;
   if (loopCharacteristics && executeContent.isRootScope) {
@@ -44,13 +42,13 @@ proto.execute = function execute(executeMessage) {
   });
 };
 
-proto.getService = function getService(message) {
+ServiceTaskBehaviour.prototype.getService = function getService(message) {
   let Service = this.activity.behaviour.Service;
   if (!Service && this.environment.settings.enableDummyService) Service = DummyService;
   return Service && new Service(this.activity, cloneMessage(message));
 };
 
-proto._onApiMessage = function onApiMessage(executeMessage, _, message) {
+ServiceTaskBehaviour.prototype._onApiMessage = function onApiMessage(executeMessage, _, message) {
   const broker = this.broker;
   switch (message.properties.type) {
     case 'discard': {

package/src/tasks/SignalTask.js

@@ -1,6 +1,6 @@
-import Activity from '../activity/Activity';
-import {ActivityError} from '../error/Errors';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {ActivityError} from '../error/Errors.js';
+import {cloneContent} from '../messageHelper.js';
 
 export default function SignalTask(activityDef, context) {
   return new Activity(SignalTaskBehaviour, activityDef, context);
@@ -16,9 +16,7 @@ export function SignalTaskBehaviour(activity) {
   this.broker = activity.broker;
 }
 
-const proto = SignalTaskBehaviour.prototype;
-
-proto.execute = function execute(executeMessage) {
+SignalTaskBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;
   if (loopCharacteristics && executeContent.isRootScope) {
@@ -39,7 +37,7 @@ proto.execute = function execute(executeMessage) {
   broker.publish('event', 'activity.wait', cloneContent(executeContent, {state: 'wait'}));
 };
 
-proto._onDelegatedApiMessage = function onDelegatedApiMessage(executeMessage, routingKey, message) {
+SignalTaskBehaviour.prototype._onDelegatedApiMessage = function onDelegatedApiMessage(executeMessage, routingKey, message) {
   if (!message.properties.delegate) return;
 
   const {content: delegateContent} = message;
@@ -61,7 +59,7 @@ proto._onDelegatedApiMessage = function onDelegatedApiMessage(executeMessage, ro
   return this._onApiMessage(executeMessage, routingKey, message);
 };
 
-proto._onApiMessage = function onApiMessage(executeMessage, routingKey, message) {
+SignalTaskBehaviour.prototype._onApiMessage = function onApiMessage(executeMessage, routingKey, message) {
   const {type: messageType, correlationId} = message.properties;
   const executeContent = executeMessage.content;
   switch (messageType) {
@@ -89,7 +87,7 @@ proto._onApiMessage = function onApiMessage(executeMessage, routingKey, message)
   }
 };
 
-proto._stop = function stop(executionId) {
+SignalTaskBehaviour.prototype._stop = function stop(executionId) {
   const broker = this.broker;
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);

package/src/tasks/StandardLoopCharacteristics.js

@@ -1,4 +1,4 @@
-import LoopCharacteristics from './LoopCharacteristics';
+import LoopCharacteristics from './LoopCharacteristics.js';
 
 export default function StandardLoopCharacteristics(activity, loopCharacteristics) {
   let {behaviour} = loopCharacteristics;