bpmn-elements 6.0.1 → 7.0.0

package/src/process/ProcessExecution.js

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