bpmn-elements 5.1.3 → 7.0.0

package/dist/src/events/StartEvent.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = StartEvent;
 exports.StartEventBehaviour = StartEventBehaviour;
+exports.default = StartEvent;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
@@ -14,108 +14,123 @@ var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const executeMessageSymbol = Symbol.for('executeMessage');
+const executionSymbol = Symbol.for('execution');
+
 function StartEvent(activityDef, context) {
-  return (0, _Activity.default)(StartEventBehaviour, activityDef, context);
+  return new _Activity.default(StartEventBehaviour, activityDef, context);
 }
 
 function StartEventBehaviour(activity) {
-  const {
-    id,
-    type = 'startevent',
-    broker,
-    eventDefinitions
-  } = activity;
-  const eventDefinitionExecution = eventDefinitions && (0, _EventDefinitionExecution.default)(activity, eventDefinitions);
-  const event = {
-    id,
-    type,
-    execute
-  };
-  return event;
+  this.id = activity.id;
+  this.type = activity.type;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this[executionSymbol] = activity.eventDefinitions && new _EventDefinitionExecution.default(activity, activity.eventDefinitions);
+}
 
-  function execute(executeMessage) {
-    if (eventDefinitionExecution) {
-      return eventDefinitionExecution.execute(executeMessage);
-    }
+const proto = StartEventBehaviour.prototype;
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const message = this[executeMessageSymbol];
+    return message && message.content.executionId;
+  }
 
-    const content = (0, _messageHelper.cloneContent)(executeMessage.content);
+});
 
-    if (!content.form) {
-      return broker.publish('execution', 'execute.completed', content);
-    }
+proto.execute = function execute(executeMessage) {
+  const execution = this[executionSymbol];
 
-    const {
-      executionId
-    } = content;
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: `_api-${executionId}`,
-      priority: 300
-    });
-    broker.subscribeTmp('api', '#.signal.*', onDelegatedApiMessage, {
-      noAck: true,
-      consumerTag: `_api-delegated-${executionId}`
-    });
-    broker.publish('event', 'activity.wait', { ...content,
-      executionId,
-      state: 'wait'
-    });
-
-    function onDelegatedApiMessage(routingKey, message) {
-      if (!message.properties.delegate) return;
-      const {
-        content: delegateContent
-      } = message;
-      if (!delegateContent || !delegateContent.message) return;
-      const {
-        id: signalId,
-        executionId: signalExecutionId
-      } = delegateContent.message;
-      if (signalId !== id && signalExecutionId !== executionId) return;
-      const {
-        type: messageType,
-        correlationId
-      } = message.properties;
-      broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(content, {
-        message: { ...delegateContent.message
-        }
-      }), {
-        correlationId,
-        type: messageType
-      });
-      return onApiMessage(routingKey, message);
-    }
+  if (execution) {
+    return execution.execute(executeMessage);
+  }
+
+  const content = (0, _messageHelper.cloneContent)(executeMessage.content);
+  const broker = this.broker;
 
-    function onApiMessage(routingKey, message) {
-      const {
-        type: messageType,
-        correlationId
-      } = message.properties;
-
-      switch (messageType) {
-        case 'stop':
-          return stop();
-
-        case 'signal':
-          stop();
-          return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
-            output: message.content.message,
-            state: 'signal'
-          }), {
-            correlationId
-          });
-
-        case 'discard':
-          stop();
-          return broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content), {
-            correlationId
-          });
+  if (!content.form) {
+    return broker.publish('execution', 'execute.completed', content);
+  }
+
+  const executionId = content.executionId;
+  this[executeMessageSymbol] = executeMessage;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(...args), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 300
+  });
+  broker.subscribeTmp('api', '#.signal.*', (...args) => this._onDelegatedApiMessage(...args), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`
+  });
+  broker.publish('event', 'activity.wait', { ...content,
+    executionId,
+    state: 'wait'
+  });
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const {
+    type: messageType,
+    correlationId
+  } = message.properties;
+
+  switch (messageType) {
+    case 'stop':
+      return this._stop();
+
+    case 'signal':
+      {
+        this._stop();
+
+        const content = this[executeMessageSymbol].content;
+        return this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
+          output: message.content.message,
+          state: 'signal'
+        }), {
+          correlationId
+        });
       }
-    }
 
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_api-delegated-${executionId}`);
-    }
+    case 'discard':
+      {
+        this._stop();
+
+        const content = this[executeMessageSymbol].content;
+        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content), {
+          correlationId
+        });
+      }
   }
-}
+};
+
+proto._onDelegatedApiMessage = function onDelegatedApiMessage(routingKey, message) {
+  if (!message.properties.delegate) return;
+  const content = message.content;
+  if (!content.message) return;
+  const {
+    id: signalId,
+    executionId: signalExecutionId
+  } = content.message;
+  if (signalId !== this.id && signalExecutionId !== this.executionId) return;
+  const {
+    type,
+    correlationId
+  } = message.properties;
+  const executeContent = this[executeMessageSymbol].content;
+  this.broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(executeContent, {
+    message: { ...content.message
+    }
+  }), {
+    correlationId,
+    type
+  });
+  return this._onApiMessage(routingKey, message);
+};
+
+proto._stop = function stop() {
+  const broker = this.broker,
+        executionId = this.executionId;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
+};

package/dist/src/flows/Association.js

@@ -13,6 +13,8 @@ var _Api = require("../Api");
 
 var _shared = require("../shared");
 
+const countersSymbol = Symbol.for('counters');
+
 function Association(associationDef, {
   environment
 }) {
@@ -20,132 +22,123 @@ function Association(associationDef, {
     id,
     type = 'association',
     name,
-    parent: originalParent,
+    parent,
     targetId,
     sourceId,
     behaviour = {}
   } = associationDef;
-  const parent = (0, _messageHelper.cloneParent)(originalParent);
-  const logger = environment.Logger(type.toLowerCase());
-  const 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.isAssociation = true;
+  this.environment = environment;
+  const logger = this.logger = environment.Logger(type.toLowerCase());
+  this[countersSymbol] = {
     complete: 0,
     take: 0,
     discard: 0
   };
-  const associationApi = {
-    id,
-    type,
-    name,
-    parent,
-    behaviour,
-    sourceId,
-    targetId,
-    isAssociation: true,
-    environment,
-
-    get counters() {
-      return { ...counters
-      };
-    },
-
-    complete,
-    discard,
-    getApi,
-    getState,
-    recover,
-    stop,
-    take
-  };
   const {
     broker,
     on,
     once,
     waitFor
-  } = (0, _EventBroker.EventBroker)(associationApi, {
+  } = new _EventBroker.EventBroker(this, {
     prefix: 'association',
     durable: true,
     autoDelete: false
   });
-  associationApi.on = on;
-  associationApi.once = once;
-  associationApi.waitFor = waitFor;
-  Object.defineProperty(associationApi, 'broker', {
-    enumerable: true,
-    get: () => broker
-  });
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
-  return associationApi;
+}
 
-  function take(content = {}) {
-    logger.debug(`<${id}> take target <${targetId}>`);
-    ++counters.discard;
-    publishEvent('take', content);
-    return true;
-  }
+const proto = Association.prototype;
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
 
-  function discard(content = {}) {
-    logger.debug(`<${id}> discard target <${targetId}>`);
-    ++counters.take;
-    publishEvent('discard', content);
-    return true;
+  get() {
+    return { ...this[countersSymbol]
+    };
   }
 
-  function complete(content = {}) {
-    logger.debug(`<${id}> completed target <${targetId}>`);
-    ++counters.complete;
-    publishEvent('complete', content);
-    return true;
-  }
+});
 
-  function publishEvent(action, content) {
-    const eventContent = createMessageContent({
-      action,
-      message: content,
-      sequenceId: (0, _shared.getUniqueId)(id)
-    });
-    broker.publish('event', `association.${action}`, eventContent, {
-      type: action
-    });
-  }
+proto.take = function take(content = {}) {
+  this.logger.debug(`<${this.id}> take target <${this.targetId}>`);
+  ++this[countersSymbol].take;
 
-  function createMessageContent(override = {}) {
-    return { ...override,
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      isAssociation: true,
-      parent: (0, _messageHelper.cloneParent)(parent)
-    };
-  }
+  this._publishEvent('take', content);
 
-  function getState() {
-    const result = {
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      counters: { ...counters
-      }
-    };
-    result.broker = broker.getState();
-    return result;
-  }
+  return true;
+};
 
-  function recover(state) {
-    Object.assign(counters, state.counters);
-    broker.recover(state.broker);
-  }
+proto.discard = function discard(content = {}) {
+  this.logger.debug(`<${this.id}> discard target <${this.targetId}>`);
+  ++this[countersSymbol].discard;
 
-  function getApi(message) {
-    return (0, _Api.FlowApi)(broker, message || {
-      content: createMessageContent()
-    });
-  }
+  this._publishEvent('discard', content);
 
-  function stop() {
-    broker.stop();
-  }
-}
+  return true;
+};
+
+proto.complete = function complete(content = {}) {
+  this.logger.debug(`<${this.id}> completed target <${this.targetId}>`);
+  ++this[countersSymbol].complete;
+
+  this._publishEvent('complete', content);
+
+  return true;
+};
+
+proto.getState = function getState() {
+  return this._createMessageContent({
+    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._createMessageContent()
+  });
+};
+
+proto.stop = function stop() {
+  this.broker.stop();
+};
+
+proto._publishEvent = function publishEvent(action, content) {
+  const eventContent = this._createMessageContent({
+    action,
+    message: content,
+    sequenceId: (0, _shared.getUniqueId)(this.id)
+  });
+
+  this.broker.publish('event', `association.${action}`, eventContent, {
+    type: action
+  });
+};
+
+proto._createMessageContent = function createMessageContent(override) {
+  return { ...override,
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    sourceId: this.sourceId,
+    targetId: this.targetId,
+    isAssociation: true,
+    parent: (0, _messageHelper.cloneParent)(this.parent)
+  };
+};

package/dist/src/flows/MessageFlow.js

@@ -11,47 +11,30 @@ var _messageHelper = require("../messageHelper");
 
 var _EventBroker = require("../EventBroker");
 
+const countersSymbol = Symbol.for('counters');
+const sourceElementSymbol = Symbol.for('sourceElement');
+
 function MessageFlow(flowDef, context) {
   const {
     id,
-    type = 'message',
+    type = 'messageflow',
     name,
     target,
     source,
     behaviour,
     parent
   } = flowDef;
-  const sourceElement = context.getActivityById(source.id) || context.getProcessById(source.processId);
-  const sourceEndConsumerTag = `_message-on-end-${(0, _shared.brokerSafeId)(id)}`;
-  const sourceMessageConsumerTag = `_message-on-message-${(0, _shared.brokerSafeId)(id)}`;
-  const {
-    debug
-  } = context.environment.Logger(type.toLowerCase());
-  if (!sourceElement) return;
-  const counters = {
-    messages: 0,
-    discard: 0
-  };
-  const flowApi = {
-    id,
-    type,
-    name,
-    target,
-    source,
-    behaviour,
-
-    get counters() {
-      return { ...counters
-      };
-    },
-
-    activate,
-    deactivate,
-    getApi,
-    getState,
-    recover,
-    resume,
-    stop
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = (0, _messageHelper.cloneParent)(parent);
+  this.source = source;
+  this.target = target;
+  this.behaviour = behaviour;
+  this.environment = context.environment;
+  this.context = context;
+  this[countersSymbol] = {
+    messages: 0
   };
   const {
     broker,
@@ -59,81 +42,81 @@ function MessageFlow(flowDef, context) {
     once,
     emit,
     waitFor
-  } = (0, _EventBroker.MessageFlowBroker)(flowApi);
-  flowApi.on = on;
-  flowApi.once = once;
-  flowApi.emit = emit;
-  flowApi.waitFor = waitFor;
-  Object.defineProperty(flowApi, 'broker', {
-    enumerable: true,
-    get: () => broker
-  });
-  return flowApi;
-
-  function onSourceEnd({
-    content
-  }) {
-    ++counters.messages;
-    debug(`<${id}> sending message from <${source.processId}.${source.id}> to`, target.id ? `<${target.processId}.${target.id}>` : `<${target.processId}>`);
-    broker.publish('event', 'message.outbound', createMessage(content.message));
-  }
-
-  function onSourceMessage() {
-    deactivate();
-  }
-
-  function createMessage(message) {
-    return {
-      id,
-      type,
-      name,
-      source: { ...source
-      },
-      target: { ...target
-      },
-      parent: parent && (0, _messageHelper.cloneParent)(parent),
-      message
+  } = (0, _EventBroker.MessageFlowBroker)(this);
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.emit = emit;
+  this.waitFor = waitFor;
+  this[sourceElementSymbol] = context.getActivityById(source.id) || context.getProcessById(source.processId);
+  this.logger = context.environment.Logger(type.toLowerCase());
+}
+
+const proto = MessageFlow.prototype;
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+
+  get() {
+    return { ...this[countersSymbol]
     };
   }
 
-  function stop() {
-    deactivate();
-    broker.stop();
-  }
-
-  function getState() {
-    return {
-      id,
-      type,
-      counters: { ...counters
-      }
-    };
-  }
-
-  function recover(state) {
-    Object.assign(counters, state.counters);
-    broker.recover(state.broker);
-  }
+});
 
-  function resume() {
-    broker.resume();
-  }
+proto.getState = function getState() {
+  return {
+    id: this.id,
+    type: this.type,
+    counters: this.counters
+  };
+};
 
-  function getApi() {
-    return flowApi;
-  }
+proto.recover = function recover(state) {
+  Object.assign(this[countersSymbol], state.counters);
+};
 
-  function activate() {
-    sourceElement.on('message', onSourceMessage, {
-      consumerTag: sourceMessageConsumerTag
-    });
-    sourceElement.on('end', onSourceEnd, {
-      consumerTag: sourceEndConsumerTag
-    });
-  }
+proto.getApi = function getApi() {
+  return this;
+};
 
-  function deactivate() {
-    sourceElement.broker.cancel(sourceMessageConsumerTag);
-    sourceElement.broker.cancel(sourceEndConsumerTag);
-  }
-}
+proto.activate = function activate() {
+  const sourceElement = this[sourceElementSymbol];
+  const safeId = (0, _shared.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() {
+  const sourceElement = this[sourceElementSymbol];
+  const safeId = (0, _shared.brokerSafeId)(this.id);
+  sourceElement.broker.cancel(`_message-on-end-${safeId}`);
+  sourceElement.broker.cancel(`_message-on-message-${safeId}`);
+};
+
+proto._onSourceEnd = function onSourceEnd({
+  content
+}) {
+  ++this[countersSymbol].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));
+};
+
+proto._createMessage = function createMessage(message) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    source: { ...this.source
+    },
+    target: { ...this.target
+    },
+    parent: (0, _messageHelper.cloneParent)(this.parent),
+    message
+  };
+};