@onify/flow-extensions 9.1.1 → 10.0.0

package/dist/Connector.js

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

package/dist/ExecutionListeners.js

@@ -3,8 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.ExecutionListeners = void 0;
 class Listener {
+  /**
+   * @param {import('bpmn-elements').Activity | import('bpmn-elements').SequenceFlow} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   * @param {{$type:string, event:string, [x:string]: any}} extension
+   */
   constructor(activity, context, extension) {
     this.activity = activity;
     this.environment = this.activity.environment;
@@ -13,13 +18,24 @@ class Listener {
     this.type = extension.$type;
     this.event = extension.event;
   }
-  _getScope(message, extend) {
+  /**
+   * @param {import('bpmn-elements').IApi<any>} _api
+   * @returns {Promise<any>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  execute(_api) {}
+  /**
+   * @internal
+   * @param {import('bpmn-elements').IApi<any>} api
+   * @param {Record<string, any>} [extend]
+   */
+  _getScope(api, extend) {
     const environment = this.environment;
     const {
       fields,
       content,
       properties
-    } = message;
+    } = api;
     const scope = {
       ...extend,
       type: this.type,
@@ -36,6 +52,12 @@ class Listener {
     if (listenerFields) scope.listener.fields = listenerFields;
     return scope;
   }
+  /**
+   * @internal
+   * @param {import('bpmn-elements').Environment} environment
+   * @param {any} scope
+   * @returns {Record<string, any>}
+   */
   _getFields(environment, scope) {
     const fields = this.extension.fields;
     if (!fields?.length) return;
@@ -51,6 +73,12 @@ class Listener {
   }
 }
 class ScriptListener extends Listener {
+  /**
+   * @param {import('bpmn-elements').Activity | import('bpmn-elements').SequenceFlow} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   * @param {{script: {$type:string, [x:string]: any}, [x:string]: any}} extension
+   * @param {Number} pos execution listener position
+   */
   constructor(activity, context, extension, pos) {
     super(activity, context, extension);
     const id = this.id = `${activity.id}/${extension.script.$type}/${this.event}/${pos}`;
@@ -100,17 +128,23 @@ class ScriptListener extends Listener {
   }
 }
 class ExpressionListener extends Listener {
-  execute(message) {
-    const scope = this._getScope(message);
-    return {
+  execute(api) {
+    const scope = this._getScope(api);
+    return Promise.resolve({
       expression: this.environment.resolveExpression(this.extension.expression, scope)
-    };
+    });
   }
 }
 class ExecutionListeners {
+  /**
+   *
+   * @param {import('bpmn-elements').Activity | import('bpmn-elements').SequenceFlow} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
   constructor(activity, context) {
     this.activity = activity;
     this.context = context;
+    /** @type {(ScriptListener | ExpressionListener)[]} */
     this.listeners = [];
   }
   get length() {
@@ -144,4 +178,4 @@ class ExecutionListeners {
     return format;
   }
 }
-exports.default = ExecutionListeners;
+exports.ExecutionListeners = ExecutionListeners;

package/dist/FlowScripts.js

@@ -14,6 +14,7 @@ var _nodeVm = require("node:vm");
 const kSyntaxError = Symbol.for('syntax error');
 const kResources = Symbol.for('resources base');
 class FlowScriptError extends Error {
+  /** @param {Error} fromErr */
   constructor(fromErr) {
     super(fromErr.message);
     this.name = this.constructor.name;
@@ -35,6 +36,7 @@ class FlowScriptError extends Error {
 }
 exports.FlowScriptError = FlowScriptError;
 class FlowSyntaxError extends Error {
+  /** @param {Error} fromErr */
   constructor(fromErr) {
     super(fromErr.message);
     this.name = this.constructor.name;
@@ -56,20 +58,38 @@ class FlowSyntaxError extends Error {
 }
 exports.FlowSyntaxError = FlowSyntaxError;
 class FlowResourceError extends FlowScriptError {
+  /**
+   * @param {Error} fromErr
+   * @param {string} [filename]
+   */
   constructor(fromErr, filename) {
     super(fromErr);
     this.filename = filename;
     this.inner = fromErr;
   }
 }
+
+/**
+ * Flow scripts provider
+ * @param {string} flowName Flow name
+ * @param {string} resourceBase External resource base
+ * @param {any} [runContext] Optional script globals
+ * @param {number} [timeout] Optional execution timeout in milliseconds, default 60000
+ */
 exports.FlowResourceError = FlowResourceError;
 function FlowScripts(flowName, resourceBase, runContext, timeout = 60000) {
   this.flowName = flowName;
+  /** @type {Map<string, JavaScript | JavaScriptResource>} */
   this.scripts = new Map();
   this.timeout = timeout;
   this.runContext = runContext;
   this[kResources] = resourceBase;
 }
+
+/**
+ * Register script element
+ * @param {import('moddle-context-serializer').SerializableElement} element
+ */
 FlowScripts.prototype.register = function register({
   id,
   type,
@@ -94,7 +114,6 @@ FlowScripts.prototype.register = function register({
   }
   if (!language) return;
   if (!['js', 'javascript'].includes(language.toLowerCase().trim())) return;
-  language = 'javascript';
   const flowName = this.flowName;
   const filename = `${flowName}/${type}/${id}`;
   if (scriptBody) {
@@ -109,6 +128,12 @@ FlowScripts.prototype.register = function register({
     }));
   }
 };
+
+/**
+ * Get registered script
+ * @param {string} scriptType
+ * @param {{ id: string }} identifier
+ */
 FlowScripts.prototype.getScript = function getScript(scriptType, {
   id
 }) {
@@ -120,7 +145,7 @@ FlowScripts.prototype.getScript = function getScript(scriptType, {
  * @param {string} flowName
  * @param {string|Buffer} scriptBody
  * @param {any} [runContext]
- * @param {import('node:vm').ScriptOptions} options
+ * @param {import('node:vm').ScriptOptions & { filename?: string, timeout?: number }} [options]
  */
 function JavaScript(flowName, scriptBody, runContext, options) {
   this.flowName = flowName;
@@ -133,6 +158,12 @@ function JavaScript(flowName, scriptBody, runContext, options) {
     this[kSyntaxError] = new FlowSyntaxError(err);
   }
 }
+
+/**
+ * Execute script
+ * @param {import('bpmn-elements').ExecutionScope} executionContext
+ * @param {CallableFunction} callback
+ */
 JavaScript.prototype.execute = async function execute(executionContext, callback) {
   let callbackCalled;
   const syntaxError = this[kSyntaxError];
@@ -163,6 +194,15 @@ JavaScript.prototype.execute = async function execute(executionContext, callback
     callback(null, ...args);
   }
 };
+
+/**
+ * Java script resource
+ * @param {string} flowName
+ * @param {string} resource Resource name or path
+ * @param {string} resourceBase Resource base
+ * @param {any} [runContext]
+ * @param {import('node:vm').ScriptOptions & { filename?: string, timeout?: number }} [options]
+ */
 function JavaScriptResource(flowName, resource, resourceBase, runContext, options) {
   this.flowName = flowName;
   this.resource = resource;
@@ -175,12 +215,18 @@ function JavaScriptResource(flowName, resource, resourceBase, runContext, option
 /**
  * Get javascript resource content
  * @param {string} resourceBase Resource base
- * @param {*} resource Resource name or path
- * @returns {Promise<string|Buffer} Resource content
+ * @param {string} resource Resolved resource name or path
+ * @returns {Promise<string|Buffer>} Resource content
  */
 JavaScriptResource.prototype.getResourceContent = function getResourceContent(resourceBase, resource) {
   return _nodeFs.promises.readFile((0, _nodePath.join)(resourceBase, resource));
 };
+
+/**
+ * Execute script resource
+ * @param {import('bpmn-elements').ExecutionScope} executionContext
+ * @param {CallableFunction} callback
+ */
 JavaScriptResource.prototype.execute = async function execute(executionContext, callback) {
   let resource;
   try {

package/dist/IO.js

@@ -6,10 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.InputOutput = exports.IOScript = exports.IOList = exports.IOBase = void 0;
 class IOBase {
   constructor(parm) {
+    /** @type {string} */
     this.name = parm.name;
+    /** @type {string} */
     this.type = parm.definition && parm.definition.$type || 'string';
+    /** @type {any} */
     this.behaviour = parm;
   }
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ElementBrokerMessage} executionMessage
+   * @returns {Promise<{name: any}>}
+   */
   getValue(activity, executionMessage) {
     return {
       [this.name]: activity.environment.resolveExpression(this.behaviour.value, executionMessage)
@@ -18,9 +26,6 @@ class IOBase {
 }
 exports.IOBase = IOBase;
 class IOMap extends IOBase {
-  constructor(parm) {
-    super(parm);
-  }
   getValue(activity, executionMessage) {
     const name = this.name;
     const entries = this.behaviour.definition.entries;
@@ -122,30 +127,54 @@ class IOScript extends IOBase {
 }
 exports.IOScript = IOScript;
 class InputOutput {
+  /**
+   * @param {string} parentId
+   * @param {any} behaviour
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
   constructor(parentId, behaviour, context) {
     this.parentId = parentId;
     this.context = context;
     const {
       inputParameters,
       outputParameters
-    } = behaviour;
+    } = behaviour ?? {};
     this.input = this._map(parentId, inputParameters, 'input', context);
     this.output = this._map(parentId, outputParameters, 'output', context);
   }
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ElementBrokerMessage} executionMessage
+   * @returns {Promise<Record<string, any>}
+   */
   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), {});
   }
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ElementBrokerMessage} executionMessage
+   * @returns {Promise<Record<string, any>}
+   */
   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), {});
   }
+  /**
+   * @internal
+   * @param {string} parentId parent element id
+   * @param {any[]} list list of IO behaviours
+   * @param {string} ioType type of IO
+   * @param {import('bpmn-elements').ContextInstance} context
+   * @returns {IOBase[]}
+   */
   _map(parentId, list, ioType, context) {
     const mapped = [];
-    if (!list) return mapped;
+    if (!Array.isArray(list)) return mapped;
     for (const parm of list) {
+      if (!parm) continue;
       const definition = parm.definition;
       const type = definition && definition.$type;
       switch (type) {

package/dist/IOForm.js

@@ -3,14 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _IOProperties = _interopRequireDefault(require("./IOProperties.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+exports.IOForm = void 0;
+var _IOProperties = require("./IOProperties.js");
 class IOForm {
   constructor(activity, behaviour) {
     this.activity = activity;
     this.behaviour = behaviour;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   * @returns {Record<string, any>}
+   */
   resolve(elementApi) {
     const form = {};
     for (const field of this.behaviour.fields) {
@@ -24,10 +27,10 @@ class IOForm {
         })
       };
       if (f.properties) {
-        f.properties = new _IOProperties.default(this.activity, f.properties).resolve(elementApi);
+        f.properties = new _IOProperties.IOProperties(this.activity, f.properties).resolve(elementApi);
       }
     }
     return form;
   }
 }
-exports.default = IOForm;
+exports.IOForm = IOForm;

package/dist/IOProperties.js

@@ -3,12 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.IOProperties = void 0;
 class IOProperties {
   constructor(activity, behaviour) {
     this.activity = activity;
     this.behaviour = behaviour;
   }
+  /**
+   * @param {elementApi: import('bpmn-elements').IApi<any>} elementApi
+   * @returns {Record<string, any>}
+   */
   resolve(elementApi) {
     const properties = {};
     for (const {
@@ -21,4 +25,4 @@ class IOProperties {
     return properties;
   }
 }
-exports.default = IOProperties;
+exports.IOProperties = IOProperties;

package/dist/OnifyBoundaryEventExtensions.js

@@ -6,28 +6,33 @@ Object.defineProperty(exports, "__esModule", {
 exports.OnifyBoundaryEventExtensions = void 0;
 var _OnifyElementExtensions = require("./OnifyElementExtensions.js");
 class OnifyBoundaryEventExtensions extends _OnifyElementExtensions.OnifyElementExtensions {
+  #syncFormatOnEnter;
   constructor(activity, context) {
     super(activity, context);
-    this._syncFormatOnEnter = this._syncFormatOnEnter.bind(this);
+    this.#syncFormatOnEnter = this._syncFormatOnEnter.bind(this);
   }
   activate(message) {
     const activity = this.activity;
     const formatQ = activity.broker.getQueue('format-run-q');
     const executionListeners = this.extensions.listeners;
-    if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', this._syncFormatOnEnter, {
-        consumerTag: '_onify-extension-on-enter'
-      });
-    } else {
-      activity.on('enter', this._syncFormatOnEnter, {
-        consumerTag: '_onify-extension-on-enter'
+    if (this._formatOnEnter) {
+      if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
+        activity.on('start', this.#syncFormatOnEnter, {
+          consumerTag: '_onify-extension-on-enter'
+        });
+      } else {
+        activity.on('enter', this.#syncFormatOnEnter, {
+          consumerTag: '_onify-extension-on-enter'
+        });
+      }
+    }
+    if (this._formatOnEnd) {
+      activity.on('activity.execution.completed', elementApi => {
+        return this._onExecutionCompleted(elementApi, formatQ);
+      }, {
+        consumerTag: '_onify-extension-on-executed'
       });
     }
-    activity.on('activity.execution.completed', elementApi => {
-      return this._onExecutionCompleted(elementApi, formatQ);
-    }, {
-      consumerTag: '_onify-extension-on-executed'
-    });
     if (executionListeners?.onStart) {
       activity.on('start', async elementApi => {
         try {
@@ -47,6 +52,11 @@ class OnifyBoundaryEventExtensions extends _OnifyElementExtensions.OnifyElementE
       });
     }
   }
+  /**
+   * @internal
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   * @returns {void}
+   */
   _syncFormatOnEnter(elementApi) {
     try {
       var format = this._onEnterSync(elementApi);
@@ -61,6 +71,11 @@ class OnifyBoundaryEventExtensions extends _OnifyElementExtensions.OnifyElementE
       persistent: false
     });
   }
+  /**
+   * @internal
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   * @returns {void}
+   */
   _onEnterSync(elementApi) {
     const {
       format,

package/dist/OnifyElementExtensions.js

@@ -6,35 +6,49 @@ Object.defineProperty(exports, "__esModule", {
 exports.OnifyElementExtensions = void 0;
 var _getExtensions = require("./getExtensions.js");
 class OnifyElementExtensions {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
   constructor(activity, context) {
     this.activity = activity;
     this.context = context;
     this.formatQ = activity.broker.getQueue('format-run-q');
     this._asyncFormatOnEnter = this._asyncFormatOnEnter.bind(this);
     const {
-      Service
+      Service,
+      format,
+      properties,
+      io,
+      form
     } = this.extensions = (0, _getExtensions.getExtensions)(activity, context);
     if (Service) {
       activity.behaviour.Service = Service;
     }
+    this._formatOnEnter = Boolean(format?.hasFormatting || properties || form || io?.input.length || io?.output.length);
+    this._formatOnEnd = Boolean(properties || io?.output.length || format?.resultVariable);
   }
   activate(message) {
     const activity = this.activity;
     const executionListeners = this.extensions.listeners;
-    if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', this._asyncFormatOnEnter, {
-        consumerTag: '_onify-extension-on-enter'
-      });
-    } else {
-      activity.on('enter', this._asyncFormatOnEnter, {
-        consumerTag: '_onify-extension-on-enter'
+    if (this._formatOnEnter) {
+      if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
+        activity.on('start', this._asyncFormatOnEnter, {
+          consumerTag: '_onify-extension-on-enter'
+        });
+      } else {
+        activity.on('enter', this._asyncFormatOnEnter, {
+          consumerTag: '_onify-extension-on-enter'
+        });
+      }
+    }
+    if (this._formatOnEnd) {
+      activity.on('activity.execution.completed', elementApi => {
+        return this._onExecutionCompleted(elementApi);
+      }, {
+        consumerTag: '_onify-extension-on-executed'
       });
     }
-    activity.on('activity.execution.completed', elementApi => {
-      return this._onExecutionCompleted(elementApi);
-    }, {
-      consumerTag: '_onify-extension-on-executed'
-    });
     if (executionListeners?.onStart) {
       activity.on('start', elementApi => {
         this._executeExecutionListener('start', elementApi);

package/dist/OnifyProcessExtensions.js

@@ -7,6 +7,10 @@ exports.OnifyProcessExtensions = void 0;
 var _Errors = require("./Errors.js");
 var _getExtensions = require("./getExtensions.js");
 class OnifyProcessExtensions {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
   constructor(bp, context) {
     this.process = bp;
     this.context = context;

package/dist/OnifySequenceFlow.js

@@ -7,27 +7,35 @@ exports.OnifySequenceFlow = void 0;
 var _bpmnElements = require("bpmn-elements");
 var _getExtensions = require("./getExtensions.js");
 class OnifySequenceFlow extends _bpmnElements.SequenceFlow {
+  /**
+   * @param {import('bpmn-elements').SequenceFlowDefinition} flowDef
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
   constructor(flowDef, context) {
     super(flowDef, context);
     this.extensions = (0, _getExtensions.getExtensions)(this, context);
-    this._activate();
+    this.#activate();
   }
-  _activate() {
+  #activate() {
     if (!this.extensions.listeners?.onTake) return;
     this.broker.subscribeTmp('event', 'flow.take', (_, msg) => {
-      this._executeListeners(msg);
+      this.#executeListeners(msg);
     }, {
       noAck: true,
       consumerTag: '_onify-execution-listener'
     });
   }
-  async _executeListeners(message) {
+  async #executeListeners(message) {
     try {
       await this.extensions.listeners.execute('take', message);
     } catch (err) {
       this.logger.error(`<${this.id}> execution listener error: ${err}`);
     }
   }
+  /**
+   * @param {import('bpmn-elements').ElementBrokerMessage} fromMessage
+   * @param {(err: Error | null, result?: boolean | unknown) => void} callback
+   */
   evaluate(fromMessage, callback) {
     const properties = this.extensions.properties;
     if (!properties) return super.evaluate(fromMessage, callback);

package/dist/OnifySubProcessExtensions.js

@@ -6,25 +6,26 @@ Object.defineProperty(exports, "__esModule", {
 exports.OnifySubProcessExtensions = void 0;
 var _OnifyElementExtensions = require("./OnifyElementExtensions.js");
 class OnifySubProcessExtensions extends _OnifyElementExtensions.OnifyElementExtensions {
-  constructor(activity, context) {
-    super(activity, context);
-  }
   activate(runMessage) {
     const activity = this.activity;
     const broker = activity.broker;
     const executionListeners = this.extensions.listeners;
-    if (runMessage.fields.redelivered && runMessage.fields.routingKey === 'run.start') {
-      this._setupListener(broker, 'activity.start', elementApi => {
-        return this._asyncFormatOnEnter(elementApi);
-      }, '_onify-extension-on-enter');
-    } else {
-      this._setupListener(broker, 'activity.enter', elementApi => {
-        return this._asyncFormatOnEnter(elementApi);
-      }, '_onify-extension-on-enter');
+    if (this._formatOnEnter) {
+      if (runMessage.fields.redelivered && runMessage.fields.routingKey === 'run.start') {
+        this._setupListener(broker, 'activity.start', elementApi => {
+          return this._asyncFormatOnEnter(elementApi);
+        }, '_onify-extension-on-enter');
+      } else {
+        this._setupListener(broker, 'activity.enter', elementApi => {
+          return this._asyncFormatOnEnter(elementApi);
+        }, '_onify-extension-on-enter');
+      }
+    }
+    if (this._formatOnEnd) {
+      this._setupListener(broker, 'activity.execution.completed', elementApi => {
+        return this._onExecutionCompleted(elementApi);
+      }, '_onify-extension-on-executed');
     }
-    this._setupListener(broker, 'activity.execution.completed', elementApi => {
-      return this._onExecutionCompleted(elementApi);
-    }, '_onify-extension-on-executed');
     if (executionListeners?.onStart) {
       this._setupListener(broker, 'activity.start', elementApi => {
         this._executeExecutionListener('start', elementApi);

package/dist/OnifyTimerEventDefinition.js

@@ -7,12 +7,18 @@ exports.OnifyTimerEventDefinition = void 0;
 var _croner = require("croner");
 var _bpmnElements = require("bpmn-elements");
 class OnifyTimerEventDefinition extends _bpmnElements.TimerEventDefinition {
-  constructor(activity, def) {
-    super(activity, def);
-    Object.defineProperty(this, 'supports', {
-      value: ['cron', 'iso8601']
-    });
+  /**
+   * Supported timeCycle formats
+   * @returns {string[]}
+   */
+  get supports() {
+    return ['cron', 'iso8601'];
   }
+  /**
+   * @param {import('bpmn-elements').TimerType} timerType
+   * @param {string} value
+   * @returns {import('bpmn-elements').parsedTimer}
+   */
   parse(timerType, value) {
     if (timerType === 'timeCycle') {
       try {
@@ -29,7 +35,9 @@ class OnifyTimerEventDefinition extends _bpmnElements.TimerEventDefinition {
       } catch (err) {
         this.logger.error(`<${this.activity?.id}> failed to parse timeCycle: ${rangeError.message}`);
         this.logger.error(`<${this.activity?.id}> failed to parse timeCycle as cron: ${err.message}`);
-        throw new RangeError(`Failed to parse timeCycle <${value?.substring(0, 255)}> as ISO 8601 interval or cron`);
+        throw new RangeError(`Failed to parse timeCycle <${value?.substring(0, 255)}> as ISO 8601 interval or cron`, {
+          cause: err
+        });
       }
     }
     return super.parse(timerType, value);

package/dist/ServiceExpression.js

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