bpmn-elements 7.0.0 → 8.0.0

package/src/definition/DefinitionExecution.js

@@ -3,45 +3,54 @@ import {DefinitionApi} from '../Api';
 import {brokerSafeId} from '../shared';
 import {cloneContent, cloneMessage, pushParent, cloneParent} from '../messageHelper';
 
-const activatedSymbol = Symbol.for('activated');
-const processesQSymbol = Symbol.for('processesQ');
-const completedSymbol = Symbol.for('completed');
-const executeMessageSymbol = Symbol.for('executeMessage');
-const messageHandlersSymbol = Symbol.for('messageHandlers');
-const parentSymbol = Symbol.for('definition');
-const processesSymbol = Symbol.for('processes');
-const statusSymbol = Symbol.for('status');
-const stoppedSymbol = Symbol.for('stopped');
+const kActivated = Symbol.for('activated');
+const kProcessesQ = Symbol.for('processesQ');
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
+const kMessageHandlers = Symbol.for('messageHandlers');
+const kParent = Symbol.for('definition');
+const kProcesses = Symbol.for('processes');
+const kStatus = Symbol.for('status');
+const kStopped = Symbol.for('stopped');
 
 export default function DefinitionExecution(definition, context) {
   const broker = definition.broker;
 
-  this[parentSymbol] = definition;
+  this[kParent] = definition;
   this.id = definition.id;
   this.type = definition.type;
   this.broker = broker;
-  this.environment = definition.environment;
+  const environment = this.environment = definition.environment;
   this.context = context;
 
-  const processes = this[processesSymbol] = context.getProcesses();
-  this[processesSymbol] = {
+  const processes = context.getProcesses();
+  const ids = [];
+  const executable = [];
+  for (const bp of processes) {
+    bp.environment.assignVariables(environment.variables);
+    bp.environment.assignSettings(environment.settings);
+    ids.push(bp.id);
+    if (bp.isExecutable) executable.push(bp);
+  }
+
+  this[kProcesses] = {
     processes,
     running: [],
-    ids: processes.map(({id: childId}) => childId),
-    executable: context.getExecutableProcesses(),
+    ids,
+    executable,
     postponed: [],
   };
 
   broker.assertExchange('execution', 'topic', {autoDelete: false, durable: true});
-  broker.assertQueue('activity-q', {autoDelete: false, durable: false});
 
-  this[completedSymbol] = false;
-  this[stoppedSymbol] = false;
-  this[activatedSymbol] = false;
-  this[statusSymbol] = 'init';
   this.executionId = undefined;
+  this[kCompleted] = false;
+  this[kStopped] = false;
+  this[kActivated] = false;
+  this[kStatus] = 'init';
+  this[kProcessesQ] = undefined;
 
-  this[messageHandlersSymbol] = {
+  this[kMessageHandlers] = {
     onApiMessage: this._onApiMessage.bind(this),
     onCallActivity: this._onCallActivity.bind(this),
     onCancelCallActivity: this._onCancelCallActivity.bind(this),
@@ -57,40 +66,40 @@ const proto = DefinitionExecution.prototype;
 Object.defineProperty(proto, 'stopped', {
   enumerable: true,
   get() {
-    return this[stoppedSymbol];
+    return this[kStopped];
   },
 });
 
 Object.defineProperty(proto, 'completed', {
   enumerable: true,
   get() {
-    return this[completedSymbol];
+    return this[kCompleted];
   },
 });
 
 Object.defineProperty(proto, 'status', {
   enumerable: true,
   get() {
-    return this[statusSymbol];
+    return this[kStatus];
   },
 });
 
 Object.defineProperty(proto, 'processes', {
   enumerable: true,
   get() {
-    return this[processesSymbol].running;
+    return this[kProcesses].running;
   },
 });
 
 Object.defineProperty(proto, 'postponedCount', {
   get() {
-    return this[processesSymbol].postponed.length;
+    return this[kProcesses].postponed.length;
   },
 });
 
 Object.defineProperty(proto, 'isRunning', {
   get() {
-    return this[activatedSymbol];
+    return this[kActivated];
   },
 });
 
@@ -100,21 +109,20 @@ proto.execute = function execute(executeMessage) {
   const executionId = this.executionId = content.executionId;
   if (!executionId) throw new Error('Definition execution requires execution id');
 
-
-  this[executeMessageSymbol] = cloneMessage(executeMessage, {
+  this[kExecuteMessage] = cloneMessage(executeMessage, {
     executionId,
     state: 'start',
   });
 
-  this[stoppedSymbol] = false;
+  this[kStopped] = false;
 
-  this[processesQSymbol] = this.broker.assertQueue(`execute-${executionId}-q`, {durable: true, autoDelete: false});
+  this[kProcessesQ] = this.broker.assertQueue(`execute-${executionId}-q`, {durable: true, autoDelete: false});
 
   if (executeMessage.fields.redelivered) {
     return this.resume();
   }
 
-  const {running, executable} = this[processesSymbol];
+  const {running, executable} = this[kProcesses];
 
   if (content.processId) {
     const startWithProcess = this.getProcessById(content.processId);
@@ -132,27 +140,19 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.resume = function resume() {
-  this._debug(`resume ${this.status} definition execution`);
+  this._debug(`resume ${this[kStatus]} definition execution`);
 
-  if (this.completed) return this._complete('completed');
+  if (this[kCompleted]) return this._complete('completed');
 
-  const {running, postponed} = this[processesSymbol];
+  const {running, postponed} = this[kProcesses];
   this._activate(running);
   postponed.splice(0);
-  this[processesQSymbol].consume(this[messageHandlersSymbol].onProcessMessage, {
+  this[kProcessesQ].consume(this[kMessageHandlers].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`,
   });
 
-  if (this.completed) return this._complete('completed');
-  switch (this.status) {
-    case 'init':
-      return this._start();
-    case 'executing': {
-      if (!this.postponedCount) return this._complete('completed');
-      break;
-    }
-  }
+  if (this[kCompleted]) return;
 
   for (const bp of running) bp.resume();
 };
@@ -161,21 +161,30 @@ proto.recover = function recover(state) {
   if (!state) return this;
   this.executionId = state.executionId;
 
-  this[stoppedSymbol] = state.stopped;
-  this[completedSymbol] = state.completed;
-  this[statusSymbol] = state.status;
+  this[kStopped] = state.stopped;
+  this[kCompleted] = state.completed;
+  this[kStatus] = state.status;
 
-  this._debug(`recover ${this.status} definition execution`);
+  this._debug(`recover ${this[kStatus]} definition execution`);
 
-  const running = this[processesSymbol].running;
+  const running = this[kProcesses].running;
   running.splice(0);
 
-  state.processes.map((processState) => {
-    const instance = this.context.getNewProcessById(processState.id);
-    if (!instance) return;
-    instance.recover(processState);
-    running.push(instance);
-  });
+  const ids = [];
+  for (const bpState of state.processes) {
+    const bpid = bpState.id;
+    let bp;
+    if (ids.indexOf(bpid) > -1) {
+      bp = this.context.getNewProcessById(bpid);
+    } else {
+      bp = this.getProcessById(bpid);
+    }
+    if (!bp) return;
+
+    ids.push(bpid);
+    bp.recover(bpState);
+    running.push(bp);
+  }
 
   return this;
 };
@@ -185,7 +194,7 @@ proto.stop = function stop() {
 };
 
 proto.getProcesses = function getProcesses() {
-  const {running, processes} = this[processesSymbol];
+  const {running, processes} = this[kProcesses];
   const result = running.slice();
   for (const bp of processes) {
     if (!result.find((runningBp) => bp.id === runningBp.id)) result.push(bp);
@@ -202,31 +211,31 @@ proto.getProcessesById = function getProcessesById(processId) {
 };
 
 proto.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
-  const running = this[processesSymbol].running;
+  const running = this[kProcesses].running;
   return running.find((bp) => bp.executionId === processExecutionId);
 };
 
 proto.getRunningProcesses = function getRunningProcesses() {
-  const running = this[processesSymbol].running;
+  const running = this[kProcesses].running;
   return running.filter((bp) => bp.executionId);
 };
 
 proto.getExecutableProcesses = function getExecutableProcesses() {
-  return this[processesSymbol].executable.slice();
+  return this[kProcesses].executable.slice();
 };
 
 proto.getState = function getState() {
   return {
     executionId: this.executionId,
-    stopped: this.stopped,
-    completed: this.completed,
-    status: this.status,
-    processes: this[processesSymbol].running.map((bp) => bp.getState()),
+    stopped: this[kStopped],
+    completed: this[kCompleted],
+    status: this[kStatus],
+    processes: this[kProcesses].running.map((bp) => bp.getState()),
   };
 };
 
 proto.getApi = function getApi(apiMessage) {
-  if (!apiMessage) apiMessage = this[executeMessageSymbol] || {content: this._createMessage()};
+  if (!apiMessage) apiMessage = this[kExecuteMessage] || {content: this._createMessage()};
 
   const content = apiMessage.content;
   if (content.executionId !== this.executionId) {
@@ -234,7 +243,7 @@ proto.getApi = function getApi(apiMessage) {
   }
 
   const api = DefinitionApi(this.broker, apiMessage);
-  const postponed = this[processesSymbol].postponed;
+  const postponed = this[kProcesses].postponed;
   const self = this;
 
   api.getExecuting = function getExecuting() {
@@ -249,7 +258,7 @@ proto.getApi = function getApi(apiMessage) {
 };
 
 proto.getPostponed = function getPostponed(...args) {
-  const running = this[processesSymbol].running;
+  const running = this[kProcesses].running;
   return running.reduce((result, p) => {
     result = result.concat(p.getPostponed(...args));
     return result;
@@ -257,37 +266,38 @@ proto.getPostponed = function getPostponed(...args) {
 };
 
 proto._start = function start() {
-  const {ids, executable, postponed} = this[processesSymbol];
+  const {ids, executable, postponed} = this[kProcesses];
   if (!ids.length) {
-    return this.publishCompletionMessage('completed');
+    return this._complete('completed');
   }
+
   if (!executable.length) {
     return this._complete('error', {error: new Error('No executable process')});
   }
 
-  this[statusSymbol] = 'start';
+  this[kStatus] = 'start';
 
   for (const bp of executable) bp.init();
   for (const bp of executable) bp.run();
 
   postponed.splice(0);
-  this[processesQSymbol].assertConsumer(this[messageHandlersSymbol].onProcessMessage, {
+  this[kProcessesQ].assertConsumer(this[kMessageHandlers].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`,
   });
 };
 
 proto._activate = function activate(processList) {
-  this.broker.subscribeTmp('api', '#', this[messageHandlersSymbol].onApiMessage, {
+  this.broker.subscribeTmp('api', '#', this[kMessageHandlers].onApiMessage, {
     noAck: true,
     consumerTag: '_definition-api-consumer',
   });
   for (const bp of processList) this._activateProcess(bp);
-  this[activatedSymbol] = true;
+  this[kActivated] = true;
 };
 
 proto._activateProcess = function activateProcess(bp) {
-  const handlers = this[messageHandlersSymbol];
+  const handlers = this[kMessageHandlers];
 
   bp.broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
     noAck: true,
@@ -325,7 +335,7 @@ proto._onChildEvent = function onChildEvent(routingKey, originalMessage) {
   const content = message.content;
   const parent = content.parent = content.parent || {};
 
-  const isDirectChild = this[processesSymbol].ids.indexOf(content.id) > -1;
+  const isDirectChild = this[kProcesses].ids.indexOf(content.id) > -1;
   if (isDirectChild) {
     parent.executionId = this.executionId;
   } else {
@@ -335,14 +345,14 @@ proto._onChildEvent = function onChildEvent(routingKey, originalMessage) {
   this.broker.publish('event', routingKey, content, {...message.properties, mandatory: false});
   if (!isDirectChild) return;
 
-  this[processesQSymbol].queueMessage(message.fields, cloneContent(content), message.properties);
+  this[kProcessesQ].queueMessage(message.fields, cloneContent(content), message.properties);
 };
 
 proto._deactivate = function deactivate() {
   this.broker.cancel('_definition-api-consumer');
   this.broker.cancel(`_definition-activity-${this.executionId}`);
-  for (const bp of this[processesSymbol].running) this._deactivateProcess(bp);
-  this[activatedSymbol] = false;
+  for (const bp of this[kProcesses].running) this._deactivateProcess(bp);
+  this[kActivated] = false;
 };
 
 proto._deactivateProcess = function deactivateProcess(bp) {
@@ -357,17 +367,14 @@ proto._deactivateProcess = function deactivateProcess(bp) {
 proto._onProcessMessage = function onProcessMessage(routingKey, message) {
   const content = message.content;
   const isRedelivered = message.fields.redelivered;
-  const {id: childId, executionId: childExecutionId, inbound} = content;
+  const {id: childId, inbound} = content;
 
   if (isRedelivered && message.properties.persistent === false) return;
 
   switch (routingKey) {
     case 'execution.stop': {
-      if (childExecutionId === this.executionId) {
-        message.ack();
-        return this._onStopped(message);
-      }
-      break;
+      message.ack();
+      return this._onStopped(message);
     }
     case 'process.leave': {
       return this._onProcessCompleted(message);
@@ -377,9 +384,8 @@ proto._onProcessMessage = function onProcessMessage(routingKey, message) {
   this._stateChangeMessage(message, true);
 
   switch (routingKey) {
-    case 'process.discard':
     case 'process.enter':
-      this[statusSymbol] = 'executing';
+      this[kStatus] = 'executing';
       break;
     case 'process.discarded': {
       if (inbound && inbound.length) {
@@ -412,7 +418,7 @@ proto._onProcessMessage = function onProcessMessage(routingKey, message) {
           error: content.error,
         }, {mandatory: true, type: 'error'});
       } else {
-        for (const bp of this[processesSymbol].running.slice()) {
+        for (const bp of this[kProcesses].running.slice()) {
           if (bp.id !== childId) bp.stop();
         }
 
@@ -425,7 +431,7 @@ proto._onProcessMessage = function onProcessMessage(routingKey, message) {
 
 proto._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   let previousMsg;
-  const postponed = this[processesSymbol].postponed;
+  const postponed = this[kProcesses].postponed;
   const idx = postponed.findIndex((msg) => msg.content.executionId === message.content.executionId);
   if (idx > -1) {
     previousMsg = postponed.splice(idx, 1)[0];
@@ -454,15 +460,14 @@ proto._onProcessCompleted = function onProcessCompleted(message) {
 };
 
 proto._onStopped = function onStopped(message) {
-  const running = this[processesSymbol].running;
+  const running = this[kProcesses].running;
   this._debug(`stop definition execution (stop process executions ${running.length})`);
-  this[processesQSymbol].close();
-  this._deactivate();
-
+  this[kProcessesQ].close();
   for (const bp of running.slice()) bp.stop();
+  this._deactivate();
 
-  this[stoppedSymbol] = true;
-  return this.broker.publish('execution', `execution.stopped.${this.executionId}`, cloneContent(this[executeMessageSymbol].content, {
+  this[kStopped] = true;
+  return this.broker.publish('execution', `execution.stopped.${this.executionId}`, cloneContent(this[kExecuteMessage].content, {
     ...message.content,
   }), {type: 'stopped', persistent: false});
 };
@@ -477,7 +482,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   }
 
   if (delegate) {
-    for (const bp of this[processesSymbol].running.slice()) {
+    for (const bp of this[kProcesses].running.slice()) {
       bp.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
     }
   }
@@ -485,12 +490,12 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
   if (this.executionId !== message.content.executionId) return;
 
   if (messageType === 'stop') {
-    this[processesQSymbol].queueMessage({routingKey: 'execution.stop'}, cloneContent(message.content), {persistent: false});
+    this[kProcessesQ].queueMessage({routingKey: 'execution.stop'}, cloneContent(message.content), {persistent: false});
   }
 };
 
 proto._startProcessesByMessage = function startProcessesByMessage(reference) {
-  const {processes: bps, running} = this[processesSymbol];
+  const {processes: bps, running} = this[kProcesses];
   if (bps.length < 2) return;
 
   for (const bp of bps) {
@@ -542,7 +547,7 @@ proto._onMessageOutbound = function onMessageOutbound(routingKey, message) {
   targetProcess = targetProcess || this.context.getNewProcessById(target.processId);
 
   this._activateProcess(targetProcess);
-  this[processesSymbol].running.push(targetProcess);
+  this[kProcesses].running.push(targetProcess);
   targetProcess.init();
   targetProcess.run();
   targetProcess.sendMessage(message);
@@ -574,7 +579,7 @@ proto._onCallActivity = function onCallActivity(routingKey, message) {
   this._debug(`call from <${fromParent.id}.${fromId}> to <${calledElement}>`);
 
   this._activateProcess(targetProcess);
-  this[processesSymbol].running.push(targetProcess);
+  this[kProcesses].running.push(targetProcess);
   targetProcess.init(bpExecutionId);
   targetProcess.run({inbound: [cloneContent(content)]});
 };
@@ -619,7 +624,7 @@ proto._onDelegateMessage = function onDelegateMessage(routingKey, executeMessage
 };
 
 proto._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
-  const running = this[processesSymbol].running;
+  const running = this[kProcesses].running;
   const idx = running.findIndex((p) => p.executionId === processExecutionId);
   if (idx === -1) return;
   return running.splice(idx, 1)[0];
@@ -627,12 +632,12 @@ proto._removeProcessByExecutionId = function removeProcessByExecutionId(processE
 
 proto._complete = function complete(completionType, content, options) {
   this._deactivate();
-  const stateMessage = this[executeMessageSymbol];
+  const stateMessage = this[kExecuteMessage];
   this._debug(`definition execution ${completionType} in ${Date.now() - stateMessage.properties.timestamp}ms`);
   if (!content) content = this._createMessage();
-  this[completedSymbol] = true;
-  if (this.status !== 'terminated') this[statusSymbol] = completionType;
-  this.broker.deleteQueue(this[processesQSymbol].name);
+  this[kCompleted] = true;
+  this[kStatus] = completionType;
+  this.broker.deleteQueue(this[kProcessesQ].name);
 
   return this.broker.publish('execution', `execution.${completionType}.${this.executionId}`, {
     ...stateMessage.content,
@@ -642,19 +647,12 @@ proto._complete = function complete(completionType, content, options) {
   }, {type: completionType, mandatory: completionType === 'error', ...options});
 };
 
-proto.publishCompletionMessage = function publishCompletionMessage(completionType, content) {
-  this._deactivate();
-  this._debug(completionType);
-  if (!content) content = this._createMessage();
-  return this.broker.publish('execution', `execution.${completionType}.${this.executionId}`, content, { type: completionType });
-};
-
 proto._createMessage = function createMessage(content = {}) {
   return {
     id: this.id,
     type: this.type,
     executionId: this.executionId,
-    status: this.status,
+    status: this[kStatus],
     ...content,
   };
 };
@@ -684,5 +682,5 @@ proto._getProcessApiByExecutionId = function getProcessApiByExecutionId(parentEx
 };
 
 proto._debug = function debug(logMessage) {
-  this[parentSymbol].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
+  this[kParent].logger.debug(`<${this.executionId} (${this.id})> ${logMessage}`);
 };

package/src/eventDefinitions/CancelEventDefinition.js

@@ -1,9 +1,9 @@
 import {brokerSafeId} from '../shared';
 import {cloneContent, shiftParent} from '../messageHelper';
 
-const messageQSymbol = Symbol.for('cancelQ');
-const completedSymbol = Symbol.for('completed');
-const executeMessageSymbol = Symbol.for('executeMessage');
+const kMessageQ = Symbol.for('cancelQ');
+const kCompleted = Symbol.for('completed');
+const kExecuteMessage = Symbol.for('executeMessage');
 
 export default function CancelEventDefinition(activity, eventDefinition) {
   const {id, broker, environment, isThrowing} = activity;
@@ -19,9 +19,9 @@ export default function CancelEventDefinition(activity, eventDefinition) {
   this.logger = environment.Logger(type.toLowerCase());
 
   if (!isThrowing) {
-    this[completedSymbol] = false;
+    this[kCompleted] = false;
     const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-q`;
-    this[messageQSymbol] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
+    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
     broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true, priority: 400});
   }
 }
@@ -30,7 +30,7 @@ const proto = CancelEventDefinition.prototype;
 
 Object.defineProperty(proto, 'executionId', {
   get() {
-    const message = this[executeMessageSymbol];
+    const message = this[kExecuteMessage];
     return message && message.content.executionId;
   },
 });
@@ -40,8 +40,8 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.executeCatch = function executeCatch(executeMessage) {
-  this[executeMessageSymbol] = executeMessage;
-  this[completedSymbol] = false;
+  this[kExecuteMessage] = executeMessage;
+  this[kCompleted] = false;
 
   const executeContent = executeMessage.content;
   const {executionId, parent} = executeContent;
@@ -49,12 +49,12 @@ proto.executeCatch = function executeCatch(executeMessage) {
 
   const broker = this.broker;
   const onCatchMessage = this._onCatchMessage.bind(this);
-  this[messageQSymbol].consume(onCatchMessage, {
+  this[kMessageQ].consume(onCatchMessage, {
     noAck: true,
     consumerTag: `_oncancel-${executionId}`,
   });
 
-  if (this[completedSymbol]) return;
+  if (this[kCompleted]) return;
 
   const onApiMessage = this._onApiMessage.bind(this);
   broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
@@ -109,7 +109,7 @@ proto._onCatchMessage = function onCatchMessage(_, message) {
 
 proto._onCancelTransaction = function onCancelTransaction(_, message) {
   const broker = this.broker, executionId = this.executionId;
-  const executeContent = this[executeMessageSymbol].content;
+  const executeContent = this[kExecuteMessage].content;
   broker.cancel(`_oncancel-${executionId}`);
 
   this._debug(`cancel transaction thrown by <${message.content.id}>`);
@@ -133,10 +133,10 @@ proto._onCancelTransaction = function onCancelTransaction(_, message) {
 };
 
 proto._complete = function complete(output) {
-  this[completedSymbol] = true;
+  this[kCompleted] = true;
   this._stop();
   this._debug('completed');
-  const content = cloneContent(this[executeMessageSymbol].content, {
+  const content = cloneContent(this[kExecuteMessage].content, {
     output,
     state: 'cancel',
   });
@@ -146,9 +146,9 @@ proto._complete = function complete(output) {
 proto._onApiMessage = function onApiMessage(routingKey, message) {
   switch (message.properties.type) {
     case 'discard': {
-      this[completedSymbol] = true;
+      this[kCompleted] = true;
       this._stop();
-      const content = cloneContent(this[executeMessageSymbol].content);
+      const content = cloneContent(this[kExecuteMessage].content);
       return this.broker.publish('execution', 'execute.discard', content);
     }
     case 'stop': {
@@ -165,7 +165,7 @@ proto._stop = function stop() {
   broker.cancel(`_oncancel-${executionId}`);
   broker.cancel(`_oncancelend-${executionId}`);
   broker.cancel(`_onattached-cancel-${executionId}`);
-  this[messageQSymbol].purge();
+  this[kMessageQ].purge();
 };
 
 proto._debug = function debug(msg) {