bpmn-elements 15.0.3 → 16.1.0

package/src/eventDefinitions/index.js

@@ -0,0 +1,23 @@
+import CancelEventDefinition from './CancelEventDefinition.js';
+import CompensateEventDefinition from './CompensateEventDefinition.js';
+import ConditionalEventDefinition from './ConditionalEventDefinition.js';
+import ErrorEventDefinition from './ErrorEventDefinition.js';
+import EscalationEventDefinition from './EscalationEventDefinition.js';
+import LinkEventDefinition from './LinkEventDefinition.js';
+import MessageEventDefinition from './MessageEventDefinition.js';
+import SignalEventDefinition from './SignalEventDefinition.js';
+import TerminateEventDefinition from './TerminateEventDefinition.js';
+import TimerEventDefinition from './TimerEventDefinition.js';
+
+export {
+  CancelEventDefinition,
+  CompensateEventDefinition,
+  ConditionalEventDefinition,
+  ErrorEventDefinition,
+  EscalationEventDefinition,
+  LinkEventDefinition,
+  MessageEventDefinition,
+  SignalEventDefinition,
+  TerminateEventDefinition,
+  TimerEventDefinition,
+};

package/src/events/BoundaryEvent.js

@@ -69,7 +69,11 @@ BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
     const execQ = broker.assertQueue(`_bound-execution-${executionId}`, { durable: false, autoDelete: true });
     broker.bindQueue(execQ.name, 'execution', 'execute.detach');
     broker.bindQueue(execQ.name, 'execution', 'execute.bound.completed');
-    broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+
+    if (!this.cancelActivity) {
+      broker.bindQueue(execQ.name, 'execution', 'execute.repeat');
+    }
+
     if (eventDefinitionExecution && !this.environment.settings.strict) {
       broker.bindQueue(execQ.name, 'execution', 'execute.expect');
     }
@@ -226,7 +230,6 @@ BoundaryEventBehaviour.prototype._onApiMessage = function onApiMessage(_, messag
 };
 
 BoundaryEventBehaviour.prototype._onRepeatMessage = function onRepeatMessage(_, message) {
-  if (this.cancelActivity) return;
   const executeMessage = this[kExecuteMessage];
   const repeat = message.content.repeat;
   this.broker

package/src/events/index.js

@@ -1,5 +1,18 @@
-export * from './BoundaryEvent.js';
-export * from './EndEvent.js';
-export * from './IntermediateCatchEvent.js';
-export * from './IntermediateThrowEvent.js';
-export * from './StartEvent.js';
+import BoundaryEvent, { BoundaryEventBehaviour } from './BoundaryEvent.js';
+import EndEvent, { EndEventBehaviour } from './EndEvent.js';
+import IntermediateCatchEvent, { IntermediateCatchEventBehaviour } from './IntermediateCatchEvent.js';
+import IntermediateThrowEvent, { IntermediateThrowEventBehaviour } from './IntermediateThrowEvent.js';
+import StartEvent, { StartEventBehaviour } from './StartEvent.js';
+
+export {
+  BoundaryEvent,
+  BoundaryEventBehaviour,
+  EndEvent,
+  EndEventBehaviour,
+  IntermediateCatchEvent,
+  IntermediateCatchEventBehaviour,
+  IntermediateThrowEvent,
+  IntermediateThrowEventBehaviour,
+  StartEvent,
+  StartEventBehaviour,
+};

package/src/flows/SequenceFlow.js

@@ -1,8 +1,8 @@
-import ExecutionScope from '../activity/ExecutionScope.js';
 import { cloneParent, cloneContent } from '../messageHelper.js';
 import { getUniqueId } from '../shared.js';
 import { EventBroker } from '../EventBroker.js';
 import { FlowApi } from '../Api.js';
+import { ScriptCondition, ExpressionCondition } from '../condition.js';
 
 const kCounters = Symbol.for('counters');
 
@@ -29,7 +29,6 @@ function SequenceFlow(flowDef, { environment }) {
     discard: 0,
   };
 
-  environment.registerScript(this);
   const { broker, on, once, waitFor, emitFatal } = new EventBroker(this, { prefix: 'flow', durable: true, autoDelete: false });
   this.broker = broker;
   this.on = on;
@@ -37,6 +36,8 @@ function SequenceFlow(flowDef, { environment }) {
   this.waitFor = waitFor;
   this.emitFatal = emitFatal;
 
+  environment.registerScript(this);
+
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
 }
 
@@ -167,39 +168,3 @@ SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
 
   this.broker.publish('event', `flow.${action}`, eventContent, { type: action });
 };
-
-function ScriptCondition(owner, script, language) {
-  this.type = 'script';
-  this.language = language;
-  this._owner = owner;
-  this._script = script;
-}
-
-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);
-  }
-};
-
-function ExpressionCondition(owner, expression) {
-  this.type = 'expression';
-  this.expression = expression;
-  this._owner = owner;
-}
-
-ExpressionCondition.prototype.execute = function execute(message, callback) {
-  const owner = this._owner;
-  try {
-    const result = owner.environment.resolveExpression(this.expression, owner.createMessage(message));
-    if (callback) return callback(null, result);
-    return result;
-  } catch (err) {
-    if (callback) return callback(err);
-    throw err;
-  }
-};

package/src/flows/index.js

@@ -0,0 +1,5 @@
+import Association from './Association.js';
+import MessageFlow from './MessageFlow.js';
+import SequenceFlow from './SequenceFlow.js';
+
+export { Association, MessageFlow, SequenceFlow };

package/src/gateways/index.js

@@ -1,4 +1,15 @@
-export * from './EventBasedGateway.js';
-export * from './ExclusiveGateway.js';
-export * from './InclusiveGateway.js';
-export * from './ParallelGateway.js';
+import EventBasedGateway, { EventBasedGatewayBehaviour } from './EventBasedGateway.js';
+import ExclusiveGateway, { ExclusiveGatewayBehaviour } from './ExclusiveGateway.js';
+import InclusiveGateway, { InclusiveGatewayBehaviour } from './InclusiveGateway.js';
+import ParallelGateway, { ParallelGatewayBehaviour } from './ParallelGateway.js';
+
+export {
+  EventBasedGateway,
+  EventBasedGatewayBehaviour,
+  ExclusiveGateway,
+  ExclusiveGatewayBehaviour,
+  InclusiveGateway,
+  InclusiveGatewayBehaviour,
+  ParallelGateway,
+  ParallelGatewayBehaviour,
+};

package/src/index.js

@@ -1,52 +1,38 @@
 import Activity from './activity/Activity.js';
-import Association from './flows/Association.js';
-import BoundaryEvent from './events/BoundaryEvent.js';
 import BpmnError from './error/BpmnError.js';
-import CallActivity from './tasks/CallActivity.js';
-import CancelEventDefinition from './eventDefinitions/CancelEventDefinition.js';
-import CompensateEventDefinition from './eventDefinitions/CompensateEventDefinition.js';
-import ConditionalEventDefinition from './eventDefinitions/ConditionalEventDefinition.js';
 import Context from './Context.js';
 import DataObject from './io/EnvironmentDataObject.js';
 import DataStore from './io/EnvironmentDataStore.js';
 import DataStoreReference from './io/EnvironmentDataStoreReference.js';
 import Definition from './definition/Definition.js';
 import Dummy from './activity/Dummy.js';
-import EndEvent from './events/EndEvent.js';
 import Environment from './Environment.js';
-import ErrorEventDefinition from './eventDefinitions/ErrorEventDefinition.js';
 import Escalation from './activity/Escalation.js';
-import EscalationEventDefinition from './eventDefinitions/EscalationEventDefinition.js';
-import EventBasedGateway from './gateways/EventBasedGateway.js';
-import ExclusiveGateway from './gateways/ExclusiveGateway.js';
-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';
-import MessageEventDefinition from './eventDefinitions/MessageEventDefinition.js';
-import MessageFlow from './flows/MessageFlow.js';
-import ParallelGateway from './gateways/ParallelGateway.js';
 import Process from './process/Process.js';
 import Properties from './io/Properties.js';
-import ReceiveTask from './tasks/ReceiveTask.js';
-import ScriptTask from './tasks/ScriptTask.js';
-import SequenceFlow from './flows/SequenceFlow.js';
 import ServiceImplementation from './tasks/ServiceImplementation.js';
-import ServiceTask from './tasks/ServiceTask.js';
 import Signal from './activity/Signal.js';
-import SignalEventDefinition from './eventDefinitions/SignalEventDefinition.js';
-import SignalTask from './tasks/SignalTask.js';
 import StandardLoopCharacteristics from './tasks/StandardLoopCharacteristics.js';
-import StartEvent from './events/StartEvent.js';
-import SubProcess from './tasks/SubProcess.js';
-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 { Association, MessageFlow, SequenceFlow } from './flows/index.js';
+import { BoundaryEvent, EndEvent, IntermediateCatchEvent, IntermediateThrowEvent, StartEvent } from './events/index.js';
+import { EventBasedGateway, ExclusiveGateway, InclusiveGateway, ParallelGateway } from './gateways/index.js';
+import { CallActivity, ReceiveTask, ServiceTask, ScriptTask, SubProcess, SignalTask, Task, Transaction } from './tasks/index.js';
+import {
+  CancelEventDefinition,
+  CompensateEventDefinition,
+  ConditionalEventDefinition,
+  EscalationEventDefinition,
+  ErrorEventDefinition,
+  LinkEventDefinition,
+  MessageEventDefinition,
+  SignalEventDefinition,
+  TerminateEventDefinition,
+  TimerEventDefinition,
+} from './eventDefinitions/index.js';
 import { Timers } from './Timers.js';
 
 export { ActivityError, RunError } from './error/Errors.js';

package/src/process/Process.js

@@ -306,10 +306,11 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
     }
     case 'run.leave': {
       this[kStatus] = undefined;
-      this.broker.cancel('_process-api');
+      message.ack();
+      this._deactivateRunConsumers();
       const { output, ...rest } = content; // eslint-disable-line no-unused-vars
       this._publishEvent('leave', rest);
-      break;
+      return;
     }
   }
 

package/src/tasks/index.js

@@ -1,8 +1,26 @@
-export * from './CallActivity.js';
-export * from './ReceiveTask.js';
-export * from './ScriptTask.js';
-export * from './ServiceTask.js';
-export * from './SignalTask.js';
-export * from './SubProcess.js';
-export * from './Task.js';
-export * from './Transaction.js';
+import CallActivity, { CallActivityBehaviour } from './CallActivity.js';
+import ReceiveTask, { ReceiveTaskBehaviour } from './ReceiveTask.js';
+import ScriptTask, { ScriptTaskBehaviour } from './ScriptTask.js';
+import ServiceTask, { ServiceTaskBehaviour } from './ServiceTask.js';
+import SignalTask, { SignalTaskBehaviour } from './SignalTask.js';
+import SubProcess, { SubProcessBehaviour } from './SubProcess.js';
+import Task, { TaskBehaviour } from './Task.js';
+import Transaction from './Transaction.js';
+
+export {
+  CallActivity,
+  CallActivityBehaviour,
+  ReceiveTask,
+  ReceiveTaskBehaviour,
+  ScriptTask,
+  ScriptTaskBehaviour,
+  ServiceTask,
+  ServiceTaskBehaviour,
+  SignalTask,
+  SignalTaskBehaviour,
+  SubProcess,
+  SubProcessBehaviour,
+  Task,
+  TaskBehaviour,
+  Transaction,
+};

package/types/index.d.ts

@@ -1,5 +1,15 @@
 export * from './types.js';
-import { IActivityBehaviour, ActivityBehaviour, EventDefinition, MessageElement } from './types.js';
+import {
+  Association,
+  MessageFlow,
+  SequenceFlow,
+  IActivityBehaviour,
+  ActivityBehaviour,
+  EventDefinition,
+  MessageElement,
+  ConditionalEventDefinition,
+  TimerEventDefinition,
+} from './types.js';
 
 declare module 'bpmn-elements' {
   export var BoundaryEvent: typeof ActivityBehaviour;
@@ -37,30 +47,7 @@ declare module 'bpmn-elements' {
   export var MessageEventDefinition: EventDefinition;
   export var SignalEventDefinition: EventDefinition;
   export var TerminateEventDefinition: EventDefinition;
-
-  export const enum TimerType {
-    TimeCycle = 'timeCycle',
-    TimeDuration = 'timeDuration',
-    TimeDate = 'timeDate',
-  }
-
-  type parsedTimer = {
-    /** Expires at date time */
-    expireAt?: Date;
-    /** Repeat number of times */
-    repeat?: number;
-    /** Delay in milliseconds */
-    delay?: number;
-  };
-
-  export class TimerEventDefinition extends EventDefinition {
-    /**
-     * Parse timer type
-     * @param timerType type of timer
-     * @param timerValue resolved expression timer string
-     */
-    parse(timerType: TimerType, timerValue: string): parsedTimer;
-  }
+  export var TimerEventDefinition: TimerEventDefinition;
 
   export class Message extends MessageElement {}
   export class Signal extends MessageElement {}
@@ -75,6 +62,25 @@ declare module 'bpmn-elements/events' {
   export var StartEventBehaviour: IActivityBehaviour;
 }
 
+declare module 'bpmn-elements/eventDefinitions' {
+  export var CancelEventDefinition: EventDefinition;
+  export var CompensateEventDefinition: EventDefinition;
+  export var ConditionalEventDefinition: ConditionalEventDefinition;
+  export var ErrorEventDefinition: EventDefinition;
+  export var EscalationEventDefinition: EventDefinition;
+  export var LinkEventDefinition: EventDefinition;
+  export var MessageEventDefinition: EventDefinition;
+  export var SignalEventDefinition: EventDefinition;
+  export var TerminateEventDefinition: EventDefinition;
+  export var TimerEventDefinition: TimerEventDefinition;
+}
+
+declare module 'bpmn-elements/flows' {
+  export var Association: Association;
+  export var SequenceFlow: SequenceFlow;
+  export var MessageFlow: MessageFlow;
+}
+
 declare module 'bpmn-elements/gateways' {
   export var EventBasedGatewayBehaviour: IActivityBehaviour;
   export var ExclusiveGatewayBehaviour: IActivityBehaviour;

package/types/types.d.ts

@@ -37,7 +37,7 @@ declare interface ElementBrokerMessage extends MessageMessage {
 }
 
 declare class EventDefinition {
-  constructor(activity: Activity, eventDefinitionElement: SerializableElement);
+  constructor(activity: Activity, eventDefinitionElement: SerializableElement, context?: ContextInstance, index?: number);
   get id(): string;
   get type(): string;
   get executionId(): string;
@@ -54,6 +54,57 @@ declare class EventDefinition {
   execute(executeMessage: ElementBrokerMessage): void;
 }
 
+declare const enum TimerType {
+  TimeCycle = 'timeCycle',
+  TimeDuration = 'timeDuration',
+  TimeDate = 'timeDate',
+}
+
+type parsedTimer = {
+  /** Expires at date time */
+  expireAt?: Date;
+  /** Repeat number of times */
+  repeat?: number;
+  /** Delay in milliseconds */
+  delay?: number;
+};
+
+declare class TimerEventDefinition extends EventDefinition {
+  /**
+   * Parse timer type
+   * @param timerType type of timer
+   * @param timerValue resolved expression timer string
+   */
+  parse(timerType: TimerType, timerValue: string): parsedTimer;
+}
+
+declare interface ICondition {
+  /** Condition type */
+  get type(): string;
+  [x: string]: any;
+  execute(message: ElementBrokerMessage, callback: CallableFunction): void;
+}
+
+declare class ConditionalEventDefinition extends EventDefinition {
+  /**
+   * Evaluate condition
+   * @param message
+   * @param callback
+   */
+  evaluate(message: ElementBrokerMessage, callback: CallableFunction): void;
+  /**
+   * Handle evaluate result or error
+   * @param err Condition evaluation error
+   * @param result Result from evaluated condition, completes execution if truthy
+   */
+  evaluateCallback(err: Error | null, result?: any): void;
+  /**
+   * Get condition from behaviour
+   * @param index Event definition sequence number, used to name registered script
+   */
+  getCondition(index: number): ICondition | null;
+}
+
 declare abstract class ElementBase {
   get id(): string;
   get type(): string;

package/dist/ExtensionsMapper.js

@@ -1,41 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = ExtensionsMapper;
-const kActivated = Symbol.for('activated');
-function ExtensionsMapper(context) {
-  this.context = context;
-}
-ExtensionsMapper.prototype.get = function get(activity) {
-  return new Extensions(activity, this.context, this._getExtensions());
-};
-ExtensionsMapper.prototype._getExtensions = function getExtensions() {
-  let extensions;
-  if (!(extensions = this.context.environment.extensions)) return [];
-  return Object.values(extensions);
-};
-function Extensions(activity, context, extensions) {
-  const result = this.extensions = [];
-  for (const Extension of extensions) {
-    const extension = Extension(activity, context);
-    if (extension) result.push(extension);
-  }
-  this[kActivated] = false;
-}
-Object.defineProperty(Extensions.prototype, 'count', {
-  get() {
-    return this.extensions.length;
-  }
-});
-Extensions.prototype.activate = function activate(message) {
-  if (this[kActivated]) return;
-  this[kActivated] = true;
-  for (const extension of this.extensions) extension.activate(message);
-};
-Extensions.prototype.deactivate = function deactivate(message) {
-  if (!this[kActivated]) return;
-  this[kActivated] = false;
-  for (const extension of this.extensions) extension.deactivate(message);
-};

package/dist/iso-duration.js

@@ -1,88 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.end = end;
-exports.parse = parse;
-exports.toSeconds = toSeconds;
-// License MIT @ https://tolu.mit-license.org/
-
-const numbers = '\\d+';
-const fractionalNumbers = ''.concat(numbers, '(?:[\\.,]').concat(numbers, ')?');
-const datePattern = '('.concat(numbers, 'Y)?(').concat(numbers, 'M)?(').concat(numbers, 'W)?(').concat(fractionalNumbers, 'D)?');
-const timePattern = 'T('.concat(fractionalNumbers, 'H)?(').concat(fractionalNumbers, 'M)?(').concat(fractionalNumbers, 'S)?');
-const rPattern = '(?:R('.concat(numbers).concat(')/)?');
-const iso8601 = rPattern.concat('P(?:').concat(datePattern, '(?:').concat(timePattern, ')?)');
-const objMap = ['years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds'];
-const defaultDuration = Object.freeze({
-  years: 0,
-  months: 0,
-  weeks: 0,
-  days: 0,
-  hours: 0,
-  minutes: 0,
-  seconds: 0
-});
-
-/**
- * The ISO8601 regex for matching / testing durations
- */
-const pattern = new RegExp(iso8601);
-
-/** Parse PnYnMnDTnHnMnS format to object */
-function parse(durationString) {
-  const matches = durationString.replace(/,/g, '.').match(pattern);
-  if (!matches) {
-    throw new RangeError('invalid duration: ' + durationString);
-  }
-
-  // Slice away repeat and first entry in match-array (the input string)
-  const slicedMatches = matches.slice(2);
-  if (slicedMatches.filter(Boolean).length === 0) {
-    throw new RangeError('invalid duration: ' + durationString);
-  }
-  // Check only one fraction is used
-  if (slicedMatches.filter(v => {
-    return /\./.test(v || '');
-  }).length > 1) {
-    throw new RangeError('Fractions are allowed on the smallest unit in the string, e.g. P0.5D or PT1.0001S but not PT0.5M0.1S: ' + durationString);
-  }
-  const result = {};
-  if (matches[1]) result.repeat = Number(matches[1]);
-  return slicedMatches.reduce((prev, next, idx) => {
-    prev[objMap[idx]] = parseFloat(next || '0') || 0;
-    return prev;
-  }, result);
-}
-
-/** Convert ISO8601 duration object to an end Date. */
-function end(durationInput, startDate) {
-  const duration = Object.assign({}, defaultDuration, durationInput);
-  // Create two equal timestamps, add duration to 'then' and return time difference
-  const timestamp = startDate.getTime();
-  const then = new Date(timestamp);
-  then.setFullYear(then.getFullYear() + duration.years);
-  then.setMonth(then.getMonth() + duration.months);
-  then.setDate(then.getDate() + duration.days);
-  // set time as milliseconds to get fractions working for minutes/hours
-  const hoursInMs = duration.hours * 3600 * 1000;
-  const minutesInMs = duration.minutes * 60 * 1000;
-  then.setMilliseconds(then.getMilliseconds() + duration.seconds * 1000 + hoursInMs + minutesInMs);
-  // Special case weeks
-  then.setDate(then.getDate() + duration.weeks * 7);
-  return then;
-}
-
-/** Convert ISO8601 duration object to seconds */
-function toSeconds(durationInput, startDate) {
-  if (startDate === void 0) {
-    startDate = new Date();
-  }
-  const duration = Object.assign({}, defaultDuration, durationInput);
-  const timestamp = startDate.getTime();
-  const now = new Date(timestamp);
-  const then = end(duration, now);
-  const seconds = (then.getTime() - now.getTime()) / 1000;
-  return seconds;
-}