@onify/flow-extensions 3.0.0 → 4.1.0

package/dist/src/IO.js

@@ -3,80 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.InputOutput = exports.IOScript = exports.IOMap = exports.IOList = exports.IOBase = void 0;
-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;
-  }
-}
-exports.InputOutput = InputOutput;
+exports.InputOutput = exports.IOScript = exports.IOList = exports.IOBase = void 0;
 class IOBase {
   constructor(parm) {
     this.name = parm.name;
@@ -127,7 +54,6 @@ class IOMap extends IOBase {
     };
   }
 }
-exports.IOMap = IOMap;
 class IOList extends IOBase {
   constructor(parm) {
     super(parm);
@@ -194,4 +120,77 @@ class IOScript extends IOBase {
     }
   }
 }
-exports.IOScript = IOScript;
+exports.IOScript = 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;
+  }
+}
+exports.InputOutput = InputOutput;

package/dist/src/OnifyElementExtensions.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnifyElementExtensions = void 0;
+var _getExtensions = require("./getExtensions.js");
+class OnifyElementExtensions {
+  constructor(activity, context) {
+    this.activity = activity;
+    this.context = context;
+    const {
+      Service
+    } = this.extensions = (0, _getExtensions.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 !== 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
+        });
+      }, {
+        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
+        });
+      }, {
+        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) {
+      var _io$input, _io$output;
+      if ((_io$input = io.input) !== null && _io$input !== void 0 && _io$input.length) {
+        const input = await io.getInput(this.activity, elementApi);
+        Object.assign(result, {
+          input
+        });
+        Object.assign(elementApi.content, result);
+      }
+      if ((_io$output = io.output) !== null && _io$output !== void 0 && _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 !== null && io !== void 0 && 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;
+  }
+}
+exports.OnifyElementExtensions = OnifyElementExtensions;

package/dist/src/OnifyProcessExtensions.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnifyProcessExtensions = void 0;
+var _Errors = require("./Errors.js");
+var _getExtensions = require("./getExtensions.js");
+class OnifyProcessExtensions {
+  constructor(bp, context) {
+    this.process = bp;
+    this.context = context;
+    this.extensions = (0, _getExtensions.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 _Errors.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;
+  }
+}
+exports.OnifyProcessExtensions = OnifyProcessExtensions;

package/dist/src/OnifySequenceFlow.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnifySequenceFlow = void 0;
+var _bpmnElements = require("bpmn-elements");
+var _getExtensions = require("./getExtensions.js");
+class OnifySequenceFlow extends _bpmnElements.SequenceFlow {
+  constructor(flowDef, context) {
+    super(flowDef, context);
+    this.extensions = (0, _getExtensions.getExtensions)(this, context);
+    this._activate();
+  }
+  _activate() {
+    var _this$extensions$list;
+    if (!((_this$extensions$list = this.extensions.listeners) !== null && _this$extensions$list !== void 0 && _this$extensions$list.onTake)) return;
+    this.broker.subscribeTmp('event', 'flow.take', (_, msg) => {
+      this._executeListeners(msg);
+    }, {
+      noAck: true,
+      consumerTag: '_onify-execution-listener'
+    });
+  }
+  async _executeListeners(message) {
+    try {
+      await this.extensions.listeners.execute('take', message);
+    } catch (err) {
+      this.logger.error(`<${this.id}> execution listener error: ${err}`);
+    }
+  }
+  evaluate(fromMessage, callback) {
+    const properties = this.extensions.properties;
+    if (!properties) return super.evaluate(fromMessage, callback);
+    super.evaluate(fromMessage, (err, result) => {
+      if (err) return callback(err);
+      try {
+        let overriddenResult = result ? {} : false;
+        if (result) {
+          overriddenResult = {
+            ...(typeof result === 'object' && result),
+            properties: properties.resolve(this.getApi(fromMessage))
+          };
+        }
+        return callback(err, overriddenResult);
+      } catch (formatErr) {
+        return callback(formatErr);
+      }
+    });
+  }
+}
+exports.OnifySequenceFlow = OnifySequenceFlow;

package/dist/src/ServiceExpression.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = ServiceExpression;
-var _Errors = require("./Errors");
+var _Errors = require("./Errors.js");
 function ServiceExpression(activity) {
   if (!(this instanceof ServiceExpression)) return new ServiceExpression(activity);
   this.activity = activity;

package/dist/src/formatters.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormatProcess = exports.FormatActivity = void 0;
+var _cronParser = _interopRequireDefault(require("cron-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const iso8601cycle = /^\s*(R\d+\/)?P\w+/i;
+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) {
+    var _documentation$, _user, _groups;
+    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$ = documentation[0]) === null || _documentation$ === void 0 ? void 0 : _documentation$.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.default.parseExpression(cron).next().toDate();
+        if (!expireAt || expireAtDt < expireAt) expireAt = expireAtDt;
+      }
+    }
+    return {
+      ...(this.resultVariable && {
+        resultVariable: this.resultVariable
+      }),
+      ...(scheduledStart && activity.parent.type === 'bpmn:Process' && {
+        scheduledStart
+      }),
+      ...(((_user = user) === null || _user === void 0 ? void 0 : _user.length) && {
+        candidateUsers: user
+      }),
+      ...(((_groups = groups) === null || _groups === void 0 ? void 0 : _groups.length) && {
+        candidateGroups: groups
+      }),
+      ...(!elementApi.content.description && description && {
+        description: elementApi.resolveExpression(description)
+      }),
+      ...(expireAt && {
+        expireAt
+      }),
+      ...(assigneeValue && {
+        assignee: assigneeValue
+      })
+    };
+  }
+}
+exports.FormatActivity = FormatActivity;
+class FormatProcess {
+  constructor(bp) {
+    this.process = bp;
+  }
+  resolve(elementApi) {
+    var _documentation$2, _user2, _groups2;
+    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$2 = documentation[0]) === null || _documentation$2 === void 0 ? void 0 : _documentation$2.text;
+    return {
+      ...(((_user2 = user) === null || _user2 === void 0 ? void 0 : _user2.length) && {
+        candidateStarterUsers: user
+      }),
+      ...(((_groups2 = groups) === null || _groups2 === void 0 ? void 0 : _groups2.length) && {
+        candidateStarterGroups: groups
+      }),
+      ...(!elementApi.content.description && description && {
+        description: elementApi.resolveExpression(description)
+      })
+    };
+  }
+}
+exports.FormatProcess = FormatProcess;
+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/dist/src/getExtensions.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtensions = getExtensions;
+var _formatters = require("./formatters.js");
+var _IO = require("./IO.js");
+var _Connector = _interopRequireDefault(require("./Connector.js"));
+var _ExecutionListeners = _interopRequireDefault(require("./ExecutionListeners.js"));
+var _IOForm = _interopRequireDefault(require("./IOForm.js"));
+var _IOProperties = _interopRequireDefault(require("./IOProperties.js"));
+var _ServiceExpression = _interopRequireDefault(require("./ServiceExpression.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getExtensions(element, context) {
+  var _element$behaviour$ex, _ext$values, _ext$fields;
+  const result = {};
+  switch (element.type) {
+    case 'bpmn:SequenceFlow':
+      break;
+    case 'bpmn:Process':
+      result.format = new _formatters.FormatProcess(element);
+      break;
+    default:
+      result.format = new _formatters.FormatActivity(element);
+  }
+  let listenerPosition = 0;
+  const listeners = new _ExecutionListeners.default(element, context);
+  const expression = element.behaviour.expression;
+  if (expression) result.Service = _ServiceExpression.default;
+  const extensions = (_element$behaviour$ex = element.behaviour.extensionElements) === null || _element$behaviour$ex === void 0 ? void 0 : _element$behaviour$ex.values;
+  if (extensions) {
+    for (const ext of extensions) {
+      switch (ext.$type) {
+        case 'camunda:Properties':
+          if ((_ext$values = ext.values) !== null && _ext$values !== void 0 && _ext$values.length) result.properties = new _IOProperties.default(element, ext);
+          break;
+        case 'camunda:InputOutput':
+          result.io = new _IO.InputOutput(element.id, ext, context);
+          break;
+        case 'camunda:FormData':
+          if ((_ext$fields = ext.fields) !== null && _ext$fields !== void 0 && _ext$fields.length) result.form = new _IOForm.default(element, ext);
+          break;
+        case 'camunda:Connector':
+          {
+            const {
+              connectorId,
+              inputOutput
+            } = ext;
+            const io = inputOutput && new _IO.InputOutput(`${element.id}/${ext.$type.toLowerCase()}`, inputOutput, context);
+            result.Service = _Connector.default.bind(_Connector.default, connectorId, io);
+            break;
+          }
+        case 'camunda:ExecutionListener':
+          listeners.add(ext, listenerPosition++);
+          break;
+      }
+    }
+  }
+  if (listeners.length) result.listeners = listeners;
+  return result;
+}