@onify/flow-extensions 5.0.2 → 7.0.0

package/CHANGELOG.md

@@ -1,6 +1,21 @@
 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...

package/dist/FlowScripts.js

@@ -123,7 +123,6 @@ JavaScript.prototype.execute = async function execute(executionContext, callback
       console: {
         log: console.log // eslint-disable-line no-console
       },
-
       Buffer: {
         from: Buffer.from
       },

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/OnifyTimerEventDefinition.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnifyTimerEventDefinition = void 0;
+var _bpmnElements = require("bpmn-elements");
+var _cronParser = _interopRequireDefault(require("cron-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class OnifyTimerEventDefinition extends _bpmnElements.TimerEventDefinition {
+  constructor(activity, def) {
+    super(activity, def);
+    Object.defineProperty(this, 'supports', {
+      value: ['cron']
+    });
+  }
+  parse(timerType, value) {
+    let cron;
+    if (timerType === 'timeCycle' && (cron = _cronParser.default.parseString(value))) {
+      var _cron$expressions;
+      if ((_cron$expressions = cron.expressions) !== null && _cron$expressions !== void 0 && _cron$expressions.length) {
+        // cronParser.parseString expressions disregards seconds, so we have to parse again
+        const expireAt = _cronParser.default.parseExpression(value).next().toDate();
+        return {
+          expireAt,
+          delay: expireAt - Date.now()
+        };
+      }
+    }
+    return super.parse(timerType, value);
+  }
+}
+exports.OnifyTimerEventDefinition = OnifyTimerEventDefinition;

package/dist/formatters.js

@@ -14,6 +14,8 @@ class FormatActivity {
     let timeCycles;
     if (activity.eventDefinitions) {
       for (const ed of activity.eventDefinitions.filter(e => e.type === 'bpmn:TimerEventDefinition')) {
+        var _ed$supports;
+        if ((_ed$supports = ed.supports) !== null && _ed$supports !== void 0 && _ed$supports.includes('cron')) continue;
         if (!('timeCycle' in ed)) continue;
         timeCycles = timeCycles || [];
         timeCycles.push(ed.timeCycle);

package/dist/index.js

@@ -9,14 +9,32 @@ Object.defineProperty(exports, "OnifySequenceFlow", {
     return _OnifySequenceFlow.OnifySequenceFlow;
   }
 });
+Object.defineProperty(exports, "OnifyTimerEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _OnifyTimerEventDefinition.OnifyTimerEventDefinition;
+  }
+});
 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;

package/index.d.ts

@@ -1,8 +1,11 @@
 declare module '@onify/flow-extensions' {
-  import { SequenceFlow, ElementBase, Context, IExtension } from 'bpmn-elements';
+  import { SequenceFlow, TimerEventDefinition, ElementBase, Context, IExtension } from 'bpmn-elements';
   import { extendFn as extendFunction } from 'moddle-context-serializer';
 
   export class OnifySequenceFlow extends SequenceFlow {}
+  export class OnifyTimerEventDefinition extends TimerEventDefinition {
+    readonly supports: string[];
+  }
   export function extensions(element: ElementBase, context: Context): IExtension;
   export const extendFn: extendFunction;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/flow-extensions",
-  "version": "5.0.2",
+  "version": "7.0.0",
   "description": "Onify Flow extensions",
   "type": "module",
   "module": "src/index.js",
@@ -38,26 +38,30 @@
   "license": "MIT",
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
-    "@babel/cli": "^7.21.5",
-    "@babel/core": "^7.21.8",
-    "@babel/preset-env": "^7.21.5",
-    "@babel/register": "^7.21.0",
+    "@babel/cli": "^7.23.4",
+    "@babel/core": "^7.23.6",
+    "@babel/preset-env": "^7.23.6",
+    "@babel/register": "^7.22.15",
     "bpmn-elements-8-1": "npm:bpmn-elements@8.1",
-    "bpmn-engine": "^16.0.0",
+    "bpmn-engine": "^18.0.0",
     "bpmn-engine-14": "npm:bpmn-engine@14",
-    "bpmn-moddle": "^8.0.1",
-    "c8": "^7.13.0",
+    "bpmn-moddle": "^8.1.0",
+    "c8": "^8.0.1",
     "camunda-bpmn-moddle": "^7.0.1",
-    "chai": "^4.3.7",
-    "chronokinesis": "^5.0.2",
+    "chai": "^4.3.10",
+    "chronokinesis": "^6.0.0",
     "debug": "^4.3.4",
-    "eslint": "^8.39.0",
+    "eslint": "^8.56.0",
+    "eslint-plugin-import": "^2.29.1",
     "mocha": "^10.2.0",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^3.2.2"
+    "moddle-context-serializer": "^4.1.1"
+  },
+  "peerDependencies": {
+    "bpmn-elements": ">=8"
   },
   "dependencies": {
-    "cron-parser": "^4.8.1"
+    "cron-parser": "^4.9.0"
   },
   "files": [
     "src",

package/src/OnifyBoundaryEventExtensions.js

@@ -0,0 +1,65 @@
+import { OnifyElementExtensions } from './OnifyElementExtensions.js';
+
+export class OnifyBoundaryEventExtensions extends 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?.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?.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) {
+    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?.output?.length) {
+      result.assignToOutput = true;
+    }
+
+    return result;
+  }
+}

package/src/OnifyElementExtensions.js

@@ -4,69 +4,37 @@ export class OnifyElementExtensions {
   constructor(activity, context) {
     this.activity = activity;
     this.context = context;
-    const {Service} = this.extensions = getExtensions(activity, context);
+    this.formatQ = activity.broker.getQueue('format-run-q');
+    this._asyncFormatOnEnter = this._asyncFormatOnEnter.bind(this);
+
+    const { Service } = this.extensions = getExtensions(activity, context);
     if (Service) {
       activity.behaviour.Service = Service;
     }
   }
   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);
-      }, {consumerTag: '_onify-extension-on-enter'});
+      activity.on('start', this._asyncFormatOnEnter, {consumerTag: '_onify-extension-on-enter'});
     } else {
-      activity.on('enter', (elementApi) => {
-        this._formatOnEnter(broker, formatQ, elementApi);
-      }, {consumerTag: '_onify-extension-on-enter'});
+      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?.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?.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});
+    if (executionListeners?.onEnd) {
+      activity.on('end', (elementApi) => {
+        this._executeExecutionListener('end', elementApi);
       }, {consumerTag: '_onify-extension-on-listenerend'});
     }
   }
@@ -77,20 +45,29 @@ export 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;
+  async _asyncFormatOnEnter(elementApi) {
+    this.formatQ.queueMessage({routingKey: 'run.enter.format'}, {endRoutingKey: 'run.enter.complete'}, {persistent: false});
 
-    formatQ.queueMessage({routingKey: 'run.enter.format'}, {endRoutingKey: 'run.enter.complete'}, {persistent: false});
+    try {
+      var format = await this._onEnterAsync(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});
+  }
+  async _onExecutionCompleted(elementApi) {
+    this.formatQ.queueMessage({routingKey: 'run.end.format'}, { endRoutingKey: 'run.end.complete' }, { persistent: false });
 
     try {
-      var format = await this._onEnter(elementApi);
+      var format = await this._onExecuted(elementApi);
     } catch (err) {
-      return broker.publish('format', 'run.enter.error', {error: err}, {persistent: false});
+      return elementApi.broker.publish('format', 'run.end.error', { error: err }, {persistent: false});
     }
 
-    broker.publish('format', 'run.enter.complete', format, {persistent: false});
+    elementApi.broker.publish('format', 'run.end.complete', { ...format }, {persistent: false});
   }
-  async _onEnter(elementApi) {
+  async _onEnterAsync(elementApi) {
     const {format, properties, io, form} = this.extensions;
 
     const result = {};
@@ -147,4 +124,18 @@ export 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 });
+  }
 }

package/src/OnifySubProcessExtensions.js

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,25 @@
+import { TimerEventDefinition } from 'bpmn-elements';
+import cronParser from 'cron-parser';
+
+export class OnifyTimerEventDefinition extends TimerEventDefinition {
+  constructor(activity, def) {
+    super(activity, def);
+    Object.defineProperty(this, 'supports', {
+      value: ['cron'],
+    });
+  }
+  parse(timerType, value) {
+    let cron;
+    if (timerType === 'timeCycle' && (cron = cronParser.parseString(value))) {
+      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/formatters.js

@@ -10,6 +10,7 @@ export class FormatActivity {
     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);

package/src/index.js

@@ -1,19 +1,26 @@
-import {OnifyProcessExtensions} from './OnifyProcessExtensions.js';
-import {OnifyElementExtensions} from './OnifyElementExtensions.js';
-import {OnifySequenceFlow} from './OnifySequenceFlow.js';
+import { OnifyProcessExtensions } from './OnifyProcessExtensions.js';
+import { OnifyElementExtensions } from './OnifyElementExtensions.js';
+import { OnifyBoundaryEventExtensions } from './OnifyBoundaryEventExtensions.js';
+import { OnifySubProcessExtensions } from './OnifySubProcessExtensions.js';
 
-export {
-  extensions,
-  extendFn,
-  OnifySequenceFlow,
-};
+export { OnifySequenceFlow } from './OnifySequenceFlow.js';
+export { OnifyTimerEventDefinition } from './OnifyTimerEventDefinition.js';
 
-function extensions(element, context) {
-  if (element.type === 'bpmn:Process') return new OnifyProcessExtensions(element, context);
-  return new OnifyElementExtensions(element, context);
+export function extensions(element, context) {
+  switch (element.type) {
+    case 'bpmn:Process':
+      return new OnifyProcessExtensions(element, context);
+    case 'bpmn:SubProcess':
+    case 'bpmn:Transaction':
+      return new OnifySubProcessExtensions(element, context);
+    case 'bpmn:BoundaryEvent':
+      return new OnifyBoundaryEventExtensions(element, context);
+    default:
+      return new OnifyElementExtensions(element, context);
+  }
 }
 
-function extendFn(behaviour, 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});