@onify/flow-extensions 6.0.0 → 7.1.0

package/src/ExecutionListeners.js

@@ -10,7 +10,7 @@ class Listener {
   _getScope(message, extend) {
     const environment = this.environment;
 
-    const {fields, content, properties} = message;
+    const { fields, content, properties } = message;
     const scope = {
       ...extend,
       type: this.type,
@@ -33,7 +33,7 @@ class Listener {
     const fields = this.extension.fields;
     if (!fields?.length) return;
     const result = {};
-    for (const {name, expression, string} of fields) {
+    for (const { name, expression, string } of fields) {
       result['' + name] = expression ? environment.resolveExpression(expression, scope) : string;
     }
     return result;
@@ -43,15 +43,15 @@ class Listener {
 class ScriptListener extends Listener {
   constructor(activity, context, extension, pos) {
     super(activity, context, extension);
-    const id = this.id = `${activity.id}/${extension.script.$type}/${this.event}/${pos}`;
+    const id = (this.id = `${activity.id}/${extension.script.$type}/${this.event}/${pos}`);
     this._register(context, id, extension.script);
   }
   execute(api) {
     const environment = this.environment;
-    const scope = this._getScope(api, {id: this.id, resolveExpression});
+    const scope = this._getScope(api, { id: this.id, resolveExpression });
     const listenerFields = this._getFields(environment, scope);
     if (listenerFields) scope.listener.fields = listenerFields;
-    const script = this.environment.scripts.getScript(this.extension.scriptFormat, {id: this.id});
+    const script = this.environment.scripts.getScript(this.extension.scriptFormat, { id: this.id });
 
     return new Promise((resolve, reject) => {
       return script.execute(scope, (err, result) => {
@@ -65,11 +65,7 @@ class ScriptListener extends Listener {
     }
   }
   _register(context, id, script) {
-    const {
-      scriptFormat,
-      value,
-      resource,
-    } = script;
+    const { scriptFormat, value, resource } = script;
 
     context.environment.scripts.register({
       id,
@@ -90,7 +86,7 @@ class ScriptListener extends Listener {
 class ExpressionListener extends Listener {
   execute(message) {
     const scope = this._getScope(message);
-    return {expression: this.environment.resolveExpression(this.extension.expression, scope)};
+    return { expression: this.environment.resolveExpression(this.extension.expression, scope) };
   }
 }
 
@@ -113,7 +109,7 @@ export default class ExecutionListeners {
     return this.listeners.some((l) => l.event === 'take');
   }
   add(extension, pos) {
-    const {script, expression} = extension;
+    const { script, expression } = extension;
     if (!script && !expression) return;
 
     const list = this.listeners;

package/src/IO.js

@@ -1,7 +1,7 @@
 export class IOBase {
   constructor(parm) {
     this.name = parm.name;
-    this.type = parm.definition && parm.definition.$type || 'string';
+    this.type = (parm.definition && parm.definition.$type) || 'string';
     this.behaviour = parm;
   }
   getValue(activity, executionMessage) {
@@ -18,12 +18,12 @@ class IOMap extends IOBase {
   getValue(activity, executionMessage) {
     const name = this.name;
     const entries = this.behaviour.definition.entries;
-    if (!Array.isArray(entries)) return {[name]: {}};
+    if (!Array.isArray(entries)) return { [name]: {} };
 
     const environment = activity.environment;
 
     const result = {};
-    for (const {key, value} of entries) {
+    for (const { key, value } of entries) {
       if (!key) continue;
 
       const val = environment.resolveExpression(value, executionMessage);
@@ -33,7 +33,7 @@ class IOMap extends IOBase {
         if (Array.isArray(current)) {
           current.push(val);
         } else {
-          const items = result[key] = [];
+          const items = (result[key] = []);
           if (current !== undefined) items.push(current);
           items.push(val);
         }
@@ -42,7 +42,7 @@ class IOMap extends IOBase {
       }
     }
 
-    return {[name]: result};
+    return { [name]: result };
   }
 }
 
@@ -55,7 +55,7 @@ export class IOList extends IOBase {
     const items = this.behaviour.definition.items;
 
     const result = [];
-    if (!Array.isArray(items)) return {[name]: result};
+    if (!Array.isArray(items)) return { [name]: result };
 
     const environment = activity.environment;
     for (const item of items) {
@@ -80,7 +80,7 @@ export class IOScript extends IOBase {
     const name = this.name;
     const environment = activity.environment;
 
-    const {fields, content, properties, ...rest} = executionMessage;
+    const { fields, content, properties, ...rest } = executionMessage;
     const scope = {
       id: this.id,
       type: this.type,
@@ -94,12 +94,12 @@ export class IOScript extends IOBase {
       ...rest,
     };
 
-    const script = environment.scripts.getScript(definition.scriptFormat, {id: this.id});
+    const script = environment.scripts.getScript(definition.scriptFormat, { id: this.id });
 
     return new Promise((resolve, reject) => {
       return script.execute(scope, (err, result) => {
         if (err) return reject(err);
-        resolve({[name]: result});
+        resolve({ [name]: result });
       });
     });
 
@@ -113,7 +113,7 @@ export class InputOutput {
   constructor(parentId, behaviour, context) {
     this.parentId = parentId;
     this.context = context;
-    const {inputParameters, outputParameters} = behaviour;
+    const { inputParameters, outputParameters } = behaviour;
     this.input = this._map(parentId, inputParameters, 'input', context);
     this.output = this._map(parentId, outputParameters, 'output', context);
   }
@@ -145,7 +145,7 @@ export class InputOutput {
         }
         case 'camunda:Script': {
           const id = `${parentId}/${ioType}/${type}/${parm.name}`;
-          const {scriptFormat, value, resource} = definition;
+          const { scriptFormat, value, resource } = definition;
 
           if (!value && !resource) break;
 
@@ -154,8 +154,8 @@ export class InputOutput {
             type: parm.$type,
             behaviour: {
               scriptFormat,
-              ...(value && {script: value}),
-              ...(resource && {resource}),
+              ...(value && { script: value }),
+              ...(resource && { resource }),
             },
           });
 

package/src/IOForm.js

@@ -8,11 +8,11 @@ export default class IOForm {
   resolve(elementApi) {
     const form = {};
     for (const field of this.behaviour.fields) {
-      const f = form[field.id] = {
+      const f = (form[field.id] = {
         ...field,
-        ...(field.label && {defaultValue: elementApi.resolveExpression(field.label)}),
-        ...(field.defaultValue && {defaultValue: elementApi.resolveExpression(field.defaultValue)}),
-      };
+        ...(field.label && { defaultValue: elementApi.resolveExpression(field.label) }),
+        ...(field.defaultValue && { defaultValue: elementApi.resolveExpression(field.defaultValue) }),
+      });
       if (f.properties) {
         f.properties = new IOProperties(this.activity, f.properties).resolve(elementApi);
       }

package/src/IOProperties.js

@@ -6,7 +6,7 @@ export default class IOProperties {
   resolve(elementApi) {
     const properties = {};
 
-    for (const {id, name, value} of this.behaviour.values) {
+    for (const { id, name, value } of this.behaviour.values) {
       properties[id || name] = elementApi.resolveExpression(value);
     }
 

package/src/OnifyBoundaryEventExtensions.js

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

@@ -1,150 +1,153 @@
-import {getExtensions} from './getExtensions.js';
-
-export class OnifyElementExtensions {
-  constructor(activity, context) {
-    this.activity = activity;
-    this.context = context;
-    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'});
-    } else {
-      activity.on('enter', (elementApi) => {
-        this._formatOnEnter(broker, formatQ, elementApi);
-      }, {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});
-    }, {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});
-      }, {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});
-      }, {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 _formatOnEnter(broker, formatQ, elementApi) {
-    if (this.activity.isSubProcess && this.activity.id !== elementApi.id) return;
-
-    formatQ.queueMessage({routingKey: 'run.enter.format'}, {endRoutingKey: 'run.enter.complete'}, {persistent: false});
-
-    try {
-      var format = await this._onEnter(elementApi);
-    } catch (err) {
-      return broker.publish('format', 'run.enter.error', {error: err}, {persistent: false});
-    }
-
-    broker.publish('format', 'run.enter.complete', format, {persistent: false});
-  }
-  async _onEnter(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;
-  }
-}
+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 });
+  }
+}