@onify/flow-extensions 3.0.0 → 4.1.0

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 Changelog
 =========
 
+# 4.1.0
+
+- Support sequence flow properties and take execution listener. Requires `bpmn-elements >= 9.2`
+
+# 4.0.0
+
+- make sure sub-process extensions are only triggered once. Sub process activities unintentionally trigger formatting since events bubble
+- add script element type to registered scripts
+- restructure and split up index.js to separate files
+- abide to new lint rules
+
 # 3.0.0
 
 - Support activity script and expression execution listeners

package/README.md

@@ -120,3 +120,92 @@ function getModdleContext(source, options) {
   return bpmnModdle.fromXML(Buffer.isBuffer(source) ? source.toString() : source.trim());
 }
 ```
+
+## Extend sequence flow with properties and take listeners
+
+```js
+const {OnifySequenceFlow, extensions} = require('@onify/flow-extensions');
+const FlowScripts = require('@onify/flow-extensions/dist/src/FlowScripts');
+const {Engine} = require('bpmn-engine');
+const Elements = require('bpmn-elements');
+
+const source = `
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions
+  id="Def_0"
+  xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+  targetNamespace="http://bpmn.io/schema/bpmn">
+  <process id="Process_1kk79yr" isExecutable="true">
+    <startEvent id="start" />
+    <sequenceFlow id="to-script" sourceRef="start" targetRef="script">
+      <extensionElements>
+        <camunda:properties>
+          <camunda:property name="source" value="\${content.id}" />
+        </camunda:properties>
+        <camunda:executionListener event="take">
+          <camunda:script scriptFormat="js">environment.output.fields = listener.fields; next();</camunda:script>
+          <camunda:field name="taken">
+            <camunda:expression>\${true}</camunda:expression>
+          </camunda:field>
+          <camunda:field name="bar">
+            <camunda:string>baz</camunda:string>
+          </camunda:field>
+        </camunda:executionListener>
+      </extensionElements>
+    </sequenceFlow>
+    <sequenceFlow id="to-end" sourceRef="script" targetRef="end">
+      <extensionElements>
+        <camunda:properties>
+          <camunda:property name="foo" value="bar" />
+        </camunda:properties>
+      </extensionElements>
+    </sequenceFlow>
+    <scriptTask id="script" name="script" scriptFormat="js">
+      <script>next(null, { foo: environment.variables.required.input });</script>
+    </scriptTask>
+    <boundaryEvent id="catch-err" attachedToRef="script">
+      <errorEventDefinition />
+    </boundaryEvent>
+    <endEvent id="end-err">
+      <extensionElements>
+        <camunda:executionListener event="start">
+          <camunda:script scriptFormat="js">
+            environment.output.failedBy = content.inbound[0].properties.error;
+            if (next) next();
+          </camunda:script>
+        </camunda:executionListener>
+      </extensionElements>
+    </endEvent>
+    <sequenceFlow id="to-end-err" sourceRef="catch-err" targetRef="end-err">
+      <extensionElements>
+        <camunda:properties>
+          <camunda:property name="error" value="\${content.output}" />
+        </camunda:properties>
+      </extensionElements>
+    </sequenceFlow>
+    <endEvent id="end" />
+  </process>
+</definitions>`;
+
+const engine = new Engine({
+  name: 'sequence flow extension',
+  source,
+  moddleOptions: {
+    camunda: require('camunda-bpmn-moddle/resources/camunda.json'),
+  },
+  extensions: {
+    onify: extensions,
+  },
+  scripts: new FlowScripts('sequence flow extension'),
+  elements: {
+    ...Elements,
+    SequenceFlow: OnifySequenceFlow,
+  },
+});
+
+engine.execute((err, instance) => {
+  if (err) throw err;
+  console.log(instance.name, instance.environment.output);
+});
+```

package/dist/index.js

@@ -3,423 +3,20 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "OnifySequenceFlow", {
+  enumerable: true,
+  get: function () {
+    return _OnifySequenceFlow.OnifySequenceFlow;
+  }
+});
 exports.extendFn = extendFn;
 exports.extensions = extensions;
-var _cronParser = _interopRequireDefault(require("cron-parser"));
-var _IOProperties = _interopRequireDefault(require("./src/IOProperties.js"));
-var _IOForm = _interopRequireDefault(require("./src/IOForm.js"));
-var _Connector = _interopRequireDefault(require("./src/Connector.js"));
-var _ServiceExpression = _interopRequireDefault(require("./src/ServiceExpression.js"));
-var _IO = require("./src/IO.js");
-var _ExecutionListeners = _interopRequireDefault(require("./src/ExecutionListeners.js"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const iso8601cycle = /^\s*(R\d+\/)?P\w+/i;
-class FormatError extends Error {
-  constructor(elementId, err) {
-    super(`<${elementId}> ${err.message}`);
-    this.code = 'EFLOW_FORMAT';
-    this.output = {
-      statusCode: 500
-    };
-  }
-}
+var _OnifyProcessExtensions = require("./src/OnifyProcessExtensions.js");
+var _OnifyElementExtensions = require("./src/OnifyElementExtensions.js");
+var _OnifySequenceFlow = require("./src/OnifySequenceFlow.js");
 function extensions(element, context) {
-  if (element.type === 'bpmn:Process') return new OnifyProcessExtensions(element, context);
-  return new OnifyElementExtensions(element, context);
-}
-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;
-  }
-}
-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 => {
-      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 => {
-        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 => {
-        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) {
-    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;
-  }
-}
-function getExtensions(element, context) {
-  var _element$behaviour$ex, _ext$values, _ext$fields;
-  const result = {
-    format: element.type === 'bpmn:Process' ? new FormatProcess(element) : new 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;
-}
-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;
-    let 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
-      })
-    };
-  }
-}
-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)
-      })
-    };
-  }
-}
-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);
+  if (element.type === 'bpmn:Process') return new _OnifyProcessExtensions.OnifyProcessExtensions(element, context);
+  return new _OnifyElementExtensions.OnifyElementExtensions(element, context);
 }
 function extendFn(behaviour, context) {
   var _behaviour$extensionE;
@@ -461,10 +58,12 @@ function registerIOScripts(parentId, context, type, ioBehaviour) {
   } of inputParameters.concat(outputParameters)) {
     if (!definition) continue;
     if (definition.$type !== 'camunda:Script') continue;
-    const filename = `${parentId}/${type}/${$type}/${name}`;
+    const ioType = `${type}/${$type}`;
+    const filename = `${parentId}/${ioType}/${name}`;
     context.addScript(filename, {
       id: filename,
       scriptFormat: definition.scriptFormat,
+      type: ioType,
       ...(definition.value && {
         body: definition.value
       }),
@@ -484,6 +83,7 @@ function registerListenerScript(parentId, context, type, listener, pos) {
   context.addScript(id, {
     id,
     scriptFormat: script.scriptFormat,
+    type,
     ...(script.value && {
       body: script.value
     }),

package/dist/src/Connector.js

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

package/dist/src/Errors.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NotImplemented = void 0;
+exports.NotImplemented = exports.FormatError = void 0;
 class NotImplemented extends Error {
   constructor(serviceId) {
     super(`${serviceId} service function not found`);
@@ -13,4 +13,14 @@ class NotImplemented extends Error {
     };
   }
 }
-exports.NotImplemented = NotImplemented;
+exports.NotImplemented = NotImplemented;
+class FormatError extends Error {
+  constructor(elementId, err) {
+    super(`<${elementId}> ${err.message}`);
+    this.code = 'EFLOW_FORMAT';
+    this.output = {
+      statusCode: 500
+    };
+  }
+}
+exports.FormatError = FormatError;

package/dist/src/ExecutionListeners.js

@@ -62,6 +62,8 @@ class ScriptListener extends Listener {
       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
     });
@@ -109,23 +111,27 @@ class ExecutionListeners {
     this.activity = activity;
     this.context = context;
     this.listeners = [];
-    this.onStart = false;
-    this.onEnd = false;
   }
   get length() {
     return this.listeners.length;
   }
+  get onStart() {
+    return this.listeners.some(l => l.event === 'start');
+  }
+  get onEnd() {
+    return this.listeners.some(l => l.event === 'end');
+  }
+  get onTake() {
+    return this.listeners.some(l => l.event === 'take');
+  }
   add(extension, pos) {
     const {
-      event,
       script,
       expression
     } = extension;
     if (!script && !expression) return;
     const list = this.listeners;
     if (script && (script.value || script.resource)) list.push(new ScriptListener(this.activity, this.context, extension, pos));else if (expression) list.push(new ExpressionListener(this.activity, this.context, extension));
-    if (event === 'start') this.onStart = true;
-    if (event === 'end') this.onEnd = true;
   }
   async execute(event, message) {
     const found = this.listeners.filter(l => l.event === event);

package/dist/src/FlowScripts.js

@@ -80,7 +80,7 @@ FlowScripts.prototype.register = function register({
         resource = behaviour.resource;
       }
   }
-  if (!language) language = 'javascript';
+  if (!language) return;
   if (!['js', 'javascript'].includes(language.toLowerCase().trim())) return;
   language = 'javascript';
   const name = this._name;