@onify/flow-extensions 0.0.1

package/dist/src/FlowScripts.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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);
+    this.name = this.constructor.name;
+    this.message = fromErr.message;
+    Object.defineProperty(this, 'stack', {
+      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);
+    this.name = this.constructor.name;
+    this.message = fromErr.message;
+    Object.defineProperty(this, 'stack', {
+      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 = {};
+  this._timeout = timeout;
+  this._runContext = runContext;
+  this[kResources] = resourceBase;
+}
+
+FlowScripts.prototype.register = function register({
+  id,
+  type,
+  behaviour
+}) {
+  let language, scriptBody, resource;
+
+  switch (type) {
+    case 'bpmn:SequenceFlow':
+      {
+        if (!behaviour.conditionExpression) return;
+        language = behaviour.conditionExpression.language;
+        scriptBody = behaviour.conditionExpression.body;
+        resource = behaviour.conditionExpression.resource;
+        break;
+      }
+
+    default:
+      {
+        language = behaviour.scriptFormat;
+        scriptBody = behaviour.script;
+        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,
+      timeout: this._timeout
+    });
+  } else if (resource) {
+    this._scripts[id] = new JavaScriptResource(name, resource, this[kResources], this._runContext, {
+      filename,
+      timeout: this._timeout
+    });
+  }
+};
+
+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;
+
+  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,
+      Date,
+      console: {
+        log: console.log // eslint-disable-line no-console
+
+      },
+      Buffer: {
+        from: Buffer.from
+      },
+      contextName: this.flowName,
+      ...this._runContext,
+      next
+    }, {
+      timeout: this.timeout
+    });
+  } catch (err) {
+    return next(new FlowScriptError(err));
+  }
+
+  async 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;
+  this.options = options;
+  this._runContext = runContext;
+  this[kResources] = resourceBase;
+}
+
+JavaScriptResource.prototype.execute = async function execute(executionContext, callback) {
+  try {
+    var scriptBody = await _fs.promises.readFile((0, _path.join)(this[kResources], executionContext.resolveExpression(this.resource))); // eslint-disable-line no-var
+  } catch (err) {
+    const {
+      filename
+    } = this.options;
+    return callback(new Error(`${filename}: script resource ${this.resource} not found`));
+  }
+
+  const script = new JavaScript(this.flowName, scriptBody, this._runContext, { ...this.options,
+    filename: this.resource
+  });
+  return script.execute(executionContext, callback);
+};

package/dist/src/IO.js

@@ -0,0 +1,234 @@
+"use strict";
+
+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
+                } : undefined),
+                ...(resource ? {
+                  resource
+                } : undefined)
+              }
+            });
+            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;
+    if (!Array.isArray(entries)) return {
+      [name]: {}
+    };
+    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 {
+          const items = result[key] = [];
+          if (current !== undefined) items.push(current);
+          items.push(val);
+        }
+      } else {
+        result[key] = val;
+      }
+    }
+
+    return {
+      [name]: result
+    };
+  }
+
+}
+
+exports.IOMap = IOMap;
+
+class IOList extends IOBase {
+  constructor(parm) {
+    super(parm);
+  }
+
+  getValue(activity, executionMessage) {
+    var _this$behaviour$defin;
+
+    const name = this.name;
+    const items = (_this$behaviour$defin = this.behaviour.definition) === null || _this$behaviour$defin === void 0 ? void 0 : _this$behaviour$defin.items;
+    const result = [];
+    if (!Array.isArray(items)) return {
+      [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;
+    const environment = activity.environment;
+    const {
+      fields,
+      content,
+      properties,
+      ...rest
+    } = executionMessage;
+    const scope = {
+      id: this.scriptId,
+      type: this.type,
+      name,
+      fields,
+      content,
+      properties,
+      environment: activity.environment,
+      logger: activity.logger,
+      resolveExpression,
+      ...rest
+    };
+    const script = environment.scripts.getScript(definition.scriptFormat, {
+      id: this.id
+    });
+    return new Promise((resolve, reject) => {
+      return script.execute(scope, (err, result) => {
+        if (err) return reject(err);
+        resolve({
+          [name]: result
+        });
+      });
+    });
+
+    function resolveExpression(expression) {
+      return environment.resolveExpression(expression, scope);
+    }
+  }
+
+}
+
+exports.IOScript = IOScript;

package/dist/src/IOForm.js

@@ -0,0 +1,41 @@
+"use strict";
+
+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,
+        ...(field.label && {
+          defaultValue: elementApi.resolveExpression(field.label)
+        }),
+        ...(field.defaultValue && {
+          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

@@ -0,0 +1,30 @@
+"use strict";
+
+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,
+      value
+    } of this.behaviour.values) {
+      properties[id || name] = elementApi.resolveExpression(value);
+    }
+
+    return properties;
+  }
+
+}
+
+exports.default = IOProperties;

package/dist/src/ServiceExpression.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ServiceExpression;
+
+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) {
+  const serviceFn = this.activity.environment.resolveExpression(this.expression, executionMessage);
+  serviceFn.call(this.activity, executionMessage, (err, result) => {
+    callback(err, result);
+  });
+};