bpmn-elements 5.1.3 → 7.0.0

package/dist/src/tasks/SubProcess.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = SubProcess;
 exports.SubProcessBehaviour = SubProcessBehaviour;
+exports.default = SubProcess;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
@@ -14,9 +14,12 @@ var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const executionsSymbol = Symbol.for('executions');
+const messageHandlersSymbol = Symbol.for('messageHandlers');
+
 function SubProcess(activityDef, context) {
   const triggeredByEvent = activityDef.behaviour && activityDef.behaviour.triggeredByEvent;
-  const subProcess = (0, _Activity.default)(SubProcessBehaviour, { ...activityDef,
+  const subProcess = new _Activity.default(SubProcessBehaviour, { ...activityDef,
     isSubProcess: true,
     triggeredByEvent
   }, context);
@@ -37,7 +40,7 @@ function SubProcess(activityDef, context) {
       startId
     } = message.content;
     const last = message.content.sequence.pop();
-    const sequence = (0, _ProcessExecution.default)(subProcess, context).shake(startId);
+    const sequence = new _ProcessExecution.default(subProcess, context).shake(startId);
     message.content.sequence.push({ ...last,
       isSubProcess: true,
       sequence
@@ -49,214 +52,231 @@ function SubProcessBehaviour(activity, context) {
   const {
     id,
     type,
-    broker,
-    behaviour,
-    environment,
-    logger
+    behaviour
   } = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-  const processExecutions = [];
-  let rootExecutionId;
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-
-    get execution() {
-      return processExecutions[0];
-    },
-
-    get executions() {
-      return processExecutions;
-    },
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.context = context;
+  this.environment = activity.environment;
+  this.broker = activity.broker;
+  this.executionId = undefined;
+  this[executionsSymbol] = [];
+  this[messageHandlersSymbol] = {
+    onApiRootMessage: this._onApiRootMessage.bind(this),
+    onExecutionCompleted: this._onExecutionCompleted.bind(this)
+  };
+}
 
-    execute,
-    getApi,
-    getState,
+const proto = SubProcessBehaviour.prototype;
+Object.defineProperty(proto, 'execution', {
+  get() {
+    return this[executionsSymbol][0];
+  }
 
-    getPostponed() {
-      return this.executions.reduce((result, pe) => {
-        result = result.concat(pe.getPostponed());
-        return result;
-      }, []);
-    },
+});
+Object.defineProperty(proto, 'executions', {
+  get() {
+    return this[executionsSymbol].slice();
+  }
 
-    recover
-  };
-  return source;
+});
 
-  function execute(executeMessage) {
-    const content = executeMessage.content;
+proto.execute = function execute(executeMessage) {
+  const content = executeMessage.content;
+  let executionId = this.executionId;
 
-    if (content.isRootScope) {
-      rootExecutionId = content.executionId;
-    }
+  if (content.isRootScope) {
+    executionId = this.executionId = content.executionId;
+  }
 
-    if (loopCharacteristics && content.isRootScope) {
-      broker.subscribeTmp('api', `activity.#.${rootExecutionId}`, onApiRootMessage, {
-        noAck: true,
-        consumerTag: `_api-${rootExecutionId}`,
-        priority: 200
-      });
-      return loopCharacteristics.execute(executeMessage);
-    }
+  const loopCharacteristics = this.loopCharacteristics;
 
-    const processExecution = upsertExecution(executeMessage);
-    if (!processExecution) return;
-    return processExecution.execute(executeMessage);
+  if (loopCharacteristics && content.isRootScope) {
+    this.broker.subscribeTmp('api', `activity.#.${executionId}`, this[messageHandlersSymbol].onApiRootMessage, {
+      noAck: true,
+      consumerTag: `_api-${executionId}`,
+      priority: 200
+    });
+    return loopCharacteristics.execute(executeMessage);
+  }
 
-    function onApiRootMessage(routingKey, message) {
-      const messageType = message.properties.type;
+  const processExecution = this._upsertExecution(executeMessage);
 
-      switch (messageType) {
-        case 'stop':
-          broker.cancel(`_api-${rootExecutionId}`);
-          stop();
-          break;
+  if (!processExecution) return;
+  return processExecution.execute(executeMessage);
+};
 
-        case 'discard':
-          broker.cancel(`_api-${rootExecutionId}`);
-          discard();
-          break;
-      }
-    }
+proto.stop = function stop() {
+  for (const execution of this[executionsSymbol]) {
+    this.broker.cancel(`_sub-process-execution-${execution.executionId}`);
+    this.broker.cancel(`_sub-process-api-${execution.executionId}`);
+    execution.stop();
   }
+};
 
-  function stop() {
-    return processExecutions.forEach(pe => {
-      broker.cancel(`_sub-process-execution-${pe.executionId}`);
-      broker.cancel(`_sub-process-api-${pe.executionId}`);
-      pe.stop();
-    });
+proto.discard = function discard() {
+  for (const execution of this[executionsSymbol]) {
+    this.broker.cancel(`_sub-process-execution-${execution.executionId}`);
+    this.broker.cancel(`_sub-process-api-${execution.executionId}`);
+    execution.discard();
+  }
+};
+
+proto.getState = function getState() {
+  if (this.loopCharacteristics) {
+    return {
+      executions: this[executionsSymbol].map(pe => {
+        const state = pe.getState();
+        state.environment = pe.environment.getState();
+        return state;
+      })
+    };
   }
 
-  function discard() {
-    return processExecutions.forEach(pe => {
-      broker.cancel(`_sub-process-execution-${pe.executionId}`);
-      broker.cancel(`_sub-process-api-${pe.executionId}`);
-      pe.discard();
-    });
+  const execution = this.execution;
+
+  if (execution) {
+    const state = execution.getState();
+    state.environment = execution.environment.getState();
+    return state;
   }
+};
 
-  function getState() {
-    if (loopCharacteristics) {
-      return {
-        executions: processExecutions.map(getExecutionState)
-      };
-    }
+proto.recover = function recover(state) {
+  if (!state) return;
+  const executions = this[executionsSymbol];
+  const loopCharacteristics = this.loopCharacteristics;
 
-    if (processExecutions.length) {
-      return getExecutionState(processExecutions[0]);
-    }
+  if (loopCharacteristics && state.executions) {
+    executions.splice(0);
 
-    function getExecutionState(pe) {
-      const state = pe.getState();
-      state.environment = pe.environment.getState();
-      return state;
+    for (const se of state.executions) {
+      this.recover(se);
     }
-  }
 
-  function recover(state) {
-    if (!state) return;
+    return;
+  }
 
-    if (loopCharacteristics && state.executions) {
-      processExecutions.splice(0);
-      return state.executions.forEach(recover);
-    } else if (!loopCharacteristics) {
-      processExecutions.splice(0);
-    }
+  if (!loopCharacteristics) {
+    executions.splice(0);
+  }
 
-    const subEnvironment = environment.clone().recover(state.environment);
-    const subContext = context.clone(subEnvironment);
-    const execution = (0, _ProcessExecution.default)(activity, subContext).recover(state);
-    processExecutions.push(execution);
-    return execution;
+  const subEnvironment = this.environment.clone().recover(state.environment);
+  const subContext = this.context.clone(subEnvironment);
+  const execution = new _ProcessExecution.default(this.activity, subContext).recover(state);
+  executions.push(execution);
+  return execution;
+};
+
+proto.getPostponed = function getPostponed() {
+  return this[executionsSymbol].reduce((result, pe) => {
+    result = result.concat(pe.getPostponed());
+    return result;
+  }, []);
+};
+
+proto._onApiRootMessage = function onApiRootMessage(_, message) {
+  const messageType = message.properties.type;
+
+  switch (messageType) {
+    case 'stop':
+      this.broker.cancel(message.fields.consumerTag);
+      this.stop();
+      break;
+
+    case 'discard':
+      this.broker.cancel(message.fields.consumerTag);
+      this.discard();
+      break;
   }
+};
 
-  function upsertExecution(executeMessage) {
-    const content = executeMessage.content;
-    const executionId = content.executionId;
-    let execution = getExecutionById(executionId);
+proto._upsertExecution = function upsertExecution(executeMessage) {
+  const content = executeMessage.content;
+  const executionId = content.executionId;
 
-    if (execution) {
-      if (executeMessage.fields.redelivered) addListeners(execution, executionId);
-      return execution;
-    }
+  let execution = this._getExecutionById(executionId);
 
-    const subEnvironment = environment.clone({
-      output: {}
-    });
-    const subContext = context.clone(subEnvironment);
-    execution = (0, _ProcessExecution.default)(activity, subContext);
-    processExecutions.push(execution);
-    addListeners(execution, executionId);
+  if (execution) {
+    if (executeMessage.fields.redelivered) this._addListeners(execution, executionId);
     return execution;
   }
 
-  function addListeners(processExecution, executionId) {
-    const executionConsumerTag = `_sub-process-execution-${executionId}`;
-    broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, onExecutionCompleted, {
-      noAck: true,
-      consumerTag: executionConsumerTag
-    });
+  const subEnvironment = this.environment.clone({
+    output: {}
+  });
+  const subContext = this.context.clone(subEnvironment);
+  execution = new _ProcessExecution.default(this.activity, subContext);
+  this[executionsSymbol].push(execution);
+
+  this._addListeners(execution, executionId);
 
-    function onExecutionCompleted(_, message) {
-      const content = message.content;
-      const messageType = message.properties.type;
-      if (message.fields.redelivered && message.properties.persistent === false) return;
-
-      switch (messageType) {
-        case 'stopped':
-          {
-            broker.cancel(executionConsumerTag);
-            break;
-          }
-
-        case 'discard':
-          {
-            broker.cancel(executionConsumerTag);
-            broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content));
-            break;
-          }
-
-        case 'completed':
-          {
-            broker.cancel(executionConsumerTag);
-            broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content));
-            break;
-          }
-
-        case 'error':
-          {
-            broker.cancel(executionConsumerTag);
-            const {
-              error
-            } = content;
-            logger.error(`<${id}>`, error);
-            broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(content));
-            break;
-          }
+  return execution;
+};
+
+proto._addListeners = function addListeners(processExecution, executionId) {
+  this.broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, this[messageHandlersSymbol].onExecutionCompleted, {
+    noAck: true,
+    consumerTag: `_sub-process-execution-${executionId}`
+  });
+};
+
+proto._onExecutionCompleted = function onExecutionCompleted(_, message) {
+  if (message.fields.redelivered && message.properties.persistent === false) return;
+  const content = message.content;
+  const messageType = message.properties.type;
+  const broker = this.broker;
+
+  switch (messageType) {
+    case 'stopped':
+      {
+        broker.cancel(message.fields.consumerTag);
+        break;
       }
-    }
-  }
 
-  function getApi(apiMessage) {
-    const content = apiMessage.content;
-    if (content.id === id) return;
-    let execution;
+    case 'discard':
+      {
+        broker.cancel(message.fields.consumerTag);
+        broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content));
+        break;
+      }
 
-    if (execution = getExecutionById(content.parent.executionId)) {
-      return execution.getApi(apiMessage);
-    }
+    case 'completed':
+      {
+        broker.cancel(message.fields.consumerTag);
+        broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content));
+        break;
+      }
+
+    case 'error':
+      {
+        broker.cancel(message.fields.consumerTag);
+        const {
+          error
+        } = content;
+        this.activity.logger.error(`<${this.id}>`, error);
+        broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(content));
+        break;
+      }
+  }
+};
 
-    const parentPath = content.parent.path;
+proto.getApi = function getApi(apiMessage) {
+  const content = apiMessage.content;
+  if (content.id === this.id) return;
+  let execution;
 
-    for (let i = 0; i < parentPath.length; i++) {
-      if (execution = getExecutionById(parentPath[i].executionId)) return execution.getApi(apiMessage);
-    }
+  if (execution = this._getExecutionById(content.parent.executionId)) {
+    return execution.getApi(apiMessage);
   }
 
-  function getExecutionById(executionId) {
-    return processExecutions.find(pe => pe.executionId === executionId);
+  for (const pp of content.parent.path) {
+    if (execution = this._getExecutionById(pp.executionId)) return execution.getApi(apiMessage);
   }
-}
+};
+
+proto._getExecutionById = function getExecutionById(executionId) {
+  return this[executionsSymbol].find(pe => pe.executionId === executionId);
+};

package/dist/src/tasks/Task.js

@@ -3,15 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = Task;
 exports.TaskBehaviour = TaskBehaviour;
+exports.default = Task;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
+var _messageHelper = require("../messageHelper");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function Task(activityDef, context) {
-  return (0, _Activity.default)(TaskBehaviour, activityDef, context);
+  return new _Activity.default(TaskBehaviour, activityDef, context);
 }
 
 function TaskBehaviour(activity) {
@@ -21,23 +23,19 @@ function TaskBehaviour(activity) {
     behaviour,
     broker
   } = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute
-  };
-  return source;
-
-  function execute(executeMessage) {
-    const content = executeMessage.content;
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.broker = broker;
+}
 
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
-    }
+TaskBehaviour.prototype.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const loopCharacteristics = this.loopCharacteristics;
 
-    return broker.publish('execution', 'execute.completed', { ...content
-    });
+  if (loopCharacteristics && executeContent.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
   }
-}
+
+  return this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent));
+};

package/index.js

@@ -2,11 +2,14 @@ import Activity from './src/activity/Activity';
 import Association from './src/flows/Association';
 import BoundaryEvent from './src/events/BoundaryEvent';
 import BpmnError from './src/error/BpmnError';
+import CallActivity from './src/tasks/CallActivity';
 import CancelEventDefinition from './src/eventDefinitions/CancelEventDefinition';
 import CompensateEventDefinition from './src/eventDefinitions/CompensateEventDefinition';
 import ConditionalEventDefinition from './src/eventDefinitions/ConditionalEventDefinition';
 import Context from './src/Context';
 import DataObject from './src/io/EnvironmentDataObject';
+import DataStore from './src/io/EnvironmentDataStore';
+import DataStoreReference from './src/io/EnvironmentDataStoreReference';
 import Definition from './src/definition/Definition';
 import Dummy from './src/activity/Dummy';
 import EndEvent from './src/events/EndEvent';
@@ -27,6 +30,7 @@ import MessageEventDefinition from './src/eventDefinitions/MessageEventDefinitio
 import MessageFlow from './src/flows/MessageFlow';
 import ParallelGateway from './src/gateways/ParallelGateway';
 import Process from './src/process/Process';
+import Properties from './src/io/Properties';
 import ReceiveTask from './src/tasks/ReceiveTask';
 import ScriptTask from './src/tasks/ScriptTask';
 import SequenceFlow from './src/flows/SequenceFlow';
@@ -48,11 +52,14 @@ export {
   Activity,
   BoundaryEvent,
   BpmnError,
+  CallActivity,
   CancelEventDefinition,
   CompensateEventDefinition,
   ConditionalEventDefinition,
   Context,
   DataObject,
+  DataStore,
+  DataStoreReference,
   Definition,
   Dummy,
   Dummy as TextAnnotation,
@@ -76,6 +83,7 @@ export {
   LoopCharacteristics as MultiInstanceLoopCharacteristics,
   ParallelGateway,
   Process,
+  Properties,
   ReceiveTask,
   ScriptTask,
   SequenceFlow,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "5.1.3",
+  "version": "7.0.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "main": "dist/index.js",
   "module": "index.js",
@@ -10,7 +10,8 @@
     "prepare": "npm run dist",
     "cov:html": "nyc mocha -R dot && nyc report --reporter=html",
     "test:lcov": "nyc mocha -R dot && nyc report --reporter lcov && npm run posttest",
-    "dist": "babel index.js -d dist && rm -rf dist/src && babel src -d dist/src",
+    "dist": "babel index.js -d dist && babel src -d dist/src",
+    "predist": "node -e \"fs.rmdirSync('./dist/src', {recursive: true});\"",
     "test-md": "node scripts/test-markdown ./API.md && node scripts/test-markdown ./docs/Examples.md",
     "toc": "node scripts/generate-api-toc ./API.md,./docs/Examples.md,./docs/Form.md"
   },
@@ -46,25 +47,25 @@
   ],
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.2",
-    "@babel/cli": "^7.14.3",
-    "@babel/core": "^7.13.8",
-    "@babel/preset-env": "^7.13.8",
-    "@babel/register": "^7.15.3",
+    "@babel/cli": "^7.17.0",
+    "@babel/core": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/register": "^7.17.0",
     "bpmn-moddle": "^7.1.2",
-    "camunda-bpmn-moddle": "^5.0.0",
-    "chai": "^4.2.0",
+    "camunda-bpmn-moddle": "^6.1.0",
+    "chai": "^4.3.6",
     "chronokinesis": "^3.0.0",
-    "debug": "^4.3.1",
-    "eslint": "^7.27.0",
-    "got": "^11.8.2",
-    "mocha": "^9.0.2",
+    "debug": "^4.3.3",
+    "eslint": "^7.32.0",
+    "got": "^11.8.3",
+    "mocha": "^9.2.0",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^1.0.0",
-    "nock": "^13.0.9",
+    "moddle-context-serializer": "^2.0.0",
+    "nock": "^13.2.4",
     "nyc": "^15.1.0"
   },
   "dependencies": {
     "iso8601-duration": "^1.3.0",
-    "smqp": "^5.0.0"
+    "smqp": "^6.0.0"
   }
 }