bpmn-elements 15.0.3 → 16.1.0

package/dist/tasks/index.js

@@ -3,91 +3,104 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _CallActivity = require("./CallActivity.js");
-Object.keys(_CallActivity).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _CallActivity[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _CallActivity[key];
-    }
-  });
-});
-var _ReceiveTask = require("./ReceiveTask.js");
-Object.keys(_ReceiveTask).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _ReceiveTask[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _ReceiveTask[key];
-    }
-  });
-});
-var _ScriptTask = require("./ScriptTask.js");
-Object.keys(_ScriptTask).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _ScriptTask[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _ScriptTask[key];
-    }
-  });
-});
-var _ServiceTask = require("./ServiceTask.js");
-Object.keys(_ServiceTask).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _ServiceTask[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _ServiceTask[key];
-    }
-  });
-});
-var _SignalTask = require("./SignalTask.js");
-Object.keys(_SignalTask).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _SignalTask[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _SignalTask[key];
-    }
-  });
-});
-var _SubProcess = require("./SubProcess.js");
-Object.keys(_SubProcess).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _SubProcess[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _SubProcess[key];
-    }
-  });
-});
-var _Task = require("./Task.js");
-Object.keys(_Task).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _Task[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _Task[key];
-    }
-  });
-});
-var _Transaction = require("./Transaction.js");
-Object.keys(_Transaction).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _Transaction[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _Transaction[key];
-    }
-  });
-});
+Object.defineProperty(exports, "CallActivity", {
+  enumerable: true,
+  get: function () {
+    return _CallActivity.default;
+  }
+});
+Object.defineProperty(exports, "CallActivityBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _CallActivity.CallActivityBehaviour;
+  }
+});
+Object.defineProperty(exports, "ReceiveTask", {
+  enumerable: true,
+  get: function () {
+    return _ReceiveTask.default;
+  }
+});
+Object.defineProperty(exports, "ReceiveTaskBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _ReceiveTask.ReceiveTaskBehaviour;
+  }
+});
+Object.defineProperty(exports, "ScriptTask", {
+  enumerable: true,
+  get: function () {
+    return _ScriptTask.default;
+  }
+});
+Object.defineProperty(exports, "ScriptTaskBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _ScriptTask.ScriptTaskBehaviour;
+  }
+});
+Object.defineProperty(exports, "ServiceTask", {
+  enumerable: true,
+  get: function () {
+    return _ServiceTask.default;
+  }
+});
+Object.defineProperty(exports, "ServiceTaskBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _ServiceTask.ServiceTaskBehaviour;
+  }
+});
+Object.defineProperty(exports, "SignalTask", {
+  enumerable: true,
+  get: function () {
+    return _SignalTask.default;
+  }
+});
+Object.defineProperty(exports, "SignalTaskBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _SignalTask.SignalTaskBehaviour;
+  }
+});
+Object.defineProperty(exports, "SubProcess", {
+  enumerable: true,
+  get: function () {
+    return _SubProcess.default;
+  }
+});
+Object.defineProperty(exports, "SubProcessBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _SubProcess.SubProcessBehaviour;
+  }
+});
+Object.defineProperty(exports, "Task", {
+  enumerable: true,
+  get: function () {
+    return _Task.default;
+  }
+});
+Object.defineProperty(exports, "TaskBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _Task.TaskBehaviour;
+  }
+});
+Object.defineProperty(exports, "Transaction", {
+  enumerable: true,
+  get: function () {
+    return _Transaction.default;
+  }
+});
+var _CallActivity = _interopRequireWildcard(require("./CallActivity.js"));
+var _ReceiveTask = _interopRequireWildcard(require("./ReceiveTask.js"));
+var _ScriptTask = _interopRequireWildcard(require("./ScriptTask.js"));
+var _ServiceTask = _interopRequireWildcard(require("./ServiceTask.js"));
+var _SignalTask = _interopRequireWildcard(require("./SignalTask.js"));
+var _SubProcess = _interopRequireWildcard(require("./SubProcess.js"));
+var _Task = _interopRequireWildcard(require("./Task.js"));
+var _Transaction = _interopRequireDefault(require("./Transaction.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/eventDefinitions.d.ts

@@ -0,0 +1 @@
+import './types/index.js';

package/flows.d.ts

@@ -0,0 +1 @@
+import './types/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "15.0.3",
+  "version": "16.1.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,6 +18,16 @@
       "require": "./dist/events/index.js",
       "import": "./src/events/index.js"
     },
+    "./eventDefinitions": {
+      "types": "./types/index.d.ts",
+      "require": "./dist/eventDefinitions/index.js",
+      "import": "./src/eventDefinitions/index.js"
+    },
+    "./flows": {
+      "types": "./types/index.d.ts",
+      "require": "./dist/flows/index.js",
+      "import": "./src/flows/index.js"
+    },
     "./gateways": {
       "types": "./types/index.d.ts",
       "require": "./dist/gateways/index.js",
@@ -35,7 +45,7 @@
     "posttest": "npm run lint && npm run dist",
     "lint": "eslint . --cache && prettier . --check --cache",
     "prepack": "npm run dist",
-    "test:md": "texample ./docs/Examples.md,./docs/StartEvent.md,./docs/Extension.md",
+    "test:md": "texample ./docs/Examples.md,./docs/StartEvent.md,./docs/Extension.md,./docs/ConditionalEventDefinition.md",
     "cov:html": "c8 -r html -r text mocha -R @bonniernews/hot-bev -p -t 3000",
     "test:lcov": "c8 -r lcov mocha && npm run lint",
     "dist": "babel src -d dist/"
@@ -59,10 +69,15 @@
   ],
   "files": [
     "dist",
-    "types",
     "src",
+    "types",
     "*.d.ts"
   ],
+  "c8": {
+    "include": [
+      "src/**/*"
+    ]
+  },
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
     "@babel/cli": "^7.24.1",
@@ -82,13 +97,13 @@
     "got": "^14.2.1",
     "mocha": "^10.4.0",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^4.1.2",
+    "moddle-context-serializer": "^4.2.1",
     "nock": "^13.5.3",
     "prettier": "^3.2.5",
-    "texample": "^0.0.5"
+    "texample": "^0.0.6"
   },
   "dependencies": {
-    "@0dep/piso": "^2.0.0",
+    "@0dep/piso": "^2.0.2",
     "smqp": "^9.0.2"
   }
 }

package/src/Environment.js

@@ -88,7 +88,7 @@ Environment.prototype.assignVariables = function assignVariables(newVars) {
   };
 };
 
-Environment.prototype.assignSettings = function assignVariables(newSettings) {
+Environment.prototype.assignSettings = function assignSettings(newSettings) {
   if (!newSettings || typeof newSettings !== 'object') return;
 
   this.settings = {

package/src/activity/Activity.js

@@ -99,7 +99,7 @@ function Activity(Behaviour, activityDef, context) {
     onExecutionMessage: this._onExecutionMessage.bind(this),
   };
 
-  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed) => new ed.Behaviour(this, ed, this.context));
+  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
   this[kExtensions] = context.loadExtensions(this);
   this[kConsuming] = false;
   this[kConsumingRunQ] = undefined;

package/src/condition.js

@@ -0,0 +1,58 @@
+import ExecutionScope from './activity/ExecutionScope.js';
+
+/**
+ * Script condition
+ * @param {import('types').ElementBase} owner
+ * @param {any} script
+ * @param {string} language
+ */
+export function ScriptCondition(owner, script, language) {
+  this.type = 'script';
+  this.language = language;
+  this._owner = owner;
+  this._script = script;
+}
+
+/**
+ * Execute
+ * @param {any} message
+ * @param {CallableFunction} callback
+ */
+ScriptCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+  try {
+    return this._script.execute(ExecutionScope(owner, message), callback);
+  } catch (err) {
+    if (!callback) throw err;
+    owner.logger.error(`<${owner.id}>`, err);
+    callback(err);
+  }
+};
+
+/**
+ * Expression condition
+ * @param {import('types').ElementBase} owner
+ * @param {string} expression
+ */
+export function ExpressionCondition(owner, expression) {
+  this.type = 'expression';
+  this.expression = expression;
+  this._owner = owner;
+}
+
+/**
+ * Execute
+ * @param {any} message
+ * @param {CallableFunction} callback
+ */
+ExpressionCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+  try {
+    const result = owner.environment.resolveExpression(this.expression, message);
+    if (callback) return callback(null, result);
+    return result;
+  } catch (err) {
+    if (callback) return callback(err);
+    throw err;
+  }
+};

package/src/eventDefinitions/ConditionalEventDefinition.js

@@ -1,21 +1,21 @@
 import { cloneContent, shiftParent } from '../messageHelper.js';
 import { ActivityError } from '../error/Errors.js';
+import { ScriptCondition, ExpressionCondition } from '../condition.js';
 
 const kExecuteMessage = Symbol.for('executeMessage');
 
-export default function ConditionalEventDefinition(activity, eventDefinition) {
-  const { id, broker, environment, attachedTo } = activity;
+export default function ConditionalEventDefinition(activity, eventDefinition, _context, index) {
+  const { id, broker, environment } = activity;
 
   const { type = 'ConditionalEventDefinition', behaviour = {} } = eventDefinition;
-
   this.id = id;
   this.type = type;
-  this.isWaiting = !attachedTo;
-  this.condition = behaviour.expression;
+  this.behaviour = behaviour;
   this.activity = activity;
   this.environment = environment;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
+  this.condition = this.getCondition(index);
 }
 
 Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
@@ -27,90 +27,72 @@ Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
 
 ConditionalEventDefinition.prototype.execute = function execute(executeMessage) {
   this[kExecuteMessage] = executeMessage;
-  return this.isWaiting ? this.executeWait(executeMessage) : this.executeCatch(executeMessage);
+
+  if (!this.condition) return this._setup(executeMessage);
+
+  this.evaluate(executeMessage, (err, result) => {
+    this.evaluateCallback(err, result);
+    if (!err && !result) {
+      this._setup(executeMessage);
+    }
+  });
 };
 
-ConditionalEventDefinition.prototype.executeWait = function executeWait(executeMessage) {
+ConditionalEventDefinition.prototype._setup = function setup(executeMessage) {
+  const broker = this.broker;
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
   const parentExecutionId = parent.executionId;
 
-  if (this._evaluateWait(executeMessage)) return;
-
-  const broker = this.broker;
-  const onApiMessage = this._onWaitApiMessage.bind(this);
+  const onApiMessage = this._onApiMessage.bind(this);
   broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
     noAck: true,
     consumerTag: `_api-${executionId}`,
   });
-  broker.subscribeTmp('api', `activity.signal.${parentExecutionId}`, onApiMessage, {
+  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
     noAck: true,
     consumerTag: `_parent-signal-${executionId}`,
   });
-
-  const waitContent = cloneContent(executeContent, {
-    executionId: parentExecutionId,
-    condition: this.condition,
-  });
-  waitContent.parent = shiftParent(parent);
-
-  broker.publish('event', 'activity.wait', waitContent);
-};
-
-ConditionalEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  const executeContent = executeMessage.content;
-  const { executionId, index, parent } = executeContent;
-  const parentExecutionId = parent.executionId;
-
-  const broker = this.broker;
-  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
+  broker.subscribeTmp('api', '#.signal.*', this._onDelegateApiMessage.bind(this), {
     noAck: true,
-    consumerTag: `_api-${executionId}_${index}`,
-  });
-
-  const { id: attachedToId, broker: attachedToBroker } = this.activity.attachedTo;
-
-  this._debug(`listen for execute completed from <${attachedToId}>`);
-
-  attachedToBroker.subscribeOnce('execution', 'execute.completed', this._onAttachedCompleted.bind(this), {
-    priority: 300,
-    consumerTag: `_onend-${executionId}_${index}`,
+    consumerTag: `_api-delegated-${executionId}`,
   });
 
   const waitContent = cloneContent(executeContent, {
     executionId: parentExecutionId,
-    condition: this.condition,
+    ...(this.condition && { condition: this.condition.type }),
   });
   waitContent.parent = shiftParent(parent);
 
   broker.publish('event', 'activity.wait', waitContent);
 };
 
-ConditionalEventDefinition.prototype._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
-  const messageType = message.properties.type;
-
-  switch (messageType) {
-    case 'signal': {
-      return this._evaluateWait(message);
-    }
-    case 'discard': {
-      this._stopWait();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content, { state: 'discard' }));
-    }
-    case 'stop': {
-      return this._stopWait();
-    }
+/**
+ * Evaluate condition
+ * @param {import('types').ElementBrokerMessage} message
+ * @param {CallableFunction} callback
+ */
+ConditionalEventDefinition.prototype.evaluate = function evaluate(message, callback) {
+  const condition = this.condition;
+  if (!condition) {
+    this._debug(`condition is empty <${condition}>`);
+    return callback();
   }
+
+  condition.execute(message, callback);
 };
 
-ConditionalEventDefinition.prototype._evaluateWait = function evaluate(message) {
+/**
+ * Handle evaluate result or error
+ * @param {Error|null} err Condition evaluation error
+ * @param {any} result Result from evaluated condition, completes execution if truthy
+ */
+ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallback(err, result) {
+  const broker = this.broker;
   const executeMessage = this[kExecuteMessage];
-  const broker = this.broker,
-    executeContent = executeMessage.content;
+  const executeContent = executeMessage.content;
 
-  try {
-    var output = this.environment.resolveExpression(this.condition, message); // eslint-disable-line no-var
-  } catch (err) {
+  if (err) {
     return broker.publish(
       'execution',
       'execute.error',
@@ -118,78 +100,86 @@ ConditionalEventDefinition.prototype._evaluateWait = function evaluate(message)
     );
   }
 
-  this._debug(`condition evaluated to ${!!output}`);
+  this._debug(`condition evaluated to ${!!result}`);
 
-  broker.publish(
+  this.broker.publish(
     'event',
     'activity.condition',
-    cloneContent(executeContent, {
-      conditionResult: output,
+    cloneContent(this[kExecuteMessage].content, {
+      conditionResult: result,
     }),
   );
 
-  if (!output) return;
-  this._stopWait();
-  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output }));
-};
+  if (!result) return;
 
-ConditionalEventDefinition.prototype._stopWait = function stopWait() {
-  const broker = this.broker,
-    executionId = this.executionId;
-  broker.cancel(`_api-${executionId}`);
-  broker.cancel(`_parent-signal-${executionId}`);
+  this._stop();
+  return broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output: result }));
 };
 
-ConditionalEventDefinition.prototype._onAttachedCompleted = function onAttachedCompleted(routingKey, message) {
-  this._stopCatch();
-
-  const executeMessage = this[kExecuteMessage];
-  const broker = this.broker,
-    executeContent = executeMessage.content;
-  try {
-    var output = this.environment.resolveExpression(this.condition, message); // eslint-disable-line no-var
-  } catch (err) {
-    return broker.publish(
-      'execution',
-      'execute.error',
-      cloneContent(executeContent, { error: new ActivityError(err.message, executeMessage, err) }, { mandatory: true }),
-    );
+/**
+ * Get condition
+ * @param {number} index Eventdefinition sequence number, used to name registered script
+ * @returns {ExpressionCondition|ScriptCondition|null}
+ */
+ConditionalEventDefinition.prototype.getCondition = function getCondition(index) {
+  const behaviour = this.behaviour;
+
+  if (behaviour.script) {
+    const { language, body, resource } = behaviour.script;
+
+    const scriptId = `${this.id}/${index}`;
+
+    const script = this.environment.scripts.register({
+      id: scriptId,
+      type: this.type,
+      environment: this.environment,
+      behaviour: {
+        scriptFormat: language,
+        ...(body && { script: body }),
+        ...(resource && { resource }),
+      },
+    });
+
+    if (script) {
+      return new ScriptCondition(this, script, language);
+    }
+  } else if (behaviour.expression) {
+    return new ExpressionCondition(this, behaviour.expression);
   }
+};
 
-  this._debug(`condition from <${message.content.executionId}> evaluated to ${!!output}`);
-
-  broker.publish(
-    'event',
-    'activity.condition',
-    cloneContent(executeContent, {
-      conditionResult: output,
-    }),
-  );
-
-  if (output) {
-    broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output }));
+ConditionalEventDefinition.prototype._onDelegateApiMessage = function onDelegateApiMessage(routingKey, message) {
+  if (message.content.message && message.content.message.id === this.id) {
+    this._onApiMessage(routingKey, message);
   }
 };
 
-ConditionalEventDefinition.prototype._onCatchApiMessage = function onCatchApiMessage(routingKey, message) {
+ConditionalEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
+
   switch (messageType) {
+    case 'signal': {
+      if (!this.condition) break;
+      return this.evaluate(message, (err, result) => this.evaluateCallback(err, result));
+    }
     case 'discard': {
-      this._stopCatch();
+      this._stop();
       this._debug('discarded');
       return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content, { state: 'discard' }));
     }
     case 'stop': {
-      this._stopCatch();
+      this._stop();
       return this._debug('stopped');
     }
   }
 };
 
-ConditionalEventDefinition.prototype._stopCatch = function stopCatch() {
-  const { executionId, index } = this[kExecuteMessage].content;
-  this.activity.attachedTo.broker.cancel(`_onend-${executionId}_${index}`);
-  this.broker.cancel(`_api-${executionId}_${index}`);
+ConditionalEventDefinition.prototype._stop = function stop() {
+  const executionId = this.executionId;
+  const broker = this.broker;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_parent-signal-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
 };
 
 ConditionalEventDefinition.prototype._debug = function debug(msg) {

package/src/eventDefinitions/ErrorEventDefinition.js

@@ -200,8 +200,8 @@ ErrorEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey,
 };
 
 ErrorEventDefinition.prototype._stop = function stop() {
-  const broker = this.broker,
-    executionId = this.executionId;
+  const broker = this.broker;
+  const executionId = this.executionId;
   broker.cancel(`_onthrow-${executionId}`);
   broker.cancel(`_onerror-${executionId}`);
   broker.cancel(`_api-${executionId}`);

package/src/eventDefinitions/TimerEventDefinition.js

@@ -125,6 +125,8 @@ TimerEventDefinition.prototype._completed = function completed(completeContent,
   if (timerContent.repeat > 1) {
     const repeat = timerContent.repeat - 1;
     broker.publish('execution', 'execute.repeat', cloneContent(timerContent, { ...content, repeat }), options);
+  } else if (timerContent.repeat === -1) {
+    broker.publish('execution', 'execute.repeat', cloneContent(timerContent, content), options);
   }
 
   broker.publish('execution', 'execute.completed', cloneContent(timerContent, content), options);