bpmn-elements 8.0.1 → 8.2.0

package/src/eventDefinitions/TimerEventDefinition.js

@@ -4,6 +4,7 @@ import {toSeconds, parse} from 'iso8601-duration';
 const kStopped = Symbol.for('stopped');
 const kTimerContent = Symbol.for('timerContent');
 const kTimer = Symbol.for('timer');
+const repeatPattern = /^\s*R(\d+)\//;
 
 export default function TimerEventDefinition(activity, eventDefinition) {
   const type = this.type = eventDefinition.type || 'TimerEventDefinition';
@@ -63,7 +64,7 @@ proto.execute = function execute(executeMessage) {
   const resolvedTimer = this._getTimers(executeMessage);
   const timerContent = this[kTimerContent] = cloneContent(content, {
     ...resolvedTimer,
-    ...(isResumed ? {isResumed} : undefined),
+    ...(isResumed && {isResumed}),
     startedAt,
     state: 'timer',
   });
@@ -112,6 +113,12 @@ proto._completed = function completed(completeContent, options) {
 
   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.completed', cloneContent(timerContent, content), options);
 };
 
@@ -146,7 +153,7 @@ proto._onApiMessage = function onApiMessage(routingKey, message) {
       this._stop();
       return this._completed({
         state: 'cancel',
-        ...(message.content.message ? {message: message.content.message} : undefined),
+        ...(message.content.message && {message: message.content.message}),
       }, {correlationId});
     }
     case 'stop': {
@@ -175,7 +182,7 @@ proto._getTimers = function getTimers(executeMessage) {
 
   const now = Date.now();
   const result = {
-    ...('expireAt' in content ? {expireAt: new Date(content.expireAt)} : undefined),
+    ...('expireAt' in content && {expireAt: new Date(content.expireAt)}),
   };
 
   for (const t of ['timeDuration', 'timeDate', 'timeCycle']) {
@@ -183,33 +190,39 @@ proto._getTimers = function getTimers(executeMessage) {
     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);
-      }
-    } 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}<`);
+    let expireAtDate, repeat;
+    const timerStr = result[t];
+    if (timerStr) {
+      switch (t) {
+        case 'timeCycle': {
+          const mRepeat = timerStr.match(repeatPattern);
+          if (mRepeat && mRepeat.length) repeat = parseInt(mRepeat[1]);
+        }
+        case 'timeDuration': {
+          const delay = this._getDurationInMilliseconds(timerStr);
+          if (delay !== undefined) expireAtDate = new Date(now + delay);
+          break;
+        }
+        case 'timeDate': {
+          const dateStr = result[t];
+          const ms = Date.parse(dateStr);
+          if (!isNaN(ms)) {
+            expireAtDate = new Date(ms);
+          } else {
+            this._warn(`invalid timeDate >${dateStr}<`);
+          }
+          break;
         }
-      } else {
-        expireAtDate = new Date(now);
       }
+    } else {
+      expireAtDate = new Date(now);
     }
 
     if (!expireAtDate) continue;
     if (!('expireAt' in result) || result.expireAt > expireAtDate) {
       result.timerType = t;
       result.expireAt = expireAtDate;
+      if (repeat) result.repeat = repeat;
     }
   }
 
@@ -221,6 +234,10 @@ proto._getTimers = function getTimers(executeMessage) {
     result.timeout = 0;
   }
 
+  if (content.inbound && 'repeat' in content.inbound[0]) {
+    result.repeat = content.inbound[0].repeat;
+  }
+
   return result;
 };
 
@@ -228,7 +245,7 @@ proto._getDurationInMilliseconds = function getDurationInMilliseconds(duration)
   try {
     return toSeconds(parse(duration)) * 1000;
   } catch (err) {
-    this._warn(`failed to parse timeDuration >${duration}<: ${err.message}`);
+    this._warn(`failed to parse ${this.timerType} >${duration}<: ${err.message}`);
   }
 };
 

package/src/events/BoundaryEvent.js

@@ -50,13 +50,6 @@ proto.execute = function execute(executeMessage) {
     this[kExecuteMessage] = executeMessage;
 
     const broker = this.broker;
-    if (eventDefinitionExecution && !this.environment.settings.strict) {
-      broker.subscribeTmp('execution', 'execute.expect', this._onExpectMessage.bind(this), {
-        noAck: true,
-        consumerTag: '_expect-tag',
-      });
-    }
-
     const consumerTag = `_bound-listener-${executionId}`;
     this.attachedTo.broker.subscribeTmp('event', 'activity.leave', this._onAttachedLeave.bind(this), {
       noAck: true,
@@ -65,15 +58,19 @@ proto.execute = function execute(executeMessage) {
     });
     this[kAttachedTags].push(consumerTag);
 
-    broker.subscribeOnce('execution', 'execute.detach', this._onDetachMessage.bind(this), {
-      consumerTag: '_detach-tag',
-    });
     broker.subscribeOnce('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
       consumerTag: `_api-${executionId}`,
     });
-    broker.subscribeOnce('execution', 'execute.bound.completed', this._onCompleted.bind(this), {
-      consumerTag: `_execution-completed-${executionId}`,
-    });
+
+    const execQ = broker.assertQueue(`_bound-execution-${executionId}`, {durable: false, autoDelete: true});
+    broker.bindQueue(execQ.name, 'execution', 'execute.detach');
+    broker.bindQueue(execQ.name, 'execution', 'execute.bound.completed');
+    broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+    if (eventDefinitionExecution && !this.environment.settings.strict) {
+      broker.bindQueue(execQ.name, 'execution', 'execute.expect');
+    }
+
+    execQ.consume(this._onExecutionMessage.bind(this), {consumerTag: '_execution-tag'});
   }
 
   if (eventDefinitionExecution) {
@@ -81,15 +78,29 @@ proto.execute = function execute(executeMessage) {
   }
 };
 
+proto._onExecutionMessage = function onExecutionMessage(routingKey, message) {
+  message.ack();
+  switch (routingKey) {
+    case 'execute.detach':
+      return this._onDetachMessage(routingKey, message);
+    case 'execute.bound.completed':
+      return this._onCompleted(routingKey, message);
+    case 'execute.repeat':
+      return this._onRepeatMessage(routingKey, message);
+    case 'execute.expect':
+      return this._onExpectMessage(routingKey, message);
+  }
+};
+
 proto._onCompleted = function onCompleted(_, {content}) {
   if (!this.cancelActivity && !content.cancelActivity) {
     this._stop();
-    return this.broker.publish('execution', 'execute.completed', cloneContent(content));
+    return this.broker.publish('execution', 'execute.completed', cloneContent(content, {cancelActivity: false}));
   }
 
   this[kCompleteContent] = content;
 
-  const {inbound} = this[kExecuteMessage].content;
+  const inbound = this[kExecuteMessage].content.inbound;
   const attachedToContent = inbound && inbound[0];
   const attachedTo = this.attachedTo;
   this.activity.logger.debug(`<${this.executionId} (${this.id})> cancel ${attachedTo.status} activity <${attachedToContent.executionId} (${attachedToContent.id})>`);
@@ -160,13 +171,19 @@ proto._onApiMessage = function onApiMessage(_, message) {
   }
 };
 
+proto._onRepeatMessage = function onRepeatMessage(_, message) {
+  if (this.cancelActivity) return;
+  const executeMessage = this[kExecuteMessage];
+  const repeat = message.content.repeat;
+  this.broker.getQueue('inbound-q').queueMessage({routingKey: 'activity.restart'}, cloneContent(executeMessage.content.inbound[0], {repeat}));
+};
+
 proto._stop = function stop(detach) {
   const attachedTo = this.attachedTo, broker = this.broker, executionId = this.executionId;
   for (const tag of this[kAttachedTags].splice(0)) attachedTo.broker.cancel(tag);
   for (const shovelName of this[kShovels].splice(0)) attachedTo.broker.closeShovel(shovelName);
 
-  broker.cancel('_expect-tag');
-  broker.cancel('_detach-tag');
+  broker.cancel('_execution-tag');
   broker.cancel(`_execution-completed-${executionId}`);
 
   if (detach) return;

package/src/io/BpmnIO.js

@@ -1,6 +1,7 @@
 export default function BpmnIO(activity, context) {
   this.activity = activity;
   this.context = context;
+  this.type = 'bpmnio';
 
   const {
     ioSpecification: ioSpecificationDef,
@@ -11,6 +12,12 @@ export default function BpmnIO(activity, context) {
   this.properties = propertiesDef && new propertiesDef.Behaviour(activity, propertiesDef, context);
 }
 
+Object.defineProperty(BpmnIO.prototype, 'hasIo', {
+  get() {
+    return this.specification || this.properties;
+  },
+});
+
 BpmnIO.prototype.activate = function activate(message) {
   const properties = this.properties, specification = this.specification;
   if (properties) properties.activate(message);

package/src/io/EnvironmentDataObject.js

@@ -9,6 +9,7 @@ export default function EnvironmentDataObject(dataObjectDef, {environment}) {
 }
 
 EnvironmentDataObject.prototype.read = function read(broker, exchange, routingKeyPrefix, messageProperties) {
+
   const environment = this.environment;
   const value = environment.variables._data && environment.variables._data[this.id];
   const content = this._createContent(value);

package/src/io/InputOutputSpecification.js

@@ -15,8 +15,14 @@ export default function IoSpecification(activity, ioSpecificationDef, context) {
 
 const proto = IoSpecification.prototype;
 
-proto.activate = function activate() {
+proto.activate = function activate(message) {
   if (this[kConsuming]) return;
+  if (message && message.fields.redelivered && message.fields.routingKey === 'run.start') {
+    this._onFormatEnter();
+  }
+  if (message && message.fields.redelivered && message.fields.routingKey === 'run.end') {
+    this._onFormatComplete(message);
+  }
   this[kConsuming] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {noAck: true});
 };
 
@@ -107,6 +113,7 @@ proto._onFormatComplete = function formatOnComplete(message) {
   const broker = this.broker;
   const context = this.context;
 
+
   const {dataObjects, sources} = dataOutputs.reduce((result, ioSource, index) => {
     const {value} = messageOutputs.find((output) => output.id === ioSource.id) || {};
     const source = {
@@ -117,7 +124,6 @@ proto._onFormatComplete = function formatOnComplete(message) {
     };
     result.sources.push(source);
 
-
     const dataObjectId = getPropertyValue(ioSource, 'behaviour.association.target.dataObject.id');
     if (!dataObjectId) return result;
     const dataObject = context.getDataObjectById(dataObjectId);
@@ -143,8 +149,10 @@ proto._onFormatComplete = function formatOnComplete(message) {
   broker.publish('format', `${startRoutingKey}.begin`, {
     endRoutingKey,
     ioSpecification: {
-      dataInputs: sources.map((input) => {
-        return {...input};
+      ...(messageInputs && {
+        dataInputs: messageInputs.map((input) => {
+          return {...input};
+        }),
       }),
       dataOutputs: this._getDataOutputs(dataOutputs),
     },
@@ -155,8 +163,12 @@ proto._onFormatComplete = function formatOnComplete(message) {
 
     broker.publish('format', endRoutingKey, {
       ioSpecification: {
-        dataInputs: sources,
-        dataOutputs: this._getDataOutputs(dataOutputs),
+        ...(messageInputs && {
+          dataInputs: messageInputs.map((input) => {
+            return {...input};
+          }),
+        }),
+        dataOutputs: sources,
       },
     });
   });

package/src/io/Properties.js

@@ -13,7 +13,6 @@ export default function Properties(activity, propertiesDef, context) {
     dataOutputObjects: [],
   };
 
-
   for (const {id, ...def} of propertiesDef.values) {
     const source = {
       id,
@@ -62,6 +61,9 @@ const proto = Properties.prototype;
 
 proto.activate = function activate(message) {
   if (this[kConsuming]) return;
+  if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
+    this._onActivityEvent('activity.enter', message);
+  }
 
   if (message.fields.redelivered && message.content.properties) {
     this._onActivityEvent('activity.extension.resume', message);
@@ -75,16 +77,12 @@ proto.deactivate = function deactivate() {
 };
 
 proto._onActivityEvent = function onActivityEvent(routingKey, message) {
-  if (routingKey === 'activity.enter') {
-    return this._formatOnEnter(message);
-  }
-
-  if (routingKey === 'activity.extension.resume') {
-    return this._formatOnEnter(message);
-  }
-
-  if (routingKey === 'activity.execution.completed') {
-    return this._formatOnComplete(message);
+  switch (routingKey) {
+    case 'activity.enter':
+    case 'activity.extension.resume':
+      return this._formatOnEnter(message);
+    case 'activity.execution.completed':
+      return this._formatOnComplete(message);
   }
 };
 

package/src/tasks/ServiceTask.js

@@ -46,9 +46,7 @@ proto.execute = function execute(executeMessage) {
 
 proto.getService = function getService(message) {
   let Service = this.activity.behaviour.Service;
-  if (!Service) {
-    Service = this.environment.settings.enableDummyService ? DummyService : null;
-  }
+  if (!Service && this.environment.settings.enableDummyService) Service = DummyService;
   return Service && new Service(this.activity, cloneMessage(message));
 };