bpmn-elements 5.1.3 → 7.0.0

package/src/flows/SequenceFlow.js

@@ -4,205 +4,187 @@ import {getUniqueId} from '../shared';
 import {EventBroker} from '../EventBroker';
 import {FlowApi} from '../Api';
 
-export default function SequenceFlow(flowDef, {environment}) {
-  const {id, type = 'sequenceflow', name, parent: originalParent, targetId, sourceId, isDefault, behaviour = {}} = flowDef;
-  const parent = cloneParent(originalParent);
-  const logger = environment.Logger(type.toLowerCase());
-
-
-  const flowBase = {
-    id,
-    type,
-    name,
-    parent,
-    behaviour,
-    sourceId,
-    targetId,
-    isDefault,
-    isSequenceFlow: true,
-    environment,
-    logger,
-  };
-
-  environment.registerScript({...flowBase});
-
-  let counters = {
+const countersSymbol = Symbol.for('counters');
+
+export default SequenceFlow;
+
+function SequenceFlow(flowDef, {environment}) {
+  const {id, type = 'sequenceflow', name, parent, targetId, sourceId, isDefault, behaviour = {}} = flowDef;
+
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = cloneParent(parent);
+  this.behaviour = behaviour;
+  this.sourceId = sourceId;
+  this.targetId = targetId;
+  this.isDefault = isDefault;
+  this.isSequenceFlow = true;
+  this.environment = environment;
+  const logger = this.logger = environment.Logger(type.toLowerCase());
+
+  this[countersSymbol] = {
     looped: 0,
     take: 0,
     discard: 0,
   };
 
-  const flowApi = {
-    ...flowBase,
-    get counters() {
-      return {...counters};
-    },
-    discard,
-    evaluateCondition,
-    getApi,
-    getCondition,
-    getState,
-    recover,
-    shake,
-    stop,
-    take,
-  };
+  environment.registerScript(this);
+  const {broker, on, once, waitFor, emitFatal} = new EventBroker(this, {prefix: 'flow', durable: true, autoDelete: false});
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
+  this.emitFatal = emitFatal;
 
-  const {broker, on, once, waitFor, emitFatal} = EventBroker(flowApi, {prefix: 'flow', durable: true, autoDelete: false});
+  logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
+}
 
-  flowApi.on = on;
-  flowApi.once = once;
-  flowApi.waitFor = waitFor;
+const proto = SequenceFlow.prototype;
 
-  Object.defineProperty(flowApi, 'broker', {
-    enumerable: true,
-    get: () => broker,
-  });
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+  get() {
+    return {...this[countersSymbol]};
+  },
+});
 
-  logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
-
-  return flowApi;
+proto.take = function take(content = {}) {
+  this.looped = undefined;
 
-  function take(content = {}) {
-    flowApi.looped = undefined;
+  const {sequenceId} = content;
 
-    const {sequenceId} = content;
+  this.logger.debug(`<${sequenceId} (${this.id})> take, target <${this.targetId}>`);
+  ++this[countersSymbol].take;
 
-    logger.debug(`<${sequenceId} (${id})> take, target <${targetId}>`);
-    ++counters.take;
+  this._publishEvent('take', content);
 
-    publishEvent('take', content);
+  return true;
+};
 
-    return true;
+proto.discard = function discard(content = {}) {
+  const {sequenceId = getUniqueId(this.id)} = content;
+  const discardSequence = content.discardSequence = (content.discardSequence || []).slice();
+  if (discardSequence.indexOf(this.targetId) > -1) {
+    ++this[countersSymbol].looped;
+    this.logger.debug(`<${this.id}> discard loop detected <${this.sourceId}> -> <${this.targetId}>. Stop.`);
+    return this._publishEvent('looped', content);
   }
 
-  function discard(content = {}) {
-    const {sequenceId = getUniqueId(id)} = content;
-    const discardSequence = content.discardSequence = (content.discardSequence || []).slice();
-    if (discardSequence.indexOf(targetId) > -1) {
-      ++counters.looped;
-      logger.debug(`<${id}> discard loop detected <${sourceId}> -> <${targetId}>. Stop.`);
-      return publishEvent('looped', content);
-    }
+  discardSequence.push(this.sourceId);
 
-    discardSequence.push(sourceId);
-
-    logger.debug(`<${sequenceId} (${id})> discard, target <${targetId}>`);
-    ++counters.discard;
-    publishEvent('discard', content);
-  }
+  this.logger.debug(`<${sequenceId} (${this.id})> discard, target <${this.targetId}>`);
+  ++this[countersSymbol].discard;
+  this._publishEvent('discard', content);
+};
 
-  function publishEvent(action, content) {
-    const eventContent = createMessage({
-      action,
-      ...content,
-    });
+proto.getState = function getState() {
+  return this.createMessage({
+    counters: this.counters,
+    broker: this.broker.getState(true),
+  });
+};
 
-    broker.publish('event', `flow.${action}`, eventContent, {type: action});
-  }
+proto.recover = function recover(state) {
+  Object.assign(this[countersSymbol], state.counters);
+  this.broker.recover(state.broker);
+};
 
-  function createMessage(override) {
-    return {
-      ...override,
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      isSequenceFlow: true,
-      isDefault,
-      parent: cloneParent(parent),
-    };
-  }
+proto.getApi = function getApi(message) {
+  return FlowApi(this.broker, message || {content: this.createMessage()});
+};
 
-  function getState() {
-    const result = {
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      isDefault,
-      counters: {...counters},
-    };
-    result.broker = broker.getState();
-    return result;
-  }
+proto.stop = function stop() {
+  this.broker.stop();
+};
 
-  function recover(state) {
-    counters = {...counters, ...state.counters};
-    broker.recover(state.broker);
-  }
+proto.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});
 
-  function getApi(message) {
-    return FlowApi(broker, message || {content: createMessage()});
-  }
+  if (content.id === this.targetId) return this.broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
 
-  function stop() {
-    broker.stop();
+  for (const s of message.content.sequence) {
+    if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
   }
 
-  function shake(message) {
-    const content = cloneContent(message.content);
-    content.sequence = content.sequence || [];
-    content.sequence.push({id, type, isSequenceFlow: true, targetId});
+  this.broker.publish('event', 'flow.shake', content, {persistent: false, type: 'shake'});
+};
 
-    if (content.id === targetId) return broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
+proto.getCondition = function getCondition() {
+  const conditionExpression = this.behaviour.conditionExpression;
+  if (!conditionExpression) return null;
 
-    for (const s of message.content.sequence) {
-      if (s.id === id) return broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
-    }
-
-    broker.publish('event', 'flow.shake', content, {persistent: false, type: 'shake'});
+  const {language} = conditionExpression;
+  const script = this.environment.getScript(language, this);
+  if (script) {
+    return new ScriptCondition(this, script, language);
   }
 
-  function evaluateCondition(message, callback) {
-    const condition = getCondition(message);
-    if (!condition) return callback(null, true);
-
-    return condition.execute(message, callback);
+  if (!conditionExpression.body) {
+    const msg = language ? `Condition expression script ${language} is unsupported or was not registered` : 'Condition expression without body is unsupported';
+    return this.emitFatal(new Error(msg), this.createMessage());
   }
 
-  function getCondition() {
-    const conditionExpression = behaviour.conditionExpression;
-    if (!conditionExpression) return null;
+  return new ExpressionCondition(this, conditionExpression.body);
+};
+
+proto.createMessage = function createMessage(override) {
+  return {
+    ...override,
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    sourceId: this.sourceId,
+    targetId: this.targetId,
+    isSequenceFlow: true,
+    isDefault: this.isDefault,
+    parent: cloneParent(this.parent),
+  };
+};
 
-    const {language} = conditionExpression;
-    const script = environment.getScript(language, flowApi);
-    if (script) {
-      return ScriptCondition(script, language);
-    }
+proto._publishEvent = function publishEvent(action, content) {
+  const eventContent = this.createMessage({
+    action,
+    ...content,
+  });
 
-    if (!conditionExpression.body) {
-      const msg = language ? `Condition expression script ${language} is unsupported or was not registered` : 'Condition expression without body is unsupported';
-      return emitFatal(new Error(msg), createMessage());
-    }
+  this.broker.publish('event', `flow.${action}`, eventContent, {type: action});
+};
 
-    return ExpressionCondition(conditionExpression.body);
-  }
+function ScriptCondition(owner, script, language) {
+  this.type = 'script';
+  this.language = language;
+  this._owner = owner;
+  this._script = script;
+}
 
-  function ScriptCondition(script, language) {
-    return {
-      language,
-      execute(message, callback) {
-        try {
-          return script.execute(ExecutionScope(flowApi, message), callback);
-        } catch (err) {
-          if (!callback) throw err;
-          logger.error(`<${id}>`, err);
-          callback(err);
-        }
-      },
-    };
+ScriptCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+  try {
+    return this._script.execute(ExecutionScope(owner, message), callback);
+  } catch (err) {
+    if (!callback) throw err;
+    owner.logger.error(`<${owner.id}>`, err);
+    callback(err);
   }
+};
 
-  function ExpressionCondition(expression) {
-    return {
-      execute: (message, callback) => {
-        const result = environment.resolveExpression(expression, createMessage(message));
-        if (callback) return callback(null, result);
-        return result;
-      },
-    };
-  }
+function ExpressionCondition(owner, expression) {
+  this.type = 'expression';
+  this.expression = expression;
+  this._owner = owner;
 }
+
+ExpressionCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+  try {
+    const result = owner.environment.resolveExpression(this.expression, owner.createMessage(message));
+    if (callback) return callback(null, result);
+    return result;
+  } catch (err) {
+    if (callback) return callback(err);
+    throw err;
+  }
+};

package/src/gateways/EventBasedGateway.js

@@ -1,77 +1,84 @@
 import Activity from '../activity/Activity';
 import {cloneContent} from '../messageHelper';
 
+const completedSymbol = Symbol.for('completed');
+const targetsSymbol = Symbol.for('targets');
+
 export default function EventBasedGateway(activityDef, context) {
-  return Activity(EventBasedGatewayBehaviour, {...activityDef}, context);
+  return new Activity(EventBasedGatewayBehaviour, activityDef, context);
 }
 
 export function EventBasedGatewayBehaviour(activity, context) {
-  const {id, type, broker, logger, outbound: outboundSequenceFlows = []} = activity;
-  let executing = false;
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute(executeMessage) {
-    const isRedelivered = executeMessage.fields.redelivered;
-    const content = executeMessage.content;
-    const {executionId, outbound = [], outboundTaken} = content;
-
-    const targets = [];
-    for (let i = 0; i < outboundSequenceFlows.length; i++) {
-      const flow = outboundSequenceFlows[i];
-      targets.push(context.getActivityById(flow.targetId));
-      outbound.push({id: flow.id, action: 'take'});
-    }
-
-    if (!targets.length) return complete(content);
-
-    if (executing && outboundTaken) return;
-
-    const targetConsumerTag = `_gateway-listener-${id}`;
-
-    targets.forEach((target) => {
-      target.broker.subscribeOnce('event', 'activity.end', onTargetCompleted, {consumerTag: targetConsumerTag});
-    });
-
-    broker.subscribeOnce('api', `activity.stop.${executionId}`, stop, {noAck: true, consumerTag: `_api-stop-${executionId}`});
-
-    executing = true;
-    if (!isRedelivered) return broker.publish('execution', 'execute.outbound.take', cloneContent(content, {outboundTaken: true}));
-
-    function onTargetCompleted(_, message, owner) {
-      const {id: targetId, exexutionId: targetExecutionId} = message.content;
-      logger.debug(`<${executionId} (${id})> <${targetExecutionId}> completed run, discarding the rest`);
-      targets.forEach((target) => {
-        if (target === owner) return;
-        target.broker.cancel(targetConsumerTag);
-        target.discard();
-      });
-
-      const completedContent = cloneContent(executeMessage.content, {taken: {
-        id: targetId,
-        executionId: targetExecutionId,
-      }, ignoreOutbound: true});
-
-      complete(completedContent);
-    }
-
-    function complete(completedContent) {
-      broker.publish('execution', 'execute.completed', completedContent);
-    }
-
-    function stop() {
-      executing = false;
-      targets.forEach((target) => {
-        target.broker.cancel(targetConsumerTag);
-      });
-      broker.cancel(`_api-stop-${executionId}`);
-    }
-  }
+  this.id = activity.id;
+  this.type = activity.type;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this.context = context;
+  this[targetsSymbol] = activity.outbound.map((flow) => context.getActivityById(flow.targetId));
 }
 
+EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const {executionId, outbound = [], outboundTaken} = executeContent;
+
+  const targets = this[targetsSymbol];
+  this[completedSymbol] = false;
+  if (!targets.length) return this._complete(executeContent);
+
+  for (const flow of this.activity.outbound) {
+    outbound.push({id: flow.id, action: 'take'});
+  }
+
+  if (!this[completedSymbol] && outboundTaken) return;
+
+  const targetConsumerTag = `_gateway-listener-${this.id}`;
+
+  const onTargetCompleted = this._onTargetCompleted.bind(this, executeMessage);
+  for (const target of this[targetsSymbol]) {
+    target.broker.subscribeOnce('event', 'activity.end', onTargetCompleted, {consumerTag: targetConsumerTag});
+  }
+
+  const broker = this.activity.broker;
+  broker.subscribeOnce('api', `activity.stop.${executionId}`, () => this._stop(), {
+    noAck: true,
+    consumerTag: '_api-stop-execution',
+  });
+
+  this[completedSymbol] = false;
+  if (!executeMessage.fields.redelivered) return broker.publish('execution', 'execute.outbound.take', cloneContent(executeContent, {outboundTaken: true}));
+};
+
+EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompleted(executeMessage, _, message, owner) {
+  const {id: targetId, exexutionId: targetExecutionId} = message.content;
+  const executeContent = executeMessage.content;
+  const executionId = executeContent.executionId;
+  this.activity.logger.debug(`<${executionId} (${this.id})> <${targetExecutionId}> completed run, discarding the rest`);
+
+  this._stop();
+  for (const target of this[targetsSymbol]) {
+    if (target === owner) continue;
+    target.discard();
+  }
+
+  const completedContent = cloneContent(executeContent, {
+    taken: {
+      id: targetId,
+      executionId: targetExecutionId,
+    },
+    ignoreOutbound: true,
+  });
+
+  this._complete(completedContent);
+};
+
+EventBasedGatewayBehaviour.prototype._complete = function complete(completedContent) {
+  this[completedSymbol] = 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[targetsSymbol]) target.broker.cancel(targetConsumerTag);
+  this.broker.cancel('_api-stop-execution');
+};
+

package/src/gateways/ExclusiveGateway.js

@@ -2,21 +2,16 @@ import Activity from '../activity/Activity';
 import {cloneContent} from '../messageHelper';
 
 export default function ExclusiveGateway(activityDef, context) {
-  return Activity(ExclusiveGatewayBehaviour, activityDef, context);
+  return new Activity(ExclusiveGatewayBehaviour, activityDef, context);
 }
 
 export function ExclusiveGatewayBehaviour(activity) {
   const {id, type, broker} = activity;
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute({content}) {
-    broker.publish('execution', 'execute.completed', cloneContent(content, {outboundTakeOne: true}));
-  }
+  this.id = id;
+  this.type = type;
+  this.broker = broker;
 }
+
+ExclusiveGatewayBehaviour.prototype.execute = function execute({content}) {
+  this.broker.publish('execution', 'execute.completed', cloneContent(content, {outboundTakeOne: true}));
+};

package/src/gateways/InclusiveGateway.js

@@ -2,21 +2,16 @@ import Activity from '../activity/Activity';
 import {cloneContent} from '../messageHelper';
 
 export default function InclusiveGateway(activityDef, context) {
-  return Activity(InclusiveGatewayBehaviour, activityDef, context);
+  return new Activity(InclusiveGatewayBehaviour, activityDef, context);
 }
 
 export function InclusiveGatewayBehaviour(activity) {
   const {id, type, broker} = activity;
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute({content}) {
-    broker.publish('execution', 'execute.completed', cloneContent(content));
-  }
+  this.id = id;
+  this.type = type;
+  this.broker = broker;
 }
+
+InclusiveGatewayBehaviour.prototype.execute = function execute({content}) {
+  this.broker.publish('execution', 'execute.completed', cloneContent(content));
+};

package/src/gateways/ParallelGateway.js

@@ -2,21 +2,16 @@ import Activity from '../activity/Activity';
 import {cloneContent} from '../messageHelper';
 
 export default function ParallelGateway(activityDef, context) {
-  return Activity(ParallelGatewayBehaviour, {...activityDef, isParallelGateway: true}, context);
+  return new Activity(ParallelGatewayBehaviour, {...activityDef, isParallelGateway: true}, context);
 }
 
 export function ParallelGatewayBehaviour(activity) {
   const {id, type, broker} = activity;
-
-  const source = {
-    id,
-    type,
-    execute,
-  };
-
-  return source;
-
-  function execute({content}) {
-    broker.publish('execution', 'execute.completed', cloneContent(content));
-  }
+  this.id = id;
+  this.type = type;
+  this.broker = broker;
 }
+
+ParallelGatewayBehaviour.prototype.execute = function execute({content}) {
+  this.broker.publish('execution', 'execute.completed', cloneContent(content));
+};