@onify/flow-extensions 7.0.0 → 8.0.0

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

@@ -1,65 +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;
-  }
-}
+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,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;
+  }
+}