@onify/flow-extensions 6.0.0 → 7.0.0

package/CHANGELOG.md

@@ -1,6 +1,16 @@
 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`

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

@@ -19,11 +19,22 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/flow-extensions",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "Onify Flow extensions",
   "type": "module",
   "module": "src/index.js",
@@ -39,20 +39,20 @@
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
     "@babel/cli": "^7.23.4",
-    "@babel/core": "^7.23.5",
-    "@babel/preset-env": "^7.23.5",
+    "@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": "^17.1.1",
+    "bpmn-engine": "^18.0.0",
     "bpmn-engine-14": "npm:bpmn-engine@14",
-    "bpmn-moddle": "^8.0.1",
+    "bpmn-moddle": "^8.1.0",
     "c8": "^8.0.1",
     "camunda-bpmn-moddle": "^7.0.1",
     "chai": "^4.3.10",
     "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"

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

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