bpmn-elements 6.0.1 → 7.0.0

package/dist/src/eventDefinitions/TimerEventDefinition.js

@@ -9,261 +9,276 @@ var _messageHelper = require("../messageHelper");
 
 var _iso8601Duration = require("iso8601-duration");
 
+const stoppedSymbol = Symbol.for('stopped');
+const timerContentSymbol = Symbol.for('timerContent');
+const timerSymbol = Symbol.for('timer');
+
 function TimerEventDefinition(activity, eventDefinition) {
-  const {
-    id,
-    broker,
-    environment
-  } = activity;
-  const {
-    type = 'TimerEventDefinition',
-    behaviour = {}
-  } = eventDefinition;
-  const logger = environment.Logger(type.toLowerCase());
+  const type = this.type = eventDefinition.type || 'TimerEventDefinition';
+  this.activity = activity;
+  const environment = this.environment = activity.environment;
+  this.eventDefinition = eventDefinition;
   const {
     timeDuration,
     timeCycle,
     timeDate
-  } = behaviour;
-  const foundTimers = { ...(timeDuration ? {
-      timeDuration
-    } : undefined),
-    ...(timeCycle ? {
-      timeCycle
-    } : undefined),
-    ...(timeDate ? {
-      timeDate
-    } : undefined)
-  };
-  let stopped = false;
-  let timerRef;
-  const source = {
-    type,
-    ...foundTimers,
-    execute,
+  } = eventDefinition.behaviour || {};
+  if (timeDuration) this.timeDuration = timeDuration;
+  if (timeCycle) this.timeCycle = timeCycle;
+  if (timeDate) this.timeDate = timeDate;
+  this.broker = activity.broker;
+  this.logger = environment.Logger(type.toLowerCase());
+  this[stoppedSymbol] = false;
+  this[timerSymbol] = null;
+}
+
+const proto = TimerEventDefinition.prototype;
+Object.defineProperty(proto, 'executionId', {
+  get() {
+    const content = this[timerContentSymbol];
+    return content && content.executionId;
+  }
 
-    stop() {
-      if (timerRef) timerRef = environment.timers.clearTimeout(timerRef);
-    }
+});
+Object.defineProperty(proto, 'stopped', {
+  enumerable: true,
 
-  };
-  Object.defineProperty(source, 'timer', {
-    get() {
-      return timerRef;
-    }
+  get() {
+    return this[stoppedSymbol];
+  }
+
+});
+Object.defineProperty(proto, 'timer', {
+  enumerable: true,
 
+  get() {
+    return this[timerSymbol];
+  }
+
+});
+
+proto.execute = function execute(executeMessage) {
+  const {
+    routingKey: executeKey,
+    redelivered: isResumed
+  } = executeMessage.fields;
+  const timer = this[timerSymbol];
+
+  if (timer && executeKey === 'execute.timer') {
+    return;
+  }
+
+  if (timer) this[timerSymbol] = this.environment.timers.clearTimeout(timer);
+  this[stoppedSymbol] = false;
+  const content = executeMessage.content;
+  const executionId = content.executionId;
+  const startedAt = this.startedAt = 'startedAt' in content ? new Date(content.startedAt) : new Date();
+
+  const resolvedTimer = this._getTimers(executeMessage);
+
+  const timerContent = this[timerContentSymbol] = (0, _messageHelper.cloneContent)(content, { ...resolvedTimer,
+    ...(isResumed ? {
+      isResumed
+    } : undefined),
+    startedAt,
+    state: 'timer'
+  });
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
+    priority: 400
   });
-  return source;
+  broker.subscribeTmp('api', '#.cancel.*', this._onDelegatedApiMessage.bind(this), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`
+  });
+  broker.publish('execution', 'execute.timer', (0, _messageHelper.cloneContent)(timerContent));
+  broker.publish('event', 'activity.timer', (0, _messageHelper.cloneContent)(timerContent));
+  if (this.stopped) return;
+  if (timerContent.timeout === undefined) return this._debug(`waiting for ${timerContent.timerType || 'signal'}`);
+  if (timerContent.timeout <= 0) return this._completed();
+  const timers = this.environment.timers.register(timerContent);
+  this[timerSymbol] = timers.setTimeout(this._completed.bind(this), timerContent.timeout, {
+    id: content.id,
+    type: this.type,
+    executionId,
+    state: 'timeout'
+  });
+};
 
-  function execute(executeMessage) {
-    const {
-      routingKey: executeKey,
-      redelivered: isResumed
-    } = executeMessage.fields;
-    const running = !!timerRef;
+proto.stop = function stopTimer() {
+  const timer = this[timerSymbol];
+  if (timer) this[timerSymbol] = this.environment.timers.clearTimeout(timer);
+};
 
-    if (running && executeKey === 'execute.timer') {
-      return;
-    }
+proto._completed = function completed(completeContent, options) {
+  this._stop();
 
-    if (timerRef) timerRef = environment.timers.clearTimeout(timerRef);
-    stopped = false;
-    const {
-      executionId
-    } = executeMessage.content;
-    const messageContent = executeMessage.content;
-    const startedAt = 'startedAt' in messageContent ? new Date(messageContent.startedAt) : new Date();
-    const resolvedTimer = getTimers(foundTimers, executeMessage);
-    const timerContent = (0, _messageHelper.cloneContent)(messageContent, { ...resolvedTimer,
-      ...(isResumed ? {
-        isResumed
-      } : undefined),
-      startedAt,
-      state: 'timer'
-    });
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: `_api-${executionId}`,
-      priority: 400
-    });
-    broker.subscribeTmp('api', '#.cancel.*', onDelegatedApiMessage, {
-      noAck: true,
-      consumerTag: `_api-delegated-${executionId}`
-    });
-    broker.publish('execution', 'execute.timer', timerContent);
-    broker.publish('event', 'activity.timer', (0, _messageHelper.cloneContent)(timerContent));
-    if (stopped) return;
-    if (timerContent.timeout === undefined) return logger.debug(`<${executionId} (${id})> waiting for ${timerContent.timerType || 'signal'}`);
-    if (timerContent.timeout <= 0) return completed();
-    const timers = environment.timers.register(timerContent);
-    timerRef = timers.setTimeout(completed, timerContent.timeout, (0, _messageHelper.cloneMessage)(executeMessage, timerContent));
-
-    function completed(completeContent, options) {
-      stop();
-      const stoppedAt = new Date();
-      const runningTime = stoppedAt.getTime() - startedAt.getTime();
-      logger.debug(`<${executionId} (${id})> completed in ${runningTime}ms`);
-      const completedContent = { ...timerContent,
-        stoppedAt,
-        runningTime,
-        state: 'timeout',
-        ...completeContent
-      };
-      broker.publish('event', 'activity.timeout', (0, _messageHelper.cloneContent)(messageContent, completedContent), options);
-      broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(messageContent, completedContent), options);
-    }
+  const stoppedAt = new Date();
+  const runningTime = stoppedAt.getTime() - this.startedAt.getTime();
 
-    function onDelegatedApiMessage(routingKey, message) {
-      if (!message.properties.delegate) return;
-      const {
-        content: delegateContent
-      } = message;
-      if (!delegateContent.message) return;
-      const {
-        id: signalId,
-        executionId: signalExecutionId
-      } = delegateContent.message;
-      if (signalId !== id && signalExecutionId !== executionId) return;
-      if (signalExecutionId && signalId === id && signalExecutionId !== executionId) return;
-      const {
-        type: messageType,
-        correlationId
-      } = message.properties;
-      broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(timerContent, {
-        message: { ...delegateContent.message
-        }
-      }), {
-        correlationId,
-        type: messageType
-      });
-      return onApiMessage(routingKey, message);
+  this._debug(`completed in ${runningTime}ms`);
+
+  const timerContent = this[timerContentSymbol];
+  const content = {
+    stoppedAt,
+    runningTime,
+    state: 'timeout',
+    ...completeContent
+  };
+  const broker = this.broker;
+  broker.publish('event', 'activity.timeout', (0, _messageHelper.cloneContent)(timerContent, content), options);
+  broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(timerContent, content), options);
+};
+
+proto._onDelegatedApiMessage = function onDelegatedApiMessage(routingKey, message) {
+  if (!message.properties.delegate) return;
+  const content = message.content;
+  if (!content.message) return;
+  const {
+    id: signalId,
+    executionId: signalExecutionId
+  } = content.message;
+  const executionId = this.executionId;
+  const id = this.activity.id;
+  if (signalId !== id && signalExecutionId !== executionId) return;
+  if (signalExecutionId && signalId === id && signalExecutionId !== executionId) return;
+  const {
+    type,
+    correlationId
+  } = message.properties;
+  this.broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(this[timerContentSymbol], {
+    message: { ...content.message
     }
+  }), {
+    correlationId,
+    type
+  });
+  return this._onApiMessage(routingKey, message);
+};
 
-    function onApiMessage(routingKey, message) {
-      const {
-        type: messageType,
-        correlationId
-      } = message.properties;
-
-      switch (messageType) {
-        case 'cancel':
-          {
-            stop();
-            return completed({
-              state: 'cancel',
-              ...(message.content.message ? {
-                message: message.content.message
-              } : undefined)
-            }, {
-              correlationId
-            });
-          }
-
-        case 'stop':
-          {
-            stop();
-            return logger.debug(`<${executionId} (${id})> stopped`);
-          }
-
-        case 'discard':
-          {
-            stop();
-            logger.debug(`<${executionId} (${id})> discarded`);
-            return broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(timerContent, {
-              state: 'discard'
-            }), {
-              correlationId
-            });
-          }
+proto._onApiMessage = function onApiMessage(routingKey, message) {
+  const {
+    type: messageType,
+    correlationId
+  } = message.properties;
+
+  switch (messageType) {
+    case 'cancel':
+      {
+        this._stop();
+
+        return this._completed({
+          state: 'cancel',
+          ...(message.content.message ? {
+            message: message.content.message
+          } : undefined)
+        }, {
+          correlationId
+        });
       }
-    }
 
-    function stop() {
-      stopped = true;
-      if (timerRef) timerRef = environment.timers.clearTimeout(timerRef);
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_api-delegated-${executionId}`);
-    }
-  }
+    case 'stop':
+      {
+        this._stop();
 
-  function getTimers(timers, executionMessage) {
-    const content = executionMessage.content;
-    let expireAt;
+        return this._debug('stopped');
+      }
 
-    if ('expireAt' in content) {
-      expireAt = new Date(content.expireAt);
-    }
+    case 'discard':
+      {
+        this._stop();
 
-    const now = Date.now();
-    const timerContent = ['timeDuration', 'timeDate', 'timeCycle'].reduce((result, t) => {
-      if (t in content) result[t] = content[t];else if (t in timers) result[t] = environment.resolveExpression(timers[t], executionMessage);else return result;
-      let expireAtDate;
-
-      switch (t) {
-        case 'timeDuration':
-          {
-            const durationStr = result[t];
-
-            if (durationStr) {
-              const delay = getDurationInMilliseconds(durationStr);
-              if (delay !== undefined) expireAtDate = new Date(now + delay);
-            } else {
-              expireAtDate = new Date(now);
-            }
-
-            break;
-          }
-
-        case 'timeDate':
-          {
-            const dateStr = result[t];
-
-            if (dateStr) {
-              const ms = Date.parse(dateStr);
-
-              if (isNaN(ms)) {
-                logger.warn(`<${content.executionId} (${id})> invalid timeDate >${dateStr}<`);
-                break;
-              }
-
-              expireAtDate = new Date(ms);
-            } else {
-              expireAtDate = new Date(now);
-            }
-
-            break;
-          }
+        this._debug('discarded');
+
+        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[timerContentSymbol], {
+          state: 'discard'
+        }), {
+          correlationId
+        });
       }
+  }
+};
+
+proto._stop = function stop() {
+  this[stoppedSymbol] = true;
+  const timer = this[timerSymbol];
+  if (timer) this[timerSymbol] = this.environment.timers.clearTimeout(timer);
+  const broker = this.broker;
+  broker.cancel(`_api-${this.executionId}`);
+  broker.cancel(`_api-delegated-${this.executionId}`);
+};
+
+proto._getTimers = function getTimers(executeMessage) {
+  const content = executeMessage.content;
+  const now = Date.now();
+  const result = { ...('expireAt' in content ? {
+      expireAt: new Date(content.expireAt)
+    } : undefined)
+  };
+
+  for (const t of ['timeDuration', 'timeDate', 'timeCycle']) {
+    if (t in content) result[t] = content[t];else if (t in this) result[t] = this.environment.resolveExpression(this[t], executeMessage);else continue;
+    let expireAtDate;
+
+    if (t === 'timeDuration') {
+      const durationStr = result[t];
 
-      if (!expireAtDate) return result;
+      if (durationStr) {
+        const delay = this._getDurationInMilliseconds(durationStr);
 
-      if (!('expireAt' in result) || result.expireAt > expireAtDate) {
-        result.timerType = t;
-        result.expireAt = expireAtDate;
+        if (delay !== undefined) expireAtDate = new Date(now + delay);
+      } else {
+        expireAtDate = new Date(now);
       }
+    } else if (t === 'timeDate') {
+      const dateStr = result[t];
 
-      return result;
-    }, { ...(expireAt ? {
-        expireAt
-      } : undefined)
-    });
-
-    if ('expireAt' in timerContent) {
-      timerContent.timeout = timerContent.expireAt - now;
-    } else if ('timeout' in content) {
-      timerContent.timeout = content.timeout;
-    } else if (!Object.keys(timerContent).length) {
-      timerContent.timeout = 0;
+      if (dateStr) {
+        const ms = Date.parse(dateStr);
+
+        if (!isNaN(ms)) {
+          expireAtDate = new Date(ms);
+        } else {
+          this._warn(`invalid timeDate >${dateStr}<`);
+        }
+      } else {
+        expireAtDate = new Date(now);
+      }
     }
 
-    return timerContent;
+    if (!expireAtDate) continue;
 
-    function getDurationInMilliseconds(duration) {
-      try {
-        return (0, _iso8601Duration.toSeconds)((0, _iso8601Duration.parse)(duration)) * 1000;
-      } catch (err) {
-        logger.warn(`<${content.executionId} (${id})> failed to parse timeDuration >${duration}<: ${err.message}`);
-      }
+    if (!('expireAt' in result) || result.expireAt > expireAtDate) {
+      result.timerType = t;
+      result.expireAt = expireAtDate;
     }
   }
-}
+
+  if ('expireAt' in result) {
+    result.timeout = result.expireAt - now;
+  } else if ('timeout' in content) {
+    result.timeout = content.timeout;
+  } else if (!Object.keys(result).length) {
+    result.timeout = 0;
+  }
+
+  return result;
+};
+
+proto._getDurationInMilliseconds = function getDurationInMilliseconds(duration) {
+  try {
+    return (0, _iso8601Duration.toSeconds)((0, _iso8601Duration.parse)(duration)) * 1000;
+  } catch (err) {
+    this._warn(`failed to parse timeDuration >${duration}<: ${err.message}`);
+  }
+};
+
+proto._debug = function debug(msg) {
+  this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};
+
+proto._warn = function debug(msg) {
+  this.logger.warn(`<${this.executionId} (${this.activity.id})> ${msg}`);
+};