@onify/flow-extensions 2.0.0 → 4.0.0

package/src/IO.js

@@ -1,75 +1,4 @@
-export {
-  InputOutput,
-  IOBase,
-  IOMap,
-  IOList,
-  IOScript,
-};
-
-class InputOutput {
-  constructor(parentId, behaviour, context) {
-    this.parentId = parentId;
-    this.context = context;
-    const {inputParameters, outputParameters} = behaviour;
-    this.input = this._map(parentId, inputParameters, 'input', context);
-    this.output = this._map(parentId, outputParameters, 'output', context);
-  }
-  async getInput(activity, executionMessage) {
-    const input = this.input;
-    const values = await Promise.all(input.map((parm) => parm.getValue(activity, executionMessage)));
-    return values.reduce((result, parm) => Object.assign(result, parm), {});
-  }
-  async getOutput(activity, executionMessage) {
-    const output = this.output;
-    const values = await Promise.all(output.map((parm) => parm.getValue(activity, executionMessage)));
-    return values.reduce((result, parm) => Object.assign(result, parm), {});
-  }
-  _map(parentId, list, ioType, context) {
-    const mapped = [];
-    if (!list) return mapped;
-
-    for (const parm of list) {
-      const definition = parm.definition;
-      const type = definition && definition.$type;
-      switch (type) {
-        case 'camunda:Map': {
-          mapped.push(new IOMap(parm));
-          break;
-        }
-        case 'camunda:List': {
-          mapped.push(new IOList(parm));
-          break;
-        }
-        case 'camunda:Script': {
-          const id = `${parentId}/${ioType}/${type}/${parm.name}`;
-          const {scriptFormat, value, resource} = definition;
-
-          if (!value && !resource) break;
-
-          context.environment.scripts.register({
-            id,
-            type: parm.$type,
-            behaviour: {
-              scriptFormat,
-              ...(value && {script: value}),
-              ...(resource && {resource}),
-            },
-          });
-
-          mapped.push(new IOScript(parm, id));
-          break;
-        }
-        default: {
-          mapped.push(new IOBase(parm));
-        }
-      }
-    }
-
-    return mapped;
-  }
-}
-
-class IOBase {
+export class IOBase {
   constructor(parm) {
     this.name = parm.name;
     this.type = parm.definition && parm.definition.$type || 'string';
@@ -117,7 +46,7 @@ class IOMap extends IOBase {
   }
 }
 
-class IOList extends IOBase {
+export class IOList extends IOBase {
   constructor(parm) {
     super(parm);
   }
@@ -140,7 +69,7 @@ class IOList extends IOBase {
   }
 }
 
-class IOScript extends IOBase {
+export class IOScript extends IOBase {
   constructor(parm, scriptId) {
     super(parm);
     this.id = scriptId;
@@ -153,7 +82,7 @@ class IOScript extends IOBase {
 
     const {fields, content, properties, ...rest} = executionMessage;
     const scope = {
-      id: this.scriptId,
+      id: this.id,
       type: this.type,
       name,
       fields,
@@ -179,3 +108,66 @@ class IOScript extends IOBase {
     }
   }
 }
+
+export class InputOutput {
+  constructor(parentId, behaviour, context) {
+    this.parentId = parentId;
+    this.context = context;
+    const {inputParameters, outputParameters} = behaviour;
+    this.input = this._map(parentId, inputParameters, 'input', context);
+    this.output = this._map(parentId, outputParameters, 'output', context);
+  }
+  async getInput(activity, executionMessage) {
+    const input = this.input;
+    const values = await Promise.all(input.map((parm) => parm.getValue(activity, executionMessage)));
+    return values.reduce((result, parm) => Object.assign(result, parm), {});
+  }
+  async getOutput(activity, executionMessage) {
+    const output = this.output;
+    const values = await Promise.all(output.map((parm) => parm.getValue(activity, executionMessage)));
+    return values.reduce((result, parm) => Object.assign(result, parm), {});
+  }
+  _map(parentId, list, ioType, context) {
+    const mapped = [];
+    if (!list) return mapped;
+
+    for (const parm of list) {
+      const definition = parm.definition;
+      const type = definition && definition.$type;
+      switch (type) {
+        case 'camunda:Map': {
+          mapped.push(new IOMap(parm));
+          break;
+        }
+        case 'camunda:List': {
+          mapped.push(new IOList(parm));
+          break;
+        }
+        case 'camunda:Script': {
+          const id = `${parentId}/${ioType}/${type}/${parm.name}`;
+          const {scriptFormat, value, resource} = definition;
+
+          if (!value && !resource) break;
+
+          context.environment.scripts.register({
+            id,
+            type: parm.$type,
+            behaviour: {
+              scriptFormat,
+              ...(value && {script: value}),
+              ...(resource && {resource}),
+            },
+          });
+
+          mapped.push(new IOScript(parm, id));
+          break;
+        }
+        default: {
+          mapped.push(new IOBase(parm));
+        }
+      }
+    }
+
+    return mapped;
+  }
+}

package/src/OnifyElementExtensions.js

@@ -0,0 +1,150 @@
+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');
+
+    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'});
+
+    const executionListeners = this.extensions.listeners;
+    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) return result;
+
+    if (assignToOutput && typeof output === 'object') {
+      Object.assign(this.activity.environment.output, output);
+    } else if (resultVariable) {
+      elementApi.environment.output[resultVariable] = output;
+    }
+
+    return result;
+  }
+}

package/src/OnifyProcessExtensions.js

@@ -0,0 +1,40 @@
+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/ServiceExpression.js

@@ -1,4 +1,4 @@
-import {NotImplemented} from './Errors';
+import {NotImplemented} from './Errors.js';
 
 export default function ServiceExpression(activity) {
   if (!(this instanceof ServiceExpression)) return new ServiceExpression(activity);

package/src/formatters.js

@@ -0,0 +1,97 @@
+import cronParser from 'cron-parser';
+
+const iso8601cycle = /^\s*(R\d+\/)?P\w+/i;
+
+export class FormatActivity {
+  constructor(activity) {
+    this.activity = activity;
+    this.resultVariable = activity.behaviour.resultVariable;
+
+    let timeCycles;
+    if (activity.eventDefinitions) {
+      for (const ed of activity.eventDefinitions.filter((e) => e.type === 'bpmn:TimerEventDefinition')) {
+        if (!('timeCycle' in ed)) continue;
+        timeCycles = timeCycles || [];
+        timeCycles.push(ed.timeCycle);
+      }
+    }
+    this.timeCycles = timeCycles;
+  }
+  resolve(elementApi) {
+    let user, groups, assigneeValue, description;
+    const activity = this.activity;
+    const {
+      documentation,
+      candidateUsers,
+      candidateGroups,
+      scheduledStart,
+      assignee,
+    } = activity.behaviour;
+
+    if (candidateUsers) user = resolveAndSplit(elementApi, candidateUsers);
+    if (candidateGroups) groups = resolveAndSplit(elementApi, candidateGroups);
+    if (assignee) assigneeValue = elementApi.resolveExpression(assignee);
+    if (documentation) description = documentation[0]?.text;
+
+    let expireAt;
+    const timeCycles = this.timeCycles;
+    if (timeCycles) {
+      for (const cycle of timeCycles) {
+        const cron = elementApi.resolveExpression(cycle);
+        if (!cron || iso8601cycle.test(cron)) continue;
+
+        const expireAtDt = cronParser.parseExpression(cron).next().toDate();
+        if (!expireAt || expireAtDt < expireAt) expireAt = expireAtDt;
+      }
+    }
+
+    return {
+      ...(this.resultVariable && {resultVariable: this.resultVariable}),
+      ...(scheduledStart && activity.parent.type === 'bpmn:Process' && {scheduledStart}),
+      ...(user?.length && {candidateUsers: user}),
+      ...(groups?.length && {candidateGroups: groups}),
+      ...(!elementApi.content.description && description && {description: elementApi.resolveExpression(description)}),
+      ...(expireAt && {expireAt}),
+      ...(assigneeValue && {assignee: assigneeValue}),
+    };
+  }
+}
+
+export class FormatProcess {
+  constructor(bp) {
+    this.process = bp;
+  }
+  resolve(elementApi) {
+    let user, groups, description;
+    const bp = this.process;
+    const {
+      documentation,
+      candidateStarterUsers,
+      candidateStarterGroups,
+    } = bp.behaviour;
+
+    if (candidateStarterUsers) user = resolveAndSplit(elementApi, candidateStarterUsers);
+    if (candidateStarterGroups) groups = resolveAndSplit(elementApi, candidateStarterGroups);
+    if (documentation) description = documentation[0]?.text;
+
+    return {
+      ...(user?.length && {candidateStarterUsers: user}),
+      ...(groups?.length && {candidateStarterGroups: groups}),
+      ...(!elementApi.content.description && description && {description: elementApi.resolveExpression(description)}),
+    };
+  }
+}
+
+function resolveAndSplit(elementApi, str) {
+  if (Array.isArray(str)) return str.filter(Boolean);
+  if (typeof str !== 'string') return;
+
+  const resolved = elementApi.resolveExpression(str);
+  if (Array.isArray(resolved)) return resolved.filter(Boolean);
+  if (typeof resolved !== 'string') return;
+
+  return resolved
+    .split(',')
+    .map((g) => g.trim && g.trim().toLowerCase())
+    .filter(Boolean);
+}

package/src/getExtensions.js

@@ -0,0 +1,49 @@
+import {FormatActivity, FormatProcess} from './formatters.js';
+import {InputOutput} from './IO.js';
+import Connector from './Connector.js';
+import ExecutionListeners from './ExecutionListeners.js';
+import IOForm from './IOForm.js';
+import IOProperties from './IOProperties.js';
+import ServiceExpression from './ServiceExpression.js';
+
+export function getExtensions(element, context) {
+  const result = {
+    format: element.type === 'bpmn:Process' ? new FormatProcess(element) : new FormatActivity(element),
+  };
+
+  const expression = element.behaviour.expression;
+  if (expression) result.Service = ServiceExpression;
+
+  const extensions = element.behaviour.extensionElements?.values;
+  if (!extensions) return result;
+
+  const listeners = new ExecutionListeners(element, context);
+
+  let listener = 0;
+  for (const ext of extensions) {
+    switch (ext.$type) {
+      case 'camunda:Properties':
+        if (ext.values?.length) result.properties = new IOProperties(element, ext);
+        break;
+      case 'camunda:InputOutput':
+        result.io = new InputOutput(element.id, ext, context);
+        break;
+      case 'camunda:FormData':
+        if (ext.fields?.length) result.form = new IOForm(element, ext);
+        break;
+      case 'camunda:Connector': {
+        const {connectorId, inputOutput} = ext;
+        const io = inputOutput && new InputOutput(`${element.id}/${ext.$type.toLowerCase()}`, inputOutput, context);
+        result.Service = Connector.bind(Connector, connectorId, io);
+        break;
+      }
+      case 'camunda:ExecutionListener':
+        listeners.add(ext, listener++);
+        break;
+    }
+  }
+
+  if (listeners.length) result.listeners = listeners;
+
+  return result;
+}