@onify/flow-extensions 3.0.0 → 4.0.0

package/dist/src/OnifyElementExtensions.js

@@ -0,0 +1,223 @@
+"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');
+    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 !== 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) return result;
+    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/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,54 @@
+"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 = {
+    format: element.type === 'bpmn:Process' ? new _formatters.FormatProcess(element) : new _formatters.FormatActivity(element)
+  };
+  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) return result;
+  const listeners = new _ExecutionListeners.default(element, context);
+  let listener = 0;
+  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, listener++);
+        break;
+    }
+  }
+  if (listeners.length) result.listeners = listeners;
+  return result;
+}