bpmn-elements 8.2.4 → 9.1.0

package/src/flows/Association.js

@@ -1,7 +1,7 @@
-import {cloneParent} from '../messageHelper';
-import {EventBroker} from '../EventBroker';
-import {FlowApi} from '../Api';
-import {getUniqueId} from '../shared';
+import {cloneParent} from '../messageHelper.js';
+import {EventBroker} from '../EventBroker.js';
+import {Api} from '../Api.js';
+import {getUniqueId} from '../shared.js';
 
 const kCounters = Symbol.for('counters');
 
@@ -20,7 +20,6 @@ export default function Association(associationDef, {environment}) {
   const logger = this.logger = environment.Logger(type.toLowerCase());
 
   this[kCounters] = {
-    complete: 0,
     take: 0,
     discard: 0,
   };
@@ -34,16 +33,14 @@ export default function Association(associationDef, {environment}) {
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
 }
 
-const proto = Association.prototype;
-
-Object.defineProperty(proto, 'counters', {
+Object.defineProperty(Association.prototype, 'counters', {
   enumerable: true,
   get() {
     return {...this[kCounters]};
   },
 });
 
-proto.take = function take(content = {}) {
+Association.prototype.take = function take(content = {}) {
   this.logger.debug(`<${this.id}> take target <${this.targetId}>`);
   ++this[kCounters].take;
 
@@ -52,7 +49,7 @@ proto.take = function take(content = {}) {
   return true;
 };
 
-proto.discard = function discard(content = {}) {
+Association.prototype.discard = function discard(content = {}) {
   this.logger.debug(`<${this.id}> discard target <${this.targetId}>`);
   ++this[kCounters].discard;
 
@@ -61,36 +58,27 @@ proto.discard = function discard(content = {}) {
   return true;
 };
 
-proto.complete = function complete(content = {}) {
-  this.logger.debug(`<${this.id}> completed target <${this.targetId}>`);
-  ++this[kCounters].complete;
-
-  this._publishEvent('complete', content);
-
-  return true;
-};
-
-proto.getState = function getState() {
+Association.prototype.getState = function getState() {
   return this._createMessageContent({
     counters: this.counters,
     broker: this.broker.getState(true),
   });
 };
 
-proto.recover = function recover(state) {
+Association.prototype.recover = function recover(state) {
   Object.assign(this[kCounters], state.counters);
   this.broker.recover(state.broker);
 };
 
-proto.getApi = function getApi(message) {
-  return FlowApi(this.broker, message || {content: this._createMessageContent()});
+Association.prototype.getApi = function getApi(message) {
+  return new Api('association', this.broker, message || {content: this._createMessageContent()});
 };
 
-proto.stop = function stop() {
+Association.prototype.stop = function stop() {
   this.broker.stop();
 };
 
-proto._publishEvent = function publishEvent(action, content) {
+Association.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this._createMessageContent({
     action,
     message: content,
@@ -100,7 +88,7 @@ proto._publishEvent = function publishEvent(action, content) {
   this.broker.publish('event', `association.${action}`, eventContent, {type: action});
 };
 
-proto._createMessageContent = function createMessageContent(override) {
+Association.prototype._createMessageContent = function createMessageContent(override) {
   return {
     ...override,
     id: this.id,

package/src/flows/MessageFlow.js

@@ -1,6 +1,7 @@
-import {brokerSafeId} from '../shared';
-import {cloneParent} from '../messageHelper';
-import {MessageFlowBroker} from '../EventBroker';
+import {brokerSafeId} from '../shared.js';
+import {cloneParent} from '../messageHelper.js';
+import {MessageFlowBroker} from '../EventBroker.js';
+import {Api} from '../Api.js';
 
 const kCounters = Symbol.for('counters');
 const kSourceElement = Symbol.for('sourceElement');
@@ -33,16 +34,14 @@ export default function MessageFlow(flowDef, context) {
   this.logger = context.environment.Logger(type.toLowerCase());
 }
 
-const proto = MessageFlow.prototype;
-
-Object.defineProperty(proto, 'counters', {
+Object.defineProperty(MessageFlow.prototype, 'counters', {
   enumerable: true,
   get() {
     return {...this[kCounters]};
   },
 });
 
-proto.getState = function getState() {
+MessageFlow.prototype.getState = function getState() {
   return {
     id: this.id,
     type: this.type,
@@ -50,37 +49,37 @@ proto.getState = function getState() {
   };
 };
 
-proto.recover = function recover(state) {
+MessageFlow.prototype.recover = function recover(state) {
   Object.assign(this[kCounters], state.counters);
 };
 
-proto.getApi = function getApi() {
-  return this;
+MessageFlow.prototype.getApi = function getApi(message) {
+  return new Api('message', this.broker, message || {content: this._createMessageContent()});
 };
 
-proto.activate = function activate() {
+MessageFlow.prototype.activate = function activate() {
   const sourceElement = this[kSourceElement];
   const safeId = brokerSafeId(this.id);
   sourceElement.on('message', this.deactivate.bind(this), {consumerTag: `_message-on-message-${safeId}`});
   sourceElement.on('end', this._onSourceEnd.bind(this), {consumerTag: `_message-on-end-${safeId}`});
 };
 
-proto.deactivate = function deactivate() {
+MessageFlow.prototype.deactivate = function deactivate() {
   const sourceElement = this[kSourceElement];
   const safeId = brokerSafeId(this.id);
   sourceElement.broker.cancel(`_message-on-end-${safeId}`);
   sourceElement.broker.cancel(`_message-on-message-${safeId}`);
 };
 
-proto._onSourceEnd = function onSourceEnd({content}) {
+MessageFlow.prototype._onSourceEnd = function onSourceEnd({content}) {
   ++this[kCounters].messages;
   const source = this.source;
   const target = this.target;
   this.logger.debug(`<${this.id}> sending message from <${source.processId}.${source.id}> to <${target.id ? `${target.processId}.${target.id}` : target.processId}>`);
-  this.broker.publish('event', 'message.outbound', this._createMessage(content.message));
+  this.broker.publish('event', 'message.outbound', this._createMessageContent(content.message));
 };
 
-proto._createMessage = function createMessage(message) {
+MessageFlow.prototype._createMessageContent = function createMessage(message) {
   return {
     id: this.id,
     type: this.type,

package/src/flows/SequenceFlow.js

@@ -1,8 +1,8 @@
-import ExecutionScope from '../activity/ExecutionScope';
-import {cloneParent, cloneContent} from '../messageHelper';
-import {getUniqueId} from '../shared';
-import {EventBroker} from '../EventBroker';
-import {FlowApi} from '../Api';
+import ExecutionScope from '../activity/ExecutionScope.js';
+import {cloneParent, cloneContent} from '../messageHelper.js';
+import {getUniqueId} from '../shared.js';
+import {EventBroker} from '../EventBroker.js';
+import {FlowApi} from '../Api.js';
 
 const kCounters = Symbol.for('counters');
 
@@ -40,18 +40,14 @@ function SequenceFlow(flowDef, {environment}) {
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
 }
 
-const proto = SequenceFlow.prototype;
-
-Object.defineProperty(proto, 'counters', {
+Object.defineProperty(SequenceFlow.prototype, 'counters', {
   enumerable: true,
   get() {
     return {...this[kCounters]};
   },
 });
 
-proto.take = function take(content = {}) {
-  this.looped = undefined;
-
+SequenceFlow.prototype.take = function take(content = {}) {
   const {sequenceId} = content;
 
   this.logger.debug(`<${sequenceId} (${this.id})> take, target <${this.targetId}>`);
@@ -62,7 +58,7 @@ proto.take = function take(content = {}) {
   return true;
 };
 
-proto.discard = function discard(content = {}) {
+SequenceFlow.prototype.discard = function discard(content = {}) {
   const {sequenceId = getUniqueId(this.id)} = content;
   const discardSequence = content.discardSequence = (content.discardSequence || []).slice();
   if (discardSequence.indexOf(this.targetId) > -1) {
@@ -78,27 +74,27 @@ proto.discard = function discard(content = {}) {
   this._publishEvent('discard', content);
 };
 
-proto.getState = function getState() {
+SequenceFlow.prototype.getState = function getState() {
   return this.createMessage({
     counters: this.counters,
     broker: this.broker.getState(true),
   });
 };
 
-proto.recover = function recover(state) {
+SequenceFlow.prototype.recover = function recover(state) {
   Object.assign(this[kCounters], state.counters);
   this.broker.recover(state.broker);
 };
 
-proto.getApi = function getApi(message) {
+SequenceFlow.prototype.getApi = function getApi(message) {
   return FlowApi(this.broker, message || {content: this.createMessage()});
 };
 
-proto.stop = function stop() {
+SequenceFlow.prototype.stop = function stop() {
   this.broker.stop();
 };
 
-proto.shake = function shake(message) {
+SequenceFlow.prototype.shake = function shake(message) {
   const content = cloneContent(message.content);
   content.sequence = content.sequence || [];
   content.sequence.push({id: this.id, type: this.type, isSequenceFlow: true, targetId: this.targetId});
@@ -112,7 +108,7 @@ proto.shake = function shake(message) {
   this.broker.publish('event', 'flow.shake', content, {persistent: false, type: 'shake'});
 };
 
-proto.getCondition = function getCondition() {
+SequenceFlow.prototype.getCondition = function getCondition() {
   const conditionExpression = this.behaviour.conditionExpression;
   if (!conditionExpression) return null;
 
@@ -130,7 +126,7 @@ proto.getCondition = function getCondition() {
   return new ExpressionCondition(this, conditionExpression.body);
 };
 
-proto.createMessage = function createMessage(override) {
+SequenceFlow.prototype.createMessage = function createMessage(override) {
   return {
     ...override,
     id: this.id,
@@ -144,7 +140,7 @@ proto.createMessage = function createMessage(override) {
   };
 };
 
-proto._publishEvent = function publishEvent(action, content) {
+SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,
     ...content,

package/src/gateways/EventBasedGateway.js

@@ -1,5 +1,5 @@
-import Activity from '../activity/Activity';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {cloneContent} from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kTargets = Symbol.for('targets');
@@ -40,7 +40,6 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
 
   const broker = this.activity.broker;
   broker.subscribeOnce('api', `activity.stop.${executionId}`, () => this._stop(), {
-    noAck: true,
     consumerTag: '_api-stop-execution',
   });
 
@@ -49,7 +48,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
 };
 
 EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompleted(executeMessage, _, message, owner) {
-  const {id: targetId, exexutionId: targetExecutionId} = message.content;
+  const {id: targetId, executionId: targetExecutionId} = message.content;
   const executeContent = executeMessage.content;
   const executionId = executeContent.executionId;
   this.activity.logger.debug(`<${executionId} (${this.id})> <${targetExecutionId}> completed run, discarding the rest`);

package/src/gateways/ExclusiveGateway.js

@@ -1,5 +1,5 @@
-import Activity from '../activity/Activity';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {cloneContent} from '../messageHelper.js';
 
 export default function ExclusiveGateway(activityDef, context) {
   return new Activity(ExclusiveGatewayBehaviour, activityDef, context);

package/src/gateways/InclusiveGateway.js

@@ -1,5 +1,5 @@
-import Activity from '../activity/Activity';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {cloneContent} from '../messageHelper.js';
 
 export default function InclusiveGateway(activityDef, context) {
   return new Activity(InclusiveGatewayBehaviour, activityDef, context);

package/src/gateways/ParallelGateway.js

@@ -1,5 +1,5 @@
-import Activity from '../activity/Activity';
-import {cloneContent} from '../messageHelper';
+import Activity from '../activity/Activity.js';
+import {cloneContent} from '../messageHelper.js';
 
 export default function ParallelGateway(activityDef, context) {
   return new Activity(ParallelGatewayBehaviour, {...activityDef, isParallelGateway: true}, context);

package/src/index.js

@@ -0,0 +1,106 @@
+import Activity from './activity/Activity.js';
+import Association from './flows/Association.js';
+import BoundaryEvent from './events/BoundaryEvent.js';
+import BpmnError from './error/BpmnError.js';
+import CallActivity from './tasks/CallActivity.js';
+import CancelEventDefinition from './eventDefinitions/CancelEventDefinition.js';
+import CompensateEventDefinition from './eventDefinitions/CompensateEventDefinition.js';
+import ConditionalEventDefinition from './eventDefinitions/ConditionalEventDefinition.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 EndEvent from './events/EndEvent.js';
+import Environment from './Environment.js';
+import ErrorEventDefinition from './eventDefinitions/ErrorEventDefinition.js';
+import Escalation from './activity/Escalation.js';
+import EscalationEventDefinition from './eventDefinitions/EscalationEventDefinition.js';
+import EventBasedGateway from './gateways/EventBasedGateway.js';
+import ExclusiveGateway from './gateways/ExclusiveGateway.js';
+import InclusiveGateway from './gateways/InclusiveGateway.js';
+import InputOutputSpecification from './io/InputOutputSpecification.js';
+import IntermediateCatchEvent from './events/IntermediateCatchEvent.js';
+import IntermediateThrowEvent from './events/IntermediateThrowEvent.js';
+import LinkEventDefinition from './eventDefinitions/LinkEventDefinition.js';
+import LoopCharacteristics from './tasks/LoopCharacteristics.js';
+import Message from './activity/Message.js';
+import MessageEventDefinition from './eventDefinitions/MessageEventDefinition.js';
+import MessageFlow from './flows/MessageFlow.js';
+import ParallelGateway from './gateways/ParallelGateway.js';
+import Process from './process/Process.js';
+import Properties from './io/Properties.js';
+import ReceiveTask from './tasks/ReceiveTask.js';
+import ScriptTask from './tasks/ScriptTask.js';
+import SequenceFlow from './flows/SequenceFlow.js';
+import ServiceImplementation from './tasks/ServiceImplementation.js';
+import ServiceTask from './tasks/ServiceTask.js';
+import Signal from './activity/Signal.js';
+import SignalEventDefinition from './eventDefinitions/SignalEventDefinition.js';
+import SignalTask from './tasks/SignalTask.js';
+import StandardLoopCharacteristics from './tasks/StandardLoopCharacteristics.js';
+import StartEvent from './events/StartEvent.js';
+import SubProcess from './tasks/SubProcess.js';
+import Task from './tasks/Task.js';
+import TerminateEventDefinition from './eventDefinitions/TerminateEventDefinition.js';
+import TimerEventDefinition from './eventDefinitions/TimerEventDefinition.js';
+import Transaction from './tasks/Transaction.js';
+
+export {
+  Association,
+  Activity,
+  BoundaryEvent,
+  BpmnError,
+  CallActivity,
+  CancelEventDefinition,
+  CompensateEventDefinition,
+  ConditionalEventDefinition,
+  Context,
+  DataObject,
+  DataStore,
+  DataStoreReference,
+  Definition,
+  Dummy,
+  Dummy as TextAnnotation,
+  Dummy as Group,
+  Dummy as Category,
+  EndEvent,
+  Environment,
+  ErrorEventDefinition,
+  Escalation,
+  EscalationEventDefinition,
+  EventBasedGateway,
+  ExclusiveGateway,
+  InclusiveGateway,
+  InputOutputSpecification,
+  IntermediateCatchEvent,
+  IntermediateThrowEvent,
+  LinkEventDefinition,
+  Message,
+  MessageEventDefinition,
+  MessageFlow,
+  LoopCharacteristics as MultiInstanceLoopCharacteristics,
+  ParallelGateway,
+  Process,
+  Properties,
+  ReceiveTask,
+  ScriptTask,
+  SequenceFlow,
+  ServiceImplementation,
+  ServiceTask as SendTask,
+  ServiceTask as BusinessRuleTask,
+  ServiceTask,
+  Signal,
+  SignalEventDefinition,
+  SignalTask as ManualTask,
+  SignalTask as UserTask,
+  SignalTask,
+  StandardLoopCharacteristics,
+  StartEvent,
+  SubProcess,
+  Task,
+  TerminateEventDefinition,
+  TimerEventDefinition,
+  Transaction,
+};

package/src/io/InputOutputSpecification.js

@@ -1,5 +1,5 @@
-import getPropertyValue from '../getPropertyValue';
-import {brokerSafeId} from '../shared';
+import getPropertyValue from '../getPropertyValue.js';
+import {brokerSafeId} from '../shared.js';
 
 const kConsuming = Symbol.for('consuming');
 
@@ -13,9 +13,7 @@ export default function IoSpecification(activity, ioSpecificationDef, context) {
   this.context = context;
 }
 
-const proto = IoSpecification.prototype;
-
-proto.activate = function activate(message) {
+IoSpecification.prototype.activate = function activate(message) {
   if (this[kConsuming]) return;
   if (message && message.fields.redelivered && message.fields.routingKey === 'run.start') {
     this._onFormatEnter();
@@ -26,11 +24,11 @@ proto.activate = function activate(message) {
   this[kConsuming] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {noAck: true});
 };
 
-proto.deactivate = function deactivate() {
+IoSpecification.prototype.deactivate = function deactivate() {
   if (this[kConsuming]) this[kConsuming] = this[kConsuming].cancel();
 };
 
-proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+IoSpecification.prototype._onActivityEvent = function onActivityEvent(routingKey, message) {
   const {dataInputs, dataOutputs} = this.behaviour;
   if ((dataInputs || dataOutputs) && routingKey === 'activity.enter') {
     return this._onFormatEnter();
@@ -41,7 +39,7 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   }
 };
 
-proto._onFormatEnter = function onFormatOnEnter() {
+IoSpecification.prototype._onFormatEnter = function onFormatOnEnter() {
   const safeType = brokerSafeId(this.type).toLowerCase();
   const startRoutingKey = `run.onstart.${safeType}`;
   const {dataInputs, dataOutputs} = this.behaviour;
@@ -105,7 +103,7 @@ proto._onFormatEnter = function onFormatOnEnter() {
   });
 };
 
-proto._onFormatComplete = function formatOnComplete(message) {
+IoSpecification.prototype._onFormatComplete = function formatOnComplete(message) {
   const safeType = brokerSafeId(this.type).toLowerCase();
   const messageInputs = getPropertyValue(message, 'content.ioSpecification.dataInputs');
   const messageOutputs = getPropertyValue(message, 'content.output.ioSpecification.dataOutputs') || [];
@@ -173,7 +171,7 @@ proto._onFormatComplete = function formatOnComplete(message) {
   });
 };
 
-proto._getDataOutputs = function getDataOutputs(dataOutputs) {
+IoSpecification.prototype._getDataOutputs = function getDataOutputs(dataOutputs) {
   if (!dataOutputs) return;
   return dataOutputs.map((dataOutput) => {
     return {

package/src/io/Properties.js

@@ -1,4 +1,4 @@
-import getPropertyValue from '../getPropertyValue';
+import getPropertyValue from '../getPropertyValue.js';
 
 const kProperties = Symbol.for('properties');
 const kConsuming = Symbol.for('consuming');
@@ -57,9 +57,7 @@ export default function Properties(activity, propertiesDef, context) {
   }
 }
 
-const proto = Properties.prototype;
-
-proto.activate = function activate(message) {
+Properties.prototype.activate = function activate(message) {
   if (this[kConsuming]) return;
   if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
     this._onActivityEvent('activity.enter', message);
@@ -72,11 +70,11 @@ proto.activate = function activate(message) {
   this[kConsuming] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {noAck: true});
 };
 
-proto.deactivate = function deactivate() {
+Properties.prototype.deactivate = function deactivate() {
   if (this[kConsuming]) this[kConsuming] = this[kConsuming].cancel();
 };
 
-proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+Properties.prototype._onActivityEvent = function onActivityEvent(routingKey, message) {
   switch (routingKey) {
     case 'activity.enter':
     case 'activity.extension.resume':
@@ -86,7 +84,7 @@ proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   }
 };
 
-proto._formatOnEnter = function formatOnEnter(message) {
+Properties.prototype._formatOnEnter = function formatOnEnter(message) {
   const startRoutingKey = 'run.enter.bpmn-properties';
 
   const dataInputObjects = this[kProperties].dataInputObjects;
@@ -110,7 +108,7 @@ proto._formatOnEnter = function formatOnEnter(message) {
   });
 };
 
-proto._formatOnComplete = function formatOnComplete(message) {
+Properties.prototype._formatOnComplete = function formatOnComplete(message) {
   const startRoutingKey = 'run.end.bpmn-properties';
 
   const messageOutput = getPropertyValue(message, 'content.output.properties') || {};
@@ -137,7 +135,7 @@ proto._formatOnComplete = function formatOnComplete(message) {
   });
 };
 
-proto._getProperties = function getProperties(message, values) {
+Properties.prototype._getProperties = function getProperties(message, values) {
   let response = {};
 
   if (message.content.properties) {