bpmn-elements 7.0.0 → 8.0.0

package/dist/src/tasks/SubProcess.js

@@ -14,8 +14,8 @@ var _messageHelper = require("../messageHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const executionsSymbol = Symbol.for('executions');
-const messageHandlersSymbol = Symbol.for('messageHandlers');
+const kExecutions = Symbol.for('executions');
+const kMessageHandlers = Symbol.for('messageHandlers');
 
 function SubProcess(activityDef, context) {
   const triggeredByEvent = activityDef.behaviour && activityDef.behaviour.triggeredByEvent;
@@ -62,8 +62,8 @@ function SubProcessBehaviour(activity, context) {
   this.environment = activity.environment;
   this.broker = activity.broker;
   this.executionId = undefined;
-  this[executionsSymbol] = [];
-  this[messageHandlersSymbol] = {
+  this[kExecutions] = [];
+  this[kMessageHandlers] = {
     onApiRootMessage: this._onApiRootMessage.bind(this),
     onExecutionCompleted: this._onExecutionCompleted.bind(this)
   };
@@ -72,13 +72,13 @@ function SubProcessBehaviour(activity, context) {
 const proto = SubProcessBehaviour.prototype;
 Object.defineProperty(proto, 'execution', {
   get() {
-    return this[executionsSymbol][0];
+    return this[kExecutions][0];
   }
 
 });
 Object.defineProperty(proto, 'executions', {
   get() {
-    return this[executionsSymbol].slice();
+    return this[kExecutions].slice();
   }
 
 });
@@ -94,7 +94,7 @@ proto.execute = function execute(executeMessage) {
   const loopCharacteristics = this.loopCharacteristics;
 
   if (loopCharacteristics && content.isRootScope) {
-    this.broker.subscribeTmp('api', `activity.#.${executionId}`, this[messageHandlersSymbol].onApiRootMessage, {
+    this.broker.subscribeTmp('api', `activity.#.${executionId}`, this[kMessageHandlers].onApiRootMessage, {
       noAck: true,
       consumerTag: `_api-${executionId}`,
       priority: 200
@@ -109,7 +109,7 @@ proto.execute = function execute(executeMessage) {
 };
 
 proto.stop = function stop() {
-  for (const execution of this[executionsSymbol]) {
+  for (const execution of this[kExecutions]) {
     this.broker.cancel(`_sub-process-execution-${execution.executionId}`);
     this.broker.cancel(`_sub-process-api-${execution.executionId}`);
     execution.stop();
@@ -117,7 +117,7 @@ proto.stop = function stop() {
 };
 
 proto.discard = function discard() {
-  for (const execution of this[executionsSymbol]) {
+  for (const execution of this[kExecutions]) {
     this.broker.cancel(`_sub-process-execution-${execution.executionId}`);
     this.broker.cancel(`_sub-process-api-${execution.executionId}`);
     execution.discard();
@@ -127,7 +127,7 @@ proto.discard = function discard() {
 proto.getState = function getState() {
   if (this.loopCharacteristics) {
     return {
-      executions: this[executionsSymbol].map(pe => {
+      executions: this[kExecutions].map(pe => {
         const state = pe.getState();
         state.environment = pe.environment.getState();
         return state;
@@ -146,7 +146,7 @@ proto.getState = function getState() {
 
 proto.recover = function recover(state) {
   if (!state) return;
-  const executions = this[executionsSymbol];
+  const executions = this[kExecutions];
   const loopCharacteristics = this.loopCharacteristics;
 
   if (loopCharacteristics && state.executions) {
@@ -171,7 +171,7 @@ proto.recover = function recover(state) {
 };
 
 proto.getPostponed = function getPostponed() {
-  return this[executionsSymbol].reduce((result, pe) => {
+  return this[kExecutions].reduce((result, pe) => {
     result = result.concat(pe.getPostponed());
     return result;
   }, []);
@@ -204,12 +204,10 @@ proto._upsertExecution = function upsertExecution(executeMessage) {
     return execution;
   }
 
-  const subEnvironment = this.environment.clone({
-    output: {}
-  });
+  const subEnvironment = this.environment.clone();
   const subContext = this.context.clone(subEnvironment);
   execution = new _ProcessExecution.default(this.activity, subContext);
-  this[executionsSymbol].push(execution);
+  this[kExecutions].push(execution);
 
   this._addListeners(execution, executionId);
 
@@ -217,7 +215,7 @@ proto._upsertExecution = function upsertExecution(executeMessage) {
 };
 
 proto._addListeners = function addListeners(processExecution, executionId) {
-  this.broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, this[messageHandlersSymbol].onExecutionCompleted, {
+  this.broker.subscribeTmp('subprocess-execution', `execution.#.${executionId}`, this[kMessageHandlers].onExecutionCompleted, {
     noAck: true,
     consumerTag: `_sub-process-execution-${executionId}`
   });
@@ -278,5 +276,5 @@ proto.getApi = function getApi(apiMessage) {
 };
 
 proto._getExecutionById = function getExecutionById(executionId) {
-  return this[executionsSymbol].find(pe => pe.executionId === executionId);
+  return this[kExecutions].find(pe => pe.executionId === executionId);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "7.0.0",
+  "version": "8.0.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "main": "dist/index.js",
   "module": "index.js",
@@ -46,21 +46,21 @@
     "index.js"
   ],
   "devDependencies": {
-    "@aircall/expression-parser": "^1.0.2",
-    "@babel/cli": "^7.17.0",
-    "@babel/core": "^7.17.0",
+    "@aircall/expression-parser": "^1.0.4",
+    "@babel/cli": "^7.17.6",
+    "@babel/core": "^7.17.8",
     "@babel/preset-env": "^7.16.11",
-    "@babel/register": "^7.17.0",
+    "@babel/register": "^7.17.7",
     "bpmn-moddle": "^7.1.2",
-    "camunda-bpmn-moddle": "^6.1.0",
+    "camunda-bpmn-moddle": "^6.1.2",
     "chai": "^4.3.6",
     "chronokinesis": "^3.0.0",
-    "debug": "^4.3.3",
+    "debug": "^4.3.4",
     "eslint": "^7.32.0",
     "got": "^11.8.3",
-    "mocha": "^9.2.0",
+    "mocha": "^9.2.2",
     "mocha-cakes-2": "^3.3.0",
-    "moddle-context-serializer": "^2.0.0",
+    "moddle-context-serializer": "^2.1.0",
     "nock": "^13.2.4",
     "nyc": "^15.1.0"
   },

package/src/Context.js

@@ -30,7 +30,9 @@ function ContextInstance(definitionContext, environment) {
   };
 }
 
-ContextInstance.prototype.getActivityById = function getActivityById(activityId) {
+const proto = ContextInstance.prototype;
+
+proto.getActivityById = function getActivityById(activityId) {
   const activityInstance = this.refs.activityRefs[activityId];
   if (activityInstance) return activityInstance;
   const activity = this.definitionContext.getActivityById(activityId);
@@ -38,7 +40,7 @@ ContextInstance.prototype.getActivityById = function getActivityById(activityId)
   return this.upsertActivity(activity);
 };
 
-ContextInstance.prototype.upsertActivity = function upsertActivity(activityDef) {
+proto.upsertActivity = function upsertActivity(activityDef) {
   let activityInstance = this.refs.activityRefs[activityDef.id];
   if (activityInstance) return activityInstance;
 
@@ -47,7 +49,7 @@ ContextInstance.prototype.upsertActivity = function upsertActivity(activityDef)
   return activityInstance;
 };
 
-ContextInstance.prototype.getSequenceFlowById = function getSequenceFlowById(sequenceFlowId) {
+proto.getSequenceFlowById = function getSequenceFlowById(sequenceFlowId) {
   const flowInstance = this.refs.sequenceFlowRefs[sequenceFlowId];
   if (flowInstance) return flowInstance;
 
@@ -56,31 +58,31 @@ ContextInstance.prototype.getSequenceFlowById = function getSequenceFlowById(seq
   return this.upsertSequenceFlow(flowDef);
 };
 
-ContextInstance.prototype.getInboundSequenceFlows = function getInboundSequenceFlows(activityId) {
+proto.getInboundSequenceFlows = function getInboundSequenceFlows(activityId) {
   return (this.definitionContext.getInboundSequenceFlows(activityId) || []).map((flow) => this.upsertSequenceFlow(flow));
 };
 
-ContextInstance.prototype.getOutboundSequenceFlows = function getOutboundSequenceFlows(activityId) {
+proto.getOutboundSequenceFlows = function getOutboundSequenceFlows(activityId) {
   return (this.definitionContext.getOutboundSequenceFlows(activityId) || []).map((flow) => this.upsertSequenceFlow(flow));
 };
 
-ContextInstance.prototype.getInboundAssociations = function getInboundAssociations(activityId) {
+proto.getInboundAssociations = function getInboundAssociations(activityId) {
   return (this.definitionContext.getInboundAssociations(activityId) || []).map((association) => this.upsertAssociation(association));
 };
 
-ContextInstance.prototype.getOutboundAssociations = function getOutboundAssociations(activityId) {
+proto.getOutboundAssociations = function getOutboundAssociations(activityId) {
   return (this.definitionContext.getOutboundAssociations(activityId) || []).map((association) => this.upsertAssociation(association));
 };
 
-ContextInstance.prototype.getActivities = function getActivities(scopeId) {
+proto.getActivities = function getActivities(scopeId) {
   return (this.definitionContext.getActivities(scopeId) || []).map((activityDef) => this.upsertActivity(activityDef));
 };
 
-ContextInstance.prototype.getSequenceFlows = function getSequenceFlows(scopeId) {
+proto.getSequenceFlows = function getSequenceFlows(scopeId) {
   return (this.definitionContext.getSequenceFlows(scopeId) || []).map((flow) => this.upsertSequenceFlow(flow));
 };
 
-ContextInstance.prototype.upsertSequenceFlow = function upsertSequenceFlow(flowDefinition) {
+proto.upsertSequenceFlow = function upsertSequenceFlow(flowDefinition) {
   const refs = this.refs.sequenceFlowRefs;
   let flowInstance = refs[flowDefinition.id];
   if (flowInstance) return flowInstance;
@@ -91,11 +93,11 @@ ContextInstance.prototype.upsertSequenceFlow = function upsertSequenceFlow(flowD
   return flowInstance;
 };
 
-ContextInstance.prototype.getAssociations = function getAssociations(scopeId) {
+proto.getAssociations = function getAssociations(scopeId) {
   return (this.definitionContext.getAssociations(scopeId) || []).map((association) => this.upsertAssociation(association));
 };
 
-ContextInstance.prototype.upsertAssociation = function upsertAssociation(associationDefinition) {
+proto.upsertAssociation = function upsertAssociation(associationDefinition) {
   const refs = this.refs.associationRefs;
   let instance = refs[associationDefinition.id];
   if (instance) return instance;
@@ -105,40 +107,41 @@ ContextInstance.prototype.upsertAssociation = function upsertAssociation(associa
   return instance;
 };
 
-ContextInstance.prototype.clone = function clone(newEnvironment) {
+proto.clone = function clone(newEnvironment) {
   return new ContextInstance(this.definitionContext, newEnvironment || this.environment);
 };
 
-ContextInstance.prototype.getProcessById = function getProcessById(processId) {
+proto.getProcessById = function getProcessById(processId) {
   const refs = this.refs.processRefs;
-  let processInstance = this.refs.processRefs[processId];
-  if (processInstance) return processInstance;
+  let bp = this.refs.processRefs[processId];
+  if (bp) return bp;
 
   const processDefinition = this.definitionContext.getProcessById(processId);
   if (!processDefinition) return null;
 
-  processInstance = refs[processId] = new processDefinition.Behaviour(processDefinition, this);
-  this.refs.processes.push(processInstance);
+  const bpContext = this.clone(this.environment.clone());
+  bp = refs[processId] = new processDefinition.Behaviour(processDefinition, bpContext);
+  this.refs.processes.push(bp);
 
-  return processInstance;
+  return bp;
 };
 
-ContextInstance.prototype.getNewProcessById = function getNewProcessById(processId, processOptions) {
+proto.getNewProcessById = function getNewProcessById(processId) {
   if (!this.getProcessById(processId)) return null;
-  const processDefinition = this.definitionContext.getProcessById(processId);
-  const processInstance = new processDefinition.Behaviour(processDefinition, this.clone(this.environment.clone({output: {}, ...processOptions})));
-  return processInstance;
+  const bpDef = this.definitionContext.getProcessById(processId);
+  const bp = new bpDef.Behaviour(bpDef, this.clone(this.environment.clone()));
+  return bp;
 };
 
-ContextInstance.prototype.getProcesses = function getProcesses() {
+proto.getProcesses = function getProcesses() {
   return this.definitionContext.getProcesses().map(({id: processId}) => this.getProcessById(processId));
 };
 
-ContextInstance.prototype.getExecutableProcesses = function getExecutableProcesses() {
+proto.getExecutableProcesses = function getExecutableProcesses() {
   return this.definitionContext.getExecutableProcesses().map(({id: processId}) => this.getProcessById(processId));
 };
 
-ContextInstance.prototype.getMessageFlows = function getMessageFlows(sourceId) {
+proto.getMessageFlows = function getMessageFlows(sourceId) {
   if (!this.refs.messageFlows.length) {
     const flows = this.definitionContext.getMessageFlows() || [];
     this.refs.messageFlows.push(...flows.map((flow) => new flow.Behaviour(flow, this)));
@@ -147,7 +150,7 @@ ContextInstance.prototype.getMessageFlows = function getMessageFlows(sourceId) {
   return this.refs.messageFlows.filter((flow) => flow.source.processId === sourceId);
 };
 
-ContextInstance.prototype.getDataObjectById = function getDataObjectById(referenceId) {
+proto.getDataObjectById = function getDataObjectById(referenceId) {
   let dataObject;
   if ((dataObject = this.refs.dataObjectRefs[referenceId])) return dataObject;
 
@@ -159,7 +162,7 @@ ContextInstance.prototype.getDataObjectById = function getDataObjectById(referen
   return dataObject;
 };
 
-ContextInstance.prototype.getDataStoreById = function getDataStoreById(referenceId) {
+proto.getDataStoreById = function getDataStoreById(referenceId) {
   let dataStore;
   if ((dataStore = this.refs.dataStoreRefs[referenceId])) return dataStore;
 
@@ -171,23 +174,28 @@ ContextInstance.prototype.getDataStoreById = function getDataStoreById(reference
   return dataStore;
 };
 
-ContextInstance.prototype.getStartActivities = function getStartActivities(filterOptions, scopeId) {
+proto.getStartActivities = function getStartActivities(filterOptions, scopeId) {
   const {referenceId, referenceType = 'unknown'} = filterOptions || {};
-  return this.getActivities().filter((activity) => {
-    if (!activity.isStart) return false;
-    if (scopeId && activity.parent.id !== scopeId) return false;
-    if (!filterOptions) return true;
-
-    if (!activity.behaviour.eventDefinitions && !activity.behaviour.eventDefinitions) return false;
-
-
-    return activity.eventDefinitions.some((ed) => {
+  const result = [];
+  for (const activity of this.getActivities()) {
+    if (!activity.isStart) continue;
+    if (scopeId && activity.parent.id !== scopeId) continue;
+    if (!filterOptions) {
+      result.push(activity);
+      continue;
+    }
+
+    if (!activity.behaviour.eventDefinitions && !activity.behaviour.eventDefinitions) continue;
+
+    const ref = activity.eventDefinitions.some((ed) => {
       return ed.reference && ed.reference.id === referenceId && ed.reference.referenceType === referenceType;
     });
-  });
+    if (ref) result.push(activity);
+  }
+  return result;
 };
 
-ContextInstance.prototype.loadExtensions = function loadExtensions(activity) {
+proto.loadExtensions = function loadExtensions(activity) {
   return this.extensionsMapper.get(activity);
 };
 

package/src/Environment.js

@@ -2,24 +2,33 @@ import Expressions from './Expressions';
 import {Scripts as IScripts} from './Scripts';
 import {Timers} from './Timers';
 
-const optionsSymbol = Symbol.for('options');
-const variablesSymbol = Symbol.for('variables');
-
-const defaultOptions = ['extensions', 'output', 'services', 'scripts', 'settings', 'variables', 'Logger'];
+const kServices = Symbol.for('services');
+const kVariables = Symbol.for('variables');
+
+const defaultOptions = [
+  'expressions',
+  'extensions',
+  'Logger',
+  'output',
+  'scripts',
+  'services',
+  'settings',
+  'timers',
+  'variables',
+];
 
 export default function Environment(options = {}) {
-  this[optionsSymbol] = options;
   this.options = validateOptions(options);
 
   this.expressions = options.expressions || Expressions();
   this.extensions = options.extensions;
   this.output = options.output || {};
   this.scripts = options.scripts || IScripts();
-  this.services = options.services || {};
-  this.settings = {...options.settings};
   this.timers = options.timers || Timers();
+  this.settings = {...options.settings};
   this.Logger = options.Logger || DummyLogger;
-  this[variablesSymbol] = options.variables || {};
+  this[kServices] = options.services || {};
+  this[kVariables] = options.variables || {};
 }
 
 const proto = Environment.prototype;
@@ -27,14 +36,28 @@ const proto = Environment.prototype;
 Object.defineProperty(proto, 'variables', {
   enumerable: true,
   get() {
-    return this[variablesSymbol];
+    return this[kVariables];
+  },
+});
+
+Object.defineProperty(proto, 'services', {
+  enumerable: true,
+  get() {
+    return this[kServices];
+  },
+  set(value) {
+    const services = this[kServices];
+    for (const name in services) {
+      if (!(name in value)) delete services[name];
+    }
+    Object.assign(services, value);
   },
 });
 
 proto.getState = function getState() {
   return {
     settings: {...this.settings},
-    variables: {...this.variables},
+    variables: {...this[kVariables]},
     output: {...this.output},
   };
 };
@@ -42,22 +65,18 @@ proto.getState = function getState() {
 proto.recover = function recover(state) {
   if (!state) return this;
 
-  const recoverOptions = validateOptions(state);
-  Object.assign(this[optionsSymbol], recoverOptions);
-
   if (state.settings) Object.assign(this.settings, state.settings);
-  if (state.variables) Object.assign(this[variablesSymbol], state.variables);
+  if (state.variables) Object.assign(this[kVariables], state.variables);
   if (state.output) Object.assign(this.output, state.output);
 
   return this;
 };
 
 proto.clone = function clone(overrideOptions = {}) {
-  const services = this.services;
+  const services = this[kServices];
   const newOptions = {
     settings: {...this.settings},
-    variables: {...this.variables},
-    output: {...this.output},
+    variables: {...this[kVariables]},
     Logger: this.Logger,
     extensions: this.extensions,
     scripts: this.scripts,
@@ -76,12 +95,21 @@ proto.clone = function clone(overrideOptions = {}) {
 proto.assignVariables = function assignVariables(newVars) {
   if (!newVars || typeof newVars !== 'object') return;
 
-  this[variablesSymbol] = {
+  this[kVariables] = {
     ...this.variables,
     ...newVars,
   };
 };
 
+proto.assignSettings = function assignVariables(newSettings) {
+  if (!newSettings || typeof newSettings !== 'object') return;
+
+  this.settings = {
+    ...this.settings,
+    ...newSettings,
+  };
+};
+
 proto.getScript = function getScript(...args) {
   return this.scripts.getScript(...args);
 };
@@ -91,7 +119,7 @@ proto.registerScript = function registerScript(...args) {
 };
 
 proto.getServiceByName = function getServiceByName(serviceName) {
-  return this.services[serviceName];
+  return this[kServices][serviceName];
 };
 
 proto.resolveExpression = function resolveExpression(expression, message = {}, expressionFnContext) {
@@ -104,7 +132,7 @@ proto.resolveExpression = function resolveExpression(expression, message = {}, e
 };
 
 proto.addService = function addService(name, fn) {
-  this.services[name] = fn;
+  this[kServices][name] = fn;
 };
 
 function validateOptions(input) {

package/src/EventBroker.js

@@ -90,7 +90,7 @@ EventBroker.prototype.waitFor = function waitFor(eventName, onMessage) {
   return new Promise((resolve, reject) => {
     const consumers = [
       this.broker.subscribeTmp('event', key, eventCallback, {noAck: true}),
-      this.broker.subscribeTmp('event', '*.error', errorCallback, {noAck: true})
+      this.broker.subscribeTmp('event', '*.error', errorCallback, {noAck: true}),
     ];
 
     function eventCallback(routingKey, message, owner) {

package/src/MessageFormatter.js

@@ -3,8 +3,8 @@ import {getUniqueId} from './shared';
 import {ActivityError} from './error/Errors';
 import {getRoutingKeyPattern} from 'smqp';
 
-const onMessageSymbol = Symbol.for('onMessage');
-const executionSymbol = Symbol.for('execution');
+const kOnMessage = Symbol.for('onMessage');
+const kExecution = Symbol.for('execution');
 
 export {Formatter};
 
@@ -17,7 +17,7 @@ function Formatter(element, formatQ) {
 
   this.pendingFormats = [];
 
-  this[onMessageSymbol] = this._onMessage.bind(this);
+  this[kOnMessage] = this._onMessage.bind(this);
 }
 
 Formatter.prototype.format = function format(message, callback) {
@@ -32,7 +32,7 @@ Formatter.prototype.format = function format(message, callback) {
     persistent: false,
   });
 
-  this[executionSymbol] = {
+  this[kExecution] = {
     correlationId,
     formatKey: message.fields.routingKey,
     runMessage: cloneMessage(message),
@@ -42,14 +42,14 @@ Formatter.prototype.format = function format(message, callback) {
     executeMessage: null,
   };
 
-  formatQ.consume(this[onMessageSymbol], {
+  formatQ.consume(this[kOnMessage], {
     consumerTag,
     prefetch: 100,
   });
 };
 
 Formatter.prototype._onMessage = function onMessage(routingKey, message) {
-  const {formatKey, correlationId, pending, executeMessage} = this[executionSymbol];
+  const {formatKey, correlationId, pending, executeMessage} = this[kExecution];
   const asyncFormatting = pending.length;
 
   switch (routingKey) {
@@ -59,7 +59,7 @@ Formatter.prototype._onMessage = function onMessage(routingKey, message) {
         message.ack();
         return this._complete(message);
       }
-      this[executionSymbol].executeMessage = message;
+      this[kExecution].executeMessage = message;
       break;
     default: {
       message.ack();
@@ -91,8 +91,8 @@ Formatter.prototype._onMessage = function onMessage(routingKey, message) {
 };
 
 Formatter.prototype._complete = function complete(message, isError) {
-  const {runMessage, formatKey, callback, formatted, executeMessage} = this[executionSymbol];
-  this[executionSymbol] = null;
+  const {runMessage, formatKey, callback, formatted, executeMessage} = this[kExecution];
+  this[kExecution] = null;
   if (executeMessage) executeMessage.ack();
 
   this.broker.cancel(message.fields.consumerTag);
@@ -108,7 +108,7 @@ Formatter.prototype._complete = function complete(message, isError) {
 };
 
 Formatter.prototype._decorate = function decorate(withContent) {
-  const content = this[executionSymbol].runMessage.content;
+  const content = this[kExecution].runMessage.content;
   for (const key in withContent) {
     switch (key) {
       case 'id':
@@ -125,7 +125,7 @@ Formatter.prototype._decorate = function decorate(withContent) {
         break;
       default: {
         content[key] = withContent[key];
-        this[executionSymbol].formatted = true;
+        this[kExecution].formatted = true;
       }
     }
   }