bpmn-elements 13.1.2 → 14.0.0

package/src/eventDefinitions/MessageEventDefinition.js

@@ -1,6 +1,6 @@
 import getPropertyValue from '../getPropertyValue.js';
-import {brokerSafeId} from '../shared.js';
-import {cloneContent, shiftParent} from '../messageHelper.js';
+import { brokerSafeId } from '../shared.js';
+import { cloneContent, shiftParent } from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kMessageQ = Symbol.for('messageQ');
@@ -9,30 +9,30 @@ const kReferenceElement = Symbol.for('referenceElement');
 const kReferenceInfo = Symbol.for('referenceInfo');
 
 export default function MessageEventDefinition(activity, eventDefinition) {
-  const {id, broker, environment, isThrowing} = activity;
-  const {type = 'MessageEventDefinition', behaviour = {}} = eventDefinition;
+  const { id, broker, environment, isThrowing } = activity;
+  const { type = 'MessageEventDefinition', behaviour = {} } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = this.reference = {
+  const reference = (this.reference = {
     name: 'anonymous',
     ...behaviour.messageRef,
     referenceType: 'message',
-  };
+  });
 
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  const referenceElement = this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+  const referenceElement = (this[kReferenceElement] = reference.id && activity.getActivityById(reference.id));
   if (!isThrowing) {
     this[kCompleted] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
     const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true});
+    this[kMessageQ] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, { durable: true });
   }
 }
 
@@ -52,10 +52,10 @@ MessageEventDefinition.prototype.executeCatch = function executeCatch(executeMes
   this[kCompleted] = false;
 
   const executeContent = executeMessage.content;
-  const {executionId, parent} = executeContent;
+  const { executionId, parent } = executeContent;
   const parentExecutionId = parent && parent.executionId;
 
-  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
+  const info = (this[kReferenceInfo] = this._getReferenceInfo(executeMessage));
   this._debug(`expect ${info.description}`);
 
   const broker = this.broker;
@@ -85,7 +85,7 @@ MessageEventDefinition.prototype.executeCatch = function executeCatch(executeMes
 
   const waitContent = cloneContent(executeContent, {
     executionId: parentExecutionId,
-    message: {...info.message},
+    message: { ...info.message },
   });
   waitContent.parent = shiftParent(parent);
 
@@ -94,7 +94,7 @@ MessageEventDefinition.prototype.executeCatch = function executeCatch(executeMes
 
 MessageEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
-  const {executionId, parent} = executeContent;
+  const { executionId, parent } = executeContent;
   const info = this._getReferenceInfo(executeMessage);
 
   this.logger.debug(`<${executionId} (${this.activity.id})> message ${info.description}`);
@@ -102,12 +102,12 @@ MessageEventDefinition.prototype.executeThrow = function executeThrow(executeMes
   const broker = this.broker;
   const throwContent = cloneContent(executeContent, {
     executionId: parent.executionId,
-    message: {...executeContent.input, ...info.message},
+    message: { ...executeContent.input, ...info.message },
     state: 'throw',
   });
   throwContent.parent = shiftParent(parent);
 
-  broker.publish('event', 'activity.message', throwContent, {type: 'message', delegate: true});
+  broker.publish('event', 'activity.message', throwContent, { type: 'message', delegate: true });
 
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
@@ -115,28 +115,33 @@ MessageEventDefinition.prototype.executeThrow = function executeThrow(executeMes
 MessageEventDefinition.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
   if (getPropertyValue(message, 'content.message.id') !== this[kReferenceInfo].message.id) return;
 
-  const {type, correlationId} = message.properties;
-  this.broker.publish('event', 'activity.consumed', cloneContent(this[kExecuteMessage].content, {
-    message: {...message.content.message},
-  }), {
-    correlationId,
-    type,
-  });
-
-  this._complete('caught', message.content.message, {correlationId});
+  const { type, correlationId } = message.properties;
+  this.broker.publish(
+    'event',
+    'activity.consumed',
+    cloneContent(this[kExecuteMessage].content, {
+      message: { ...message.content.message },
+    }),
+    {
+      correlationId,
+      type,
+    },
+  );
+
+  this._complete('caught', message.content.message, { correlationId });
 };
 
 MessageEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const {type, correlationId} = message.properties;
+  const { type, correlationId } = message.properties;
   switch (type) {
     case 'message':
     case 'signal': {
-      return this._complete('got signal with', message.content.message, {correlationId});
+      return this._complete('got signal with', message.content.message, { correlationId });
     }
     case 'discard': {
       this[kCompleted] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), { correlationId });
     }
     case 'stop': {
       return this._stop();
@@ -153,21 +158,27 @@ MessageEventDefinition.prototype._complete = function complete(verb, output, opt
   const broker = this.broker;
   const executeContent = this[kExecuteMessage].content;
   const catchContent = cloneContent(executeContent, {
-    message: {...output},
+    message: { ...output },
     executionId: executeContent.parent.executionId,
   });
   catchContent.parent = shiftParent(executeContent.parent);
 
-  broker.publish('event', 'activity.catch', catchContent, {type: 'catch'});
-
-  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {
-    output,
-    state: 'catch',
-  }), options);
+  broker.publish('event', 'activity.catch', catchContent, { type: 'catch' });
+
+  return broker.publish(
+    'execution',
+    'execute.completed',
+    cloneContent(executeContent, {
+      output,
+      state: 'catch',
+    }),
+    options,
+  );
 };
 
 MessageEventDefinition.prototype._stop = function stop() {
-  const broker = this.broker, executionId = this.executionId;
+  const broker = this.broker,
+    executionId = this.executionId;
   broker.cancel(`_api-message-${executionId}`);
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-parent-${executionId}`);
@@ -179,7 +190,7 @@ MessageEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(m
   const referenceElement = this[kReferenceElement];
   if (!referenceElement) {
     return {
-      message: {...this.reference},
+      message: { ...this.reference },
       description: 'anonymous message',
     };
   }

package/src/eventDefinitions/SignalEventDefinition.js

@@ -1,6 +1,6 @@
 import getPropertyValue from '../getPropertyValue.js';
-import {brokerSafeId} from '../shared.js';
-import {cloneContent, shiftParent} from '../messageHelper.js';
+import { brokerSafeId } from '../shared.js';
+import { cloneContent, shiftParent } from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kMessageQ = Symbol.for('messageQ');
@@ -9,30 +9,30 @@ const kReferenceElement = Symbol.for('referenceElement');
 const kReferenceInfo = Symbol.for('referenceInfo');
 
 export default function SignalEventDefinition(activity, eventDefinition) {
-  const {id, broker, environment, isStart, isThrowing} = activity;
-  const {type, behaviour = {}} = eventDefinition;
+  const { id, broker, environment, isStart, isThrowing } = activity;
+  const { type, behaviour = {} } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = this.reference = {
+  const reference = (this.reference = {
     name: 'anonymous',
     ...behaviour.signalRef,
     referenceType: 'signal',
-  };
+  });
 
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  const referenceElement = this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+  const referenceElement = (this[kReferenceElement] = reference.id && activity.getActivityById(reference.id));
   if (!isThrowing && isStart) {
     this[kCompleted] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
     const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, {autoDelete: false, durable: true});
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {durable: true});
+    this[kMessageQ] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
+    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, { durable: true });
   }
 }
 
@@ -52,10 +52,10 @@ SignalEventDefinition.prototype.executeCatch = function executeCatch(executeMess
   this[kCompleted] = false;
 
   const executeContent = executeMessage.content;
-  const {executionId, parent} = executeContent;
+  const { executionId, parent } = executeContent;
   const parentExecutionId = parent && parent.executionId;
 
-  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
+  const info = (this[kReferenceInfo] = this._getReferenceInfo(executeMessage));
   const broker = this.broker;
 
   const onCatchMessage = this._onCatchMessage.bind(this);
@@ -85,7 +85,7 @@ SignalEventDefinition.prototype.executeCatch = function executeCatch(executeMess
 
   const waitContent = cloneContent(executeContent, {
     executionId: parent.executionId,
-    signal: {...info.message},
+    signal: { ...info.message },
   });
   waitContent.parent = shiftParent(parent);
 
@@ -94,7 +94,7 @@ SignalEventDefinition.prototype.executeCatch = function executeCatch(executeMess
 
 SignalEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
-  const {executionId, parent} = executeContent;
+  const { executionId, parent } = executeContent;
 
   const info = this._getReferenceInfo(executeMessage);
 
@@ -102,13 +102,13 @@ SignalEventDefinition.prototype.executeThrow = function executeThrow(executeMess
 
   const throwContent = cloneContent(executeContent, {
     executionId: parent.executionId,
-    message: {...executeContent.input, ...info.message},
+    message: { ...executeContent.input, ...info.message },
     state: 'throw',
   });
   throwContent.parent = shiftParent(parent);
 
   const broker = this.broker;
-  broker.publish('event', 'activity.signal', throwContent, {type: 'signal'});
+  broker.publish('event', 'activity.signal', throwContent, { type: 'signal' });
 
   return broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };
@@ -119,28 +119,33 @@ SignalEventDefinition.prototype._onCatchMessage = function onCatchMessage(routin
   this[kCompleted] = true;
   this._stop();
 
-  const {type, correlationId} = message.properties;
-  this.broker.publish('event', 'activity.consumed', cloneContent(this[kExecuteMessage].content, {
-    message: { ...message.content.message},
-  }), {
-    correlationId,
-    type,
-  });
+  const { type, correlationId } = message.properties;
+  this.broker.publish(
+    'event',
+    'activity.consumed',
+    cloneContent(this[kExecuteMessage].content, {
+      message: { ...message.content.message },
+    }),
+    {
+      correlationId,
+      type,
+    },
+  );
 
   return this._complete(message.content.message, message.properties);
 };
 
 SignalEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const {type, correlationId} = message.properties;
+  const { type, correlationId } = message.properties;
 
   switch (type) {
     case 'signal': {
-      return this._complete(message.content.message, {correlationId});
+      return this._complete(message.content.message, { correlationId });
     }
     case 'discard': {
       this[kCompleted] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), { correlationId });
     }
     case 'stop': {
       this._stop();
@@ -153,14 +158,20 @@ SignalEventDefinition.prototype._complete = function complete(output, options) {
   this[kCompleted] = true;
   this._stop();
   this._debug(`signaled with ${this[kReferenceInfo].description}`);
-  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, {
-    output,
-    state: 'signal',
-  }), options);
+  return this.broker.publish(
+    'execution',
+    'execute.completed',
+    cloneContent(this[kExecuteMessage].content, {
+      output,
+      state: 'signal',
+    }),
+    options,
+  );
 };
 
 SignalEventDefinition.prototype._stop = function stop() {
-  const broker = this.broker, executionId = this.executionId;
+  const broker = this.broker,
+    executionId = this.executionId;
   broker.cancel(`_api-signal-${executionId}`);
   broker.cancel(`_api-parent-${executionId}`);
   broker.cancel(`_api-${executionId}`);
@@ -172,7 +183,7 @@ SignalEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(me
   const referenceElement = this[kReferenceElement];
   if (!referenceElement) {
     return {
-      message: {...this.reference},
+      message: { ...this.reference },
       description: 'anonymous signal',
     };
   }

package/src/eventDefinitions/TerminateEventDefinition.js

@@ -1,8 +1,8 @@
-import {cloneContent, shiftParent} from '../messageHelper.js';
+import { cloneContent, shiftParent } from '../messageHelper.js';
 
 export default function TerminateEventDefinition(activity, eventDefinition) {
-  const {id, broker, environment} = activity;
-  const {type = 'TerminateEventDefinition'} = eventDefinition;
+  const { id, broker, environment } = activity;
+  const { type = 'TerminateEventDefinition' } = eventDefinition;
 
   this.id = id;
   this.type = type;
@@ -21,6 +21,6 @@ TerminateEventDefinition.prototype.execute = function execute(executeMessage) {
 
   this.logger.debug(`<${executeContent.executionId} (${executeContent.id})> terminate`);
   const broker = this.broker;
-  broker.publish('event', 'process.terminate', throwContent, {type: 'terminate'});
+  broker.publish('event', 'process.terminate', throwContent, { type: 'terminate' });
   broker.publish('execution', 'execute.completed', cloneContent(executeContent));
 };

package/src/eventDefinitions/TimerEventDefinition.js

@@ -1,17 +1,19 @@
-import {cloneContent} from '../messageHelper.js';
-import {toSeconds, parse as parseIsoDuration} from '../iso-duration.js';
+import { cloneContent } from '../messageHelper.js';
+import { ISOInterval, getDate } from '@0dep/piso';
 
 const kStopped = Symbol.for('stopped');
 const kTimerContent = Symbol.for('timerContent');
 const kTimer = Symbol.for('timer');
 
+const timerTypes = ['timeDuration', 'timeDate', 'timeCycle'];
+
 export default function TimerEventDefinition(activity, eventDefinition) {
-  const type = this.type = eventDefinition.type || 'TimerEventDefinition';
+  const type = (this.type = eventDefinition.type || 'TimerEventDefinition');
   this.activity = activity;
-  const environment = this.environment = activity.environment;
+  const environment = (this.environment = activity.environment);
   this.eventDefinition = eventDefinition;
 
-  const {timeDuration, timeCycle, timeDate} = eventDefinition.behaviour || {};
+  const { timeDuration, timeCycle, timeDate } = eventDefinition.behaviour || {};
   if (timeDuration) this.timeDuration = timeDuration;
   if (timeCycle) this.timeCycle = timeCycle;
   if (timeDate) this.timeDate = timeDate;
@@ -43,7 +45,7 @@ Object.defineProperties(TimerEventDefinition.prototype, {
 });
 
 TimerEventDefinition.prototype.execute = function execute(executeMessage) {
-  const {routingKey: executeKey, redelivered: isResumed} = executeMessage.fields;
+  const { routingKey: executeKey, redelivered: isResumed } = executeMessage.fields;
   const timer = this[kTimer];
   if (timer && executeKey === 'execute.timer') {
     return;
@@ -54,23 +56,25 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
 
   const content = executeMessage.content;
   const executionId = content.executionId;
-  const startedAt = this.startedAt = 'startedAt' in content ? new Date(content.startedAt) : new Date();
+  const startedAt = (this.startedAt = 'startedAt' in content ? new Date(content.startedAt) : new Date());
 
   const resolvedTimer = this._getTimers(executeMessage);
-  const timerContent = this[kTimerContent] = cloneContent(content, {
+  const timerContent = (this[kTimerContent] = cloneContent(content, {
     ...resolvedTimer,
-    ...(isResumed && {isResumed}),
+    ...(isResumed && { isResumed }),
     startedAt,
     state: 'timer',
-  });
+  }));
 
   const broker = this.broker;
   broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
-    noAck: true, consumerTag: `_api-${executionId}`,
+    noAck: true,
+    consumerTag: `_api-${executionId}`,
     priority: 400,
   });
   broker.subscribeTmp('api', '#.cancel.*', this._onDelegatedApiMessage.bind(this), {
-    noAck: true, consumerTag: `_api-delegated-${executionId}`,
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`,
   });
 
   broker.publish('execution', 'execute.timer', cloneContent(timerContent));
@@ -78,7 +82,6 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
 
   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);
@@ -106,14 +109,14 @@ TimerEventDefinition.prototype._completed = function completed(completeContent,
   this._debug(`completed in ${runningTime}ms`);
 
   const timerContent = this[kTimerContent];
-  const content = {stoppedAt, runningTime, state: 'timeout', ...completeContent};
+  const content = { stoppedAt, runningTime, state: 'timeout', ...completeContent };
 
   const broker = this.broker;
   broker.publish('event', 'activity.timeout', cloneContent(timerContent, content), options);
 
   if (timerContent.repeat > 1) {
     const repeat = timerContent.repeat - 1;
-    broker.publish('execution', 'execute.repeat', cloneContent(timerContent, {...content, repeat}), options);
+    broker.publish('execution', 'execute.repeat', cloneContent(timerContent, { ...content, repeat }), options);
   }
 
   broker.publish('execution', 'execute.completed', cloneContent(timerContent, content), options);
@@ -125,33 +128,41 @@ TimerEventDefinition.prototype._onDelegatedApiMessage = function onDelegatedApiM
   const content = message.content;
   if (!content.message) return;
 
-  const {id: signalId, executionId: signalExecutionId} = content.message;
+  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', cloneContent(this[kTimerContent], {
-    message: {
-      ...content.message,
-    },
-  }), {correlationId, type});
+  const { type, correlationId } = message.properties;
+  this.broker.publish(
+    'event',
+    'activity.consumed',
+    cloneContent(this[kTimerContent], {
+      message: {
+        ...content.message,
+      },
+    }),
+    { correlationId, type },
+  );
 
   return this._onApiMessage(routingKey, message);
 };
 
 TimerEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const {type: messageType, correlationId} = message.properties;
+  const { type: messageType, correlationId } = message.properties;
 
   switch (messageType) {
     case 'cancel': {
       this._stop();
-      return this._completed({
-        state: 'cancel',
-        ...(message.content.message && {message: message.content.message}),
-      }, {correlationId});
+      return this._completed(
+        {
+          state: 'cancel',
+          ...(message.content.message && { message: message.content.message }),
+        },
+        { correlationId },
+      );
     }
     case 'stop': {
       this._stop();
@@ -160,7 +171,9 @@ TimerEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey,
     case 'discard': {
       this._stop();
       this._debug('discarded');
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kTimerContent], {state: 'discard'}), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kTimerContent], { state: 'discard' }), {
+        correlationId,
+      });
     }
   }
 };
@@ -176,23 +189,19 @@ TimerEventDefinition.prototype._stop = function stop() {
 
 TimerEventDefinition.prototype.parse = function parse(timerType, value) {
   let repeat, delay, expireAt;
+  const now = new Date();
   switch (timerType) {
     case 'timeCycle':
     case 'timeDuration': {
-      const parsed = parseIsoDuration(value);
+      const parsed = new ISOInterval(value).parse();
       if (parsed.repeat) repeat = parsed.repeat;
-      delay = toSeconds(parsed) * 1000;
-      expireAt = new Date(Date.now() + delay);
+      expireAt = parsed.getExpireAt(now, now);
+      delay = expireAt.getTime() - now.getTime();
       break;
     }
     case 'timeDate': {
-      const ms = Date.parse(value);
-      if (!isNaN(ms)) {
-        expireAt = new Date(ms);
-        delay = Date.now() - expireAt;
-      } else {
-        throw new TypeError(`invalid timeDate >${value}<`);
-      }
+      expireAt = getDate(value);
+      delay = now.getTime() - expireAt;
       break;
     }
   }
@@ -208,32 +217,26 @@ TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
   const content = executeMessage.content;
 
   const result = {
-    ...('expireAt' in content && {expireAt: new Date(content.expireAt)}),
+    ...('expireAt' in content && { expireAt: new Date(content.expireAt) }),
   };
 
-  let parseErr;
-  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);
+  for (const timerType of timerTypes) {
+    if (timerType in content) result[timerType] = content[timerType];
+    else if (timerType in this) result[timerType] = this.environment.resolveExpression(this[timerType], executeMessage);
     else continue;
 
     let expireAtDate, repeat;
-    const timerStr = result[t];
+    const timerStr = result[timerType];
     if (timerStr) {
-      try {
-        const {repeat: parsedRepeat, expireAt: parsedExpireAt} = this.parse(t, timerStr);
-        repeat = parsedRepeat;
-        expireAtDate = parsedExpireAt;
-      } catch (err) {
-        parseErr = err;
-      }
+      const { repeat: parsedRepeat, expireAt: parsedExpireAt } = this.parse(timerType, timerStr);
+      repeat = parsedRepeat;
+      expireAtDate = parsedExpireAt;
     } else {
       expireAtDate = new Date();
     }
 
-    if (!expireAtDate) continue;
     if (!('expireAt' in result) || result.expireAt > expireAtDate) {
-      result.timerType = t;
+      result.timerType = timerType;
       result.expireAt = expireAtDate;
       result.repeat = repeat;
     }
@@ -247,10 +250,6 @@ TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
     result.timeout = 0;
   }
 
-  if (!('timeout' in result) && parseErr) {
-    this.logger.warn(`<${this.activity.id}> failed to parse timer: ${parseErr.message}`);
-  }
-
   if (content.inbound && 'repeat' in content.inbound[0]) {
     result.repeat = content.inbound[0].repeat;
   }