bpmn-elements 6.0.0 → 8.0.0

package/src/eventDefinitions/TimerEventDefinition.js

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