bpmn-elements 5.1.3 → 7.0.0

package/dist/src/activity/ActivityExecution.js

@@ -3,376 +3,421 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = ActivityExecution;
+exports.default = void 0;
 
 var _Api = require("../Api");
 
 var _messageHelper = require("../messageHelper");
 
+const completedSymbol = Symbol.for('completed');
+const executeQSymbol = Symbol.for('executeQ');
+const executeMessageSymbol = Symbol.for('executeMessage');
+const messageHandlersSymbol = Symbol.for('messageHandlers');
+const postponedSymbol = Symbol.for('postponed');
+var _default = ActivityExecution;
+exports.default = _default;
+
 function ActivityExecution(activity, context) {
-  const {
-    id,
-    broker,
-    logger,
-    isSubProcess,
-    Behaviour,
-    environment
-  } = activity;
-  const {
-    batchSize = 50
-  } = environment.settings;
-  const postponed = [];
-  let source,
-      initMessage,
-      completed = false,
-      executionId;
-  const executeQ = broker.assertQueue('execute-q', {
+  this.activity = activity;
+  this.context = context;
+  this.id = activity.id;
+  this.broker = activity.broker;
+  this[postponedSymbol] = [];
+  this[completedSymbol] = false;
+  this[executeQSymbol] = this.broker.assertQueue('execute-q', {
     durable: true,
     autoDelete: false
   });
-  const executionApi = {
-    get completed() {
-      return completed;
-    },
-
-    get source() {
-      return source;
-    },
-
-    discard,
-    execute,
-    passthrough,
-    getApi,
-    getPostponed,
-    getState,
-    recover,
-    stop
+  this[messageHandlersSymbol] = {
+    onParentApiMessage: this._onParentApiMessage.bind(this),
+    onExecuteMessage: this._onExecuteMessage.bind(this)
   };
-  return executionApi;
+}
 
-  function getPostponed() {
-    let apis = postponed.map(msg => getApi(msg));
-    if (!isSubProcess || !source) return apis;
-    apis = apis.concat(source.getPostponed());
-    return apis;
+const proto = ActivityExecution.prototype;
+Object.defineProperty(proto, 'completed', {
+  enumerable: true,
+
+  get() {
+    return this[completedSymbol];
   }
 
-  function execute(executeMessage) {
-    if (!executeMessage) throw new Error('Execution requires message');
-    if (!executeMessage.content || !executeMessage.content.executionId) throw new Error('Execution requires execution id');
-    const isRedelivered = executeMessage.fields.redelivered;
-    executionId = executeMessage.content.executionId;
-    initMessage = (0, _messageHelper.cloneMessage)(executeMessage);
-    initMessage.content = { ...initMessage.content,
-      executionId,
-      state: 'start',
-      isRootScope: true
-    };
-
-    if (isRedelivered) {
-      postponed.splice(0);
-      logger.debug(`<${executionId} (${id})> resume execution`);
-      if (!source) source = Behaviour(activity, context);
-      activate();
-      return broker.publish('execution', 'execute.resume.execution', (0, _messageHelper.cloneContent)(initMessage.content), {
-        persistent: false
-      });
-    }
+});
 
-    logger.debug(`<${executionId} (${id})> execute`);
-    activate();
-    source = Behaviour(activity, context);
-    broker.publish('execution', 'execute.start', (0, _messageHelper.cloneContent)(initMessage.content));
-  }
+proto.execute = function execute(executeMessage) {
+  if (!executeMessage) throw new Error('Execution requires message');
+  const executionId = executeMessage.content && executeMessage.content.executionId;
+  if (!executionId) throw new Error('Execution requires execution id');
+  this.executionId = executionId;
+  const initMessage = this[executeMessageSymbol] = (0, _messageHelper.cloneMessage)(executeMessage, {
+    executionId,
+    state: 'start',
+    isRootScope: true
+  });
 
-  function passthrough(executeMessage) {
-    if (!source) return execute(executeMessage);
-    return source.execute(executeMessage);
-  }
+  if (executeMessage.fields.redelivered) {
+    this[postponedSymbol].splice(0);
 
-  function discard() {
-    if (completed) return;
-    if (!initMessage) return logger.warn(`<${id}> is not executing`);
-    getApi(initMessage).discard();
-  }
+    this._debug('resume execution');
 
-  function stop() {
-    if (!initMessage) return;
-    getApi(initMessage).stop();
+    if (!this.source) this.source = new this.activity.Behaviour(this.activity, this.context);
+    this.activate();
+    return this.broker.publish('execution', 'execute.resume.execution', (0, _messageHelper.cloneContent)(initMessage.content), {
+      persistent: false
+    });
   }
 
-  function getState() {
-    const result = {
-      completed
-    };
-    if (!source || !source.getState) return result;
-    return { ...result,
-      ...source.getState()
-    };
+  this._debug('execute');
+
+  this.activate();
+  this.source = new this.activity.Behaviour(this.activity, this.context);
+  this.broker.publish('execution', 'execute.start', (0, _messageHelper.cloneContent)(initMessage.content));
+};
+
+proto.activate = function activate() {
+  if (this[completedSymbol]) return;
+  const broker = this.broker;
+  const batchSize = this.activity.environment.settings.batchSize || 50;
+  broker.bindQueue('execute-q', 'execution', 'execute.#', {
+    priority: 100
+  });
+  const {
+    onExecuteMessage,
+    onParentApiMessage
+  } = this[messageHandlersSymbol];
+  this[executeQSymbol].assertConsumer(onExecuteMessage, {
+    exclusive: true,
+    prefetch: batchSize * 2,
+    priority: 100,
+    consumerTag: '_activity-execute'
+  });
+  if (this[completedSymbol]) return this.deactivate();
+  broker.subscribeTmp('api', `activity.*.${this.executionId}`, onParentApiMessage, {
+    noAck: true,
+    consumerTag: '_activity-api-execution',
+    priority: 200
+  });
+};
+
+proto.deactivate = function deactivate() {
+  const broker = this.broker;
+  broker.cancel('_activity-api-execution');
+  broker.cancel('_activity-execute');
+  broker.unbindQueue('execute-q', 'execution', 'execute.#');
+};
+
+proto.discard = function discard() {
+  if (this[completedSymbol]) return;
+  const initMessage = this[executeMessageSymbol];
+  if (!initMessage) return this.activity.logger.warn(`<${this.id}> is not executing`);
+  this.getApi(initMessage).discard();
+};
+
+proto.getApi = function getApi(apiMessage) {
+  const self = this;
+  if (!apiMessage) apiMessage = this[executeMessageSymbol];
+
+  if (self.source.getApi) {
+    const sourceApi = self.source.getApi(apiMessage);
+    if (sourceApi) return sourceApi;
   }
 
-  function recover(state) {
-    postponed.splice(0);
-    if (!state) return executionApi;
-    if ('completed' in state) completed = state.completed;
-    source = Behaviour(activity, context);
+  const api = (0, _Api.ActivityApi)(self.broker, apiMessage);
 
-    if (source.recover) {
-      source.recover(state);
-    }
+  api.getExecuting = function getExecuting() {
+    return self[postponedSymbol].reduce((result, msg) => {
+      if (msg.content.executionId === apiMessage.content.executionId) return result;
+      result.push(self.getApi(msg));
+      return result;
+    }, []);
+  };
 
-    return executionApi;
-  }
+  return api;
+};
 
-  function activate() {
-    if (completed) return;
-    broker.bindQueue(executeQ.name, 'execution', 'execute.#', {
-      priority: 100
-    });
-    executeQ.assertConsumer(onExecuteMessage, {
-      exclusive: true,
-      prefetch: batchSize * 2,
-      priority: 100,
-      consumerTag: '_activity-execute'
-    });
-    if (completed) return deactivate();
-    broker.subscribeTmp('api', `activity.*.${executionId}`, onParentApiMessage, {
-      noAck: true,
-      consumerTag: '_activity-api-execution',
-      priority: 200
-    });
-  }
+proto.passthrough = function passthrough(executeMessage) {
+  if (!this.source) return this.execute(executeMessage);
+  return this._sourceExecute(executeMessage);
+};
 
-  function deactivate() {
-    broker.cancel('_activity-api-execution');
-    broker.cancel('_activity-execute');
-    broker.unbindQueue(executeQ.name, 'execution', 'execute.#');
-  }
+proto.getPostponed = function getPostponed() {
+  let apis = this[postponedSymbol].map(msg => this.getApi(msg));
+  if (!this.activity.isSubProcess || !this.source) return apis;
+  apis = apis.concat(this.source.getPostponed());
+  return apis;
+};
 
-  function onParentApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
+proto.getState = function getState() {
+  const result = {
+    completed: this[completedSymbol]
+  };
+  const source = this.source;
+  if (!source || !source.getState) return result;
+  return { ...result,
+    ...source.getState()
+  };
+};
 
-    switch (messageType) {
-      case 'discard':
-        executeQ.queueMessage({
-          routingKey: 'execute.discard'
-        }, (0, _messageHelper.cloneContent)(initMessage.content));
-        break;
+proto.recover = function recover(state) {
+  this[postponedSymbol].splice(0);
+  if (!state) return this;
+  if ('completed' in state) this[completedSymbol] = state.completed;
+  const source = this.source = new this.activity.Behaviour(this.activity, this.context);
 
-      case 'stop':
-        onStop(message);
-        break;
-    }
+  if (source.recover) {
+    source.recover(state);
   }
 
-  function onStop(message) {
-    const stoppedId = message && message.content && message.content.executionId;
-    const running = getPostponed();
-    running.forEach(api => {
-      if (stoppedId !== api.content.executionId) {
-        api.stop();
-      }
-    });
-    broker.cancel('_activity-execute');
-    broker.cancel('_activity-api-execution');
-  }
+  return this;
+};
+
+proto.stop = function stop() {
+  const executeMessage = this[executeMessageSymbol];
+  if (!executeMessage) return;
+  this.getApi(executeMessage).stop();
+};
 
-  function onExecuteMessage(routingKey, message) {
-    const {
-      fields = {},
-      content = {},
-      properties = {}
-    } = message;
-    const isRedelivered = fields.redelivered;
-    const {
-      isRootScope,
-      ignoreIfExecuting,
-      keep,
-      executionId: cexid,
+proto._sourceExecute = function sourceExecute(executeMessage) {
+  try {
+    return this.source.execute(executeMessage);
+  } catch (error) {
+    return this.broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeMessage.content, {
       error
-    } = content;
-    const {
-      persistent,
-      correlationId
-    } = properties;
-    if (isRedelivered && persistent === false) return message.ack();
-
-    switch (routingKey) {
-      case 'execute.resume.execution':
-        {
-          if (!postponed.length) return broker.publish('execution', 'execute.start', (0, _messageHelper.cloneContent)(initMessage.content));
-          break;
-        }
+    }));
+  }
+};
 
-      case 'execute.error':
-      case 'execute.discard':
-        executionDiscard();
+proto._onExecuteMessage = function onExecuteMessage(routingKey, message) {
+  const {
+    fields,
+    content,
+    properties
+  } = message;
+  const isRedelivered = fields.redelivered;
+  if (isRedelivered && properties.persistent === false) return message.ack();
+
+  switch (routingKey) {
+    case 'execute.resume.execution':
+      {
+        if (!this[postponedSymbol].length) return this.broker.publish('execution', 'execute.start', (0, _messageHelper.cloneContent)(this[executeMessageSymbol].content));
         break;
+      }
 
-      case 'execute.cancel':
-      case 'execute.completed':
-        {
-          if (isRedelivered) {
-            message.ack();
-            return broker.publish('execution', routingKey, getExecuteMessage().content);
-          }
+    case 'execute.error':
+    case 'execute.discard':
+      return this._onExecutionDiscarded(message);
 
-          executionCompleted();
-          break;
+    case 'execute.cancel':
+    case 'execute.completed':
+      {
+        if (isRedelivered) {
+          message.ack();
+          return this.broker.publish('execution', routingKey, getExecuteMessage(message).content);
         }
 
-      case 'execute.start':
-        {
-          if (!stateChangeMessage()) return;
-          return source.execute(getExecuteMessage());
-        }
+        return this._onExecutionCompleted(message);
+      }
 
-      case 'execute.outbound.take':
-        {
-          if (isRedelivered) {
-            message.ack();
-            break;
-          }
+    case 'execute.start':
+      {
+        if (!this._onStateChangeMessage(message)) return;
+        return this._sourceExecute(getExecuteMessage(message));
+      }
 
-          broker.publish('execution', 'execution.outbound.take', (0, _messageHelper.cloneContent)(content), {
-            type: 'outbound'
-          });
+    case 'execute.outbound.take':
+      {
+        if (isRedelivered) {
+          message.ack();
           break;
         }
 
-      default:
-        {
-          if (!stateChangeMessage()) return;
+        this.broker.publish('execution', 'execution.outbound.take', (0, _messageHelper.cloneContent)(content), {
+          type: 'outbound'
+        });
+        break;
+      }
+
+    default:
+      {
+        if (!this._onStateChangeMessage(message)) return;
 
-          if (isRedelivered) {
-            return source.execute(getExecuteMessage());
-          }
+        if (isRedelivered) {
+          return this._sourceExecute(getExecuteMessage(message));
         }
+      }
+  }
+};
+
+proto._onStateChangeMessage = function onStateChangeMessage(message) {
+  const {
+    ignoreIfExecuting,
+    executionId
+  } = message.content;
+  const postponed = this[postponedSymbol];
+  const idx = postponed.findIndex(msg => msg.content.executionId === executionId);
+  let previousMsg;
+
+  if (idx > -1) {
+    if (ignoreIfExecuting) {
+      message.ack();
+      return false;
     }
 
-    function stateChangeMessage() {
-      const idx = postponed.findIndex(msg => msg.content.executionId === cexid);
-      let previousMsg;
+    previousMsg = postponed.splice(idx, 1, message)[0];
+    previousMsg.ack();
+    return true;
+  }
 
-      if (idx > -1) {
-        if (ignoreIfExecuting) {
-          message.ack();
-          return false;
-        }
+  postponed.push(message);
+  return true;
+};
 
-        previousMsg = postponed.splice(idx, 1, message)[0];
-        previousMsg.ack();
-        return true;
-      }
+proto._onExecutionCompleted = function onExecutionCompleted(message) {
+  const postponedMsg = this._ackPostponed(message);
 
-      postponed.push(message);
-      return true;
-    }
+  if (!postponedMsg) return;
+  const postponed = this[postponedSymbol];
+  const {
+    executionId,
+    keep,
+    isRootScope
+  } = message.content;
 
-    function getExecuteMessage() {
-      const result = (0, _messageHelper.cloneMessage)(message, { ...(isRedelivered ? {
-          isRecovered: true
-        } : undefined)
-      });
-      result.content.ignoreIfExecuting = undefined;
-      return result;
+  if (!isRootScope) {
+    this._debug('completed sub execution');
+
+    if (!keep) message.ack();
+
+    if (postponed.length === 1 && postponed[0].content.isRootScope && !postponed[0].content.preventComplete) {
+      return this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(postponed[0].content));
     }
 
-    function executionCompleted() {
-      const postponedMsg = ackPostponed(message);
-      if (!postponedMsg) return;
+    return;
+  }
 
-      if (!isRootScope) {
-        logger.debug(`<${cexid} (${id})> completed sub execution`);
-        if (!keep) message.ack();
+  this._debug('completed execution', executionId);
 
-        if (postponed.length === 1 && postponed[0].content.isRootScope && !postponed[0].content.preventComplete) {
-          return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(postponed[0].content));
-        }
+  this[completedSymbol] = true;
+  message.ack(true);
+  this.deactivate();
+  const subApis = this.getPostponed();
+  postponed.splice(0);
 
-        return;
-      }
+  for (const api of subApis) api.discard();
 
-      logger.debug(`<${cexid} (${id})> completed execution`);
-      completed = true;
-      message.ack(true);
-      deactivate();
-      const subApis = getPostponed();
-      postponed.splice(0);
-      subApis.forEach(api => api.discard());
-      publishExecutionCompleted('completed', { ...postponedMsg.content,
-        ...message.content
+  this._publishExecutionCompleted('completed', { ...postponedMsg.content,
+    ...message.content
+  }, message.properties.correlationId);
+};
+
+proto._onExecutionDiscarded = function onExecutionDiscarded(message) {
+  const postponedMsg = this._ackPostponed(message);
+
+  const {
+    isRootScope,
+    error
+  } = message.content;
+  if (!isRootScope && !postponedMsg) return;
+  const postponed = this[postponedSymbol];
+  const correlationId = message.properties.correlationId;
+
+  if (!error && !isRootScope) {
+    message.ack();
+
+    if (postponed.length === 1 && postponed[0].content.isRootScope) {
+      return this.broker.publish('execution', 'execute.discard', postponed[0].content, {
+        correlationId
       });
     }
 
-    function executionDiscard() {
-      const postponedMsg = ackPostponed(message);
-      if (!isRootScope && !postponedMsg) return;
+    return;
+  }
 
-      if (!error && !isRootScope) {
-        message.ack();
+  message.ack(true);
+  this.deactivate();
+  const subApis = this.getPostponed();
+  postponed.splice(0);
 
-        if (postponed.length === 1 && postponed[0].content.isRootScope) {
-          return broker.publish('execution', 'execute.discard', { ...postponed[0].content
-          }, {
-            correlationId
-          });
-        }
+  for (const api of subApis) api.discard();
 
-        return;
-      }
+  if (error) {
+    return this._publishExecutionCompleted('error', (0, _messageHelper.cloneContent)(message.content, {
+      error
+    }), correlationId);
+  }
 
-      message.ack(true);
-      deactivate();
-      const subApis = getPostponed();
-      postponed.splice(0);
-      subApis.forEach(api => api.discard());
-      publishExecutionCompleted(error ? 'error' : 'discard', { ...content
-      });
-    }
+  this._publishExecutionCompleted('discard', message.content, correlationId);
+};
 
-    function publishExecutionCompleted(completionType, completeContent) {
-      completed = true;
-      broker.publish('execution', `execution.${completionType}`, { ...completeContent,
-        state: completionType
+proto._publishExecutionCompleted = function publishExecutionCompleted(completionType, completeContent, correlationId) {
+  this[completedSymbol] = true;
+  this.broker.publish('execution', `execution.${completionType}`, { ...completeContent,
+    state: completionType
+  }, {
+    type: completionType,
+    correlationId
+  });
+};
+
+proto._ackPostponed = function ackPostponed(completeMessage) {
+  const {
+    executionId: eid
+  } = completeMessage.content;
+  const postponed = this[postponedSymbol];
+  const idx = postponed.findIndex(({
+    content: c
+  }) => c.executionId === eid);
+  if (idx === -1) return;
+  const [msg] = postponed.splice(idx, 1);
+  msg.ack();
+  return msg;
+};
+
+proto._onParentApiMessage = function onParentApiMessage(routingKey, message) {
+  switch (message.properties.type) {
+    case 'error':
+      return this[executeQSymbol].queueMessage({
+        routingKey: 'execute.error'
       }, {
-        type: completionType,
-        correlationId
+        error: message.content.error
       });
-    }
-  }
 
-  function ackPostponed(completeMessage) {
-    const {
-      executionId: eid
-    } = completeMessage.content;
-    const idx = postponed.findIndex(({
-      content
-    }) => content.executionId === eid);
-    if (idx === -1) return;
-    const [msg] = postponed.splice(idx, 1);
-    msg.ack();
-    return msg;
+    case 'discard':
+      return this[executeQSymbol].queueMessage({
+        routingKey: 'execute.discard'
+      }, (0, _messageHelper.cloneContent)(this[executeMessageSymbol].content));
+
+    case 'stop':
+      {
+        return this._onStop(message);
+      }
   }
+};
 
-  function getApi(apiMessage) {
-    if (!apiMessage) apiMessage = initMessage;
+proto._onStop = function onStop(message) {
+  const stoppedId = message && message.content && message.content.executionId;
+  const running = this.getPostponed();
 
-    if (source.getApi) {
-      const sourceApi = source.getApi(apiMessage);
-      if (sourceApi) return sourceApi;
+  for (const api of running) {
+    if (stoppedId !== api.content.executionId) {
+      api.stop();
     }
+  }
 
-    const api = (0, _Api.ActivityApi)(broker, apiMessage);
+  this.broker.cancel('_activity-execute');
+  this.broker.cancel('_activity-api-execution');
+};
 
-    api.getExecuting = function getExecuting() {
-      return postponed.reduce((result, msg) => {
-        if (msg.content.executionId === apiMessage.content.executionId) return result;
-        result.push(getApi(msg));
-        return result;
-      }, []);
-    };
+proto._debug = function debug(logMessage, executionId) {
+  executionId = executionId || this.executionId;
+  this.activity.logger.debug(`<${executionId} (${this.id})> ${logMessage}`);
+};
 
-    return api;
-  }
+function getExecuteMessage(message) {
+  const result = (0, _messageHelper.cloneMessage)(message, { ...(message.fields.redelivered ? {
+      isRecovered: true
+    } : undefined),
+    ignoreIfExecuting: undefined
+  });
+  return result;
 }