@onify/flow-extensions 7.0.0 → 8.0.0

package/src/OnifySequenceFlow.js

@@ -1,5 +1,5 @@
-import {SequenceFlow} from 'bpmn-elements';
-import {getExtensions} from './getExtensions.js';
+import { SequenceFlow } from 'bpmn-elements';
+import { getExtensions } from './getExtensions.js';
 
 export class OnifySequenceFlow extends SequenceFlow {
   constructor(flowDef, context) {
@@ -10,9 +10,14 @@ export class OnifySequenceFlow extends SequenceFlow {
   _activate() {
     if (!this.extensions.listeners?.onTake) return;
 
-    this.broker.subscribeTmp('event', 'flow.take', (_, msg) => {
-      this._executeListeners(msg);
-    }, {noAck: true, consumerTag: '_onify-execution-listener'});
+    this.broker.subscribeTmp(
+      'event',
+      'flow.take',
+      (_, msg) => {
+        this._executeListeners(msg);
+      },
+      { noAck: true, consumerTag: '_onify-execution-listener' },
+    );
   }
   async _executeListeners(message) {
     try {
@@ -25,7 +30,18 @@ export class OnifySequenceFlow extends SequenceFlow {
     const properties = this.extensions.properties;
     if (!properties) return super.evaluate(fromMessage, callback);
 
-    super.evaluate(fromMessage, (err, result) => {
+    try {
+      const preProperties = properties.resolve(this.getApi(fromMessage));
+      var evaluateMessage = fromMessage;
+      evaluateMessage.content.properties = {
+        ...fromMessage.content.properties,
+        ...preProperties,
+      };
+    } catch (err) {
+      return callback(err);
+    }
+
+    super.evaluate(evaluateMessage, (err, result) => {
       if (err) return callback(err);
 
       try {
@@ -33,7 +49,7 @@ export class OnifySequenceFlow extends SequenceFlow {
         if (result) {
           overriddenResult = {
             ...(typeof result === 'object' && result),
-            properties: properties.resolve(this.getApi(fromMessage)),
+            properties: properties.resolve(this.getApi(evaluateMessage)),
           };
         }
         return callback(err, overriddenResult);

package/src/OnifySubProcessExtensions.js

@@ -1,46 +1,76 @@
-import { OnifyElementExtensions } from './OnifyElementExtensions.js';
-
-export class OnifySubProcessExtensions extends OnifyElementExtensions {
-  constructor(activity, context) {
-    super(activity, context);
-  }
-  activate(runMessage) {
-    const activity = this.activity;
-    const broker = activity.broker;
-    const executionListeners = this.extensions.listeners;
-
-    if (runMessage.fields.redelivered && runMessage.fields.routingKey === 'run.start') {
-      this._setupListener(broker, 'activity.start', (elementApi) => {
-        return this._asyncFormatOnEnter(elementApi);
-      }, '_onify-extension-on-enter');
-    } else {
-      this._setupListener(broker, 'activity.enter', (elementApi) => {
-        return this._asyncFormatOnEnter(elementApi);
-      }, '_onify-extension-on-enter');
-    }
-
-    this._setupListener(broker, 'activity.execution.completed', (elementApi) => {
-      return this._onExecutionCompleted(elementApi);
-    }, '_onify-extension-on-executed');
-
-    if (executionListeners?.onStart) {
-      this._setupListener(broker, 'activity.start', (elementApi) => {
-        this._executeExecutionListener('start', elementApi);
-      }, '_onify-extension-on-listenerstart');
-    }
-
-    if (executionListeners?.onEnd) {
-      this._setupListener(broker, 'activity.end', (elementApi) => {
-        this._executeExecutionListener('end', elementApi);
-      }, '_onify-extension-on-listenerend');
-    }
-  }
-  _setupListener(broker, routingKey, callback, consumerTag) {
-    const activity = this.activity;
-    broker.subscribeTmp('event', routingKey, (_, message) => {
-      if (activity.id !== message.content.id) return;
-
-      return callback(activity.getApi(message));
-    }, { noAck: true, consumerTag });
-  }
-}
+import { OnifyElementExtensions } from './OnifyElementExtensions.js';
+
+export class OnifySubProcessExtensions extends OnifyElementExtensions {
+  constructor(activity, context) {
+    super(activity, context);
+  }
+  activate(runMessage) {
+    const activity = this.activity;
+    const broker = activity.broker;
+    const executionListeners = this.extensions.listeners;
+
+    if (runMessage.fields.redelivered && runMessage.fields.routingKey === 'run.start') {
+      this._setupListener(
+        broker,
+        'activity.start',
+        (elementApi) => {
+          return this._asyncFormatOnEnter(elementApi);
+        },
+        '_onify-extension-on-enter',
+      );
+    } else {
+      this._setupListener(
+        broker,
+        'activity.enter',
+        (elementApi) => {
+          return this._asyncFormatOnEnter(elementApi);
+        },
+        '_onify-extension-on-enter',
+      );
+    }
+
+    this._setupListener(
+      broker,
+      'activity.execution.completed',
+      (elementApi) => {
+        return this._onExecutionCompleted(elementApi);
+      },
+      '_onify-extension-on-executed',
+    );
+
+    if (executionListeners?.onStart) {
+      this._setupListener(
+        broker,
+        'activity.start',
+        (elementApi) => {
+          this._executeExecutionListener('start', elementApi);
+        },
+        '_onify-extension-on-listenerstart',
+      );
+    }
+
+    if (executionListeners?.onEnd) {
+      this._setupListener(
+        broker,
+        'activity.end',
+        (elementApi) => {
+          this._executeExecutionListener('end', elementApi);
+        },
+        '_onify-extension-on-listenerend',
+      );
+    }
+  }
+  _setupListener(broker, routingKey, callback, consumerTag) {
+    const activity = this.activity;
+    broker.subscribeTmp(
+      'event',
+      routingKey,
+      (_, message) => {
+        if (activity.id !== message.content.id) return;
+
+        return callback(activity.getApi(message));
+      },
+      { noAck: true, consumerTag },
+    );
+  }
+}

package/src/OnifyTimerEventDefinition.js

@@ -1,5 +1,5 @@
-import { TimerEventDefinition } from 'bpmn-elements';
 import cronParser from 'cron-parser';
+import { TimerEventDefinition } from 'bpmn-elements';
 
 export class OnifyTimerEventDefinition extends TimerEventDefinition {
   constructor(activity, def) {
@@ -14,12 +14,14 @@ export class OnifyTimerEventDefinition extends TimerEventDefinition {
       if (cron.expressions?.length) {
         // cronParser.parseString expressions disregards seconds, so we have to parse again
         const expireAt = cronParser.parseExpression(value).next().toDate();
+
         return {
           expireAt,
           delay: expireAt - Date.now(),
         };
       }
     }
+
     return super.parse(timerType, value);
   }
 }

package/src/ServiceExpression.js

@@ -1,4 +1,4 @@
-import {NotImplemented} from './Errors.js';
+import { NotImplemented } from './Errors.js';
 
 export default function ServiceExpression(activity) {
   if (!(this instanceof ServiceExpression)) return new ServiceExpression(activity);

package/src/formatters.js

@@ -1,98 +1,76 @@
-import cronParser from 'cron-parser';
-
-const iso8601cycle = /^\s*(R\d+\/)?P\w+/i;
-
-export class FormatActivity {
-  constructor(activity) {
-    this.activity = activity;
-    this.resultVariable = activity.behaviour.resultVariable;
-
-    let timeCycles;
-    if (activity.eventDefinitions) {
-      for (const ed of activity.eventDefinitions.filter((e) => e.type === 'bpmn:TimerEventDefinition')) {
-        if (ed.supports?.includes('cron')) continue;
-        if (!('timeCycle' in ed)) continue;
-        timeCycles = timeCycles || [];
-        timeCycles.push(ed.timeCycle);
-      }
-    }
-    this.timeCycles = timeCycles;
-  }
-  resolve(elementApi) {
-    let user, groups, assigneeValue, description;
-    const activity = this.activity;
-    const {
-      documentation,
-      candidateUsers,
-      candidateGroups,
-      scheduledStart,
-      assignee,
-    } = activity.behaviour;
-
-    if (candidateUsers) user = resolveAndSplit(elementApi, candidateUsers);
-    if (candidateGroups) groups = resolveAndSplit(elementApi, candidateGroups);
-    if (assignee) assigneeValue = elementApi.resolveExpression(assignee);
-    if (documentation) description = documentation[0]?.text;
-
-    let expireAt;
-    const timeCycles = this.timeCycles;
-    if (timeCycles) {
-      for (const cycle of timeCycles) {
-        const cron = elementApi.resolveExpression(cycle);
-        if (!cron || iso8601cycle.test(cron)) continue;
-
-        const expireAtDt = cronParser.parseExpression(cron).next().toDate();
-        if (!expireAt || expireAtDt < expireAt) expireAt = expireAtDt;
-      }
-    }
-
-    return {
-      ...(this.resultVariable && {resultVariable: this.resultVariable}),
-      ...(scheduledStart && activity.parent.type === 'bpmn:Process' && {scheduledStart}),
-      ...(user?.length && {candidateUsers: user}),
-      ...(groups?.length && {candidateGroups: groups}),
-      ...(!elementApi.content.description && description && {description: elementApi.resolveExpression(description)}),
-      ...(expireAt && {expireAt}),
-      ...(assigneeValue && {assignee: assigneeValue}),
-    };
-  }
-}
-
-export class FormatProcess {
-  constructor(bp) {
-    this.process = bp;
-  }
-  resolve(elementApi) {
-    let user, groups, description;
-    const bp = this.process;
-    const {
-      documentation,
-      candidateStarterUsers,
-      candidateStarterGroups,
-    } = bp.behaviour;
-
-    if (candidateStarterUsers) user = resolveAndSplit(elementApi, candidateStarterUsers);
-    if (candidateStarterGroups) groups = resolveAndSplit(elementApi, candidateStarterGroups);
-    if (documentation) description = documentation[0]?.text;
-
-    return {
-      ...(user?.length && {candidateStarterUsers: user}),
-      ...(groups?.length && {candidateStarterGroups: groups}),
-      ...(!elementApi.content.description && description && {description: elementApi.resolveExpression(description)}),
-    };
-  }
-}
-
-function resolveAndSplit(elementApi, str) {
-  if (Array.isArray(str)) return str.filter(Boolean);
-  if (typeof str !== 'string') return;
-
-  const resolved = elementApi.resolveExpression(str);
-  if (Array.isArray(resolved)) return resolved.filter(Boolean);
-  if (typeof resolved !== 'string') return;
-
-  return resolved
-    .split(',')
-    .map((g) => g.trim && g.trim().toLowerCase())
-    .filter(Boolean);
-}
+export class FormatActivity {
+  constructor(activity) {
+    this.activity = activity;
+    this.resultVariable = activity.behaviour.resultVariable;
+
+    let timeCycles;
+    if (activity.eventDefinitions) {
+      for (const ed of activity.eventDefinitions.filter((e) => e.type === 'bpmn:TimerEventDefinition')) {
+        if (!ed.supports?.includes('cron')) continue;
+        if (!('timeCycle' in ed)) continue;
+        timeCycles = timeCycles || [];
+        timeCycles.push(ed.timeCycle);
+      }
+    }
+    this.timeCycles = timeCycles;
+  }
+  resolve(elementApi) {
+    let user, groups, assigneeValue, description;
+    const activity = this.activity;
+    const { documentation, candidateUsers, candidateGroups, scheduledStart, assignee } = activity.behaviour;
+
+    if (candidateUsers) user = resolveAndSplit(elementApi, candidateUsers);
+    if (candidateGroups) groups = resolveAndSplit(elementApi, candidateGroups);
+    if (assignee) assigneeValue = elementApi.resolveExpression(assignee);
+    if (documentation) description = documentation[0]?.text;
+
+    return {
+      ...(this.resultVariable && { resultVariable: this.resultVariable }),
+      ...(scheduledStart && activity.parent.type === 'bpmn:Process' && { scheduledStart }),
+      ...(user?.length && { candidateUsers: user }),
+      ...(groups?.length && { candidateGroups: groups }),
+      ...(!elementApi.content.description && description && { description: elementApi.resolveExpression(description) }),
+      ...(assigneeValue && { assignee: assigneeValue }),
+    };
+  }
+}
+
+export class FormatProcess {
+  constructor(bp) {
+    this.process = bp;
+    this._historyTTL = undefined;
+    if (bp.behaviour.historyTimeToLive) {
+      this._historyTTL = bp.context.definitionContext.getTimersByElementId(bp.id).find((t) => t.timer.type === 'historyTimeToLive');
+    }
+  }
+  resolve(elementApi) {
+    let user, groups, description;
+    const bp = this.process;
+    const { documentation, candidateStarterUsers, candidateStarterGroups } = bp.behaviour;
+
+    if (candidateStarterUsers) user = resolveAndSplit(elementApi, candidateStarterUsers);
+    if (candidateStarterGroups) groups = resolveAndSplit(elementApi, candidateStarterGroups);
+    if (documentation) description = documentation[0]?.text;
+
+    return {
+      ...(user?.length && { candidateStarterUsers: user }),
+      ...(groups?.length && { candidateStarterGroups: groups }),
+      ...(!elementApi.content.description && description && { description: elementApi.resolveExpression(description) }),
+      ...(this._historyTTL && { historyTimeToLive: this._historyTTL.timer.value }),
+    };
+  }
+}
+
+function resolveAndSplit(elementApi, str) {
+  if (Array.isArray(str)) return str.filter(Boolean);
+  if (typeof str !== 'string') return;
+
+  const resolved = elementApi.resolveExpression(str);
+  if (Array.isArray(resolved)) return resolved.filter(Boolean);
+  if (typeof resolved !== 'string') return;
+
+  return resolved
+    .split(',')
+    .map((g) => g.trim && g.trim().toLowerCase())
+    .filter(Boolean);
+}

package/src/getExtensions.js

@@ -1,57 +1,57 @@
-import {FormatActivity, FormatProcess} from './formatters.js';
-import {InputOutput} from './IO.js';
-import Connector from './Connector.js';
-import ExecutionListeners from './ExecutionListeners.js';
-import IOForm from './IOForm.js';
-import IOProperties from './IOProperties.js';
-import ServiceExpression from './ServiceExpression.js';
-
-export function getExtensions(element, context) {
-  const result = {};
-
-  switch (element.type) {
-    case 'bpmn:SequenceFlow':
-      break;
-    case 'bpmn:Process':
-      result.format = new FormatProcess(element);
-      break;
-    default:
-      result.format = new FormatActivity(element);
-  }
-
-  let listenerPosition = 0;
-  const listeners = new ExecutionListeners(element, context);
-
-  const expression = element.behaviour.expression;
-  if (expression) result.Service = ServiceExpression;
-
-  const extensions = element.behaviour.extensionElements?.values;
-  if (extensions) {
-    for (const ext of extensions) {
-      switch (ext.$type) {
-        case 'camunda:Properties':
-          if (ext.values?.length) result.properties = new IOProperties(element, ext);
-          break;
-        case 'camunda:InputOutput':
-          result.io = new InputOutput(element.id, ext, context);
-          break;
-        case 'camunda:FormData':
-          if (ext.fields?.length) result.form = new IOForm(element, ext);
-          break;
-        case 'camunda:Connector': {
-          const {connectorId, inputOutput} = ext;
-          const io = inputOutput && new InputOutput(`${element.id}/${ext.$type.toLowerCase()}`, inputOutput, context);
-          result.Service = Connector.bind(Connector, connectorId, io);
-          break;
-        }
-        case 'camunda:ExecutionListener':
-          listeners.add(ext, listenerPosition++);
-          break;
-      }
-    }
-  }
-
-  if (listeners.length) result.listeners = listeners;
-
-  return result;
-}
+import { FormatActivity, FormatProcess } from './formatters.js';
+import { InputOutput } from './IO.js';
+import Connector from './Connector.js';
+import ExecutionListeners from './ExecutionListeners.js';
+import IOForm from './IOForm.js';
+import IOProperties from './IOProperties.js';
+import ServiceExpression from './ServiceExpression.js';
+
+export function getExtensions(element, context) {
+  const result = {};
+
+  switch (element.type) {
+    case 'bpmn:SequenceFlow':
+      break;
+    case 'bpmn:Process':
+      result.format = new FormatProcess(element);
+      break;
+    default:
+      result.format = new FormatActivity(element);
+  }
+
+  let listenerPosition = 0;
+  const listeners = new ExecutionListeners(element, context);
+
+  const expression = element.behaviour.expression;
+  if (expression) result.Service = ServiceExpression;
+
+  const extensions = element.behaviour.extensionElements?.values;
+  if (extensions) {
+    for (const ext of extensions) {
+      switch (ext.$type) {
+        case 'camunda:Properties':
+          if (ext.values?.length) result.properties = new IOProperties(element, ext);
+          break;
+        case 'camunda:InputOutput':
+          result.io = new InputOutput(element.id, ext, context);
+          break;
+        case 'camunda:FormData':
+          if (ext.fields?.length) result.form = new IOForm(element, ext);
+          break;
+        case 'camunda:Connector': {
+          const { connectorId, inputOutput } = ext;
+          const io = inputOutput && new InputOutput(`${element.id}/${ext.$type.toLowerCase()}`, inputOutput, context);
+          result.Service = Connector.bind(Connector, connectorId, io);
+          break;
+        }
+        case 'camunda:ExecutionListener':
+          listeners.add(ext, listenerPosition++);
+          break;
+      }
+    }
+  }
+
+  if (listeners.length) result.listeners = listeners;
+
+  return result;
+}

package/src/index.js

@@ -21,9 +21,28 @@ export function extensions(element, context) {
 }
 
 export function extendFn(behaviour, context) {
-  if (behaviour.$type === 'bpmn:StartEvent' && behaviour.eventDefinitions) {
-    const timer = behaviour.eventDefinitions.find(({type, behaviour: edBehaviour}) => edBehaviour && type === 'bpmn:TimerEventDefinition');
-    if (timer && timer.behaviour.timeCycle) Object.assign(behaviour, {scheduledStart: timer.behaviour.timeCycle});
+  switch (behaviour.$type) {
+    case 'bpmn:StartEvent': {
+      if (!behaviour.eventDefinitions) break;
+
+      const timer = behaviour.eventDefinitions.find(
+        ({ type, behaviour: edBehaviour }) => edBehaviour && type === 'bpmn:TimerEventDefinition',
+      );
+      if (timer && timer.behaviour.timeCycle) Object.assign(behaviour, { scheduledStart: timer.behaviour.timeCycle });
+
+      break;
+    }
+    case 'bpmn:Process': {
+      if (!behaviour.isExecutable) break;
+
+      const { historyTimeToLive, isExecutable } = behaviour;
+
+      if (historyTimeToLive && isExecutable) {
+        context.addTimer(behaviour.id + ':historyTimeToLive', getHistoryTimeToLiveTimer(behaviour));
+      }
+
+      break;
+    }
   }
 
   if (!Array.isArray(behaviour.extensionElements?.values)) return;
@@ -47,8 +66,8 @@ export function extendFn(behaviour, context) {
 function registerIOScripts(parentId, context, type, ioBehaviour) {
   if (!ioBehaviour) return;
 
-  const {inputParameters = [], outputParameters = []} = ioBehaviour;
-  for (const {$type, name, definition} of inputParameters.concat(outputParameters)) {
+  const { inputParameters = [], outputParameters = [] } = ioBehaviour;
+  for (const { $type, name, definition } of inputParameters.concat(outputParameters)) {
     if (!definition) continue;
     if (definition.$type !== 'camunda:Script') continue;
 
@@ -59,14 +78,14 @@ function registerIOScripts(parentId, context, type, ioBehaviour) {
       id: filename,
       scriptFormat: definition.scriptFormat,
       type: ioType,
-      ...(definition.value && {body: definition.value}),
-      ...(definition.resource && {resource: definition.resource}),
+      ...(definition.value && { body: definition.value }),
+      ...(definition.resource && { resource: definition.resource }),
     });
   }
 }
 
 function registerListenerScript(parentId, context, type, listener, pos) {
-  const {event, script} = listener;
+  const { event, script } = listener;
   if (!script) return;
 
   const id = `${parentId}/${type}/${event}/${pos}`;
@@ -74,7 +93,23 @@ function registerListenerScript(parentId, context, type, listener, pos) {
     id,
     scriptFormat: script.scriptFormat,
     type,
-    ...(script.value && {body: script.value}),
-    ...(script.resource && {resource: script.resource}),
+    ...(script.value && { body: script.value }),
+    ...(script.resource && { resource: script.resource }),
   });
 }
+
+function getHistoryTimeToLiveTimer(behaviour) {
+  const { id, $type: type, historyTimeToLive } = behaviour;
+
+  let value = historyTimeToLive;
+  if (/^\d+$/.test(historyTimeToLive)) {
+    value = `P${historyTimeToLive}D`;
+  }
+  return {
+    id: `${type}/${id}:historyTimeToLive`,
+    type: 'historyTimeToLive',
+    timerType: 'timeDuration',
+    value,
+    parent: { id, type },
+  };
+}

package/CHANGELOG.md

@@ -1,70 +0,0 @@
-Changelog
-=========
-
-# 7.0.0
-
-Attempting to mitigate Boundary Event formatting interrupting normal execution flow. Asynchronous formatting prevents catching events from attached task. Should probably be done in bpmn-elements but the developer is busy.
-
-## Breaking
-
-- No async formatting on boundary events before end
-- Boundary event start execution listener will be executed but _without_ formatting capabilities and detached from execution. Occasional error will just be logged
-- Boundary event end execution listener is still executed _with_ formatting capabilities
-
-# 6.0.0
-
-- Require peer dependency `bpmn-elements >= 8`
-- Support timer event definition cron time cycle by overloading parse function. Requires `bpmn-elements >= 10`
-
-# 5.0.2
-
-- Correct package module file...
-
-# 5.0.1
-
-- Doh! Add neglected package.json file to common js dist folder
-
-# 5.0.0
-
-- Turn into module with exports for node
-- Add type declaration
-
-# 4.1.0
-
-- Support sequence flow properties and take execution listener. Requires `bpmn-elements >= 9.2`
-
-# 4.0.0
-
-- make sure sub-process extensions are only triggered once. Sub process activities unintentionally trigger formatting since events bubble
-- add script element type to registered scripts
-- restructure and split up index.js to separate files
-- abide to new lint rules
-
-# 3.0.0
-
-- Support activity script and expression execution listeners
-- Remove default behaviour of saving activity output even if output is not declared. Output **was** saved to `environment.output._<Activity ID>` if no result variable or output was declared. The reason was that there was no easy way of getting output from SubProcess or a multi-instance task. Now SubProcess output can be defined and multi-instance output can be solved with execution listener
-
-# 2.0.0
-
-- fix resume extension when recovered mid formatting
-- drop node 12 support
-
-# 1.1.0
-
-- allow ISO8601 repeating interval and duration in timeCycle
-
-# 1.0.0
-
-- proper routing keys for end formatting
-
-# 0.1.0
-
-- catch errors when resolving service expression
-- test with bpmn-engine@14
-
-# 0.0.2
-
-- allow expressions in timeCycle
-- test with bpmn-engine@13
-- error message changed in node 16