bpmn-elements 6.0.0 → 8.0.0

package/dist/src/process/ProcessExecution.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = ProcessExecution;
+exports.default = void 0;
 
 var _Api = require("../Api");
 
@@ -11,782 +11,884 @@ var _messageHelper = require("../messageHelper");
 
 var _shared = require("../shared");
 
+var _default = ProcessExecution;
+exports.default = _default;
+const kActivated = Symbol.for('activated');
+const kActivityQ = Symbol.for('activityQ');
+const kCompleted = Symbol.for('completed');
+const kElements = Symbol.for('elements');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kParent = Symbol.for('parent');
+const kStatus = Symbol.for('status');
+const kStopped = Symbol.for('stopped');
+
 function ProcessExecution(parentActivity, context) {
   const {
     id,
     type,
     broker,
-    logger,
     isSubProcess
   } = parentActivity;
-  const {
-    environment
-  } = context;
-  const children = context.getActivities(id);
-  const flows = context.getSequenceFlows(id);
-  const associations = context.getAssociations(id);
-  const outboundMessageFlows = context.getMessageFlows(id);
-  const startActivities = [];
-  const triggeredByEventActivities = [];
-  const detachedActivities = [];
-  const postponed = [];
-  const startSequences = {};
-  const exchangeName = isSubProcess ? 'subprocess-execution' : 'execution';
+  this[kParent] = parentActivity;
+  this.id = id;
+  this.type = type;
+  this.isSubProcess = isSubProcess;
+  this.broker = broker;
+  this.environment = context.environment;
+  this.context = context;
+  this[kElements] = {
+    children: context.getActivities(id),
+    associations: context.getAssociations(id),
+    flows: context.getSequenceFlows(id),
+    outboundMessageFlows: context.getMessageFlows(id),
+    startActivities: [],
+    triggeredByEvent: [],
+    detachedActivities: [],
+    startSequences: {},
+    postponed: []
+  };
+  const exchangeName = this._exchangeName = isSubProcess ? 'subprocess-execution' : 'execution';
   broker.assertExchange(exchangeName, 'topic', {
     autoDelete: false,
     durable: true
   });
-  let activityQ,
-      status = 'init',
-      executionId,
-      stopped,
-      activated,
-      stateMessage,
-      completed = false,
-      executionName;
-  const processExecution = {
-    id,
-    type,
-    broker,
+  this[kCompleted] = false;
+  this[kStopped] = false;
+  this[kActivated] = false;
+  this[kStatus] = 'init';
+  this.executionId = undefined;
+  this[kMessageHandlers] = {
+    onActivityEvent: this._onActivityEvent.bind(this),
+    onApiMessage: this._onApiMessage.bind(this),
+    onChildMessage: this._onChildMessage.bind(this),
+    onMessageFlowEvent: this._onMessageFlowEvent.bind(this)
+  };
+}
 
-    get environment() {
-      return environment;
-    },
+const proto = ProcessExecution.prototype;
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
 
-    get executionId() {
-      return executionId;
-    },
+  get() {
+    return this[kStopped];
+  }
 
-    get completed() {
-      return completed;
-    },
+});
+Object.defineProperty(proto, 'completed', {
+  enumerable: true,
 
-    get status() {
-      return status;
-    },
+  get() {
+    return this[kCompleted];
+  }
 
-    get stopped() {
-      return stopped;
-    },
+});
+Object.defineProperty(proto, 'status', {
+  enumerable: true,
 
-    get postponedCount() {
-      return postponed.length;
-    },
+  get() {
+    return this[kStatus];
+  }
 
-    get isRunning() {
-      if (activated) return true;
-      return false;
-    },
+});
+Object.defineProperty(proto, 'postponedCount', {
+  get() {
+    return this[kElements].postponed.length;
+  }
 
-    discard,
-    execute,
-    getApi,
-    getActivityById,
-    getActivities,
-    getPostponed,
-    getSequenceFlows,
-    getState,
-    recover,
-    shake,
-    stop
-  };
-  return processExecution;
-
-  function execute(executeMessage) {
-    if (!executeMessage) throw new Error('Process execution requires message');
-    if (!executeMessage.content || !executeMessage.content.executionId) throw new Error('Process execution requires execution id');
-    const isRedelivered = executeMessage.fields.redelivered;
-    executionId = executeMessage.content.executionId;
-    prepare();
-    stateMessage = (0, _messageHelper.cloneMessage)(executeMessage);
-    stateMessage.content = { ...stateMessage.content,
-      executionId,
-      state: 'start'
-    };
-    stopped = false;
-    environment.assignVariables(executeMessage);
-    activityQ = broker.assertQueue(`execute-${executionId}-q`, {
-      durable: true,
-      autoDelete: false
-    });
+});
+Object.defineProperty(proto, 'isRunning', {
+  get() {
+    return this[kActivated];
+  }
 
-    if (isRedelivered) {
-      return resume();
-    }
+});
 
-    logger.debug(`<${executionName}> execute`, isSubProcess ? 'sub process' : 'process');
-    activate();
-    start();
-    return true;
+proto.execute = function execute(executeMessage) {
+  if (!executeMessage) throw new Error('Process execution requires message');
+  if (!executeMessage.content || !executeMessage.content.executionId) throw new Error('Process execution requires execution id');
+  const executionId = this.executionId = executeMessage.content.executionId;
+  this[kExecuteMessage] = (0, _messageHelper.cloneMessage)(executeMessage, {
+    executionId,
+    state: 'start'
+  });
+  this[kStopped] = false;
+  this.environment.assignVariables(executeMessage);
+  this[kActivityQ] = this.broker.assertQueue(`execute-${executionId}-q`, {
+    durable: true,
+    autoDelete: false
+  });
+
+  if (executeMessage.fields.redelivered) {
+    return this.resume();
   }
 
-  function resume() {
-    logger.debug(`<${executionName}> resume process execution at`, status);
-    if (completed) return complete('completed');
-    activate();
+  this._debug(`execute ${this.isSubProcess ? 'sub process' : 'process'}`);
 
-    if (startActivities.length > 1) {
-      startActivities.forEach(a => a.shake());
-    }
+  this._activate();
 
-    postponed.splice(0);
-    detachedActivities.splice(0);
-    activityQ.consume(onChildMessage, {
-      prefetch: 1000,
-      consumerTag: `_process-activity-${executionId}`
-    });
-    if (completed) return complete('completed');
+  this._start();
 
-    switch (status) {
-      case 'init':
-        return start();
+  return true;
+};
 
-      case 'executing':
-        {
-          if (!postponed.length) return complete('completed');
-          break;
-        }
-    }
+proto.resume = function resume() {
+  this._debug(`resume process execution at ${this.status}`);
 
-    postponed.slice().forEach(({
-      content
-    }) => {
-      const activity = getActivityById(content.id);
-      if (!activity) return;
-      if (content.placeholder) return;
-      activity.resume();
-    });
+  if (this[kCompleted]) return this._complete('completed');
+
+  this._activate();
+
+  const {
+    startActivities,
+    detachedActivities,
+    postponed
+  } = this[kElements];
+
+  if (startActivities.length > 1) {
+    for (const a of startActivities) a.shake();
   }
 
-  function start() {
-    if (children.length === 0) {
-      return complete('completed');
-    }
+  postponed.splice(0);
+  detachedActivities.splice(0);
+  this[kActivityQ].consume(this[kMessageHandlers].onChildMessage, {
+    prefetch: 1000,
+    consumerTag: `_process-activity-${this.executionId}`
+  });
+  if (this[kCompleted]) return;
 
-    status = 'start';
-    const executeContent = { ...stateMessage.content,
-      state: status
-    };
-    broker.publish(exchangeName, 'execute.start', (0, _messageHelper.cloneContent)(executeContent));
+  switch (this.status) {
+    case 'init':
+      return this._start();
 
-    if (startActivities.length > 1) {
-      startActivities.forEach(a => a.shake());
-    }
+    case 'executing':
+      {
+        if (!postponed.length) return this._complete('completed');
+        break;
+      }
+  }
 
-    startActivities.forEach(activity => activity.init());
-    startActivities.forEach(activity => activity.run());
-    postponed.splice(0);
-    detachedActivities.splice(0);
-    activityQ.assertConsumer(onChildMessage, {
-      prefetch: 1000,
-      consumerTag: `_process-activity-${executionId}`
-    });
+  for (const {
+    content
+  } of postponed.slice()) {
+    const activity = this.getActivityById(content.id);
+    if (!activity) continue;
+    if (content.placeholder) continue;
+    activity.resume();
   }
+};
 
-  function recover(state) {
-    if (!state) return processExecution;
-    executionId = state.executionId;
-    prepare();
-    stopped = state.stopped;
-    completed = state.completed;
-    status = state.status;
-    logger.debug(`<${executionName}> recover process execution at`, status);
-
-    if (state.messageFlows) {
-      state.messageFlows.forEach(flowState => {
-        const flow = getMessageFlowById(flowState.id);
-        if (!flow) return;
-        flow.recover(flowState);
-      });
+proto.recover = function recover(state) {
+  if (!state) return this;
+  this.executionId = state.executionId;
+  this[kStopped] = state.stopped;
+  this[kCompleted] = state.completed;
+  this[kStatus] = state.status;
+
+  this._debug(`recover process execution at ${this.status}`);
+
+  if (state.messageFlows) {
+    for (const flowState of state.messageFlows) {
+      const flow = this._getMessageFlowById(flowState.id);
+
+      if (!flow) continue;
+      flow.recover(flowState);
     }
+  }
 
-    if (state.associations) {
-      state.associations.forEach(associationState => {
-        const association = getAssociationById(associationState.id);
-        if (!association) return;
-        association.recover(associationState);
-      });
+  if (state.associations) {
+    for (const associationState of state.associations) {
+      const association = this._getAssociationById(associationState.id);
+
+      if (!association) continue;
+      association.recover(associationState);
     }
+  }
 
-    if (state.flows) {
-      state.flows.forEach(flowState => {
-        const flow = getFlowById(flowState.id);
-        if (!flow) return;
-        flow.recover(flowState);
-      });
+  if (state.flows) {
+    for (const flowState of state.flows) {
+      const flow = this._getFlowById(flowState.id);
+
+      if (!flow) continue;
+      flow.recover(flowState);
     }
+  }
 
-    if (state.children) {
-      state.children.forEach(childState => {
-        const child = getActivityById(childState.id);
-        if (!child) return;
-        child.recover(childState);
-      });
+  if (state.children) {
+    for (const childState of state.children) {
+      const child = this.getActivityById(childState.id);
+      if (!child) continue;
+      child.recover(childState);
     }
+  }
 
-    return processExecution;
+  return this;
+};
+
+proto.shake = function shake(fromId) {
+  let executing = true;
+  const id = this.id;
+
+  if (!this.isRunning) {
+    executing = false;
+    this.executionId = (0, _shared.getUniqueId)(id);
+
+    this._activate();
   }
 
-  function shake(fromId) {
-    let executing = true;
+  const toShake = fromId ? [this.getActivityById(fromId)].filter(Boolean) : this[kElements].startActivities;
+  const result = {};
+  this.broker.subscribeTmp('event', '*.shake.*', (routingKey, {
+    content
+  }) => {
+    let isLooped = false;
+
+    switch (routingKey) {
+      case 'flow.shake.loop':
+        isLooped = true;
 
-    if (!processExecution.isRunning) {
-      executing = false;
-      executionId = (0, _shared.getUniqueId)(id);
-      prepare();
-      activate();
+      case 'activity.shake.end':
+        {
+          const {
+            id: shakeId,
+            parent: shakeParent
+          } = content;
+          if (shakeParent.id !== id) return;
+          result[shakeId] = result[shakeId] || [];
+          result[shakeId].push({ ...content,
+            isLooped
+          });
+          break;
+        }
     }
+  }, {
+    noAck: true,
+    consumerTag: `_shaker-${this.executionId}`
+  });
 
-    const toShake = fromId ? [getActivityById(fromId)].filter(Boolean) : startActivities;
-    const result = {};
-    broker.subscribeTmp('event', '*.shake.*', (routingKey, {
-      content
-    }) => {
-      let isLooped = false;
+  for (const a of toShake) a.shake();
 
-      switch (routingKey) {
-        case 'flow.shake.loop':
-          isLooped = true;
+  if (!executing) this._deactivate();
+  this.broker.cancel(`_shaker-${this.executionId}`);
+  return result;
+};
 
-        case 'activity.shake.end':
-          onShakeEnd(content, isLooped);
-          break;
-      }
-    }, {
-      noAck: true,
-      consumerTag: `_shaker-${executionId}`
-    });
-    toShake.forEach(a => a.shake());
-    if (!executing) deactivate();
-    broker.cancel(`_shaker-${executionId}`);
-    return result;
+proto.stop = function stop() {
+  this.getApi().stop();
+};
 
-    function onShakeEnd(content, isLooped) {
-      const {
-        id: shakeId,
-        parent: shakeParent
-      } = content;
-      if (shakeParent.id !== id) return;
-      result[shakeId] = result[shakeId] || [];
-      result[shakeId].push({ ...content,
-        isLooped
-      });
+proto.getPostponed = function getPostponed(filterFn) {
+  return this[kElements].postponed.slice().reduce((result, msg) => {
+    const api = this._getChildApi(msg);
+
+    if (api) {
+      if (filterFn && !filterFn(api)) return result;
+      result.push(api);
     }
+
+    return result;
+  }, []);
+};
+
+proto.discard = function discard() {
+  this[kStatus] = 'discard';
+  return this[kActivityQ].queueMessage({
+    routingKey: 'execution.discard'
+  }, {
+    id: this.id,
+    type: this.type,
+    executionId: this.executionId
+  }, {
+    type: 'discard'
+  });
+};
+
+proto.getState = function getState() {
+  const {
+    children,
+    flows,
+    outboundMessageFlows,
+    associations
+  } = this[kElements];
+  return {
+    executionId: this.executionId,
+    stopped: this[kStopped],
+    completed: this[kCompleted],
+    status: this.status,
+    children: children.reduce((result, activity) => {
+      if (activity.placeholder) return result;
+      result.push(activity.getState());
+      return result;
+    }, []),
+    ...(flows.length && {
+      flows: flows.map(f => f.getState())
+    }),
+    ...(outboundMessageFlows.length && {
+      messageFlows: outboundMessageFlows.length && outboundMessageFlows.map(f => f.getState())
+    }),
+    ...(associations.length && {
+      associations: associations.map(f => f.getState())
+    })
+  };
+};
+
+proto.getActivities = function getActivities() {
+  return this[kElements].children.slice();
+};
+
+proto.getActivityById = function getActivityById(activityId) {
+  return this[kElements].children.find(child => child.id === activityId);
+};
+
+proto.getSequenceFlows = function getSequenceFlows() {
+  return this[kElements].flows.slice();
+};
+
+proto.getApi = function getApi(message) {
+  if (!message) return (0, _Api.ProcessApi)(this.broker, this[kExecuteMessage]);
+  const content = message.content;
+
+  if (content.executionId !== this.executionId) {
+    return this._getChildApi(message);
   }
 
-  function stop() {
-    getApi().stop();
+  const api = (0, _Api.ProcessApi)(this.broker, message);
+  const postponed = this[kElements].postponed;
+  const self = this;
+
+  api.getExecuting = function getExecuting() {
+    return postponed.reduce((result, msg) => {
+      const childApi = self._getChildApi(msg);
+
+      if (childApi) result.push(childApi);
+      return result;
+    }, []);
+  };
+
+  return api;
+};
+
+proto._start = function start() {
+  if (this[kElements].children.length === 0) {
+    return this._complete('completed');
+  }
+
+  this[kStatus] = 'start';
+  const executeContent = { ...this[kExecuteMessage].content,
+    state: this.status
+  };
+  this.broker.publish(this._exchangeName, 'execute.start', (0, _messageHelper.cloneContent)(executeContent));
+  const {
+    startActivities,
+    postponed,
+    detachedActivities
+  } = this[kElements];
+
+  if (startActivities.length > 1) {
+    for (const a of startActivities) a.shake();
   }
 
-  function activate() {
-    broker.subscribeTmp('api', '#', onApiMessage, {
+  for (const a of startActivities) a.init();
+
+  for (const a of startActivities) a.run();
+
+  postponed.splice(0);
+  detachedActivities.splice(0);
+  this[kActivityQ].assertConsumer(this[kMessageHandlers].onChildMessage, {
+    prefetch: 1000,
+    consumerTag: `_process-activity-${this.executionId}`
+  });
+};
+
+proto._activate = function activate() {
+  const {
+    onApiMessage,
+    onMessageFlowEvent,
+    onActivityEvent
+  } = this[kMessageHandlers];
+  this.broker.subscribeTmp('api', '#', onApiMessage, {
+    noAck: true,
+    consumerTag: `_process-api-consumer-${this.executionId}`,
+    priority: 200
+  });
+  const {
+    outboundMessageFlows,
+    flows,
+    associations,
+    startActivities,
+    triggeredByEvent,
+    children
+  } = this[kElements];
+
+  for (const flow of outboundMessageFlows) {
+    flow.activate();
+    flow.broker.subscribeTmp('event', '#', onMessageFlowEvent, {
+      consumerTag: '_process-message-consumer',
       noAck: true,
-      consumerTag: `_process-api-consumer-${executionId}`,
       priority: 200
     });
-    outboundMessageFlows.forEach(flow => {
-      flow.activate();
-      flow.broker.subscribeTmp('event', '#', onMessageFlowEvent, {
-        consumerTag: '_process-message-consumer',
-        noAck: true,
-        priority: 200
-      });
-    });
-    flows.forEach(flow => {
-      flow.broker.subscribeTmp('event', '#', onActivityEvent, {
-        consumerTag: '_process-flow-controller',
-        noAck: true,
-        priority: 200
-      });
+  }
+
+  for (const flow of flows) {
+    flow.broker.subscribeTmp('event', '#', onActivityEvent, {
+      consumerTag: '_process-flow-controller',
+      noAck: true,
+      priority: 200
     });
-    associations.forEach(association => {
-      association.broker.subscribeTmp('event', '#', onActivityEvent, {
-        consumerTag: '_process-association-controller',
-        noAck: true,
-        priority: 200
-      });
+  }
+
+  for (const association of associations) {
+    association.broker.subscribeTmp('event', '#', onActivityEvent, {
+      consumerTag: '_process-association-controller',
+      noAck: true,
+      priority: 200
     });
-    startActivities.splice(0);
-    triggeredByEventActivities.splice(0);
-    children.forEach(activity => {
-      if (activity.placeholder) return;
-      activity.activate(processExecution);
-      activity.broker.subscribeTmp('event', '#', onActivityEvent, {
-        noAck: true,
-        consumerTag: '_process-activity-consumer',
-        priority: 200
-      });
-      if (activity.isStart) startActivities.push(activity);
-      if (activity.triggeredByEvent) triggeredByEventActivities.push(activity);
+  }
+
+  startActivities.splice(0);
+  triggeredByEvent.splice(0);
+
+  for (const activity of children) {
+    if (activity.placeholder) continue;
+    activity.activate(this);
+    activity.broker.subscribeTmp('event', '#', onActivityEvent, {
+      noAck: true,
+      consumerTag: '_process-activity-consumer',
+      priority: 200
     });
-    activated = true;
-
-    function onActivityEvent(routingKey, activityMessage) {
-      const message = (0, _messageHelper.cloneMessage)(activityMessage);
-      if (message.fields.redelivered && message.properties.persistent === false) return;
-      const content = message.content;
-      const parent = content.parent = content.parent || {};
-      let delegate = message.properties.delegate;
-      const shaking = message.properties.type === 'shake';
-      const isDirectChild = content.parent.id === id;
-
-      if (isDirectChild) {
-        parent.executionId = executionId;
-      } else {
-        content.parent = (0, _messageHelper.pushParent)(parent, {
-          id,
-          type,
-          executionId
-        });
-      }
+    if (activity.isStart) startActivities.push(activity);
+    if (activity.triggeredByEvent) triggeredByEvent.push(activity);
+  }
 
-      if (delegate) delegate = onDelegateEvent(message);
-      broker.publish('event', routingKey, content, { ...message.properties,
-        delegate,
-        mandatory: false
-      });
-      if (shaking) return onShookEnd(message);
-      if (!isDirectChild) return;
-      if (content.isAssociation) return;
-
-      switch (routingKey) {
-        case 'process.terminate':
-          return activityQ.queueMessage({
-            routingKey: 'execution.terminate'
-          }, (0, _messageHelper.cloneContent)(content), {
-            type: 'terminate',
-            persistent: true
-          });
+  this[kActivated] = true;
+};
 
-        case 'activity.stop':
-          return;
-      }
+proto._deactivate = function deactivate() {
+  const broker = this.broker;
+  const executionId = this.executionId;
+  broker.cancel(`_process-api-consumer-${executionId}`);
+  broker.cancel(`_process-activity-${executionId}`);
+  const {
+    children,
+    flows,
+    associations,
+    outboundMessageFlows
+  } = this[kElements];
+
+  for (const activity of children) {
+    if (activity.placeholder) continue;
+    activity.broker.cancel('_process-activity-consumer');
+    activity.deactivate();
+  }
 
-      activityQ.queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), {
-        persistent: true,
-        ...message.properties
-      });
-    }
+  for (const flow of flows) {
+    flow.broker.cancel('_process-flow-controller');
   }
 
-  function deactivate() {
-    broker.cancel(`_process-api-consumer-${executionId}`);
-    broker.cancel(`_process-activity-${executionId}`);
-    children.forEach(activity => {
-      if (activity.placeholder) return;
-      activity.broker.cancel('_process-activity-consumer');
-      activity.deactivate();
-    });
-    flows.forEach(flow => {
-      flow.broker.cancel('_process-flow-controller');
-    });
-    associations.forEach(association => {
-      association.broker.cancel('_process-association-controller');
-    });
-    outboundMessageFlows.forEach(flow => {
-      flow.deactivate();
-      flow.broker.cancel('_process-message-consumer');
-    });
-    activated = false;
-  }
-
-  function onDelegateEvent(message) {
-    const eventType = message.properties.type;
-    let delegate = true;
-    const content = message.content;
-    logger.debug(`<${executionName}> delegate`, eventType, content.message && content.message.id ? `event with id <${content.message.id}>` : 'anonymous event');
-    triggeredByEventActivities.forEach(activity => {
-      if (activity.getStartActivities({
-        referenceId: content.message && content.message.id,
-        referenceType: eventType
-      }).length) {
-        delegate = false;
-        activity.run(content.message);
-      }
-    });
-    getApi().sendApiMessage(eventType, content, {
-      delegate: true
-    });
-    return delegate;
+  for (const association of associations) {
+    association.broker.cancel('_process-association-controller');
   }
 
-  function onMessageFlowEvent(routingKey, message) {
-    broker.publish('message', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
+  for (const flow of outboundMessageFlows) {
+    flow.deactivate();
+    flow.broker.cancel('_process-message-consumer');
   }
 
-  function onChildMessage(routingKey, message) {
-    const content = message.content;
-    const isRedelivered = message.fields.redelivered;
-    const {
-      id: childId,
-      type: activityType,
-      isEnd
-    } = content;
-    const {
-      persistent
-    } = message.properties;
-    if (isRedelivered && persistent === false) return message.ack();
+  this[kActivated] = false;
+};
 
-    switch (routingKey) {
-      case 'execution.stop':
-        message.ack();
-        return stopExecution();
-
-      case 'execution.terminate':
-        message.ack();
-        return terminate(message);
-
-      case 'execution.discard':
-        message.ack();
-        return onDiscard(message);
-
-      case 'activity.compensation.end':
-      case 'flow.looped':
-      case 'activity.leave':
-        return onChildCompleted();
+proto._onDelegateEvent = function onDelegateEvent(message) {
+  const eventType = message.properties.type;
+  let delegate = true;
+  const content = message.content;
+
+  if (content.message && content.message.id) {
+    this._debug(`delegate ${eventType} event with id <${content.message.id}>`);
+  } else {
+    this._debug(`delegate ${eventType} anonymous event`);
+  }
+
+  for (const activity of this[kElements].triggeredByEvent) {
+    if (activity.getStartActivities({
+      referenceId: content.message && content.message.id,
+      referenceType: eventType
+    }).length) {
+      delegate = false;
+      activity.run(content.message);
     }
+  }
 
-    stateChangeMessage(true);
+  this.getApi().sendApiMessage(eventType, content, {
+    delegate: true
+  });
+  return delegate;
+};
+
+proto._onMessageFlowEvent = function onMessageFlowEvent(routingKey, message) {
+  this.broker.publish('message', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
+};
+
+proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+  if (message.fields.redelivered && message.properties.persistent === false) return;
+  const content = message.content;
+  const parent = content.parent = content.parent || {};
+  let delegate = message.properties.delegate;
+  const shaking = message.properties.type === 'shake';
+  const isDirectChild = content.parent.id === this.id;
+
+  if (isDirectChild) {
+    parent.executionId = this.executionId;
+  } else {
+    content.parent = (0, _messageHelper.pushParent)(parent, {
+      id: this.id,
+      type: this.type,
+      executionId: this.executionId
+    });
+  }
 
-    switch (routingKey) {
-      case 'activity.detach':
-        {
-          detachedActivities.push((0, _messageHelper.cloneMessage)(message));
-          break;
-        }
+  if (delegate) delegate = this._onDelegateEvent(message);
+  this.broker.publish('event', routingKey, content, { ...message.properties,
+    delegate,
+    mandatory: false
+  });
+  if (shaking) return this._onShookEnd(message);
+  if (!isDirectChild) return;
+  if (content.isAssociation) return;
+
+  switch (routingKey) {
+    case 'process.terminate':
+      return this[kActivityQ].queueMessage({
+        routingKey: 'execution.terminate'
+      }, (0, _messageHelper.cloneContent)(content), {
+        type: 'terminate',
+        persistent: true
+      });
 
-      case 'activity.discard':
-      case 'activity.compensation.start':
-      case 'activity.enter':
-        {
-          status = 'executing';
-          popInbound();
-          break;
-        }
+    case 'activity.stop':
+      return;
+  }
 
-      case 'flow.error':
-      case 'activity.error':
-        {
-          if (isEventCaught()) {
-            logger.debug(`<${executionName}> error was caught`);
-            break;
-          }
+  this[kActivityQ].queueMessage(message.fields, (0, _messageHelper.cloneContent)(content), {
+    persistent: true,
+    ...message.properties
+  });
+};
 
-          complete('error', {
-            error: content.error
-          });
-          break;
-        }
-    }
+proto._onChildMessage = function onChildMessage(routingKey, message) {
+  if (message.fields.redelivered && message.properties.persistent === false) return message.ack();
+  const content = message.content;
 
-    function stateChangeMessage(postponeMessage = true) {
-      const previousMsg = popPostponed(content);
-      if (previousMsg) previousMsg.ack();
-      if (postponeMessage) postponed.push(message);
-    }
+  switch (routingKey) {
+    case 'execution.stop':
+      message.ack();
+      return this._stopExecution(message);
 
-    function popInbound() {
-      if (!content.inbound) return;
-      content.inbound.forEach(trigger => {
-        if (!trigger.isSequenceFlow) return;
-        const msg = popPostponed(trigger, postponed);
-        if (msg) msg.ack();
-      });
-    }
+    case 'execution.terminate':
+      message.ack();
+      return this._terminate(message);
 
-    function popPostponed(byContent) {
-      const postponedIdx = postponed.findIndex(msg => {
-        if (msg.content.isSequenceFlow) return msg.content.sequenceId === byContent.sequenceId;
-        return msg.content.executionId === byContent.executionId;
-      });
-      let postponedMsg;
+    case 'execution.discard':
+      message.ack();
+      return this._onDiscard(message);
 
-      if (postponedIdx > -1) {
-        postponedMsg = postponed.splice(postponedIdx, 1)[0];
+    case 'activity.compensation.end':
+    case 'flow.looped':
+    case 'activity.leave':
+      return this._onChildCompleted(message);
+  }
+
+  this._stateChangeMessage(message, true);
+
+  switch (routingKey) {
+    case 'activity.detach':
+      {
+        this[kElements].detachedActivities.push((0, _messageHelper.cloneMessage)(message));
+        break;
       }
 
-      const detachedIdx = detachedActivities.findIndex(msg => msg.content.executionId === byContent.executionId);
-      if (detachedIdx > -1) detachedActivities.splice(detachedIdx, 1);
-      return postponedMsg;
-    }
+    case 'activity.discard':
+    case 'activity.compensation.start':
+    case 'activity.enter':
+      {
+        this[kStatus] = 'executing';
+        if (!content.inbound) break;
+
+        for (const inbound of content.inbound) {
+          if (!inbound.isSequenceFlow) continue;
+
+          const inboundMessage = this._popPostponed(inbound);
+
+          if (inboundMessage) inboundMessage.ack();
+        }
 
-    function onChildCompleted() {
-      stateChangeMessage(false);
-      if (isRedelivered) return message.ack();
-      logger.debug(`<${executionName}> left <${childId}> (${activityType}), pending runs ${postponed.length}`, postponed.map(a => a.content.id));
-      const postponedLength = postponed.length;
-
-      if (!postponedLength) {
-        message.ack();
-        return complete('completed');
-      } else if (postponedLength === detachedActivities.length) {
-        getPostponed().forEach(api => api.discard());
-      } else if (isEnd && startActivities.length) {
-        discardPostponedIfNecessary();
+        break;
       }
-    }
 
-    function discardPostponedIfNecessary() {
-      for (const p of postponed) {
-        const postponedId = p.content.id;
-        const startSequence = startSequences[postponedId];
-
-        if (startSequence) {
-          if (startSequence.content.sequence.some(({
-            id: sid
-          }) => sid === childId)) {
-            getApi(p).discard();
-          }
+    case 'activity.error':
+      {
+        const eventCaughtBy = this[kElements].postponed.find(msg => {
+          if (msg.fields.routingKey !== 'activity.catch') return;
+          return msg.content.source && msg.content.source.executionId === content.executionId;
+        });
+
+        if (eventCaughtBy) {
+          return this._debug('error was caught');
         }
+
+        return this._complete('error', {
+          error: content.error
+        });
       }
-    }
+  }
+};
 
-    function stopExecution() {
-      if (stopped) return;
-      logger.debug(`<${executionName}> stop process execution (stop child executions ${postponed.length})`);
-      getPostponed().forEach(api => {
-        api.stop();
-      });
-      deactivate();
-      stopped = true;
-      return broker.publish(exchangeName, `execution.stopped.${executionId}`, { ...stateMessage.content,
-        ...content
-      }, {
-        type: 'stopped',
-        persistent: false
-      });
-    }
+proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
+  const previousMsg = this._popPostponed(message.content);
 
-    function onDiscard() {
-      deactivate();
-      const running = postponed.splice(0);
-      logger.debug(`<${executionName}> discard process execution (discard child executions ${running.length})`);
-      getSequenceFlows().forEach(flow => {
-        flow.stop();
-      });
-      running.forEach(msg => {
-        getApi(msg).discard();
-      });
-      activityQ.purge();
-      return complete('discard');
-    }
+  if (previousMsg) previousMsg.ack();
+  if (postponeMessage) this[kElements].postponed.push(message);
+};
 
-    function isEventCaught() {
-      return postponed.find(msg => {
-        if (msg.fields.routingKey !== 'activity.catch') return;
-        return msg.content.source && msg.content.source.executionId === content.executionId;
-      });
-    }
+proto._popPostponed = function popPostponed(byContent) {
+  const {
+    postponed,
+    detachedActivities
+  } = this[kElements];
+  const postponedIdx = postponed.findIndex(msg => {
+    if (msg.content.isSequenceFlow) return msg.content.sequenceId === byContent.sequenceId;
+    return msg.content.executionId === byContent.executionId;
+  });
+  let postponedMsg;
+
+  if (postponedIdx > -1) {
+    postponedMsg = postponed.splice(postponedIdx, 1)[0];
   }
 
-  function onApiMessage(routingKey, message) {
-    if (message.properties.delegate) {
-      return delegateApiMessage();
-    }
+  const detachedIdx = detachedActivities.findIndex(msg => msg.content.executionId === byContent.executionId);
+  if (detachedIdx > -1) detachedActivities.splice(detachedIdx, 1);
+  return postponedMsg;
+};
 
-    if (id !== message.content.id) {
-      const child = getActivityById(message.content.id);
-      if (!child) return null;
-      return child.broker.publish('api', routingKey, message.content, message.properties);
-    }
+proto._onChildCompleted = function onChildCompleted(message) {
+  this._stateChangeMessage(message, false);
 
-    if (executionId !== message.content.executionId) return;
+  if (message.fields.redelivered) return message.ack();
+  const {
+    id,
+    type,
+    isEnd
+  } = message.content;
+  const {
+    postponed,
+    detachedActivities,
+    startActivities
+  } = this[kElements];
+  const postponedCount = postponed.length;
 
-    switch (message.properties.type) {
-      case 'discard':
-        return discard(message);
+  if (!postponedCount) {
+    this._debug(`left <${id}> (${type}), pending runs ${postponedCount}`);
 
-      case 'stop':
-        activityQ.queueMessage({
-          routingKey: 'execution.stop'
-        }, (0, _messageHelper.cloneContent)(message.content), {
-          persistent: false
-        });
-        break;
-    }
+    message.ack();
+    return this._complete('completed');
+  }
 
-    function delegateApiMessage() {
-      const {
-        correlationId
-      } = message.properties || (0, _shared.getUniqueId)(executionId);
-      logger.debug(`<${executionName}> delegate api`, routingKey, `message to children, with correlationId <${correlationId}>`);
-      let consumed = false;
-      broker.subscribeTmp('event', 'activity.consumed', (_, msg) => {
-        if (msg.properties.correlationId === correlationId) {
-          consumed = true;
-          logger.debug(`<${executionName}> delegated api message was consumed by`, msg.content ? msg.content.executionId : 'unknown');
-        }
-      }, {
-        consumerTag: `_ct-delegate-${correlationId}`,
-        noAck: true
-      });
+  this._debug(`left <${id}> (${type}), pending runs ${postponedCount}, ${postponed.map(a => a.content.id).join(',')}`);
 
-      for (const child of children) {
-        if (child.placeholder) continue;
-        child.broker.publish('api', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
-        if (consumed) break;
-      }
+  if (postponedCount === detachedActivities.length) {
+    for (const api of this.getPostponed()) api.discard();
 
-      broker.cancel(`_ct-delegate-${correlationId}`);
-    }
+    return;
   }
 
-  function getPostponed(filterFn) {
-    return postponed.slice().reduce((result, p) => {
-      const api = getApi(p);
+  if (isEnd && startActivities.length) {
+    const startSequences = this[kElements].startSequences;
 
-      if (api) {
-        if (filterFn && !filterFn(api)) return result;
-        result.push(api);
-      }
+    for (const msg of postponed) {
+      const postponedId = msg.content.id;
+      const startSequence = startSequences[postponedId];
 
-      return result;
-    }, []);
+      if (startSequence) {
+        if (startSequence.content.sequence.some(({
+          id: sid
+        }) => sid === id)) {
+          this._getChildApi(msg).discard();
+        }
+      }
+    }
   }
+};
 
-  function complete(completionType, content = {}) {
-    deactivate();
-    logger.debug(`<${executionName}> process execution ${completionType}`);
-    completed = true;
-    if (status !== 'terminated') status = completionType;
-    broker.deleteQueue(activityQ.name);
-    return broker.publish(exchangeName, `execution.${completionType}.${executionId}`, { ...stateMessage.content,
-      output: environment.output,
-      ...content,
-      state: completionType
-    }, {
-      type: completionType,
-      mandatory: completionType === 'error'
-    });
+proto._stopExecution = function stopExecution(message) {
+  const postponedCount = this.postponedCount;
+
+  this._debug(`stop process execution (stop child executions ${postponedCount})`);
+
+  if (postponedCount) {
+    for (const api of this.getPostponed()) api.stop();
   }
 
-  function discard() {
-    status = 'discard';
-    return activityQ.queueMessage({
-      routingKey: 'execution.discard'
-    }, {
-      id,
-      type,
-      executionId
+  this._deactivate();
+
+  this[kStopped] = true;
+  return this.broker.publish(this._exchangeName, `execution.stopped.${this.executionId}`, { ...this[kExecuteMessage].content,
+    ...(message && message.content)
+  }, {
+    type: 'stopped',
+    persistent: false
+  });
+};
+
+proto._onDiscard = function onDiscard() {
+  this._deactivate();
+
+  const running = this[kElements].postponed.splice(0);
+
+  this._debug(`discard process execution (discard child executions ${running.length})`);
+
+  for (const flow of this.getSequenceFlows()) flow.stop();
+
+  for (const msg of running) this._getChildApi(msg).discard();
+
+  this[kActivityQ].purge();
+  return this._complete('discard');
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const executionId = this.executionId;
+  const broker = this.broker;
+
+  if (message.properties.delegate) {
+    const correlationId = message.properties.correlationId || (0, _shared.getUniqueId)(executionId);
+
+    this._debug(`delegate api ${routingKey} message to children, with correlationId <${correlationId}>`);
+
+    let consumed = false;
+    broker.subscribeTmp('event', 'activity.consumed', (_, msg) => {
+      if (msg.properties.correlationId === correlationId) {
+        consumed = true;
+
+        this._debug(`delegated api message was consumed by ${msg.content ? msg.content.executionId : 'unknown'}`);
+      }
     }, {
-      type: 'discard'
+      consumerTag: `_ct-delegate-${correlationId}`,
+      noAck: true
     });
-  }
 
-  function terminate(message) {
-    status = 'terminated';
-    logger.debug(`<${executionName}> terminating process execution`);
-    const running = postponed.splice(0);
-    getSequenceFlows().forEach(flow => {
-      flow.stop();
-    });
-    running.forEach(msg => {
-      const {
-        id: postponedId,
-        isSequenceFlow
-      } = msg.content;
-      if (postponedId === message.content.id) return;
-      if (isSequenceFlow) return;
-      getApi(msg).stop();
-      msg.ack();
-    });
-    activityQ.purge();
-  }
-
-  function getState() {
-    return {
-      executionId,
-      stopped,
-      completed,
-      status,
-      children: children.reduce((result, activity) => {
-        if (activity.placeholder) return result;
-        result.push(activity.getState());
-        return result;
-      }, []),
-      flows: flows.map(f => f.getState()),
-      messageFlows: outboundMessageFlows.map(f => f.getState()),
-      associations: associations.map(f => f.getState())
-    };
-  }
+    for (const child of this[kElements].children) {
+      if (child.placeholder) continue;
+      child.broker.publish('api', routingKey, (0, _messageHelper.cloneContent)(message.content), message.properties);
+      if (consumed) break;
+    }
 
-  function getActivities() {
-    return children.slice();
+    return broker.cancel(`_ct-delegate-${correlationId}`);
   }
 
-  function getActivityById(activityId) {
-    return children.find(child => child.id === activityId);
+  if (this.id !== message.content.id) {
+    const child = this.getActivityById(message.content.id);
+    if (!child) return null;
+    return child.broker.publish('api', routingKey, message.content, message.properties);
   }
 
-  function getFlowById(flowId) {
-    return flows.find(f => f.id === flowId);
-  }
+  if (this.executionId !== message.content.executionId) return;
 
-  function getAssociationById(associationId) {
-    return associations.find(a => a.id === associationId);
-  }
+  switch (message.properties.type) {
+    case 'discard':
+      return this.discard(message);
 
-  function getMessageFlowById(flowId) {
-    return outboundMessageFlows.find(f => f.id === flowId);
+    case 'stop':
+      this[kActivityQ].queueMessage({
+        routingKey: 'execution.stop'
+      }, (0, _messageHelper.cloneContent)(message.content), {
+        persistent: false
+      });
+      break;
   }
+};
 
-  function getChildById(childId) {
-    return getActivityById(childId) || getFlowById(childId);
-  }
+proto._complete = function complete(completionType, content) {
+  this._deactivate();
 
-  function getSequenceFlows() {
-    return flows.slice();
-  }
+  this._debug(`process execution ${completionType}`);
 
-  function getApi(message) {
-    if (!message) return (0, _Api.ProcessApi)(broker, stateMessage);
-    const content = message.content;
+  this[kCompleted] = true;
+  if (this.status !== 'terminated') this[kStatus] = completionType;
+  const broker = this.broker;
+  this[kActivityQ].delete();
+  return broker.publish(this._exchangeName, `execution.${completionType}.${this.executionId}`, (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
+    output: { ...this.environment.output
+    },
+    ...content,
+    state: completionType
+  }), {
+    type: completionType,
+    mandatory: completionType === 'error'
+  });
+};
 
-    if (content.executionId !== executionId) {
-      return getChildApi(message);
-    }
+proto._terminate = function terminate(message) {
+  this[kStatus] = 'terminated';
 
-    const api = (0, _Api.ProcessApi)(broker, message);
+  this._debug('terminating process execution');
 
-    api.getExecuting = function getExecuting() {
-      return postponed.reduce((result, msg) => {
-        if (msg.content.executionId === content.executionId) return result;
-        result.push(getApi(msg));
-        return result;
-      }, []);
-    };
+  const running = this[kElements].postponed.splice(0);
 
-    return api;
-  }
+  for (const flow of this.getSequenceFlows()) flow.stop();
 
-  function getChildApi(message) {
-    const content = message.content;
-    let api = getApiByChildId(content.id);
-    if (api) return api;
-    if (!content.parent) return;
-    api = getApiByChildId(content.parent.id);
-    if (api) return api;
-    if (!content.parent.path) return;
+  for (const msg of running) {
+    const {
+      id: postponedId,
+      isSequenceFlow
+    } = msg.content;
+    if (postponedId === message.content.id) continue;
+    if (isSequenceFlow) continue;
 
-    for (let i = 0; i < content.parent.path.length; i++) {
-      api = getApiByChildId(content.parent.path[i].id);
-      if (api) return api;
-    }
+    this._getChildApi(msg).stop();
 
-    function getApiByChildId(childId) {
-      const child = getChildById(childId);
-      if (!child) return;
-      return child.getApi(message);
-    }
+    msg.ack();
   }
 
-  function onShookEnd(message) {
-    const routingKey = message.fields.routingKey;
-    if (routingKey !== 'activity.shake.end') return;
-    startSequences[message.content.id] = (0, _messageHelper.cloneMessage)(message);
-  }
+  this[kActivityQ].purge();
+};
+
+proto._getFlowById = function getFlowById(flowId) {
+  return this[kElements].flows.find(f => f.id === flowId);
+};
 
-  function prepare() {
-    executionName = `${executionId} (${id})`;
+proto._getAssociationById = function getAssociationById(associationId) {
+  return this[kElements].associations.find(a => a.id === associationId);
+};
+
+proto._getMessageFlowById = function getMessageFlowById(flowId) {
+  return this[kElements].outboundMessageFlows.find(f => f.id === flowId);
+};
+
+proto._getChildById = function getChildById(childId) {
+  return this.getActivityById(childId) || this._getFlowById(childId);
+};
+
+proto._getChildApi = function getChildApi(message) {
+  const content = message.content;
+
+  let child = this._getChildById(content.id);
+
+  if (child) return child.getApi(message);
+  if (!content.parent) return;
+  child = this._getChildById(content.parent.id);
+  if (child) return child.getApi(message);
+  if (!content.parent.path) return;
+
+  for (const pp of content.parent.path) {
+    child = this._getChildById(pp.id, message);
+    if (child) return child.getApi(message);
   }
-}
+};
+
+proto._onShookEnd = function onShookEnd(message) {
+  const routingKey = message.fields.routingKey;
+  if (routingKey !== 'activity.shake.end') return;
+  this[kElements].startSequences[message.content.id] = (0, _messageHelper.cloneMessage)(message);
+};
+
+proto._debug = function debugMessage(logMessage) {
+  this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
+};