@onify/flow-extensions 3.0.0 → 4.1.0

package/index.js

@@ -1,24 +1,11 @@
-import cronParser from 'cron-parser';
-import IOProperties from './src/IOProperties.js';
-import IOForm from './src/IOForm.js';
-import Connector from './src/Connector.js';
-import ServiceExpression from './src/ServiceExpression.js';
-import {InputOutput} from './src/IO.js';
-import ExtensionListeners from './src/ExecutionListeners.js';
-
-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};
-  }
-}
+import {OnifyProcessExtensions} from './src/OnifyProcessExtensions.js';
+import {OnifyElementExtensions} from './src/OnifyElementExtensions.js';
+import {OnifySequenceFlow} from './src/OnifySequenceFlow.js';
 
 export {
   extensions,
   extendFn,
+  OnifySequenceFlow,
 };
 
 function extensions(element, context) {
@@ -26,321 +13,6 @@ function extensions(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?.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?.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) {
-      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;
-  }
-}
-
-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 ExtensionListeners(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;
-}
-
-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;
-    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.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}),
-    };
-  }
-}
-
-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);
-}
-
 function extendFn(behaviour, context) {
   if (behaviour.$type === 'bpmn:StartEvent' && behaviour.eventDefinitions) {
     const timer = behaviour.eventDefinitions.find(({type, behaviour: edBehaviour}) => edBehaviour && type === 'bpmn:TimerEventDefinition');
@@ -373,11 +45,13 @@ function registerIOScripts(parentId, context, type, ioBehaviour) {
     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}),
       ...(definition.resource && {resource: definition.resource}),
     });
@@ -392,6 +66,7 @@ function registerListenerScript(parentId, context, type, listener, pos) {
   context.addScript(id, {
     id,
     scriptFormat: script.scriptFormat,
+    type,
     ...(script.value && {body: script.value}),
     ...(script.resource && {resource: script.resource}),
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/flow-extensions",
-  "version": "3.0.0",
+  "version": "4.1.0",
   "description": "Onify Flow extensions",
   "module": "index.js",
   "main": "dist/index.js",
@@ -35,26 +35,26 @@
   "license": "MIT",
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
-    "@babel/cli": "^7.19.3",
-    "@babel/core": "^7.20.2",
-    "@babel/preset-env": "^7.20.2",
-    "@babel/register": "^7.18.9",
+    "@babel/cli": "^7.21.5",
+    "@babel/core": "^7.21.5",
+    "@babel/preset-env": "^7.21.5",
+    "@babel/register": "^7.21.0",
     "bpmn-elements-8-1": "npm:bpmn-elements@8.1",
-    "bpmn-engine": "^15.1.2",
+    "bpmn-engine": "^16.0.0",
     "bpmn-engine-14": "npm:bpmn-engine@14",
-    "bpmn-moddle": "^7.1.3",
-    "c8": "^7.12.0",
+    "bpmn-moddle": "^8.0.1",
+    "c8": "^7.13.0",
     "camunda-bpmn-moddle": "^7.0.1",
     "chai": "^4.3.7",
-    "chronokinesis": "^3.1.2",
+    "chronokinesis": "^5.0.2",
     "debug": "^4.3.4",
-    "eslint": "^8.28.0",
-    "mocha": "^10.1.0",
+    "eslint": "^8.39.0",
+    "mocha": "^10.2.0",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^2.1.0"
+    "moddle-context-serializer": "^3.2.2"
   },
   "dependencies": {
-    "cron-parser": "^4.7.0"
+    "cron-parser": "^4.8.1"
   },
   "files": [
     "src",

package/src/Connector.js

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

package/src/Errors.js

@@ -1,4 +1,4 @@
-class NotImplemented extends Error {
+export class NotImplemented extends Error {
   constructor(serviceId) {
     super(`${serviceId} service function not found`);
     this.code = 'EFLOW_NOT_IMPLEMENTED';
@@ -6,6 +6,10 @@ class NotImplemented extends Error {
   }
 }
 
-export {
-  NotImplemented,
-};
+export class FormatError extends Error {
+  constructor(elementId, err) {
+    super(`<${elementId}> ${err.message}`);
+    this.code = 'EFLOW_FORMAT';
+    this.output = {statusCode: 500};
+  }
+}

package/src/ExecutionListeners.js

@@ -49,6 +49,8 @@ class ScriptListener extends Listener {
   execute(api) {
     const environment = this.environment;
     const scope = this._getScope(api, {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});
 
     return new Promise((resolve, reject) => {
@@ -66,7 +68,7 @@ class ScriptListener extends Listener {
     const {
       scriptFormat,
       value,
-      resource
+      resource,
     } = script;
 
     context.environment.scripts.register({
@@ -75,12 +77,12 @@ class ScriptListener extends Listener {
       behaviour: {
         scriptFormat,
         ...(value && {
-          script: value
+          script: value,
         }),
         ...(resource && {
-          resource
-        })
-      }
+          resource,
+        }),
+      },
     });
   }
 }
@@ -97,22 +99,26 @@ export default 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;
+    const {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/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;
@@ -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;
+  }
+}