bpmn-elements 9.2.0 → 10.1.0

package/dist/process/Process.js

@@ -17,6 +17,7 @@ const kCounters = Symbol.for('counters');
 const kExec = Symbol.for('execution');
 const kExecuteMessage = Symbol.for('executeMessage');
 const kExtensions = Symbol.for('extensions');
+const kLanes = Symbol.for('lanes');
 const kMessageHandlers = Symbol.for('messageHandlers');
 const kStateMessage = Symbol.for('stateMessage');
 const kStatus = Symbol.for('status');
@@ -66,6 +67,9 @@ function Process(processDef, context) {
     onExecutionMessage: this._onExecutionMessage.bind(this)
   };
   this.logger = environment.Logger(type.toLowerCase());
+  if (behaviour.lanes) {
+    this[kLanes] = behaviour.lanes.map(lane => new lane.Behaviour(this, lane));
+  }
   this[kExtensions] = context.loadExtensions(this);
 }
 Object.defineProperty(Process.prototype, 'counters', {
@@ -76,6 +80,13 @@ Object.defineProperty(Process.prototype, 'counters', {
     };
   }
 });
+Object.defineProperty(Process.prototype, 'lanes', {
+  enumerable: true,
+  get() {
+    const lanes = this[kLanes];
+    return lanes && lanes.slice();
+  }
+});
 Object.defineProperty(Process.prototype, 'extensions', {
   enumerable: true,
   get() {
@@ -404,6 +415,11 @@ Process.prototype.getSequenceFlows = function getSequenceFlows() {
   if (execution) return execution.getSequenceFlows();
   return this.context.getSequenceFlows();
 };
+Process.prototype.getLaneById = function getLaneById(laneId) {
+  const lanes = this[kLanes];
+  if (!lanes) return;
+  return lanes.find(lane => lane.id === laneId);
+};
 Process.prototype.getPostponed = function getPostponed(...args) {
   const execution = this.execution;
   if (!execution) return [];

package/dist/tasks/SubProcess.js

@@ -135,7 +135,7 @@ SubProcessBehaviour.prototype.recover = function recover(state) {
     executions.splice(0);
   }
   const subEnvironment = this.environment.clone().recover(state.environment);
-  const subContext = this.context.clone(subEnvironment);
+  const subContext = this.context.clone(subEnvironment, this.activity);
   const execution = new _ProcessExecution.default(this.activity, subContext).recover(state);
   executions.push(execution);
   return execution;
@@ -168,7 +168,7 @@ SubProcessBehaviour.prototype._upsertExecution = function upsertExecution(execut
     return execution;
   }
   const subEnvironment = this.environment.clone();
-  const subContext = this.context.clone(subEnvironment);
+  const subContext = this.context.clone(subEnvironment, this.activity);
   execution = new _ProcessExecution.default(this.activity, subContext);
   this[kExecutions].push(execution);
   this._addListeners(execution, executionId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "9.2.0",
+  "version": "10.1.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -13,11 +13,11 @@
   },
   "sideEffects": false,
   "scripts": {
-    "test": "mocha -R dot",
+    "test": "mocha -R @bonniernews/hot-bev -p -t 2000",
     "posttest": "npm run lint && npm run dist",
     "lint": "eslint . --cache",
     "prepack": "npm run dist",
-    "cov:html": "c8 -r html -r text mocha -R dot",
+    "cov:html": "c8 -r html -r text mocha -R @bonniernews/hot-bev -p -t 2000",
     "test:lcov": "c8 -r lcov mocha && npm run lint",
     "dist": "babel src -d dist/"
   },
@@ -45,26 +45,26 @@
   ],
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
-    "@babel/cli": "^7.21.0",
-    "@babel/core": "^7.21.4",
-    "@babel/preset-env": "^7.21.4",
-    "@babel/register": "^7.21.0",
+    "@babel/cli": "^7.22.5",
+    "@babel/core": "^7.22.5",
+    "@babel/preset-env": "^7.22.5",
+    "@babel/register": "^7.22.5",
+    "@bonniernews/hot-bev": "^0.4.0",
     "bpmn-moddle": "^8.0.1",
-    "c8": "^7.13.0",
+    "c8": "^7.14.0",
     "camunda-bpmn-moddle": "^7.0.1",
     "chai": "^4.3.7",
     "chronokinesis": "^5.0.2",
     "debug": "^4.3.4",
-    "eslint": "^8.39.0",
+    "eslint": "^8.42.0",
     "eslint-plugin-import": "^2.27.5",
-    "got": "^12.6.0",
+    "got": "^12.6.1",
     "mocha": "^10.1.0",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^3.2.2",
-    "nock": "^13.2.8"
+    "moddle-context-serializer": "^4.0.0",
+    "nock": "^13.3.1"
   },
   "dependencies": {
-    "iso8601-duration": "^2.1.1",
     "smqp": "^7.1.4"
   }
 }

package/src/Context.js

@@ -3,12 +3,14 @@ import Environment from './Environment.js';
 import ExtensionsMapper from './ExtensionsMapper.js';
 import {getUniqueId} from './shared.js';
 
+const kOwner = Symbol.for('owner');
+
 export default function Context(definitionContext, environment) {
   environment = environment ? environment.clone() : new Environment();
   return new ContextInstance(definitionContext, environment);
 }
 
-function ContextInstance(definitionContext, environment) {
+function ContextInstance(definitionContext, environment, owner) {
   const {id = 'Def', name, type = 'context'} = definitionContext;
   const sid = getUniqueId(id);
   this.id = id;
@@ -29,8 +31,15 @@ function ContextInstance(definitionContext, environment) {
     sequenceFlowRefs: {},
     sequenceFlows: [],
   };
+  this[kOwner] = owner;
 }
 
+Object.defineProperty(ContextInstance.prototype, 'owner', {
+  get() {
+    return this[kOwner];
+  },
+});
+
 ContextInstance.prototype.getActivityById = function getActivityById(activityId) {
   const activityInstance = this.refs.activityRefs[activityId];
   if (activityInstance) return activityInstance;
@@ -106,8 +115,8 @@ ContextInstance.prototype.upsertAssociation = function upsertAssociation(associa
   return instance;
 };
 
-ContextInstance.prototype.clone = function clone(newEnvironment) {
-  return new ContextInstance(this.definitionContext, newEnvironment || this.environment);
+ContextInstance.prototype.clone = function clone(newEnvironment, newOwner) {
+  return new ContextInstance(this.definitionContext, newEnvironment || this.environment, newOwner);
 };
 
 ContextInstance.prototype.getProcessById = function getProcessById(processId) {
@@ -120,6 +129,8 @@ ContextInstance.prototype.getProcessById = function getProcessById(processId) {
 
   const bpContext = this.clone(this.environment.clone());
   bp = refs[processId] = new processDefinition.Behaviour(processDefinition, bpContext);
+  bpContext[kOwner] = bp;
+
   this.refs.processes.push(bp);
 
   return bp;
@@ -128,7 +139,11 @@ ContextInstance.prototype.getProcessById = function getProcessById(processId) {
 ContextInstance.prototype.getNewProcessById = function getNewProcessById(processId) {
   if (!this.getProcessById(processId)) return null;
   const bpDef = this.definitionContext.getProcessById(processId);
-  const bp = new bpDef.Behaviour(bpDef, this.clone(this.environment.clone()));
+
+  const bpContext = this.clone(this.environment.clone());
+  const bp = new bpDef.Behaviour(bpDef, bpContext);
+  bpContext[kOwner] = bp;
+
   return bp;
 };
 
@@ -201,3 +216,11 @@ ContextInstance.prototype.loadExtensions = function loadExtensions(activity) {
   if (!extensions.extensions.length) return;
   return extensions;
 };
+
+ContextInstance.prototype.getActivityParentById = function getActivityParentById(activityId) {
+  const owner = this[kOwner];
+  if (owner) return owner;
+  const activity = this.getActivityById(activityId);
+  const parentId = activity.parent.id;
+  return this.getProcessById(parentId) || this.getActivityById(parentId);
+};

package/src/Environment.js

@@ -24,7 +24,7 @@ export default function Environment(options = {}) {
   this.extensions = options.extensions;
   this.output = options.output || {};
   this.scripts = options.scripts || IScripts();
-  this.timers = options.timers || Timers();
+  this.timers = options.timers || new Timers();
   this.settings = {...options.settings};
   this.Logger = options.Logger || DummyLogger;
   this[kServices] = options.services || {};

package/src/Timers.js

@@ -1,56 +1,87 @@
-export function Timers(options) {
-  let count = 0;
-  const executing = [];
+const kExecuting = Symbol.for('executing');
+const kTimerApi = Symbol.for('timers api');
+
+const MAX_DELAY = 2147483647;
 
-  options = {
+export function Timers(options) {
+  this.count = 0;
+  this.options = {
     setTimeout,
     clearTimeout,
     ...options,
   };
+  this[kExecuting] = [];
+  this.setTimeout = this.setTimeout.bind(this);
+  this.clearTimeout = this.clearTimeout.bind(this);
+}
 
-  const timersApi = {
-    get executing() {
-      return executing.slice();
-    },
-    register,
-    setTimeout: wrappedSetTimeout,
-    clearTimeout: wrappedClearTimeout,
-  };
+Object.defineProperty(Timers.prototype, 'executing', {
+  get() {
+    return this[kExecuting].slice();
+  },
+});
 
-  return timersApi;
+Timers.prototype.register = function register(owner) {
+  return new RegisteredTimers(this, owner);
+};
 
-  function register(owner) {
-    return {
-      setTimeout: registerTimeout(owner),
-      clearTimeout: timersApi.clearTimeout,
-    };
-  }
+Timers.prototype.setTimeout = function wrappedSetTimeout(callback, delay, ...args) {
+  return this._setTimeout(null, callback, delay, ...args);
+};
 
-  function registerTimeout(owner) {
-    return function registeredSetTimeout(...args) {
-      return timersApi.setTimeout.call(owner, ...args);
-    };
+Timers.prototype.clearTimeout = function wrappedClearTimeout(ref) {
+  const executing = this[kExecuting];
+  const idx = executing.indexOf(ref);
+  if (idx > -1) {
+    executing.splice(idx, 1);
+    ref.timerRef = this.options.clearTimeout(ref.timerRef);
+    return;
   }
+  return this.options.clearTimeout(ref);
+};
 
-  function wrappedSetTimeout(callback, delay, ...args) {
-    const ref = {timerId: `timer_${count++}`, callback, delay, args, owner: this};
-    executing.push(ref);
-    ref.timerRef = options.setTimeout.call(null, onTimeout, delay, ...args);
-    return ref;
-
-    function onTimeout(...rargs) {
-      const idx = executing.indexOf(ref);
-      if (idx > -1) executing.splice(idx, 1);
-      return callback(...rargs);
-    }
+Timers.prototype._setTimeout = function setTimeout(owner, callback, delay, ...args) {
+  const executing = this[kExecuting];
+  const ref = this._getReference(owner, callback, delay, args);
+  executing.push(ref);
+  if (delay < MAX_DELAY) {
+    ref.timerRef = this.options.setTimeout(onTimeout, ref.delay, ...ref.args);
   }
+  return ref;
 
-  function wrappedClearTimeout(ref) {
+  function onTimeout(...rargs) {
     const idx = executing.indexOf(ref);
-    if (idx > -1) {
-      executing.splice(idx, 1);
-      return options.clearTimeout.call(null, ref.timerRef);
-    }
-    return options.clearTimeout.call(null, ref);
+    if (idx > -1) executing.splice(idx, 1);
+    return callback(...rargs);
   }
+};
+
+Timers.prototype._getReference = function getReference(owner, callback, delay, args) {
+  return new Timer(owner, `timer_${this.count++}`, callback, delay, args);
+};
+
+function RegisteredTimers(timersApi, owner) {
+  this[kTimerApi] = timersApi;
+  this.owner = owner;
+  this.setTimeout = this.setTimeout.bind(this);
+  this.clearTimeout = this.clearTimeout.bind(this);
+}
+
+RegisteredTimers.prototype.setTimeout = function registeredSetTimeout(callback, delay, ...args) {
+  const timersApi = this[kTimerApi];
+  return timersApi._setTimeout(this.owner, callback, delay, ...args);
+};
+
+RegisteredTimers.prototype.clearTimeout = function registeredClearTimeout(ref) {
+  this[kTimerApi].clearTimeout(ref);
+};
+
+function Timer(owner, timerId, callback, delay, args) {
+  this.callback = callback;
+  this.delay = delay;
+  this.args = args;
+  this.owner = owner;
+  this.timerId = timerId;
+  this.expireAt = new Date(Date.now() + delay);
+  this.timerRef = null;
 }

package/src/activity/Activity.js

@@ -87,6 +87,7 @@ function Activity(Behaviour, activityDef, context) {
     isTransaction: activityDef.isTransaction,
     isParallelJoin,
     isThrowing: activityDef.isThrowing,
+    lane: activityDef.lane && activityDef.lane.id,
   };
   this[kExec] = {};
 
@@ -235,6 +236,16 @@ Object.defineProperty(Activity.prototype, 'attachedTo', {
   },
 });
 
+Object.defineProperty(Activity.prototype, 'lane', {
+  enumerable: true,
+  get() {
+    const laneId = this[kFlags].lane;
+    if (!laneId) return undefined;
+    const parent = this.parentElement;
+    return parent.getLaneById && parent.getLaneById(laneId);
+  },
+});
+
 Object.defineProperty(Activity.prototype, 'eventDefinitions', {
   enumerable: true,
   get() {
@@ -242,6 +253,13 @@ Object.defineProperty(Activity.prototype, 'eventDefinitions', {
   },
 });
 
+Object.defineProperty(Activity.prototype, 'parentElement', {
+  enumerable: true,
+  get() {
+    return this.context.getActivityParentById(this.id);
+  },
+});
+
 Activity.prototype.activate = function activate() {
   this[kActivated] = true;
   this.addInboundListeners();

package/src/definition/DefinitionExecution.js

@@ -322,32 +322,29 @@ DefinitionExecution.prototype._activate = function activate(processList) {
 
 DefinitionExecution.prototype._activateProcess = function activateProcess(bp) {
   const handlers = this[kMessageHandlers];
+  const broker = bp.broker;
 
-  bp.broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
+  broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
     noAck: true,
     consumerTag: '_definition-outbound-message-consumer',
   });
-  bp.broker.subscribeTmp('event', 'activity.signal', handlers.onDelegateMessage, {
-    noAck: true,
-    consumerTag: '_definition-signal-consumer',
-    priority: 200,
-  });
-  bp.broker.subscribeTmp('event', 'activity.message', handlers.onDelegateMessage, {
-    noAck: true,
-    consumerTag: '_definition-message-consumer',
-    priority: 200,
-  });
-  bp.broker.subscribeTmp('event', 'activity.call', handlers.onCallActivity, {
+
+  const delegateEventQ = broker.assertQueue('_delegate-event-q', {autoDelete: false, durable: false});
+  delegateEventQ.consume(handlers.onDelegateMessage, {noAck: true, consumerTag: '_definition-signal-consumer'});
+  broker.bindQueue('_delegate-event-q', 'event', 'activity.signal', {priority: 200});
+  broker.bindQueue('_delegate-event-q', 'event', 'activity.message', {priority: 200});
+
+  broker.subscribeTmp('event', 'activity.call', handlers.onCallActivity, {
     noAck: true,
     consumerTag: '_definition-call-consumer',
     priority: 200,
   });
-  bp.broker.subscribeTmp('event', 'activity.call.cancel', handlers.onCancelCallActivity, {
+  broker.subscribeTmp('event', 'activity.call.cancel', handlers.onCancelCallActivity, {
     noAck: true,
     consumerTag: '_definition-call-cancel-consumer',
     priority: 200,
   });
-  bp.broker.subscribeTmp('event', '#', handlers.onChildEvent, {
+  broker.subscribeTmp('event', '#', handlers.onChildEvent, {
     noAck: true,
     consumerTag: '_definition-activity-consumer',
     priority: 100,
@@ -383,7 +380,6 @@ DefinitionExecution.prototype._deactivateProcess = function deactivateProcess(bp
   bp.broker.cancel('_definition-outbound-message-consumer');
   bp.broker.cancel('_definition-activity-consumer');
   bp.broker.cancel('_definition-signal-consumer');
-  bp.broker.cancel('_definition-message-consumer');
   bp.broker.cancel('_definition-call-consumer');
   bp.broker.cancel('_definition-call-cancel-consumer');
 };

package/src/eventDefinitions/TimerEventDefinition.js

@@ -1,13 +1,12 @@
 import {cloneContent} from '../messageHelper.js';
-import {toSeconds, parse} from 'iso8601-duration';
+import {toSeconds, parse as parseIsoDuration} from '../iso-duration.js';
 
 const kStopped = Symbol.for('stopped');
 const kTimerContent = Symbol.for('timerContent');
 const kTimer = Symbol.for('timer');
-const repeatPattern = /^\s*R(\d+)\//;
 
 export default function TimerEventDefinition(activity, eventDefinition) {
-  const type = this.type = eventDefinition.type || 'TimerEventDefinition.js';
+  const type = this.type = eventDefinition.type || 'TimerEventDefinition';
   this.activity = activity;
   const environment = this.environment = activity.environment;
   this.eventDefinition = eventDefinition;
@@ -85,12 +84,14 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
   if (timerContent.timeout <= 0) return this._completed();
 
   const timers = this.environment.timers.register(timerContent);
-  this[kTimer] = timers.setTimeout(this._completed.bind(this), timerContent.timeout, {
+  const delay = timerContent.timeout;
+  this[kTimer] = timers.setTimeout(this._completed.bind(this), delay, {
     id: content.id,
     type: this.type,
     executionId,
     state: 'timeout',
   });
+  this._debug(`set timeout with delay ${delay}`);
 };
 
 TimerEventDefinition.prototype.stop = function stopTimer() {
@@ -175,14 +176,44 @@ TimerEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_api-delegated-${this.executionId}`);
 };
 
+TimerEventDefinition.prototype.parse = function parse(timerType, value) {
+  let repeat, delay, expireAt;
+  switch (timerType) {
+    case 'timeCycle':
+    case 'timeDuration': {
+      const parsed = parseIsoDuration(value);
+      if (parsed.repeat) repeat = parsed.repeat;
+      delay = toSeconds(parsed) * 1000;
+      expireAt = new Date(Date.now() + delay);
+      break;
+    }
+    case 'timeDate': {
+      const ms = Date.parse(value);
+      if (!isNaN(ms)) {
+        expireAt = new Date(ms);
+        delay = Date.now() - expireAt;
+      } else {
+        throw new TypeError(`invalid timeDate >${value}<`);
+      }
+      break;
+    }
+  }
+
+  return {
+    expireAt,
+    repeat,
+    delay,
+  };
+};
+
 TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
   const content = executeMessage.content;
 
-  const now = Date.now();
   const result = {
     ...('expireAt' in content && {expireAt: new Date(content.expireAt)}),
   };
 
+  let parseErr;
   for (const t of ['timeDuration', 'timeDate', 'timeCycle']) {
     if (t in content) result[t] = content[t];
     else if (t in this) result[t] = this.environment.resolveExpression(this[t], executeMessage);
@@ -191,47 +222,37 @@ TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
     let expireAtDate, repeat;
     const timerStr = result[t];
     if (timerStr) {
-      switch (t) {
-        case 'timeCycle': {
-          const mRepeat = timerStr.match(repeatPattern);
-          if (mRepeat && mRepeat.length) repeat = parseInt(mRepeat[1]);
-        }
-        case 'timeDuration': {
-          const delay = this._getDurationInMilliseconds(timerStr);
-          if (delay !== undefined) expireAtDate = new Date(now + delay);
-          break;
-        }
-        case 'timeDate': {
-          const dateStr = result[t];
-          const ms = Date.parse(dateStr);
-          if (!isNaN(ms)) {
-            expireAtDate = new Date(ms);
-          } else {
-            this._warn(`invalid timeDate >${dateStr}<`);
-          }
-          break;
-        }
+      try {
+        const {repeat: parsedRepeat, expireAt: parsedExpireAt} = this.parse(t, timerStr);
+        repeat = parsedRepeat;
+        expireAtDate = parsedExpireAt;
+      } catch (err) {
+        parseErr = err;
       }
     } else {
-      expireAtDate = new Date(now);
+      expireAtDate = new Date();
     }
 
     if (!expireAtDate) continue;
     if (!('expireAt' in result) || result.expireAt > expireAtDate) {
       result.timerType = t;
       result.expireAt = expireAtDate;
-      if (repeat) result.repeat = repeat;
+      result.repeat = repeat;
     }
   }
 
   if ('expireAt' in result) {
-    result.timeout = result.expireAt - now;
+    result.timeout = result.expireAt - Date.now();
   } else if ('timeout' in content) {
     result.timeout = content.timeout;
   } else if (!Object.keys(result).length) {
     result.timeout = 0;
   }
 
+  if (!('timeout' in result) && parseErr) {
+    this.logger.warn(`<${this.activity.id}> failed to parse timer: ${parseErr.message}`);
+  }
+
   if (content.inbound && 'repeat' in content.inbound[0]) {
     result.repeat = content.inbound[0].repeat;
   }
@@ -239,18 +260,6 @@ TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
   return result;
 };
 
-TimerEventDefinition.prototype._getDurationInMilliseconds = function getDurationInMilliseconds(duration) {
-  try {
-    return toSeconds(parse(duration)) * 1000;
-  } catch (err) {
-    this._warn(`failed to parse ${this.timerType} >${duration}<: ${err.message}`);
-  }
-};
-
 TimerEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };
-
-TimerEventDefinition.prototype._warn = function debug(msg) {
-  this.logger.warn(`<${this.executionId} (${this.activity.id})> ${msg}`);
-};

package/src/index.js

@@ -23,6 +23,7 @@ import InclusiveGateway from './gateways/InclusiveGateway.js';
 import InputOutputSpecification from './io/InputOutputSpecification.js';
 import IntermediateCatchEvent from './events/IntermediateCatchEvent.js';
 import IntermediateThrowEvent from './events/IntermediateThrowEvent.js';
+import Lane from './process/Lane.js';
 import LinkEventDefinition from './eventDefinitions/LinkEventDefinition.js';
 import LoopCharacteristics from './tasks/LoopCharacteristics.js';
 import Message from './activity/Message.js';
@@ -46,6 +47,8 @@ import Task from './tasks/Task.js';
 import TerminateEventDefinition from './eventDefinitions/TerminateEventDefinition.js';
 import TimerEventDefinition from './eventDefinitions/TimerEventDefinition.js';
 import Transaction from './tasks/Transaction.js';
+import {Timers} from './Timers.js';
+import * as ISODuration from './iso-duration.js';
 
 export {
   Association,
@@ -80,6 +83,7 @@ export {
   Message,
   MessageEventDefinition,
   MessageFlow,
+  Lane,
   LoopCharacteristics as MultiInstanceLoopCharacteristics,
   ParallelGateway,
   Process,
@@ -103,4 +107,6 @@ export {
   TerminateEventDefinition,
   TimerEventDefinition,
   Transaction,
+  Timers,
+  ISODuration,
 };