@onify/flow-extensions 6.0.0 → 7.1.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
-Changelog
-=========
+# Changelog
+
+# 7.1.0
+
+- add process attribute `historyTimeToLive` to process environment variables when running
+- add process attribute `historyTimeToLive` as timer to definition context via `extendFn`, formatted as ISO8601 duration
+- use prettier since eslint will deprecate formatting rules in the next major release
+
+# 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
 

package/README.md

@@ -1,5 +1,4 @@
-Onify Flow Extensions
-=====================
+# Onify Flow Extensions
 
 [![Built latest](https://github.com/onify/flow-extensions/actions/workflows/build-latest.yaml/badge.svg)](https://github.com/onify/flow-extensions/actions/workflows/build-latest.yaml)[![Coverage Status](https://coveralls.io/repos/github/onify/flow-extensions/badge.svg?branch=default)](https://coveralls.io/github/onify/flow-extensions?branch=default)
 
@@ -13,8 +12,8 @@ Onify Flow Extensions
 ## Bpmn engine example
 
 ```js
-const {Engine} = require('bpmn-engine');
-const {extensions} = require('@onify/flow-extensions');
+const { Engine } = require('bpmn-engine');
+const { extensions } = require('@onify/flow-extensions');
 const FlowScripts = require('@onify/flow-extensions/dist/src/FlowScripts');
 
 const source = `
@@ -41,8 +40,8 @@ const engine = new Engine({
   },
   services: {
     serviceFn(scope, callback) {
-      callback(null, {data: 1});
-    }
+      callback(null, { data: 1 });
+    },
   },
   extensions: {
     onify: extensions,
@@ -63,11 +62,11 @@ engine.execute((err, instance) => {
 ## Extract scripts with extend function
 
 ```js
-const {extendFn} = require('@onify/flow-extensions');
+const { extendFn } = require('@onify/flow-extensions');
 
 const BpmnModdle = require('bpmn-moddle');
 const Elements = require('bpmn-elements');
-const {default: Serializer, TypeResolver} = require('moddle-context-serializer');
+const { default: Serializer, TypeResolver } = require('moddle-context-serializer');
 
 const source = `
 <definitions id="Def_0" xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
@@ -124,9 +123,9 @@ function getModdleContext(source, options) {
 ## Extend sequence flow with properties and take listeners
 
 ```js
-const {OnifySequenceFlow, extensions} = require('@onify/flow-extensions');
+const { OnifySequenceFlow, extensions } = require('@onify/flow-extensions');
 const FlowScripts = require('@onify/flow-extensions/dist/src/FlowScripts');
-const {Engine} = require('bpmn-engine');
+const { Engine } = require('bpmn-engine');
 const Elements = require('bpmn-elements');
 
 const source = `

package/dist/OnifyBoundaryEventExtensions.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnifyBoundaryEventExtensions = void 0;
+var _OnifyElementExtensions = require("./OnifyElementExtensions.js");
+class OnifyBoundaryEventExtensions extends _OnifyElementExtensions.OnifyElementExtensions {
+  constructor(activity, context) {
+    super(activity, context);
+    this._syncFormatOnEnter = this._syncFormatOnEnter.bind(this);
+  }
+  activate(message) {
+    const activity = this.activity;
+    const formatQ = activity.broker.getQueue('format-run-q');
+    const executionListeners = this.extensions.listeners;
+    if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
+      activity.on('start', this._syncFormatOnEnter, {
+        consumerTag: '_onify-extension-on-enter'
+      });
+    } else {
+      activity.on('enter', this._syncFormatOnEnter, {
+        consumerTag: '_onify-extension-on-enter'
+      });
+    }
+    activity.on('activity.execution.completed', elementApi => {
+      return this._onExecutionCompleted(elementApi, formatQ);
+    }, {
+      consumerTag: '_onify-extension-on-executed'
+    });
+    if (executionListeners !== null && executionListeners !== void 0 && executionListeners.onStart) {
+      activity.on('start', async elementApi => {
+        try {
+          await executionListeners.execute('start', elementApi);
+        } catch (err) {
+          return activity.logger.error(`<${activity.id}> execution listener error`, err);
+        }
+      }, {
+        consumerTag: '_onify-extension-on-listenerstart'
+      });
+    }
+    if (executionListeners !== null && executionListeners !== void 0 && executionListeners.onEnd) {
+      activity.on('end', elementApi => {
+        this._executeExecutionListener('end', elementApi, formatQ);
+      }, {
+        consumerTag: '_onify-extension-on-listenerend'
+      });
+    }
+  }
+  _syncFormatOnEnter(elementApi) {
+    try {
+      var format = this._onEnterSync(elementApi);
+    } catch (err) {
+      return elementApi.broker.publish('format', 'run.enter.error', {
+        error: err
+      }, {
+        persistent: false
+      });
+    }
+    elementApi.broker.publish('format', 'run.enter.complete', format, {
+      persistent: false
+    });
+  }
+  _onEnterSync(elementApi) {
+    var _io$output;
+    const {
+      format,
+      properties,
+      io
+    } = this.extensions;
+    const result = {};
+    Object.assign(result, format.resolve(elementApi));
+    Object.assign(elementApi.content, result);
+    if (properties) {
+      Object.assign(result, {
+        properties: properties.resolve(elementApi)
+      });
+      Object.assign(elementApi.content, result);
+    }
+    if (io !== null && io !== void 0 && (_io$output = io.output) !== null && _io$output !== void 0 && _io$output.length) {
+      result.assignToOutput = true;
+    }
+    return result;
+  }
+}
+exports.OnifyBoundaryEventExtensions = OnifyBoundaryEventExtensions;

package/dist/OnifyElementExtensions.js

@@ -9,6 +9,8 @@ class OnifyElementExtensions {
   constructor(activity, context) {
     this.activity = activity;
     this.context = context;
+    this.formatQ = activity.broker.getQueue('format-run-q');
+    this._asyncFormatOnEnter = this._asyncFormatOnEnter.bind(this);
     const {
       Service
     } = this.extensions = (0, _getExtensions.getExtensions)(activity, context);
@@ -18,100 +20,31 @@ class OnifyElementExtensions {
   }
   activate(message) {
     const activity = this.activity;
-    const broker = activity.broker;
-    const formatQ = activity.broker.getQueue('format-run-q');
     const executionListeners = this.extensions.listeners;
     if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', elementApi => {
-        this._formatOnEnter(broker, formatQ, elementApi);
-      }, {
+      activity.on('start', this._asyncFormatOnEnter, {
         consumerTag: '_onify-extension-on-enter'
       });
     } else {
-      activity.on('enter', elementApi => {
-        this._formatOnEnter(broker, formatQ, elementApi);
-      }, {
+      activity.on('enter', this._asyncFormatOnEnter, {
         consumerTag: '_onify-extension-on-enter'
       });
     }
-    activity.on('activity.execution.completed', async elementApi => {
-      if (activity.isSubProcess && activity.id !== elementApi.id) return;
-      formatQ.queueMessage({
-        routingKey: 'run.end.format'
-      }, {
-        endRoutingKey: 'run.end.complete'
-      }, {
-        persistent: false
-      });
-      try {
-        var format = await this._onExecuted(elementApi);
-      } catch (err) {
-        return broker.publish('format', 'run.end.error', {
-          error: err
-        }, {
-          persistent: false
-        });
-      }
-      broker.publish('format', 'run.end.complete', {
-        ...format
-      }, {
-        persistent: false
-      });
+    activity.on('activity.execution.completed', elementApi => {
+      return this._onExecutionCompleted(elementApi);
     }, {
       consumerTag: '_onify-extension-on-executed'
     });
     if (executionListeners !== null && executionListeners !== void 0 && executionListeners.onStart) {
-      activity.on('start', async elementApi => {
-        if (activity.isSubProcess && activity.id !== elementApi.id) return;
-        formatQ.queueMessage({
-          routingKey: 'run.listener.start'
-        }, {
-          endRoutingKey: 'run.listener.start.complete'
-        }, {
-          persistent: false
-        });
-        try {
-          var format = await executionListeners.execute('start', elementApi);
-        } catch (err) {
-          return broker.publish('format', 'run.listener.start.error', {
-            error: err
-          }, {
-            persistent: false
-          });
-        }
-        broker.publish('format', 'run.listener.start.complete', {
-          ...format
-        }, {
-          persistent: false
-        });
+      activity.on('start', elementApi => {
+        this._executeExecutionListener('start', elementApi);
       }, {
         consumerTag: '_onify-extension-on-listenerstart'
       });
     }
     if (executionListeners !== null && executionListeners !== void 0 && executionListeners.onEnd) {
-      activity.on('end', async elementApi => {
-        if (activity.isSubProcess && activity.id !== elementApi.id) return;
-        formatQ.queueMessage({
-          routingKey: 'run.listener.end'
-        }, {
-          endRoutingKey: 'run.listener.end.complete'
-        }, {
-          persistent: false
-        });
-        try {
-          var format = await executionListeners.execute('end', elementApi);
-        } catch (err) {
-          return broker.publish('format', 'run.listener.end.error', {
-            error: err
-          }, {
-            persistent: false
-          });
-        }
-        broker.publish('format', 'run.listener.end.complete', {
-          ...format
-        }, {
-          persistent: false
-        });
+      activity.on('end', elementApi => {
+        this._executeExecutionListener('end', elementApi);
       }, {
         consumerTag: '_onify-extension-on-listenerend'
       });
@@ -124,9 +57,8 @@ class OnifyElementExtensions {
     broker.cancel('_onify-extension-on-listenerstart');
     broker.cancel('_onify-extension-on-listenerend');
   }
-  async _formatOnEnter(broker, formatQ, elementApi) {
-    if (this.activity.isSubProcess && this.activity.id !== elementApi.id) return;
-    formatQ.queueMessage({
+  async _asyncFormatOnEnter(elementApi) {
+    this.formatQ.queueMessage({
       routingKey: 'run.enter.format'
     }, {
       endRoutingKey: 'run.enter.complete'
@@ -134,19 +66,42 @@ class OnifyElementExtensions {
       persistent: false
     });
     try {
-      var format = await this._onEnter(elementApi);
+      var format = await this._onEnterAsync(elementApi);
     } catch (err) {
-      return broker.publish('format', 'run.enter.error', {
+      return elementApi.broker.publish('format', 'run.enter.error', {
         error: err
       }, {
         persistent: false
       });
     }
-    broker.publish('format', 'run.enter.complete', format, {
+    elementApi.broker.publish('format', 'run.enter.complete', format, {
       persistent: false
     });
   }
-  async _onEnter(elementApi) {
+  async _onExecutionCompleted(elementApi) {
+    this.formatQ.queueMessage({
+      routingKey: 'run.end.format'
+    }, {
+      endRoutingKey: 'run.end.complete'
+    }, {
+      persistent: false
+    });
+    try {
+      var format = await this._onExecuted(elementApi);
+    } catch (err) {
+      return elementApi.broker.publish('format', 'run.end.error', {
+        error: err
+      }, {
+        persistent: false
+      });
+    }
+    elementApi.broker.publish('format', 'run.end.complete', {
+      ...format
+    }, {
+      persistent: false
+    });
+  }
+  async _onEnterAsync(elementApi) {
     const {
       format,
       properties,
@@ -220,5 +175,30 @@ class OnifyElementExtensions {
     }
     return result;
   }
+  async _executeExecutionListener(eventName, elementApi) {
+    const routingKey = 'run.listener.' + eventName;
+    const endRoutingKey = routingKey + '.complete';
+    this.formatQ.queueMessage({
+      routingKey
+    }, {
+      endRoutingKey
+    }, {
+      persistent: false
+    });
+    try {
+      var format = await this.extensions.listeners.execute(eventName, elementApi);
+    } catch (err) {
+      return elementApi.broker.publish('format', routingKey + '.error', {
+        error: err
+      }, {
+        persistent: false
+      });
+    }
+    elementApi.broker.publish('format', endRoutingKey, {
+      ...format
+    }, {
+      persistent: false
+    });
+  }
 }
 exports.OnifyElementExtensions = OnifyElementExtensions;

package/dist/OnifySubProcessExtensions.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnifySubProcessExtensions = void 0;
+var _OnifyElementExtensions = require("./OnifyElementExtensions.js");
+class OnifySubProcessExtensions extends _OnifyElementExtensions.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 !== null && executionListeners !== void 0 && executionListeners.onStart) {
+      this._setupListener(broker, 'activity.start', elementApi => {
+        this._executeExecutionListener('start', elementApi);
+      }, '_onify-extension-on-listenerstart');
+    }
+    if (executionListeners !== null && executionListeners !== void 0 && 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
+    });
+  }
+}
+exports.OnifySubProcessExtensions = OnifySubProcessExtensions;

package/dist/formatters.js

@@ -77,6 +77,10 @@ exports.FormatActivity = FormatActivity;
 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) {
     var _documentation$2, _user2, _groups2;
@@ -99,6 +103,9 @@ class FormatProcess {
       }),
       ...(!elementApi.content.description && description && {
         description: elementApi.resolveExpression(description)
+      }),
+      ...(this._historyTTL && {
+        historyTimeToLive: this._historyTTL.timer.value
       })
     };
   }

package/dist/index.js

@@ -19,22 +19,50 @@ exports.extendFn = extendFn;
 exports.extensions = extensions;
 var _OnifyProcessExtensions = require("./OnifyProcessExtensions.js");
 var _OnifyElementExtensions = require("./OnifyElementExtensions.js");
+var _OnifyBoundaryEventExtensions = require("./OnifyBoundaryEventExtensions.js");
+var _OnifySubProcessExtensions = require("./OnifySubProcessExtensions.js");
 var _OnifySequenceFlow = require("./OnifySequenceFlow.js");
 var _OnifyTimerEventDefinition = require("./OnifyTimerEventDefinition.js");
 function extensions(element, context) {
-  if (element.type === 'bpmn:Process') return new _OnifyProcessExtensions.OnifyProcessExtensions(element, context);
-  return new _OnifyElementExtensions.OnifyElementExtensions(element, context);
+  switch (element.type) {
+    case 'bpmn:Process':
+      return new _OnifyProcessExtensions.OnifyProcessExtensions(element, context);
+    case 'bpmn:SubProcess':
+    case 'bpmn:Transaction':
+      return new _OnifySubProcessExtensions.OnifySubProcessExtensions(element, context);
+    case 'bpmn:BoundaryEvent':
+      return new _OnifyBoundaryEventExtensions.OnifyBoundaryEventExtensions(element, context);
+    default:
+      return new _OnifyElementExtensions.OnifyElementExtensions(element, context);
+  }
 }
 function extendFn(behaviour, context) {
   var _behaviour$extensionE;
-  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$extensionE = behaviour.extensionElements) === null || _behaviour$extensionE === void 0 ? void 0 : _behaviour$extensionE.values)) return;
   let listener = 0;
@@ -98,4 +126,25 @@ function registerListenerScript(parentId, context, type, listener, pos) {
       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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/flow-extensions",
-  "version": "6.0.0",
+  "version": "7.1.0",
   "description": "Onify Flow extensions",
   "type": "module",
   "module": "src/index.js",
@@ -14,7 +14,7 @@
   "scripts": {
     "test": "mocha -R dot",
     "posttest": "npm run lint && npm run dist",
-    "lint": "eslint . --cache",
+    "lint": "eslint . --cache && prettier . --check --cache",
     "prepare": "npm run dist",
     "dist": "babel src -d dist && babel test/helpers/FlowScripts.js -d dist",
     "test:lcov": "c8 -r lcov mocha && npm run lint",
@@ -39,23 +39,24 @@
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
     "@babel/cli": "^7.23.4",
-    "@babel/core": "^7.23.5",
-    "@babel/preset-env": "^7.23.5",
-    "@babel/register": "^7.22.15",
+    "@babel/core": "^7.23.7",
+    "@babel/preset-env": "^7.23.8",
+    "@babel/register": "^7.23.7",
     "bpmn-elements-8-1": "npm:bpmn-elements@8.1",
-    "bpmn-engine": "^17.1.1",
+    "bpmn-engine": "^18.0.0",
     "bpmn-engine-14": "npm:bpmn-engine@14",
-    "bpmn-moddle": "^8.0.1",
-    "c8": "^8.0.1",
+    "bpmn-moddle": "^8.1.0",
+    "c8": "^9.1.0",
     "camunda-bpmn-moddle": "^7.0.1",
-    "chai": "^4.3.10",
+    "chai": "^5.0.0",
     "chronokinesis": "^6.0.0",
     "debug": "^4.3.4",
-    "eslint": "^8.55.0",
-    "eslint-plugin-import": "^2.29.0",
+    "eslint": "^8.56.0",
+    "eslint-plugin-import": "^2.29.1",
     "mocha": "^10.2.0",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^4.1.1"
+    "moddle-context-serializer": "^4.1.1",
+    "prettier": "^3.2.4"
   },
   "peerDependencies": {
     "bpmn-elements": ">=8"

package/src/Connector.js

@@ -1,4 +1,4 @@
-import {NotImplemented} from './Errors.js';
+import { NotImplemented } from './Errors.js';
 
 export default function Connector(connectorId, io, activity, executionMessage) {
   if (!(this instanceof Connector)) return new Connector(connectorId, io, activity, executionMessage);
@@ -22,7 +22,7 @@ Connector.prototype.execute = async function execute(...args) {
   if (!serviceFunction) return callback(new NotImplemented(connectorId));
 
   try {
-    const input = io && await io.getInput(activity, executionMessage);
+    const input = io && (await io.getInput(activity, executionMessage));
     await serviceFunction.call(activity, input, ...args);
   } catch (err) {
     return callback(err);
@@ -33,7 +33,7 @@ Connector.prototype.execute = async function execute(...args) {
     if (!io?.output.length) return callback(null, result);
 
     try {
-      const formattedResult = await io.getOutput(activity, {...executionMessage, ...result});
+      const formattedResult = await io.getOutput(activity, { ...executionMessage, ...result });
       return callback(null, formattedResult);
     } catch (err) {
       return callback(err);

package/src/Errors.js

@@ -2,7 +2,7 @@ export class NotImplemented extends Error {
   constructor(serviceId) {
     super(`${serviceId} service function not found`);
     this.code = 'EFLOW_NOT_IMPLEMENTED';
-    this.output = {statusCode: 501};
+    this.output = { statusCode: 501 };
   }
 }
 
@@ -10,6 +10,6 @@ export class FormatError extends Error {
   constructor(elementId, err) {
     super(`<${elementId}> ${err.message}`);
     this.code = 'EFLOW_FORMAT';
-    this.output = {statusCode: 500};
+    this.output = { statusCode: 500 };
   }
 }