bpmn-elements 6.0.1 → 7.0.0

package/dist/src/process/Process.js

@@ -20,6 +20,15 @@ var _Errors = require("../error/Errors");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const consumingSymbol = Symbol.for('consuming');
+const countersSymbol = Symbol.for('counters');
+const execSymbol = Symbol.for('exec');
+const executeMessageSymbol = Symbol.for('executeMessage');
+const extensionsSymbol = Symbol.for('extensions');
+const messageHandlersSymbol = Symbol.for('messageHandlers');
+const stateMessageSymbol = Symbol.for('stateMessage');
+const statusSymbol = Symbol.for('status');
+const stoppedSymbol = Symbol.for('stopped');
 var _default = Process;
 exports.default = _default;
 
@@ -31,433 +40,498 @@ function Process(processDef, context) {
     parent,
     behaviour = {}
   } = processDef;
-  const environment = context.environment;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = parent ? (0, _messageHelper.cloneParent)(parent) : {};
+  this.behaviour = behaviour;
   const {
     isExecutable
   } = behaviour;
-  const logger = environment.Logger(type.toLowerCase());
-  let execution, initExecutionId, executionId, status, stopped, postponedMessage, stateMessage, consumingRunQ;
-  let counters = {
+  this.isExecutable = isExecutable;
+  const environment = this.environment = context.environment;
+  this.context = context;
+  this[countersSymbol] = {
     completed: 0,
-    discarded: 0,
-    terminated: 0
-  };
-  const processApi = {
-    id,
-    type,
-    name,
-    isExecutable,
-    behaviour,
-
-    get counters() {
-      return { ...counters
-      };
-    },
-
-    get executionId() {
-      return executionId;
-    },
-
-    get status() {
-      return status;
-    },
-
-    get stopped() {
-      return stopped;
-    },
-
-    get execution() {
-      return execution;
-    },
-
-    get isRunning() {
-      if (!consumingRunQ) return false;
-      return !!status;
-    },
-
-    context,
-    environment,
-    parent: { ...parent
-    },
-    logger,
-    getApi,
-    getActivities,
-    getActivityById,
-    getSequenceFlows,
-    getPostponed,
-    getStartActivities,
-    getState,
-    init,
-    recover,
-    resume,
-    run,
-    sendMessage,
-    shake,
-    signal,
-    cancelActivity,
-    stop
+    discarded: 0
   };
+  this[stoppedSymbol] = false;
+  this[execSymbol] = {};
   const {
     broker,
     on,
     once,
     waitFor
-  } = (0, _EventBroker.ProcessBroker)(processApi);
-  processApi.on = on;
-  processApi.once = once;
-  processApi.waitFor = waitFor;
-  const runQ = broker.getQueue('run-q');
-  const executionQ = broker.getQueue('execution-q');
-  Object.defineProperty(processApi, 'broker', {
-    enumerable: true,
-    get: () => broker
-  });
-  const extensions = context.loadExtensions(processApi);
-  Object.defineProperty(processApi, 'extensions', {
-    enumerable: true,
-    get: () => extensions
-  });
-  return processApi;
-
-  function init() {
-    initExecutionId = (0, _shared.getUniqueId)(id);
-    logger.debug(`<${id}> initialized with executionId <${initExecutionId}>`);
-    publishEvent('init', createMessage({
-      executionId: initExecutionId
-    }));
-  }
+  } = (0, _EventBroker.ProcessBroker)(this);
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
+  this[messageHandlersSymbol] = {
+    onApiMessage: this._onApiMessage.bind(this),
+    onRunMessage: this._onRunMessage.bind(this),
+    onExecutionMessage: this._onExecutionMessage.bind(this)
+  };
+  this.logger = environment.Logger(type.toLowerCase());
+  this[extensionsSymbol] = context.loadExtensions(this);
+}
 
-  function run(runContent) {
-    if (processApi.isRunning) throw new Error(`process <${id}> is already running`);
-    executionId = initExecutionId || (0, _shared.getUniqueId)(id);
-    initExecutionId = undefined;
-    const content = createMessage({ ...runContent,
-      executionId
-    });
-    broker.publish('run', 'run.enter', content);
-    broker.publish('run', 'run.start', (0, _messageHelper.cloneContent)(content));
-    broker.publish('run', 'run.execute', (0, _messageHelper.cloneContent)(content));
-    activateRunConsumers();
-  }
+const proto = Process.prototype;
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
 
-  function resume() {
-    if (processApi.isRunning) throw new Error(`cannot resume running process <${id}>`);
-    if (!status) return processApi;
-    stopped = false;
-    const content = createMessage({
-      executionId
-    });
-    broker.publish('run', 'run.resume', content, {
-      persistent: false
-    });
-    activateRunConsumers();
-    return processApi;
-  }
-
-  function recover(state) {
-    if (processApi.isRunning) throw new Error(`cannot recover running process <${id}>`);
-    if (!state) return processApi;
-    stopped = state.stopped;
-    status = state.status;
-    executionId = state.executionId;
-    counters = { ...counters,
-      ...state.counters
+  get() {
+    return { ...this[countersSymbol]
     };
+  }
 
-    if (state.execution) {
-      execution = (0, _ProcessExecution.default)(processApi, context).recover(state.execution);
-    }
+});
+Object.defineProperty(proto, 'extensions', {
+  enumerable: true,
 
-    broker.recover(state.broker);
-    return processApi;
+  get() {
+    return this[extensionsSymbol];
   }
 
-  function shake(startId) {
-    if (processApi.isRunning) return execution.shake(startId);
-    return (0, _ProcessExecution.default)(processApi, context).shake(startId);
-  }
+});
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
 
-  function activateRunConsumers() {
-    consumingRunQ = true;
-    broker.subscribeTmp('api', `process.*.${executionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: '_process-api',
-      priority: 100
-    });
-    runQ.assertConsumer(onRunMessage, {
-      exclusive: true,
-      consumerTag: '_process-run'
-    });
+  get() {
+    return this[stoppedSymbol];
   }
 
-  function deactivateRunConsumers() {
-    broker.cancel('_process-api');
-    broker.cancel('_process-run');
-    broker.cancel('_process-execution');
-    consumingRunQ = false;
-  }
+});
+Object.defineProperty(proto, 'isRunning', {
+  enumerable: true,
 
-  function stop() {
-    if (!processApi.isRunning) return;
-    getApi().stop();
+  get() {
+    if (!this[consumingSymbol]) return false;
+    return !!this.status;
   }
 
-  function getApi(message) {
-    if (execution) return execution.getApi(message);
-    return (0, _Api.ProcessApi)(broker, message || stateMessage);
+});
+Object.defineProperty(proto, 'executionId', {
+  enumerable: true,
+
+  get() {
+    const {
+      executionId,
+      initExecutionId
+    } = this[execSymbol];
+    return executionId || initExecutionId;
   }
 
-  function signal(message) {
-    return getApi().signal(message, {
-      delegate: true
-    });
+});
+Object.defineProperty(proto, 'execution', {
+  enumerable: true,
+
+  get() {
+    return this[execSymbol].execution;
   }
 
-  function cancelActivity(message) {
-    return getApi().cancel(message, {
-      delegate: true
-    });
+});
+Object.defineProperty(proto, 'status', {
+  enumerable: true,
+
+  get() {
+    return this[statusSymbol];
   }
 
-  function onRunMessage(routingKey, message) {
-    const {
-      content,
-      ack,
-      fields
-    } = message;
+});
 
-    if (routingKey === 'run.resume') {
-      return onResumeMessage();
-    }
+proto.init = function init(useAsExecutionId) {
+  const exec = this[execSymbol];
+  const initExecutionId = exec.initExecutionId = useAsExecutionId || (0, _shared.getUniqueId)(this.id);
 
-    stateMessage = message;
-
-    switch (routingKey) {
-      case 'run.enter':
-        {
-          logger.debug(`<${id}> enter`);
-          status = 'entered';
-          if (fields.redelivered) break;
-          execution = undefined;
-          publishEvent('enter', content);
-          break;
-        }
+  this._debug(`initialized with executionId <${initExecutionId}>`);
 
-      case 'run.start':
-        {
-          logger.debug(`<${id}> start`);
-          status = 'start';
-          publishEvent('start', content);
-          break;
-        }
+  this._publishEvent('init', this._createMessage({
+    executionId: initExecutionId
+  }));
+};
 
-      case 'run.execute':
-        {
-          status = 'executing';
-          const executeMessage = (0, _messageHelper.cloneMessage)(message);
-
-          if (fields.redelivered && !execution) {
-            executeMessage.fields.redelivered = undefined;
-          }
-
-          postponedMessage = message;
-          executionQ.assertConsumer(onExecutionMessage, {
-            exclusive: true,
-            consumerTag: '_process-execution'
-          });
-          execution = execution || (0, _ProcessExecution.default)(processApi, context);
-          return execution.execute(executeMessage);
-        }
+proto.run = function run(runContent) {
+  if (this.isRunning) throw new Error(`process <${this.id}> is already running`);
+  const exec = this[execSymbol];
+  const executionId = exec.executionId = exec.initExecutionId || (0, _shared.getUniqueId)(this.id);
+  exec.initExecutionId = undefined;
 
-      case 'run.error':
-        {
-          publishEvent('error', (0, _messageHelper.cloneContent)(content, {
-            error: fields.redelivered ? (0, _Errors.makeErrorFromMessage)(message) : content.error
-          }));
-          break;
-        }
+  const content = this._createMessage({ ...runContent,
+    executionId
+  });
 
-      case 'run.end':
-        {
-          status = 'end';
-          if (fields.redelivered) break;
-          logger.debug(`<${id}> completed`);
-          counters.completed++;
-          broker.publish('run', 'run.leave', content);
-          publishEvent('end', content);
-          break;
-        }
+  const broker = this.broker;
+  broker.publish('run', 'run.enter', content);
+  broker.publish('run', 'run.start', (0, _messageHelper.cloneContent)(content));
+  broker.publish('run', 'run.execute', (0, _messageHelper.cloneContent)(content));
 
-      case 'run.discarded':
-        {
-          status = 'discarded';
-          if (fields.redelivered) break;
-          counters.discarded++;
-          broker.publish('run', 'run.leave', content);
-          break;
-        }
+  this._activateRunConsumers();
+};
 
-      case 'run.leave':
-        {
-          status = undefined;
-          broker.cancel('_process-api');
-          publishEvent('leave');
-          break;
-        }
-    }
+proto.resume = function resume() {
+  if (this.isRunning) throw new Error(`cannot resume running process <${this.id}>`);
+  if (!this.status) return this;
+  this[stoppedSymbol] = false;
+
+  const content = this._createMessage();
 
-    ack();
+  this.broker.publish('run', 'run.resume', content, {
+    persistent: false
+  });
 
-    function onResumeMessage() {
-      message.ack();
+  this._activateRunConsumers();
 
-      switch (stateMessage.fields.routingKey) {
-        case 'run.enter':
-        case 'run.start':
-        case 'run.discarded':
-        case 'run.end':
-        case 'run.leave':
-          break;
+  return this;
+};
 
-        default:
-          return;
-      }
+proto.recover = function recover(state) {
+  if (this.isRunning) throw new Error(`cannot recover running process <${this.id}>`);
+  if (!state) return this;
+  this[stoppedSymbol] = !!state.stopped;
+  this[statusSymbol] = state.status;
+  const exec = this[execSymbol];
+  exec.executionId = state.executionId;
+  this[countersSymbol] = { ...this[countersSymbol],
+    ...state.counters
+  };
+  this.environment.recover(state.environment);
+
+  if (state.execution) {
+    exec.execution = new _ProcessExecution.default(this, this.context).recover(state.execution);
+  }
 
-      if (!stateMessage.fields.redelivered) return;
-      logger.debug(`<${id}> resume from ${status}`);
-      return broker.publish('run', stateMessage.fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
+  this.broker.recover(state.broker);
+  return this;
+};
+
+proto.shake = function shake(startId) {
+  if (this.isRunning) return this.execution.shake(startId);
+  return new _ProcessExecution.default(this, this.context).shake(startId);
+};
+
+proto.stop = function stop() {
+  if (!this.isRunning) return;
+  this.getApi().stop();
+};
+
+proto.getApi = function getApi(message) {
+  const execution = this.execution;
+  if (execution) return execution.getApi(message);
+  return (0, _Api.ProcessApi)(this.broker, message || this[stateMessageSymbol]);
+};
+
+proto.signal = function signal(message) {
+  return this.getApi().signal(message, {
+    delegate: true
+  });
+};
+
+proto.getState = function getState() {
+  return this._createMessage({
+    environment: this.environment.getState(),
+    status: this.status,
+    stopped: this.stopped,
+    counters: this.counters,
+    broker: this.broker.getState(true),
+    execution: this.execution && this.execution.getState(),
+    output: { ...this.environment.output
     }
+  });
+};
+
+proto.cancelActivity = function cancelActivity(message) {
+  return this.getApi().cancel(message, {
+    delegate: true
+  });
+};
+
+proto._activateRunConsumers = function activateRunConsumers() {
+  this[consumingSymbol] = true;
+  const broker = this.broker;
+  const {
+    onApiMessage,
+    onRunMessage
+  } = this[messageHandlersSymbol];
+  broker.subscribeTmp('api', `process.*.${this.executionId}`, onApiMessage, {
+    noAck: true,
+    consumerTag: '_process-api',
+    priority: 100
+  });
+  broker.getQueue('run-q').assertConsumer(onRunMessage, {
+    exclusive: true,
+    consumerTag: '_process-run'
+  });
+};
+
+proto._deactivateRunConsumers = function deactivateRunConsumers() {
+  const broker = this.broker;
+  broker.cancel('_process-api');
+  broker.cancel('_process-run');
+  broker.cancel('_process-execution');
+  this[consumingSymbol] = false;
+};
+
+proto._onRunMessage = function onRunMessage(routingKey, message) {
+  const {
+    content,
+    fields
+  } = message;
+
+  if (routingKey === 'run.resume') {
+    return this._onResumeMessage(message);
   }
 
-  function onExecutionMessage(routingKey, message) {
-    const content = message.content;
-    const messageType = message.properties.type;
-    message.ack();
+  const exec = this[execSymbol];
+  this[stateMessageSymbol] = message;
 
-    switch (messageType) {
-      case 'stopped':
-        {
-          return onStop();
-        }
+  switch (routingKey) {
+    case 'run.enter':
+      {
+        this._debug('enter');
 
-      case 'error':
-        {
-          broker.publish('run', 'run.error', content);
-          broker.publish('run', 'run.discarded', content);
-          break;
-        }
+        this[statusSymbol] = 'entered';
+        if (fields.redelivered) break;
+        exec.execution = undefined;
+
+        this._publishEvent('enter', content);
 
-      case 'discard':
-        broker.publish('run', 'run.discarded', content);
         break;
+      }
+
+    case 'run.start':
+      {
+        this._debug('start');
+
+        this[statusSymbol] = 'start';
 
-      default:
-        {
-          broker.publish('run', 'run.end', content);
+        this._publishEvent('start', content);
+
+        break;
+      }
+
+    case 'run.execute':
+      {
+        this[statusSymbol] = 'executing';
+        const executeMessage = (0, _messageHelper.cloneMessage)(message);
+
+        if (fields.redelivered && !exec.execution) {
+          executeMessage.fields.redelivered = undefined;
         }
-    }
 
-    if (postponedMessage) {
-      const ackMessage = postponedMessage;
-      postponedMessage = null;
-      ackMessage.ack();
-    }
-  }
+        this[executeMessageSymbol] = message;
+        this.broker.getQueue('execution-q').assertConsumer(this[messageHandlersSymbol].onExecutionMessage, {
+          exclusive: true,
+          consumerTag: '_process-execution'
+        });
+        const execution = exec.execution = exec.execution || new _ProcessExecution.default(this, this.context);
+        return execution.execute(executeMessage);
+      }
 
-  function publishEvent(state, content) {
-    if (!content) content = createMessage();
-    broker.publish('event', `process.${state}`, { ...content,
-      state
-    }, {
-      type: state,
-      mandatory: state === 'error'
-    });
-  }
+    case 'run.error':
+      {
+        this._publishEvent('error', (0, _messageHelper.cloneContent)(content, {
+          error: fields.redelivered ? (0, _Errors.makeErrorFromMessage)(message) : content.error
+        }));
 
-  function sendMessage(message) {
-    const messageContent = message.content;
-    if (!messageContent) return;
-    let targetsFound = false;
-
-    if (messageContent.target && messageContent.target.id && getActivityById(messageContent.target.id)) {
-      targetsFound = true;
-    } else if (messageContent.message && getStartActivities({
-      referenceId: messageContent.message.id,
-      referenceType: messageContent.message.messageType
-    }).length) {
-      targetsFound = true;
-    }
+        break;
+      }
 
-    if (!targetsFound) return;
-    if (!status) run();
-    getApi().sendApiMessage(message.properties.type || 'message', (0, _messageHelper.cloneContent)(messageContent), {
-      delegate: true
-    });
-  }
+    case 'run.end':
+      {
+        this[statusSymbol] = 'end';
+        if (fields.redelivered) break;
 
-  function getActivityById(childId) {
-    if (execution) return execution.getActivityById(childId);
-    return context.getActivityById(childId);
-  }
+        this._debug('completed');
 
-  function getActivities() {
-    if (execution) return execution.getActivities();
-    return context.getActivities(id);
-  }
+        this[countersSymbol].completed++;
+        this.broker.publish('run', 'run.leave', content);
 
-  function getStartActivities(filterOptions) {
-    return context.getStartActivities(filterOptions, id);
-  }
+        this._publishEvent('end', content);
+
+        break;
+      }
+
+    case 'run.discarded':
+      {
+        this[statusSymbol] = 'discarded';
+        if (fields.redelivered) break;
+        this[countersSymbol].discarded++;
+        this.broker.publish('run', 'run.leave', content);
+
+        this._publishEvent('discarded', content);
+
+        break;
+      }
+
+    case 'run.leave':
+      {
+        this[statusSymbol] = undefined;
+        this.broker.cancel('_process-api');
+        const {
+          output,
+          ...rest
+        } = content; // eslint-disable-line no-unused-vars
+
+        this._publishEvent('leave', rest);
 
-  function getSequenceFlows() {
-    if (execution) return execution.getSequenceFlows();
-    return context.getSequenceFlows();
+        break;
+      }
   }
 
-  function getPostponed(...args) {
-    if (execution) return execution.getPostponed(...args);
-    return [];
+  message.ack();
+};
+
+proto._onResumeMessage = function onResumeMessage(message) {
+  message.ack();
+  const stateMessage = this[stateMessageSymbol];
+
+  switch (stateMessage.fields.routingKey) {
+    case 'run.enter':
+    case 'run.start':
+    case 'run.discarded':
+    case 'run.end':
+    case 'run.leave':
+      break;
+
+    default:
+      return;
   }
 
-  function onApiMessage(routingKey, message) {
-    const messageType = message.properties.type;
+  if (!stateMessage.fields.redelivered) return;
 
-    switch (messageType) {
-      case 'stop':
-        {
-          if (execution && !execution.completed) return;
-          onStop();
-          break;
-        }
-    }
+  this._debug(`resume from ${this.status}`);
+
+  return this.broker.publish('run', stateMessage.fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
+};
+
+proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+  const content = message.content;
+  const messageType = message.properties.type;
+  message.ack();
+
+  switch (messageType) {
+    case 'stopped':
+      {
+        return this._onStop();
+      }
+
+    case 'error':
+      {
+        this.broker.publish('run', 'run.error', content);
+        this.broker.publish('run', 'run.discarded', content);
+        break;
+      }
+
+    case 'discard':
+      this.broker.publish('run', 'run.discarded', content);
+      break;
+
+    default:
+      {
+        this.broker.publish('run', 'run.end', content);
+      }
   }
 
-  function onStop() {
-    stopped = true;
-    deactivateRunConsumers();
-    return publishEvent('stop');
+  const executeMessage = this[executeMessageSymbol];
+
+  if (executeMessage) {
+    this[executeMessageSymbol] = null;
+    executeMessage.ack();
   }
+};
 
-  function createMessage(override = {}) {
-    return {
-      id,
-      type,
-      name,
-      parent: { ...parent
-      },
-      ...override
-    };
+proto._publishEvent = function publishEvent(state, content) {
+  const eventContent = this._createMessage({ ...content,
+    state
+  });
+
+  this.broker.publish('event', `process.${state}`, eventContent, {
+    type: state,
+    mandatory: state === 'error'
+  });
+};
+
+proto.sendMessage = function sendMessage(message) {
+  const messageContent = message.content;
+  if (!messageContent) return;
+  let targetsFound = false;
+
+  if (messageContent.target && messageContent.target.id && this.getActivityById(messageContent.target.id)) {
+    targetsFound = true;
+  } else if (messageContent.message && this.getStartActivities({
+    referenceId: messageContent.message.id,
+    referenceType: messageContent.message.messageType
+  }).length) {
+    targetsFound = true;
   }
 
-  function getState() {
-    return createMessage({
-      executionId,
-      status,
-      stopped,
-      counters: { ...counters
-      },
-      broker: broker.getState(true),
-      execution: execution && execution.getState()
-    });
+  if (!targetsFound) return;
+  if (!this.status) this.run();
+  this.getApi().sendApiMessage(message.properties.type || 'message', (0, _messageHelper.cloneContent)(messageContent), {
+    delegate: true
+  });
+};
+
+proto.getActivityById = function getActivityById(childId) {
+  if (this.execution) return this.execution.getActivityById(childId);
+  return this.context.getActivityById(childId);
+};
+
+proto.getActivities = function getActivities() {
+  if (this.execution) return this.execution.getActivities();
+  return this.context.getActivities(this.id);
+};
+
+proto.getStartActivities = function getStartActivities(filterOptions) {
+  return this.context.getStartActivities(filterOptions, this.id);
+};
+
+proto.getSequenceFlows = function getSequenceFlows() {
+  if (this.execution) return this.execution.getSequenceFlows();
+  return this.context.getSequenceFlows();
+};
+
+proto.getPostponed = function getPostponed(...args) {
+  if (!this.execution) return [];
+  return this.execution.getPostponed(...args);
+};
+
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'stop':
+      {
+        if (this.execution && !this.execution.completed) return;
+
+        this._onStop();
+
+        break;
+      }
   }
-}
+};
+
+proto._onStop = function onStop() {
+  this[stoppedSymbol] = true;
+
+  this._deactivateRunConsumers();
+
+  return this._publishEvent('stop');
+};
+
+proto._createMessage = function createMessage(override) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    executionId: this.executionId,
+    parent: { ...this.parent
+    },
+    ...override
+  };
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.id}> ${msg}`);
+};