bpmn-elements 5.1.3 → 7.0.0

package/dist/src/flows/SequenceFlow.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = SequenceFlow;
+exports.default = void 0;
 
 var _ExecutionScope = _interopRequireDefault(require("../activity/ExecutionScope"));
 
@@ -17,6 +17,10 @@ var _Api = require("../Api");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const countersSymbol = Symbol.for('counters');
+var _default = SequenceFlow;
+exports.default = _default;
+
 function SequenceFlow(flowDef, {
   environment
 }) {
@@ -24,233 +28,217 @@ function SequenceFlow(flowDef, {
     id,
     type = 'sequenceflow',
     name,
-    parent: originalParent,
+    parent,
     targetId,
     sourceId,
     isDefault,
     behaviour = {}
   } = flowDef;
-  const parent = (0, _messageHelper.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 = {
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = (0, _messageHelper.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
-  } = (0, _EventBroker.EventBroker)(flowApi, {
+  } = new _EventBroker.EventBroker(this, {
     prefix: 'flow',
     durable: true,
     autoDelete: false
   });
-  flowApi.on = on;
-  flowApi.once = once;
-  flowApi.waitFor = waitFor;
-  Object.defineProperty(flowApi, 'broker', {
-    enumerable: true,
-    get: () => broker
-  });
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
+  this.emitFatal = emitFatal;
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
-  return flowApi;
-
-  function take(content = {}) {
-    flowApi.looped = undefined;
-    const {
-      sequenceId
-    } = content;
-    logger.debug(`<${sequenceId} (${id})> take, target <${targetId}>`);
-    ++counters.take;
-    publishEvent('take', content);
-    return true;
-  }
+}
 
-  function discard(content = {}) {
-    const {
-      sequenceId = (0, _shared.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(sourceId);
-    logger.debug(`<${sequenceId} (${id})> discard, target <${targetId}>`);
-    ++counters.discard;
-    publishEvent('discard', content);
-  }
+const proto = SequenceFlow.prototype;
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
 
-  function publishEvent(action, content) {
-    const eventContent = createMessage({
-      action,
-      ...content
-    });
-    broker.publish('event', `flow.${action}`, eventContent, {
-      type: action
-    });
-  }
-
-  function createMessage(override) {
-    return { ...override,
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      isSequenceFlow: true,
-      isDefault,
-      parent: (0, _messageHelper.cloneParent)(parent)
+  get() {
+    return { ...this[countersSymbol]
     };
   }
 
-  function getState() {
-    const result = {
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      isDefault,
-      counters: { ...counters
-      }
-    };
-    result.broker = broker.getState();
-    return result;
-  }
+});
 
-  function recover(state) {
-    counters = { ...counters,
-      ...state.counters
-    };
-    broker.recover(state.broker);
-  }
+proto.take = function take(content = {}) {
+  this.looped = undefined;
+  const {
+    sequenceId
+  } = content;
+  this.logger.debug(`<${sequenceId} (${this.id})> take, target <${this.targetId}>`);
+  ++this[countersSymbol].take;
 
-  function getApi(message) {
-    return (0, _Api.FlowApi)(broker, message || {
-      content: createMessage()
-    });
-  }
+  this._publishEvent('take', content);
 
-  function stop() {
-    broker.stop();
+  return true;
+};
+
+proto.discard = function discard(content = {}) {
+  const {
+    sequenceId = (0, _shared.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 shake(message) {
-    const content = (0, _messageHelper.cloneContent)(message.content);
-    content.sequence = content.sequence || [];
-    content.sequence.push({
-      id,
-      type,
-      isSequenceFlow: true,
-      targetId
-    });
-    if (content.id === targetId) return broker.publish('event', 'flow.shake.loop', content, {
-      persistent: false,
-      type: 'shake'
-    });
+  discardSequence.push(this.sourceId);
+  this.logger.debug(`<${sequenceId} (${this.id})> discard, target <${this.targetId}>`);
+  ++this[countersSymbol].discard;
+
+  this._publishEvent('discard', content);
+};
 
-    for (const s of message.content.sequence) {
-      if (s.id === id) return broker.publish('event', 'flow.shake.loop', content, {
-        persistent: false,
-        type: 'shake'
-      });
-    }
+proto.getState = function getState() {
+  return this.createMessage({
+    counters: this.counters,
+    broker: this.broker.getState(true)
+  });
+};
+
+proto.recover = function recover(state) {
+  Object.assign(this[countersSymbol], state.counters);
+  this.broker.recover(state.broker);
+};
+
+proto.getApi = function getApi(message) {
+  return (0, _Api.FlowApi)(this.broker, message || {
+    content: this.createMessage()
+  });
+};
+
+proto.stop = function stop() {
+  this.broker.stop();
+};
+
+proto.shake = function shake(message) {
+  const content = (0, _messageHelper.cloneContent)(message.content);
+  content.sequence = content.sequence || [];
+  content.sequence.push({
+    id: this.id,
+    type: this.type,
+    isSequenceFlow: true,
+    targetId: this.targetId
+  });
+  if (content.id === this.targetId) return this.broker.publish('event', 'flow.shake.loop', content, {
+    persistent: false,
+    type: 'shake'
+  });
 
-    broker.publish('event', 'flow.shake', content, {
+  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 evaluateCondition(message, callback) {
-    const condition = getCondition(message);
-    if (!condition) return callback(null, true);
-    return condition.execute(message, callback);
-  }
-
-  function getCondition() {
-    const conditionExpression = behaviour.conditionExpression;
-    if (!conditionExpression) return null;
-    const {
-      language
-    } = conditionExpression;
-    const script = environment.getScript(language, flowApi);
+  this.broker.publish('event', 'flow.shake', content, {
+    persistent: false,
+    type: 'shake'
+  });
+};
 
-    if (script) {
-      return ScriptCondition(script, language);
-    }
+proto.getCondition = function getCondition() {
+  const conditionExpression = this.behaviour.conditionExpression;
+  if (!conditionExpression) return null;
+  const {
+    language
+  } = conditionExpression;
+  const script = this.environment.getScript(language, this);
 
-    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());
-    }
+  if (script) {
+    return new ScriptCondition(this, script, language);
+  }
 
-    return ExpressionCondition(conditionExpression.body);
+  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 ScriptCondition(script, language) {
-    return {
-      language,
+  return new ExpressionCondition(this, conditionExpression.body);
+};
 
-      execute(message, callback) {
-        try {
-          return script.execute((0, _ExecutionScope.default)(flowApi, message), callback);
-        } catch (err) {
-          if (!callback) throw err;
-          logger.error(`<${id}>`, err);
-          callback(err);
-        }
-      }
+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: (0, _messageHelper.cloneParent)(this.parent)
+  };
+};
 
-    };
+proto._publishEvent = function publishEvent(action, content) {
+  const eventContent = this.createMessage({
+    action,
+    ...content
+  });
+  this.broker.publish('event', `flow.${action}`, eventContent, {
+    type: action
+  });
+};
+
+function ScriptCondition(owner, script, language) {
+  this.type = 'script';
+  this.language = language;
+  this._owner = owner;
+  this._script = script;
+}
+
+ScriptCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+
+  try {
+    return this._script.execute((0, _ExecutionScope.default)(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/dist/src/gateways/EventBasedGateway.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = EventBasedGateway;
 exports.EventBasedGatewayBehaviour = EventBasedGatewayBehaviour;
+exports.default = EventBasedGateway;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
@@ -12,94 +12,98 @@ var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const completedSymbol = Symbol.for('completed');
+const targetsSymbol = Symbol.for('targets');
+
 function EventBasedGateway(activityDef, context) {
-  return (0, _Activity.default)(EventBasedGatewayBehaviour, { ...activityDef
-  }, context);
+  return new _Activity.default(EventBasedGatewayBehaviour, activityDef, context);
 }
 
 function EventBasedGatewayBehaviour(activity, context) {
+  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 {
-    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
-      });
+    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'
     });
-    broker.subscribeOnce('api', `activity.stop.${executionId}`, stop, {
-      noAck: true,
-      consumerTag: `_api-stop-${executionId}`
+  }
+
+  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
     });
-    executing = true;
-    if (!isRedelivered) return broker.publish('execution', 'execute.outbound.take', (0, _messageHelper.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 = (0, _messageHelper.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}`);
-    }
   }
-}
+
+  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', (0, _messageHelper.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 = (0, _messageHelper.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', (0, _messageHelper.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/dist/src/gateways/ExclusiveGateway.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = ExclusiveGateway;
 exports.ExclusiveGatewayBehaviour = ExclusiveGatewayBehaviour;
+exports.default = ExclusiveGateway;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
@@ -13,7 +13,7 @@ var _messageHelper = require("../messageHelper");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function ExclusiveGateway(activityDef, context) {
-  return (0, _Activity.default)(ExclusiveGatewayBehaviour, activityDef, context);
+  return new _Activity.default(ExclusiveGatewayBehaviour, activityDef, context);
 }
 
 function ExclusiveGatewayBehaviour(activity) {
@@ -22,18 +22,15 @@ function ExclusiveGatewayBehaviour(activity) {
     type,
     broker
   } = activity;
-  const source = {
-    id,
-    type,
-    execute
-  };
-  return source;
+  this.id = id;
+  this.type = type;
+  this.broker = broker;
+}
 
-  function execute({
-    content
-  }) {
-    broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
-      outboundTakeOne: true
-    }));
-  }
-}
+ExclusiveGatewayBehaviour.prototype.execute = function execute({
+  content
+}) {
+  this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
+    outboundTakeOne: true
+  }));
+};