@onify/flow-extensions 7.0.0 → 7.1.0

package/src/OnifyElementExtensions.js

@@ -1,141 +1,153 @@
-import {getExtensions} from './getExtensions.js';
-
-export 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 = getExtensions(activity, context);
-    if (Service) {
-      activity.behaviour.Service = Service;
-    }
-  }
-  activate(message) {
-    const activity = this.activity;
-    const executionListeners = this.extensions.listeners;
-
-    if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', this._asyncFormatOnEnter, {consumerTag: '_onify-extension-on-enter'});
-    } else {
-      activity.on('enter', this._asyncFormatOnEnter, {consumerTag: '_onify-extension-on-enter'});
-    }
-
-    activity.on('activity.execution.completed', (elementApi) => {
-      return this._onExecutionCompleted(elementApi);
-    }, {consumerTag: '_onify-extension-on-executed'});
-
-    if (executionListeners?.onStart) {
-      activity.on('start', (elementApi) => {
-        this._executeExecutionListener('start', elementApi);
-      }, {consumerTag: '_onify-extension-on-listenerstart'});
-    }
-
-    if (executionListeners?.onEnd) {
-      activity.on('end', (elementApi) => {
-        this._executeExecutionListener('end', elementApi);
-      }, {consumerTag: '_onify-extension-on-listenerend'});
-    }
-  }
-  deactivate() {
-    const broker = this.activity.broker;
-    broker.cancel('_onify-extension-on-enter');
-    broker.cancel('_onify-extension-on-executed');
-    broker.cancel('_onify-extension-on-listenerstart');
-    broker.cancel('_onify-extension-on-listenerend');
-  }
-  async _asyncFormatOnEnter(elementApi) {
-    this.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._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, io, form} = 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) {
-      if (io.input?.length) {
-        const input = await io.getInput(this.activity, elementApi);
-        Object.assign(result, {input});
-        Object.assign(elementApi.content, result);
-      }
-      if (io.output?.length) {
-        result.assignToOutput = true;
-      }
-    }
-
-    if (form) {
-      Object.assign(result, {form: form.resolve(elementApi)});
-    }
-
-    return result;
-  }
-  async _onExecuted(elementApi) {
-    const {properties, io} = this.extensions;
-
-    const result = {};
-    if (io?.output.length) {
-      const output = await io.getOutput(this.activity, elementApi);
-      Object.assign(result, {output});
-      Object.assign(elementApi.content, {output});
-    }
-
-    if (properties) {
-      const props = properties.resolve(elementApi);
-      Object.assign(result, {properties: props});
-      Object.assign(elementApi.content, {properties: props});
-    }
-
-    const {output, assignToOutput, resultVariable} = elementApi.content;
-
-    if (output !== undefined && output !== null) {
-      if (assignToOutput && typeof output === 'object') {
-        Object.assign(this.activity.environment.output, output);
-      } else if (resultVariable) {
-        elementApi.environment.output[resultVariable] = output;
-      }
-    }
-
-    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 });
-  }
-}
+import { getExtensions } from './getExtensions.js';
+
+export 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 = getExtensions(activity, context));
+    if (Service) {
+      activity.behaviour.Service = Service;
+    }
+  }
+  activate(message) {
+    const activity = this.activity;
+    const executionListeners = this.extensions.listeners;
+
+    if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
+      activity.on('start', this._asyncFormatOnEnter, { consumerTag: '_onify-extension-on-enter' });
+    } else {
+      activity.on('enter', this._asyncFormatOnEnter, { consumerTag: '_onify-extension-on-enter' });
+    }
+
+    activity.on(
+      'activity.execution.completed',
+      (elementApi) => {
+        return this._onExecutionCompleted(elementApi);
+      },
+      { consumerTag: '_onify-extension-on-executed' },
+    );
+
+    if (executionListeners?.onStart) {
+      activity.on(
+        'start',
+        (elementApi) => {
+          this._executeExecutionListener('start', elementApi);
+        },
+        { consumerTag: '_onify-extension-on-listenerstart' },
+      );
+    }
+
+    if (executionListeners?.onEnd) {
+      activity.on(
+        'end',
+        (elementApi) => {
+          this._executeExecutionListener('end', elementApi);
+        },
+        { consumerTag: '_onify-extension-on-listenerend' },
+      );
+    }
+  }
+  deactivate() {
+    const broker = this.activity.broker;
+    broker.cancel('_onify-extension-on-enter');
+    broker.cancel('_onify-extension-on-executed');
+    broker.cancel('_onify-extension-on-listenerstart');
+    broker.cancel('_onify-extension-on-listenerend');
+  }
+  async _asyncFormatOnEnter(elementApi) {
+    this.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._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, io, form } = 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) {
+      if (io.input?.length) {
+        const input = await io.getInput(this.activity, elementApi);
+        Object.assign(result, { input });
+        Object.assign(elementApi.content, result);
+      }
+      if (io.output?.length) {
+        result.assignToOutput = true;
+      }
+    }
+
+    if (form) {
+      Object.assign(result, { form: form.resolve(elementApi) });
+    }
+
+    return result;
+  }
+  async _onExecuted(elementApi) {
+    const { properties, io } = this.extensions;
+
+    const result = {};
+    if (io?.output.length) {
+      const output = await io.getOutput(this.activity, elementApi);
+      Object.assign(result, { output });
+      Object.assign(elementApi.content, { output });
+    }
+
+    if (properties) {
+      const props = properties.resolve(elementApi);
+      Object.assign(result, { properties: props });
+      Object.assign(elementApi.content, { properties: props });
+    }
+
+    const { output, assignToOutput, resultVariable } = elementApi.content;
+
+    if (output !== undefined && output !== null) {
+      if (assignToOutput && typeof output === 'object') {
+        Object.assign(this.activity.environment.output, output);
+      } else if (resultVariable) {
+        elementApi.environment.output[resultVariable] = output;
+      }
+    }
+
+    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/OnifyProcessExtensions.js

@@ -1,40 +1,49 @@
-import {FormatError} from './Errors.js';
-import {getExtensions} from './getExtensions.js';
-
-export class OnifyProcessExtensions {
-  constructor(bp, context) {
-    this.process = bp;
-    this.context = context;
-    this.extensions = getExtensions(bp, context);
-    this._activate();
-  }
-  _activate() {
-    const bp = this.process;
-    bp.on('process.enter', (elementApi) => {
-      try {
-        const result = this._onEnter(elementApi);
-        const environment = elementApi.environment;
-        environment.assignVariables(result);
-      } catch (err) {
-        elementApi.broker.publish('event', 'process.error', {
-          ...elementApi.content,
-          error: new FormatError(bp.id, err),
-        }, {mandatory: true, type: 'error'});
-      }
-    }, {consumerTag: '_onify-extension-on-enter'});
-  }
-  _onEnter(elementApi) {
-    const {format, properties} = this.extensions;
-    const result = {};
-
-    Object.assign(result, format.resolve(elementApi));
-    Object.assign(elementApi.content, result);
-
-    if (properties) {
-      Object.assign(result, properties.resolve(elementApi));
-      Object.assign(elementApi.content, result);
-    }
-
-    return result;
-  }
-}
+import { FormatError } from './Errors.js';
+import { getExtensions } from './getExtensions.js';
+
+export class OnifyProcessExtensions {
+  constructor(bp, context) {
+    this.process = bp;
+    this.context = context;
+    this.extensions = getExtensions(bp, context);
+    this._activate();
+  }
+  _activate() {
+    const bp = this.process;
+    bp.on(
+      'process.enter',
+      (elementApi) => {
+        try {
+          const result = this._onEnter(elementApi);
+          const environment = elementApi.environment;
+          environment.assignVariables(result);
+        } catch (err) {
+          elementApi.broker.publish(
+            'event',
+            'process.error',
+            {
+              ...elementApi.content,
+              error: new FormatError(bp.id, err),
+            },
+            { mandatory: true, type: 'error' },
+          );
+        }
+      },
+      { consumerTag: '_onify-extension-on-enter' },
+    );
+  }
+  _onEnter(elementApi) {
+    const { format, properties } = this.extensions;
+    const result = {};
+
+    Object.assign(result, format.resolve(elementApi));
+    Object.assign(elementApi.content, result);
+
+    if (properties) {
+      Object.assign(result, properties.resolve(elementApi));
+      Object.assign(elementApi.content, result);
+    }
+
+    return result;
+  }
+}

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 {

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/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);