@onify/flow-extensions 1.1.0 → 3.0.0

package/dist/src/ExecutionListeners.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class Listener {
+  constructor(activity, context, extension) {
+    this.activity = activity;
+    this.environment = this.activity.environment;
+    this.context = context;
+    this.extension = extension;
+    this.type = extension.$type;
+    this.event = extension.event;
+  }
+  _getScope(message, extend) {
+    const environment = this.environment;
+    const {
+      fields,
+      content,
+      properties
+    } = message;
+    const scope = {
+      ...extend,
+      type: this.type,
+      listener: {
+        event: this.event
+      },
+      fields,
+      content,
+      properties,
+      environment,
+      logger: this.activity.logger
+    };
+    const listenerFields = this._getFields(environment, scope);
+    if (listenerFields) scope.listener.fields = listenerFields;
+    return scope;
+  }
+  _getFields(environment, scope) {
+    const fields = this.extension.fields;
+    if (!(fields !== null && fields !== void 0 && fields.length)) return;
+    const result = {};
+    for (const {
+      name,
+      expression,
+      string
+    } of fields) {
+      result['' + name] = expression ? environment.resolveExpression(expression, scope) : string;
+    }
+    return result;
+  }
+}
+class ScriptListener extends Listener {
+  constructor(activity, context, extension, pos) {
+    super(activity, context, extension);
+    const id = this.id = `${activity.id}/${extension.script.$type}/${this.event}/${pos}`;
+    this._register(context, id, extension.script);
+  }
+  execute(api) {
+    const environment = this.environment;
+    const scope = this._getScope(api, {
+      id: this.id,
+      resolveExpression
+    });
+    const script = this.environment.scripts.getScript(this.extension.scriptFormat, {
+      id: this.id
+    });
+    return new Promise((resolve, reject) => {
+      return script.execute(scope, (err, result) => {
+        if (err) return reject(err);
+        resolve(result);
+      });
+    });
+    function resolveExpression(expression) {
+      return environment.resolveExpression(expression, scope);
+    }
+  }
+  _register(context, id, script) {
+    const {
+      scriptFormat,
+      value,
+      resource
+    } = script;
+    context.environment.scripts.register({
+      id,
+      type: this.type,
+      behaviour: {
+        scriptFormat,
+        ...(value && {
+          script: value
+        }),
+        ...(resource && {
+          resource
+        })
+      }
+    });
+  }
+}
+class ExpressionListener extends Listener {
+  execute(message) {
+    const scope = this._getScope(message);
+    return {
+      expression: this.environment.resolveExpression(this.extension.expression, scope)
+    };
+  }
+}
+class ExecutionListeners {
+  constructor(activity, context) {
+    this.activity = activity;
+    this.context = context;
+    this.listeners = [];
+    this.onStart = false;
+    this.onEnd = false;
+  }
+  get length() {
+    return this.listeners.length;
+  }
+  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);
+    const format = {};
+    for (const f of found) {
+      const result = await f.execute(message);
+      if (result !== null && typeof result === 'object') Object.assign(format, result);
+    }
+    return format;
+  }
+}
+exports.default = ExecutionListeners;

package/dist/src/FlowScripts.js

@@ -6,16 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 exports.FlowScripts = FlowScripts;
 exports.JavaScript = JavaScript;
 exports.JavaScriptResource = JavaScriptResource;
-
 var _path = require("path");
-
 var _fs = require("fs");
-
 var _vm = require("vm");
-
 const kSyntaxError = Symbol.for('syntax error');
 const kResources = Symbol.for('resources base');
-
 class FlowScriptError extends Error {
   constructor(fromErr) {
     super(fromErr.message);
@@ -25,22 +20,17 @@ class FlowScriptError extends Error {
       get() {
         return fromErr.stack && fromErr.stack.split('\n').slice(0, 7).join('\n');
       }
-
     });
     Object.defineProperty(this, 'code', {
       get() {
         return 'EFLOW_SCRIPT';
       }
-
     });
   }
-
   toString() {
     return '[FlowScriptError] ' + this.message + '\n' + this.stack;
   }
-
 }
-
 class FlowSyntaxError extends Error {
   constructor(fromErr) {
     super(fromErr.message);
@@ -50,22 +40,17 @@ class FlowSyntaxError extends Error {
       get() {
         return fromErr.stack && fromErr.stack.split('\n').slice(0, 6).join('\n');
       }
-
     });
     Object.defineProperty(this, 'code', {
       get() {
         return 'EFLOW_SCRIPT';
       }
-
     });
   }
-
   toString() {
     return '[FlowSyntaxError] ' + this.message + '\n' + this.stack;
   }
-
 }
-
 function FlowScripts(flowName, resourceBase, runContext, timeout = 60000) {
   this._name = flowName;
   this._scripts = {};
@@ -73,14 +58,12 @@ function FlowScripts(flowName, resourceBase, runContext, timeout = 60000) {
   this._runContext = runContext;
   this[kResources] = resourceBase;
 }
-
 FlowScripts.prototype.register = function register({
   id,
   type,
   behaviour
 }) {
   let language, scriptBody, resource;
-
   switch (type) {
     case 'bpmn:SequenceFlow':
       {
@@ -90,7 +73,6 @@ FlowScripts.prototype.register = function register({
         resource = behaviour.conditionExpression.resource;
         break;
       }
-
     default:
       {
         language = behaviour.scriptFormat;
@@ -98,13 +80,11 @@ FlowScripts.prototype.register = function register({
         resource = behaviour.resource;
       }
   }
-
   if (!language) language = 'javascript';
   if (!['js', 'javascript'].includes(language.toLowerCase().trim())) return;
   language = 'javascript';
   const name = this._name;
   const filename = `${name}/${type}/${id}`;
-
   if (scriptBody) {
     this._scripts[id] = new JavaScript(name, scriptBody, this._runContext, {
       filename,
@@ -117,37 +97,33 @@ FlowScripts.prototype.register = function register({
     });
   }
 };
-
 FlowScripts.prototype.getScript = function getScript(scriptType, {
   id
 }) {
   return this._scripts[id];
 };
-
 function JavaScript(flowName, scriptBody, runContext, options) {
   this.flowName = flowName;
   this._runContext = runContext;
-  this.timeout = options && options.timeout;
-
+  this.timeout = options === null || options === void 0 ? void 0 : options.timeout;
   try {
     this.script = new _vm.Script(scriptBody, options);
   } catch (err) {
     this[kSyntaxError] = new FlowSyntaxError(err);
   }
 }
-
 JavaScript.prototype.execute = async function execute(executionContext, callback) {
   let callbackCalled;
   const syntaxError = this[kSyntaxError];
   if (syntaxError) return next(syntaxError);
-
   try {
-    await this.script.runInNewContext({ ...executionContext,
+    await this.script.runInNewContext({
+      ...executionContext,
       Date,
       console: {
         log: console.log // eslint-disable-line no-console
-
       },
+
       Buffer: {
         from: Buffer.from
       },
@@ -160,15 +136,13 @@ JavaScript.prototype.execute = async function execute(executionContext, callback
   } catch (err) {
     return next(new FlowScriptError(err));
   }
-
-  async function next(err, ...args) {
+  function next(err, ...args) {
     if (callbackCalled) return;
     callbackCalled = true;
     if (err) return callback(err);
     callback(null, ...args);
   }
 };
-
 function JavaScriptResource(flowName, resource, resourceBase, runContext, options) {
   this.flowName = flowName;
   this.resource = resource;
@@ -176,19 +150,23 @@ function JavaScriptResource(flowName, resource, resourceBase, runContext, option
   this._runContext = runContext;
   this[kResources] = resourceBase;
 }
-
 JavaScriptResource.prototype.execute = async function execute(executionContext, callback) {
+  let resource;
   try {
-    var scriptBody = await _fs.promises.readFile((0, _path.join)(this[kResources], executionContext.resolveExpression(this.resource))); // eslint-disable-line no-var
+    resource = executionContext.resolveExpression(this.resource);
+    var scriptBody = await _fs.promises.readFile((0, _path.join)(this[kResources], resource)); // eslint-disable-line no-var
   } catch (err) {
+    if (err instanceof SyntaxError) {
+      return callback(err);
+    }
     const {
       filename
     } = this.options;
-    return callback(new Error(`${filename}: script resource ${this.resource} not found`));
+    return callback(new Error(`${filename}: script resource ${resource || this.resource} not found`));
   }
-
-  const script = new JavaScript(this.flowName, scriptBody, this._runContext, { ...this.options,
-    filename: this.resource
+  const script = new JavaScript(this.flowName, scriptBody, this._runContext, {
+    ...this.options,
+    filename: `${this.options.filename}/${resource}`
   });
   return script.execute(executionContext, callback);
 };

package/dist/src/IO.js

@@ -4,7 +4,6 @@ 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;
@@ -16,40 +15,33 @@ class InputOutput {
     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}`;
@@ -75,43 +67,33 @@ class InputOutput {
             mapped.push(new IOScript(parm, id));
             break;
           }
-
         default:
           {
             mapped.push(new IOBase(parm));
           }
       }
     }
-
     return mapped;
   }
-
 }
-
 exports.InputOutput = InputOutput;
-
 class IOBase {
   constructor(parm) {
     this.name = parm.name;
     this.type = parm.definition && parm.definition.$type || 'string';
     this.behaviour = parm;
   }
-
   getValue(activity, executionMessage) {
     return {
       [this.name]: activity.environment.resolveExpression(this.behaviour.value, executionMessage)
     };
   }
-
 }
-
 exports.IOBase = IOBase;
-
 class IOMap extends IOBase {
   constructor(parm) {
     super(parm);
   }
-
   getValue(activity, executionMessage) {
     const name = this.name;
     const entries = this.behaviour.definition.entries;
@@ -120,18 +102,15 @@ class IOMap extends IOBase {
     };
     const environment = activity.environment;
     const result = {};
-
     for (const {
       key,
       value
     } of entries) {
       if (!key) continue;
       const val = environment.resolveExpression(value, executionMessage);
-
       if (key in result) {
         if (val === undefined) continue;
         const current = result[key];
-
         if (Array.isArray(current)) {
           current.push(val);
         } else {
@@ -143,21 +122,16 @@ class IOMap extends IOBase {
         result[key] = val;
       }
     }
-
     return {
       [name]: result
     };
   }
-
 }
-
 exports.IOMap = IOMap;
-
 class IOList extends IOBase {
   constructor(parm) {
     super(parm);
   }
-
   getValue(activity, executionMessage) {
     const name = this.name;
     const items = this.behaviour.definition.items;
@@ -166,28 +140,22 @@ class IOList extends IOBase {
       [name]: result
     };
     const environment = activity.environment;
-
     for (const item of items) {
       const val = environment.resolveExpression(item.value, executionMessage);
       if (val !== undefined) result.push(val);
     }
-
     return {
       [name]: result
     };
   }
-
 }
-
 exports.IOList = IOList;
-
 class IOScript extends IOBase {
   constructor(parm, scriptId) {
     super(parm);
     this.id = scriptId;
     this.script = true;
   }
-
   getValue(activity, executionMessage) {
     const definition = this.behaviour.definition;
     const name = this.name;
@@ -199,7 +167,7 @@ class IOScript extends IOBase {
       ...rest
     } = executionMessage;
     const scope = {
-      id: this.scriptId,
+      id: this.id,
       type: this.type,
       name,
       fields,
@@ -221,12 +189,9 @@ class IOScript extends IOBase {
         });
       });
     });
-
     function resolveExpression(expression) {
       return environment.resolveExpression(expression, scope);
     }
   }
-
 }
-
 exports.IOScript = IOScript;

package/dist/src/IOForm.js

@@ -4,22 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _IOProperties = _interopRequireDefault(require("./IOProperties.js"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 class IOForm {
   constructor(activity, behaviour) {
     this.activity = activity;
     this.behaviour = behaviour;
   }
-
   resolve(elementApi) {
     const form = {};
-
     for (const field of this.behaviour.fields) {
-      const f = form[field.id] = { ...field,
+      const f = form[field.id] = {
+        ...field,
         ...(field.label && {
           defaultValue: elementApi.resolveExpression(field.label)
         }),
@@ -27,15 +23,11 @@ class IOForm {
           defaultValue: elementApi.resolveExpression(field.defaultValue)
         })
       };
-
       if (f.properties) {
         f.properties = new _IOProperties.default(this.activity, f.properties).resolve(elementApi);
       }
     }
-
     return form;
   }
-
 }
-
 exports.default = IOForm;

package/dist/src/IOProperties.js

@@ -4,16 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 class IOProperties {
   constructor(activity, behaviour) {
     this.activity = activity;
     this.behaviour = behaviour;
   }
-
   resolve(elementApi) {
     const properties = {};
-
     for (const {
       id,
       name,
@@ -21,10 +18,7 @@ class IOProperties {
     } of this.behaviour.values) {
       properties[id || name] = elementApi.resolveExpression(value);
     }
-
     return properties;
   }
-
 }
-
 exports.default = IOProperties;

package/dist/src/ServiceExpression.js

@@ -4,16 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = ServiceExpression;
-
 var _Errors = require("./Errors");
-
 function ServiceExpression(activity) {
   if (!(this instanceof ServiceExpression)) return new ServiceExpression(activity);
   this.activity = activity;
   this.type = `${activity.type}:expression`;
   this.expression = activity.behaviour.expression;
 }
-
 ServiceExpression.prototype.execute = function execute(executionMessage, callback) {
   try {
     const expression = this.expression;
@@ -22,7 +19,6 @@ ServiceExpression.prototype.execute = function execute(executionMessage, callbac
   } catch (err) {
     return callback(err);
   }
-
   serviceFn.call(this.activity, executionMessage, (err, result) => {
     callback(err, result);
   });